test: add schema regex validation test suite

Adds a test suite that extracts regex patterns from the JSON schema and
validates them against test cases. Tests cover:
- Transport URL pattern (http/https or template variables like {baseUrl})
- Icon sizes pattern (WxH format or "any")
- Server name pattern (namespace/name format)
- File SHA-256 pattern (64 hex chars)

Includes helper functions for cleaner schema traversal and pattern testing.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Agent Orchestrator

internal/validators/schema_regex_test.go

@@ -0,0 +1,216 @@
+package validators_test
+
+import (
+	"encoding/json"
+	"os"
+	"regexp"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const serverSchemaPath = "../../docs/reference/server-json/server.schema.json"
+
+// schemaHelper provides utilities for extracting values from the JSON schema
+type schemaHelper struct {
+	t      *testing.T
+	schema map[string]interface{}
+}
+
+func loadSchema(t *testing.T) *schemaHelper {
+	t.Helper()
+	data, err := os.ReadFile(serverSchemaPath)
+	require.NoError(t, err, "Failed to read schema file")
+
+	var schema map[string]interface{}
+	err = json.Unmarshal(data, &schema)
+	require.NoError(t, err, "Failed to parse schema JSON")
+
+	return &schemaHelper{t: t, schema: schema}
+}
+
+// getDefinition returns a definition from the schema by name
+func (s *schemaHelper) getDefinition(name string) map[string]interface{} {
+	s.t.Helper()
+	definitions := s.schema["definitions"].(map[string]interface{})
+	def, ok := definitions[name].(map[string]interface{})
+	require.True(s.t, ok, "Definition %q not found in schema", name)
+	return def
+}
+
+// getPropertyPattern extracts a regex pattern from a definition's property
+func (s *schemaHelper) getPropertyPattern(definitionName, propertyName string) string {
+	s.t.Helper()
+	def := s.getDefinition(definitionName)
+	props := def["properties"].(map[string]interface{})
+	prop, ok := props[propertyName].(map[string]interface{})
+	require.True(s.t, ok, "Property %q not found in %s", propertyName, definitionName)
+	pattern, ok := prop["pattern"].(string)
+	require.True(s.t, ok, "Pattern not found for %s.%s", definitionName, propertyName)
+	return pattern
+}
+
+// getItemsPattern extracts a regex pattern from an array property's items
+func (s *schemaHelper) getItemsPattern(definitionName, propertyName string) string {
+	s.t.Helper()
+	def := s.getDefinition(definitionName)
+	props := def["properties"].(map[string]interface{})
+	prop, ok := props[propertyName].(map[string]interface{})
+	require.True(s.t, ok, "Property %q not found in %s", propertyName, definitionName)
+	items, ok := prop["items"].(map[string]interface{})
+	require.True(s.t, ok, "Items not found for %s.%s", definitionName, propertyName)
+	pattern, ok := items["pattern"].(string)
+	require.True(s.t, ok, "Pattern not found in items for %s.%s", definitionName, propertyName)
+	return pattern
+}
+
+// testPattern runs a set of test cases against a regex pattern
+func testPattern(t *testing.T, pattern string, validCases, invalidCases []string) {
+	t.Helper()
+	re, err := regexp.Compile(pattern)
+	require.NoError(t, err, "Pattern should be valid regex: %s", pattern)
+
+	for _, tc := range validCases {
+		assert.True(t, re.MatchString(tc), "Expected %q to match pattern", tc)
+	}
+	for _, tc := range invalidCases {
+		assert.False(t, re.MatchString(tc), "Expected %q to NOT match pattern", tc)
+	}
+}
+
+// TestTransportURLPattern validates the URL pattern used by StreamableHttpTransport and SseTransport.
+// URLs must start with http://, https://, or a template variable like {baseUrl}.
+func TestTransportURLPattern(t *testing.T) {
+	schema := loadSchema(t)
+
+	streamablePattern := schema.getPropertyPattern("StreamableHttpTransport", "url")
+	ssePattern := schema.getPropertyPattern("SseTransport", "url")
+
+	// Verify both transport types use the same pattern
+	assert.Equal(t, streamablePattern, ssePattern,
+		"StreamableHttpTransport and SseTransport should use identical URL patterns")
+
+	t.Logf("Pattern: %s", streamablePattern)
+
+	validCases := []string{
+		// Standard URLs
+		"https://api.example.com/mcp",
+		"http://localhost:8080/sse",
+		"https://example.com/path?query=value",
+		"https://api.example.com/v1/mcp",
+		// Template variables
+		"{baseUrl}",
+		"{baseUrl}/mcp",
+		"{server_url}/api/v1",
+		"{API_ENDPOINT}",
+		"{a}",
+		"{_private}/endpoint",
+	}
+
+	invalidCases := []string{
+		"ftp://example.com",      // wrong protocol
+		"example.com",            // missing protocol or variable
+		"/relative/path",         // relative path
+		"{invalid-name}/path",    // hyphen in variable name
+		"{123invalid}",           // variable starts with number
+		"",                       // empty string
+		"mailto:test@example.com",// wrong protocol
+		"file:///path/to/file",   // wrong protocol
+		"{}/empty",               // empty variable name
+		"{{nested}}/path",        // nested braces
+	}
+
+	testPattern(t, streamablePattern, validCases, invalidCases)
+}
+
+// TestIconSizesPattern validates the pattern for icon size strings.
+// Sizes must be in WxH format (e.g., "48x48") or "any" for scalable formats.
+func TestIconSizesPattern(t *testing.T) {
+	schema := loadSchema(t)
+	pattern := schema.getItemsPattern("Icon", "sizes")
+
+	t.Logf("Pattern: %s", pattern)
+
+	validCases := []string{
+		"48x48",
+		"96x96",
+		"128x128",
+		"1x1",
+		"1920x1080",
+		"any",
+	}
+
+	invalidCases := []string{
+		"48",         // missing dimension
+		"x48",        // missing width
+		"48x",        // missing height
+		"48X48",      // uppercase X
+		"any x any",  // spaces
+		"48 x 48",    // spaces
+		"large",      // arbitrary string
+		"",           // empty
+		"48x48x48",   // three dimensions
+	}
+
+	testPattern(t, pattern, validCases, invalidCases)
+}
+
+// TestServerNamePattern validates the pattern for server names.
+// Names must be in reverse-DNS format with exactly one slash: namespace/name
+func TestServerNamePattern(t *testing.T) {
+	schema := loadSchema(t)
+	def := schema.getDefinition("ServerDetail")
+	props := def["properties"].(map[string]interface{})
+	nameProp := props["name"].(map[string]interface{})
+	pattern := nameProp["pattern"].(string)
+
+	t.Logf("Pattern: %s", pattern)
+
+	validCases := []string{
+		"com.example/server",
+		"io.github.user/my-server",
+		"com.microsoft.azure/webapp",
+		"org.apache/kafka-mcp",
+		"a/b",
+		"com.example/server_name",
+		"com.example/server.name",
+	}
+
+	invalidCases := []string{
+		"com.example",           // no slash
+		"com.example/",          // empty name
+		"/server",               // empty namespace
+		"com.example/a/b",       // multiple slashes
+		"com example/server",    // space in namespace
+		"com.example/my server", // space in name
+		"",                      // empty
+	}
+
+	testPattern(t, pattern, validCases, invalidCases)
+}
+
+// TestFileSHA256Pattern validates the pattern for SHA-256 file hashes.
+func TestFileSHA256Pattern(t *testing.T) {
+	schema := loadSchema(t)
+	pattern := schema.getPropertyPattern("Package", "fileSha256")
+
+	t.Logf("Pattern: %s", pattern)
+
+	validCases := []string{
+		"fe333e598595000ae021bd27117db32ec69af6987f507ba7a63c90638ff633ce",
+		"0000000000000000000000000000000000000000000000000000000000000000",
+		"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+		"abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789",
+	}
+
+	invalidCases := []string{
+		"fe333e598595000ae021bd27117db32ec69af6987f507ba7a63c90638ff633c",   // 63 chars
+		"fe333e598595000ae021bd27117db32ec69af6987f507ba7a63c90638ff633cee",  // 65 chars
+		"FE333E598595000AE021BD27117DB32EC69AF6987F507BA7A63C90638FF633CE",   // uppercase
+		"ge333e598595000ae021bd27117db32ec69af6987f507ba7a63c90638ff633ce",   // invalid char 'g'
+		"",                                                                    // empty
+	}
+
+	testPattern(t, pattern, validCases, invalidCases)
+}