upaas/internal/handlers/resource_limits_test.go

package handlers //nolint:testpackage // tests unexported parsing functions

import (
	"database/sql"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestParseOptionalFloat64(t *testing.T) {
	t.Parallel()

	t.Run("empty string returns invalid", func(t *testing.T) {
		t.Parallel()

		result, err := parseOptionalFloat64("")
		require.NoError(t, err)
		assert.False(t, result.Valid)
	})

	t.Run("whitespace only returns invalid", func(t *testing.T) {
		t.Parallel()

		result, err := parseOptionalFloat64("   ")
		require.NoError(t, err)
		assert.False(t, result.Valid)
	})

	t.Run("valid float", func(t *testing.T) {
		t.Parallel()

		result, err := parseOptionalFloat64("0.5")
		require.NoError(t, err)
		assert.True(t, result.Valid)
		assert.InDelta(t, 0.5, result.Float64, 0.001)
	})

	t.Run("valid integer", func(t *testing.T) {
		t.Parallel()

		result, err := parseOptionalFloat64("2")
		require.NoError(t, err)
		assert.True(t, result.Valid)
		assert.InDelta(t, 2.0, result.Float64, 0.001)
	})

	t.Run("negative value rejected", func(t *testing.T) {
		t.Parallel()

		_, err := parseOptionalFloat64("-1")
		require.Error(t, err)
	})

	t.Run("zero value rejected", func(t *testing.T) {
		t.Parallel()

		_, err := parseOptionalFloat64("0")
		require.Error(t, err)
	})

	t.Run("non-numeric rejected", func(t *testing.T) {
		t.Parallel()

		_, err := parseOptionalFloat64("abc")
		require.Error(t, err)
	})
}

func TestParseOptionalMemoryBytes(t *testing.T) { //nolint:funlen // table-driven test
	t.Parallel()

	t.Run("empty string returns invalid", func(t *testing.T) {
		t.Parallel()

		result, err := parseOptionalMemoryBytes("")
		require.NoError(t, err)
		assert.False(t, result.Valid)
	})

	t.Run("whitespace only returns invalid", func(t *testing.T) {
		t.Parallel()

		result, err := parseOptionalMemoryBytes("   ")
		require.NoError(t, err)
		assert.False(t, result.Valid)
	})

	t.Run("plain bytes", func(t *testing.T) {
		t.Parallel()

		result, err := parseOptionalMemoryBytes("536870912")
		require.NoError(t, err)
		assert.True(t, result.Valid)
		assert.Equal(t, int64(536870912), result.Int64)
	})

	t.Run("megabytes suffix", func(t *testing.T) {
		t.Parallel()

		result, err := parseOptionalMemoryBytes("256m")
		require.NoError(t, err)
		assert.True(t, result.Valid)
		assert.Equal(t, int64(256*1024*1024), result.Int64)
	})

	t.Run("megabytes suffix uppercase", func(t *testing.T) {
		t.Parallel()

		result, err := parseOptionalMemoryBytes("256M")
		require.NoError(t, err)
		assert.True(t, result.Valid)
		assert.Equal(t, int64(256*1024*1024), result.Int64)
	})

	t.Run("gigabytes suffix", func(t *testing.T) {
		t.Parallel()

		result, err := parseOptionalMemoryBytes("1g")
		require.NoError(t, err)
		assert.True(t, result.Valid)
		assert.Equal(t, int64(1024*1024*1024), result.Int64)
	})

	t.Run("kilobytes suffix", func(t *testing.T) {
		t.Parallel()

		result, err := parseOptionalMemoryBytes("512k")
		require.NoError(t, err)
		assert.True(t, result.Valid)
		assert.Equal(t, int64(512*1024), result.Int64)
	})

	t.Run("fractional gigabytes", func(t *testing.T) {
		t.Parallel()

		result, err := parseOptionalMemoryBytes("1.5g")
		require.NoError(t, err)
		assert.True(t, result.Valid)
		assert.Equal(t, int64(1.5*1024*1024*1024), result.Int64)
	})

	t.Run("negative value rejected", func(t *testing.T) {
		t.Parallel()

		_, err := parseOptionalMemoryBytes("-256m")
		require.Error(t, err)
	})

	t.Run("zero value rejected", func(t *testing.T) {
		t.Parallel()

		_, err := parseOptionalMemoryBytes("0")
		require.Error(t, err)
	})

	t.Run("invalid string rejected", func(t *testing.T) {
		t.Parallel()

		_, err := parseOptionalMemoryBytes("abc")
		require.Error(t, err)
	})

	t.Run("negative plain bytes rejected", func(t *testing.T) {
		t.Parallel()

		_, err := parseOptionalMemoryBytes("-100")
		require.Error(t, err)
	})
}

func TestAppResourceLimitsRoundTrip(t *testing.T) {
	t.Parallel()

	// Test that parsing and formatting are consistent
	tests := []struct {
		input    string
		expected sql.NullInt64
		format   string
	}{
		{"256m", sql.NullInt64{Int64: 256 * 1024 * 1024, Valid: true}, "256m"},
		{"1g", sql.NullInt64{Int64: 1024 * 1024 * 1024, Valid: true}, "1g"},
		{"512k", sql.NullInt64{Int64: 512 * 1024, Valid: true}, "512k"},
	}

	for _, tt := range tests {
		t.Run(tt.input, func(t *testing.T) {
			t.Parallel()

			result, err := parseOptionalMemoryBytes(tt.input)
			require.NoError(t, err)
			assert.Equal(t, tt.expected, result)
		})
	}
}