fs storage

pkg/util/semver_test.go

@@ -0,0 +1,280 @@
+package util_test
+
+import (
+	"testing"
+
+	"galaxy/util"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewSemver(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name    string
+		input   []uint
+		want    util.SemVer
+		wantErr string
+	}{
+		{
+			name:  "major only",
+			input: []uint{1},
+			want:  util.SemVer{Major: 1},
+		},
+		{
+			name:  "major and minor",
+			input: []uint{1, 2},
+			want:  util.SemVer{Major: 1, Minor: 2},
+		},
+		{
+			name:  "major minor and patch",
+			input: []uint{1, 2, 3},
+			want:  util.SemVer{Major: 1, Minor: 2, Patch: 3},
+		},
+		{
+			name:  "all components",
+			input: []uint{1, 2, 3, 4},
+			want:  util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 4},
+		},
+		{
+			name:    "missing major",
+			input:   nil,
+			wantErr: "incorrect args count: 0",
+		},
+		{
+			name:    "too many components",
+			input:   []uint{1, 2, 3, 4, 5},
+			wantErr: "incorrect args count: 5",
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := util.NewSemver(tt.input...)
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tt.wantErr)
+				assert.Equal(t, util.SemVer{}, got)
+				return
+			}
+
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func TestMustSemver(t *testing.T) {
+	t.Parallel()
+
+	t.Run("returns version", func(t *testing.T) {
+		t.Parallel()
+
+		assert.Equal(t, util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 4}, util.MustSemver(1, 2, 3, 4))
+	})
+
+	t.Run("panics on invalid input", func(t *testing.T) {
+		t.Parallel()
+
+		var recovered any
+
+		func() {
+			defer func() {
+				recovered = recover()
+			}()
+
+			util.MustSemver()
+		}()
+
+		require.NotNil(t, recovered)
+
+		err, ok := recovered.(error)
+		require.True(t, ok)
+		assert.EqualError(t, err, "new semver: incorrect args count: 0")
+	})
+}
+
+func TestParseSemver(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name    string
+		input   string
+		want    util.SemVer
+		wantErr string
+	}{
+		{
+			name:  "major only",
+			input: "1",
+			want:  util.SemVer{Major: 1},
+		},
+		{
+			name:  "major and minor",
+			input: "1.2",
+			want:  util.SemVer{Major: 1, Minor: 2},
+		},
+		{
+			name:  "major minor and patch",
+			input: "1.2.3",
+			want:  util.SemVer{Major: 1, Minor: 2, Patch: 3},
+		},
+		{
+			name:  "all components",
+			input: "1.2.3.4",
+			want:  util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 4},
+		},
+		{
+			name:  "v prefix",
+			input: "v2.3.4.5",
+			want:  util.SemVer{Major: 2, Minor: 3, Patch: 4, Build: 5},
+		},
+		{
+			name:  "v dot prefix",
+			input: "v.6.7.8.9",
+			want:  util.SemVer{Major: 6, Minor: 7, Patch: 8, Build: 9},
+		},
+		{
+			name:  "leading zeros",
+			input: "v.01.002.0003.0004",
+			want:  util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 4},
+		},
+		{
+			name:    "empty input",
+			input:   "",
+			wantErr: "missing major version",
+		},
+		{
+			name:    "prefix without version",
+			input:   "v",
+			wantErr: "missing major version",
+		},
+		{
+			name:    "prefix with dot without version",
+			input:   "v.",
+			wantErr: "missing major version",
+		},
+		{
+			name:    "leading dot",
+			input:   ".1",
+			wantErr: "empty version part at position 1",
+		},
+		{
+			name:    "trailing dot",
+			input:   "1.",
+			wantErr: "empty version part at position 2",
+		},
+		{
+			name:    "empty middle part",
+			input:   "1..2",
+			wantErr: "empty version part at position 2",
+		},
+		{
+			name:    "too many parts",
+			input:   "1.2.3.4.5",
+			wantErr: "too many version parts: 5",
+		},
+		{
+			name:    "non numeric part",
+			input:   "1.2.beta",
+			wantErr: `parse part "beta"`,
+		},
+		{
+			name:    "negative part",
+			input:   "1.-2",
+			wantErr: `parse part "-2"`,
+		},
+		{
+			name:    "spaces are not accepted",
+			input:   " 1.2 ",
+			wantErr: `parse part " 1"`,
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := util.ParseSemver(tt.input)
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tt.wantErr)
+				assert.Equal(t, util.SemVer{}, got)
+				return
+			}
+
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func TestParserSemver(t *testing.T) {
+	t.Parallel()
+
+	got, err := util.ParserSemver("v1.2.3.4")
+	require.NoError(t, err)
+	assert.Equal(t, util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 4}, got)
+}
+
+func TestCompareSemver(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		x    util.SemVer
+		y    util.SemVer
+		want int
+	}{
+		{
+			name: "equal versions",
+			x:    util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 4},
+			y:    util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 4},
+			want: 0,
+		},
+		{
+			name: "x less by major",
+			x:    util.SemVer{Major: 1, Minor: 9, Patch: 9, Build: 9},
+			y:    util.SemVer{Major: 2},
+			want: 1,
+		},
+		{
+			name: "x greater by major",
+			x:    util.SemVer{Major: 2},
+			y:    util.SemVer{Major: 1, Minor: 9, Patch: 9, Build: 9},
+			want: -1,
+		},
+		{
+			name: "x less by minor",
+			x:    util.SemVer{Major: 1, Minor: 1, Patch: 9, Build: 9},
+			y:    util.SemVer{Major: 1, Minor: 2},
+			want: 1,
+		},
+		{
+			name: "x less by patch",
+			x:    util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 9},
+			y:    util.SemVer{Major: 1, Minor: 2, Patch: 4},
+			want: 1,
+		},
+		{
+			name: "x less by build",
+			x:    util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 4},
+			y:    util.SemVer{Major: 1, Minor: 2, Patch: 3, Build: 5},
+			want: 1,
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			assert.Equal(t, tt.want, util.CompareSemver(tt.x, tt.y))
+		})
+	}
+}