Add spec tests for modelsdev, repoutil, semverutil (#43536)

Author: github-actions[bot]

pkg/modelsdev/spec_test.go

@@ -0,0 +1,57 @@
+//go:build !integration
+
+package modelsdev
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestSpec_PublicAPI_FindPricing validates the documented behavior of
+// FindPricing as described in the modelsdev README.md specification.
+func TestSpec_PublicAPI_FindPricing(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("returns nil false when pricing is unavailable", func(t *testing.T) {
+		pricing, ok := FindPricing(ctx, "definitely-not-a-provider", "definitely-not-a-model")
+		assert.False(t, ok, "FindPricing should report unavailable pricing for an unknown provider/model pair")
+		assert.Nil(t, pricing, "FindPricing should return nil pricing when no pricing is available")
+	})
+
+	t.Run("result pricing map exposes per token input and output entries when available", func(t *testing.T) {
+		pricing, ok := FindPricing(ctx, "github", "gpt-4.1")
+		if !ok {
+			t.Skip("catalog pricing unavailable in test environment; README specifies graceful degradation when network or parsing fails")
+		}
+
+		require.NotNil(t, pricing, "FindPricing should return a non-nil pricing map when pricing is available")
+		_, hasInput := pricing["input"]
+		_, hasOutput := pricing["output"]
+		assert.True(t, hasInput, "pricing map should contain documented input per-token price entry")
+		assert.True(t, hasOutput, "pricing map should contain documented output per-token price entry")
+	})
+}
+
+// TestSpec_DesignDecision_ProviderAliases validates the documented provider
+// alias normalization described in the modelsdev README.md.
+func TestSpec_DesignDecision_ProviderAliases(t *testing.T) {
+	tests := []struct {
+		name     string
+		provider string
+	}{
+		{name: "github alias", provider: "github"},
+		{name: "copilot alias", provider: "copilot"},
+		{name: "github_models alias", provider: "github_models"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			pricing, ok := FindPricing(context.Background(), tt.provider, "definitely-not-a-real-model")
+			assert.False(t, ok, "FindPricing should still return unavailable for an unknown model after normalizing provider alias %q", tt.provider)
+			assert.Nil(t, pricing, "FindPricing should return nil pricing for unknown model with provider alias %q", tt.provider)
+		})
+	}
+}

pkg/repoutil/spec_test.go

@@ -63,3 +63,35 @@ func TestSpec_PublicAPI_SplitRepoSlug(t *testing.T) {
 		})
 	}
 }
+
+// TestSpec_PublicAPI_NormalizeRepoForAPI validates the documented behavior of
+// NormalizeRepoForAPI as described in the repoutil README.md specification.
+func TestSpec_PublicAPI_NormalizeRepoForAPI(t *testing.T) {
+	tests := []struct {
+		name              string
+		input             string
+		expectedOwnerRepo string
+		expectedHost      string
+	}{
+		{
+			name:              "plain owner repo keeps empty host",
+			input:             "github/gh-aw",
+			expectedOwnerRepo: "github/gh-aw",
+			expectedHost:      "",
+		},
+		{
+			name:              "host owner repo splits into owner repo and host",
+			input:             "ghe.example.com/github/gh-aw",
+			expectedOwnerRepo: "github/gh-aw",
+			expectedHost:      "ghe.example.com",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ownerRepo, host := NormalizeRepoForAPI(tt.input)
+			assert.Equal(t, tt.expectedOwnerRepo, ownerRepo, "owner/repo mismatch for input %q", tt.input)
+			assert.Equal(t, tt.expectedHost, host, "host mismatch for input %q", tt.input)
+		})
+	}
+}

pkg/semverutil/spec_test.go

@@ -125,14 +125,12 @@ func TestSpec_PublicAPI_ParseVersion(t *testing.T) {
 	})
 
 	t.Run("Pre field is prerelease identifier without leading hyphen", func(t *testing.T) {
-		// Spec: Pre string // Prerelease identifier without leading hyphen (e.g. "beta.1")
 		ver := ParseVersion("v1.2.3-beta.1")
 		require.NotNil(t, ver, "ParseVersion should return non-nil for valid prerelease semver")
 		assert.Equal(t, "beta.1", ver.Pre, "Pre field should contain prerelease identifier without leading hyphen")
 	})
 
 	t.Run("Raw field is original version string without leading v prefix", func(t *testing.T) {
-		// Spec: Raw string // Original version string without leading "v"
 		ver := ParseVersion("v1.2.3")
 		require.NotNil(t, ver, "ParseVersion should return non-nil for valid semver")
 		assert.Equal(t, "1.2.3", ver.Raw, "Raw field should contain version string without leading v prefix")
@@ -216,6 +214,12 @@ func TestSpec_PublicAPI_Compare(t *testing.T) {
 			v2:       "v1.0.0",
 			expected: -1,
 		},
+		{
+			name:     "bare versions without v prefix are accepted",
+			v1:       "2.0.0",
+			v2:       "1.9.9",
+			expected: 1,
+		},
 	}
 
 	for _, tt := range tests {
@@ -226,6 +230,43 @@ func TestSpec_PublicAPI_Compare(t *testing.T) {
 	}
 }
 
+// TestSpec_PublicAPI_IsMorePreciseVersion validates the documented behavior of
+// IsMorePreciseVersion as described in the semverutil README.md specification.
+func TestSpec_PublicAPI_IsMorePreciseVersion(t *testing.T) {
+	tests := []struct {
+		name     string
+		v1       string
+		v2       string
+		expected bool
+	}{
+		{
+			name:     "more specific version sorts ahead of less specific version",
+			v1:       "v4.3.0",
+			v2:       "v4",
+			expected: true,
+		},
+		{
+			name:     "less specific version does not sort ahead of more specific version",
+			v1:       "v4",
+			v2:       "v4.3.0",
+			expected: false,
+		},
+		{
+			name:     "equal precision and equal value returns false",
+			v1:       "v4.3.0",
+			v2:       "v4.3.0",
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := IsMorePreciseVersion(tt.v1, tt.v2)
+			assert.Equal(t, tt.expected, result, "IsMorePreciseVersion(%q, %q) mismatch", tt.v1, tt.v2)
+		})
+	}
+}
+
 // TestSpec_PublicAPI_IsCompatible validates the documented behavior of
 // IsCompatible as described in the semverutil README.md specification.
 func TestSpec_PublicAPI_IsCompatible(t *testing.T) {
@@ -259,24 +300,6 @@ func TestSpec_PublicAPI_IsCompatible(t *testing.T) {
 			requestedVersion: "also-not-a-version",
 			expected:         false,
 		},
-		{
-			name:             "empty strings are not compatible",
-			pinVersion:       "",
-			requestedVersion: "",
-			expected:         false,
-		},
-		{
-			name:             "invalid pin with valid requested is not compatible",
-			pinVersion:       "not-a-version",
-			requestedVersion: "v5.0.0",
-			expected:         false,
-		},
-		{
-			name:             "valid pin with invalid requested is not compatible",
-			pinVersion:       "v5.0.0",
-			requestedVersion: "not-a-version",
-			expected:         false,
-		},
 	}
 
 	for _, tt := range tests {