769 lines
No EOL
22 KiB
Go
769 lines
No EOL
22 KiB
Go
//nolint:testpackage
|
|
package service
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/modelcontextprotocol/registry/internal/config"
|
|
"github.com/modelcontextprotocol/registry/internal/database"
|
|
apiv0 "github.com/modelcontextprotocol/registry/pkg/api/v0"
|
|
"github.com/modelcontextprotocol/registry/pkg/model"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestValidateNoDuplicateRemoteURLs(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
// Create test data
|
|
existingServers := map[string]*apiv0.ServerJSON{
|
|
"existing1": {
|
|
Name: "com.example/existing-server",
|
|
Description: "An existing server",
|
|
Version: "1.0.0",
|
|
Remotes: []model.Transport{
|
|
{Type: "streamable-http", URL: "https://api.example.com/mcp"},
|
|
{Type: "sse", URL: "https://webhook.example.com/sse"},
|
|
},
|
|
},
|
|
"existing2": {
|
|
Name: "com.microsoft/another-server",
|
|
Description: "Another existing server",
|
|
Version: "1.0.0",
|
|
Remotes: []model.Transport{
|
|
{Type: "streamable-http", URL: "https://api.microsoft.com/mcp"},
|
|
},
|
|
},
|
|
}
|
|
|
|
testDB := database.NewTestDB(t)
|
|
service := NewRegistryService(testDB, &config.Config{EnableRegistryValidation: false})
|
|
|
|
// Create existing servers using the new CreateServer method
|
|
for _, server := range existingServers {
|
|
_, err := service.CreateServer(ctx, server)
|
|
require.NoError(t, err, "failed to create server: %v", err)
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
serverDetail apiv0.ServerJSON
|
|
expectError bool
|
|
errorMsg string
|
|
}{
|
|
{
|
|
name: "no remote URLs - should pass",
|
|
serverDetail: apiv0.ServerJSON{
|
|
Name: "com.example/new-server",
|
|
Description: "A new server with no remotes",
|
|
Version: "1.0.0",
|
|
Remotes: []model.Transport{},
|
|
},
|
|
expectError: false,
|
|
},
|
|
{
|
|
name: "new unique remote URLs - should pass",
|
|
serverDetail: apiv0.ServerJSON{
|
|
Name: "com.example/new-server-unique",
|
|
Description: "A new server",
|
|
Version: "1.0.0",
|
|
Remotes: []model.Transport{
|
|
{Type: "streamable-http", URL: "https://new.example.com/mcp"},
|
|
{Type: "sse", URL: "https://unique.example.com/sse"},
|
|
},
|
|
},
|
|
expectError: false,
|
|
},
|
|
{
|
|
name: "duplicate remote URL - should fail",
|
|
serverDetail: apiv0.ServerJSON{
|
|
Name: "com.example/new-server-duplicate",
|
|
Description: "A new server with duplicate URL",
|
|
Version: "1.0.0",
|
|
Remotes: []model.Transport{
|
|
{Type: "streamable-http", URL: "https://api.example.com/mcp"}, // This URL already exists
|
|
},
|
|
},
|
|
expectError: true,
|
|
errorMsg: "remote URL https://api.example.com/mcp is already used by server com.example/existing-server",
|
|
},
|
|
{
|
|
name: "updating same server with same URLs - should pass",
|
|
serverDetail: apiv0.ServerJSON{
|
|
Name: "com.example/existing-server", // Same name as existing
|
|
Description: "Updated existing server",
|
|
Version: "1.1.0", // Different version
|
|
Remotes: []model.Transport{
|
|
{Type: "streamable-http", URL: "https://api.example.com/mcp"}, // Same URL as before
|
|
},
|
|
},
|
|
expectError: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
impl := service.(*registryServiceImpl)
|
|
|
|
err := impl.validateNoDuplicateRemoteURLs(ctx, nil, tt.serverDetail)
|
|
|
|
if tt.expectError {
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), tt.errorMsg)
|
|
} else {
|
|
assert.NoError(t, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetServerByName(t *testing.T) {
|
|
ctx := context.Background()
|
|
testDB := database.NewTestDB(t)
|
|
service := NewRegistryService(testDB, &config.Config{EnableRegistryValidation: false})
|
|
|
|
// Create multiple versions of the same server
|
|
_, err := service.CreateServer(ctx, &apiv0.ServerJSON{
|
|
Name: "com.example/test-server",
|
|
Description: "Test server v1",
|
|
Version: "1.0.0",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = service.CreateServer(ctx, &apiv0.ServerJSON{
|
|
Name: "com.example/test-server",
|
|
Description: "Test server v2",
|
|
Version: "2.0.0",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
tests := []struct {
|
|
name string
|
|
serverName string
|
|
expectError bool
|
|
errorMsg string
|
|
checkResult func(*testing.T, *apiv0.ServerResponse)
|
|
}{
|
|
{
|
|
name: "get latest version by server name",
|
|
serverName: "com.example/test-server",
|
|
expectError: false,
|
|
checkResult: func(t *testing.T, result *apiv0.ServerResponse) {
|
|
t.Helper()
|
|
assert.Equal(t, "2.0.0", result.Server.Version) // Should get latest version
|
|
assert.Equal(t, "Test server v2", result.Server.Description)
|
|
assert.True(t, result.Meta.Official.IsLatest)
|
|
},
|
|
},
|
|
{
|
|
name: "server not found",
|
|
serverName: "com.example/non-existent",
|
|
expectError: true,
|
|
errorMsg: "record not found",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result, err := service.GetServerByName(ctx, tt.serverName)
|
|
|
|
if tt.expectError {
|
|
assert.Error(t, err)
|
|
if tt.errorMsg != "" {
|
|
assert.Contains(t, err.Error(), tt.errorMsg)
|
|
}
|
|
assert.Nil(t, result)
|
|
} else {
|
|
assert.NoError(t, err)
|
|
assert.NotNil(t, result)
|
|
if tt.checkResult != nil {
|
|
tt.checkResult(t, result)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetServerByNameAndVersion(t *testing.T) {
|
|
ctx := context.Background()
|
|
testDB := database.NewTestDB(t)
|
|
service := NewRegistryService(testDB, &config.Config{EnableRegistryValidation: false})
|
|
|
|
serverName := "com.example/versioned-server"
|
|
|
|
// Create multiple versions of the same server
|
|
_, err := service.CreateServer(ctx, &apiv0.ServerJSON{
|
|
Name: serverName,
|
|
Description: "Versioned server v1",
|
|
Version: "1.0.0",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = service.CreateServer(ctx, &apiv0.ServerJSON{
|
|
Name: serverName,
|
|
Description: "Versioned server v2",
|
|
Version: "2.0.0",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
tests := []struct {
|
|
name string
|
|
serverName string
|
|
version string
|
|
expectError bool
|
|
errorMsg string
|
|
checkResult func(*testing.T, *apiv0.ServerResponse)
|
|
}{
|
|
{
|
|
name: "get specific version 1.0.0",
|
|
serverName: serverName,
|
|
version: "1.0.0",
|
|
expectError: false,
|
|
checkResult: func(t *testing.T, result *apiv0.ServerResponse) {
|
|
t.Helper()
|
|
assert.Equal(t, "1.0.0", result.Server.Version)
|
|
assert.Equal(t, "Versioned server v1", result.Server.Description)
|
|
assert.False(t, result.Meta.Official.IsLatest)
|
|
},
|
|
},
|
|
{
|
|
name: "get specific version 2.0.0",
|
|
serverName: serverName,
|
|
version: "2.0.0",
|
|
expectError: false,
|
|
checkResult: func(t *testing.T, result *apiv0.ServerResponse) {
|
|
t.Helper()
|
|
assert.Equal(t, "2.0.0", result.Server.Version)
|
|
assert.Equal(t, "Versioned server v2", result.Server.Description)
|
|
assert.True(t, result.Meta.Official.IsLatest)
|
|
},
|
|
},
|
|
{
|
|
name: "version not found",
|
|
serverName: serverName,
|
|
version: "3.0.0",
|
|
expectError: true,
|
|
errorMsg: "record not found",
|
|
},
|
|
{
|
|
name: "server not found",
|
|
serverName: "com.example/non-existent",
|
|
version: "1.0.0",
|
|
expectError: true,
|
|
errorMsg: "record not found",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result, err := service.GetServerByNameAndVersion(ctx, tt.serverName, tt.version)
|
|
|
|
if tt.expectError {
|
|
assert.Error(t, err)
|
|
if tt.errorMsg != "" {
|
|
assert.Contains(t, err.Error(), tt.errorMsg)
|
|
}
|
|
assert.Nil(t, result)
|
|
} else {
|
|
assert.NoError(t, err)
|
|
assert.NotNil(t, result)
|
|
if tt.checkResult != nil {
|
|
tt.checkResult(t, result)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetAllVersionsByServerName(t *testing.T) {
|
|
ctx := context.Background()
|
|
testDB := database.NewTestDB(t)
|
|
service := NewRegistryService(testDB, &config.Config{EnableRegistryValidation: false})
|
|
|
|
serverName := "com.example/multi-version-server"
|
|
|
|
// Create multiple versions of the same server
|
|
_, err := service.CreateServer(ctx, &apiv0.ServerJSON{
|
|
Name: serverName,
|
|
Description: "Multi-version server v1",
|
|
Version: "1.0.0",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = service.CreateServer(ctx, &apiv0.ServerJSON{
|
|
Name: serverName,
|
|
Description: "Multi-version server v2",
|
|
Version: "2.0.0",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = service.CreateServer(ctx, &apiv0.ServerJSON{
|
|
Name: serverName,
|
|
Description: "Multi-version server v2.1",
|
|
Version: "2.1.0",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
tests := []struct {
|
|
name string
|
|
serverName string
|
|
expectError bool
|
|
errorMsg string
|
|
checkResult func(*testing.T, []*apiv0.ServerResponse)
|
|
}{
|
|
{
|
|
name: "get all versions of server",
|
|
serverName: serverName,
|
|
expectError: false,
|
|
checkResult: func(t *testing.T, result []*apiv0.ServerResponse) {
|
|
t.Helper()
|
|
assert.Len(t, result, 3)
|
|
|
|
// Collect versions
|
|
versions := make([]string, 0, len(result))
|
|
latestCount := 0
|
|
for _, server := range result {
|
|
versions = append(versions, server.Server.Version)
|
|
assert.Equal(t, serverName, server.Server.Name)
|
|
if server.Meta.Official.IsLatest {
|
|
latestCount++
|
|
}
|
|
}
|
|
|
|
// Verify all versions are present
|
|
assert.Contains(t, versions, "1.0.0")
|
|
assert.Contains(t, versions, "2.0.0")
|
|
assert.Contains(t, versions, "2.1.0")
|
|
|
|
// Only one should be marked as latest
|
|
assert.Equal(t, 1, latestCount)
|
|
},
|
|
},
|
|
{
|
|
name: "server not found",
|
|
serverName: "com.example/non-existent",
|
|
expectError: true,
|
|
errorMsg: "record not found",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result, err := service.GetAllVersionsByServerName(ctx, tt.serverName)
|
|
|
|
if tt.expectError {
|
|
assert.Error(t, err)
|
|
if tt.errorMsg != "" {
|
|
assert.Contains(t, err.Error(), tt.errorMsg)
|
|
}
|
|
assert.Empty(t, result)
|
|
} else {
|
|
assert.NoError(t, err)
|
|
assert.NotEmpty(t, result)
|
|
if tt.checkResult != nil {
|
|
tt.checkResult(t, result)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCreateServerConcurrentVersionsNoRace(t *testing.T) {
|
|
ctx := context.Background()
|
|
testDB := database.NewTestDB(t)
|
|
service := NewRegistryService(testDB, &config.Config{EnableRegistryValidation: false})
|
|
|
|
const concurrency = 100
|
|
serverName := "com.example/test-concurrent"
|
|
results := make([]*apiv0.ServerResponse, concurrency)
|
|
errors := make([]error, concurrency)
|
|
|
|
var wg sync.WaitGroup
|
|
for i := 0; i < concurrency; i++ {
|
|
wg.Add(1)
|
|
go func(idx int) {
|
|
defer wg.Done()
|
|
result, err := service.CreateServer(ctx, &apiv0.ServerJSON{
|
|
Name: serverName,
|
|
Description: fmt.Sprintf("Version %d", idx),
|
|
Version: fmt.Sprintf("1.0.%d", idx),
|
|
})
|
|
results[idx] = result
|
|
errors[idx] = err
|
|
}(i)
|
|
}
|
|
wg.Wait()
|
|
|
|
// All publishes should succeed
|
|
for i, err := range errors {
|
|
assert.NoError(t, err, "create server %d failed", i)
|
|
}
|
|
|
|
// All results should have the same server name
|
|
for i, result := range results {
|
|
if result != nil {
|
|
assert.Equal(t, serverName, result.Server.Name, "version %d has different server name", i)
|
|
}
|
|
}
|
|
|
|
// Query database to check the final state after all creates complete
|
|
allVersions, err := service.GetAllVersionsByServerName(ctx, serverName)
|
|
require.NoError(t, err, "failed to get all versions")
|
|
|
|
latestCount := 0
|
|
var latestVersion string
|
|
for _, r := range allVersions {
|
|
if r.Meta.Official.IsLatest {
|
|
latestCount++
|
|
latestVersion = r.Server.Version
|
|
}
|
|
}
|
|
|
|
assert.Equal(t, 1, latestCount, "should have exactly one latest version in database, found version: %s", latestVersion)
|
|
assert.Len(t, allVersions, concurrency, "should have all %d versions", concurrency)
|
|
}
|
|
|
|
func TestUpdateServer(t *testing.T) {
|
|
ctx := context.Background()
|
|
testDB := database.NewTestDB(t)
|
|
service := NewRegistryService(testDB, &config.Config{EnableRegistryValidation: false})
|
|
|
|
serverName := "com.example/update-test-server"
|
|
version := "1.0.0"
|
|
|
|
// Create initial server
|
|
_, err := service.CreateServer(ctx, &apiv0.ServerJSON{
|
|
Name: serverName,
|
|
Description: "Original description",
|
|
Version: version,
|
|
Remotes: []model.Transport{
|
|
{Type: "streamable-http", URL: "https://original.example.com/mcp"},
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
tests := []struct {
|
|
name string
|
|
serverName string
|
|
version string
|
|
updatedServer *apiv0.ServerJSON
|
|
newStatus *string
|
|
expectError bool
|
|
errorMsg string
|
|
checkResult func(*testing.T, *apiv0.ServerResponse)
|
|
}{
|
|
{
|
|
name: "successful server update",
|
|
serverName: serverName,
|
|
version: version,
|
|
updatedServer: &apiv0.ServerJSON{
|
|
Name: serverName,
|
|
Description: "Updated description",
|
|
Version: version,
|
|
Remotes: []model.Transport{
|
|
{Type: "streamable-http", URL: "https://updated.example.com/mcp"},
|
|
},
|
|
},
|
|
expectError: false,
|
|
checkResult: func(t *testing.T, result *apiv0.ServerResponse) {
|
|
t.Helper()
|
|
assert.Equal(t, "Updated description", result.Server.Description)
|
|
assert.Len(t, result.Server.Remotes, 1)
|
|
assert.Equal(t, "https://updated.example.com/mcp", result.Server.Remotes[0].URL)
|
|
assert.NotZero(t, result.Meta.Official.UpdatedAt)
|
|
},
|
|
},
|
|
{
|
|
name: "update with status change",
|
|
serverName: serverName,
|
|
version: version,
|
|
updatedServer: &apiv0.ServerJSON{
|
|
Name: serverName,
|
|
Description: "Updated with status change",
|
|
Version: version,
|
|
},
|
|
newStatus: stringPtr(string(model.StatusDeprecated)),
|
|
expectError: false,
|
|
checkResult: func(t *testing.T, result *apiv0.ServerResponse) {
|
|
t.Helper()
|
|
assert.Equal(t, "Updated with status change", result.Server.Description)
|
|
assert.Equal(t, model.StatusDeprecated, result.Meta.Official.Status)
|
|
},
|
|
},
|
|
{
|
|
name: "update non-existent server",
|
|
serverName: "com.example/non-existent",
|
|
version: "1.0.0",
|
|
updatedServer: &apiv0.ServerJSON{
|
|
Name: "com.example/non-existent",
|
|
Description: "Should fail",
|
|
Version: "1.0.0",
|
|
},
|
|
expectError: true,
|
|
errorMsg: "record not found",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result, err := service.UpdateServer(ctx, tt.serverName, tt.version, tt.updatedServer, tt.newStatus)
|
|
|
|
if tt.expectError {
|
|
assert.Error(t, err)
|
|
if tt.errorMsg != "" {
|
|
assert.Contains(t, err.Error(), tt.errorMsg)
|
|
}
|
|
assert.Nil(t, result)
|
|
} else {
|
|
assert.NoError(t, err)
|
|
assert.NotNil(t, result)
|
|
if tt.checkResult != nil {
|
|
tt.checkResult(t, result)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestUpdateServer_SkipValidationForDeletedServers(t *testing.T) {
|
|
ctx := context.Background()
|
|
testDB := database.NewTestDB(t)
|
|
// Enable registry validation to test that it gets skipped for deleted servers
|
|
service := NewRegistryService(testDB, &config.Config{EnableRegistryValidation: true})
|
|
|
|
serverName := "com.example/validation-skip-test"
|
|
version := "1.0.0"
|
|
|
|
// Create server with invalid package configuration (this would fail registry validation)
|
|
invalidServer := &apiv0.ServerJSON{
|
|
Name: serverName,
|
|
Description: "Server with invalid package for testing validation skip",
|
|
Version: version,
|
|
Packages: []model.Package{
|
|
{
|
|
RegistryType: "npm",
|
|
Identifier: "non-existent-package-for-validation-test",
|
|
Version: "1.0.0",
|
|
Transport: model.Transport{Type: "stdio"},
|
|
},
|
|
},
|
|
}
|
|
|
|
// Create initial server (validation disabled for creation in this test)
|
|
originalConfig := service.(*registryServiceImpl).cfg.EnableRegistryValidation
|
|
service.(*registryServiceImpl).cfg.EnableRegistryValidation = false
|
|
_, err := service.CreateServer(ctx, invalidServer)
|
|
require.NoError(t, err, "failed to create server with validation disabled")
|
|
service.(*registryServiceImpl).cfg.EnableRegistryValidation = originalConfig
|
|
|
|
// First, set server to deleted status
|
|
deletedStatus := string(model.StatusDeleted)
|
|
_, err = service.UpdateServer(ctx, serverName, version, invalidServer, &deletedStatus)
|
|
require.NoError(t, err, "should be able to set server to deleted (validation should be skipped)")
|
|
|
|
// Verify server is now deleted
|
|
updatedServer, err := service.GetServerByNameAndVersion(ctx, serverName, version)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, model.StatusDeleted, updatedServer.Meta.Official.Status)
|
|
|
|
// Now try to update a deleted server - validation should be skipped
|
|
updatedInvalidServer := &apiv0.ServerJSON{
|
|
Name: serverName,
|
|
Description: "Updated description for deleted server",
|
|
Version: version,
|
|
Packages: []model.Package{
|
|
{
|
|
RegistryType: "npm",
|
|
Identifier: "another-non-existent-package-for-validation-test",
|
|
Version: "2.0.0",
|
|
Transport: model.Transport{Type: "stdio"},
|
|
},
|
|
},
|
|
}
|
|
|
|
// This should succeed despite invalid packages because server is deleted
|
|
result, err := service.UpdateServer(ctx, serverName, version, updatedInvalidServer, nil)
|
|
assert.NoError(t, err, "updating deleted server should skip registry validation")
|
|
assert.NotNil(t, result)
|
|
assert.Equal(t, "Updated description for deleted server", result.Server.Description)
|
|
assert.Equal(t, model.StatusDeleted, result.Meta.Official.Status)
|
|
|
|
// Test updating a server being set to deleted status
|
|
activeServer := &apiv0.ServerJSON{
|
|
Name: "com.example/being-deleted-test",
|
|
Description: "Server being deleted",
|
|
Version: "1.0.0",
|
|
Packages: []model.Package{
|
|
{
|
|
RegistryType: "npm",
|
|
Identifier: "yet-another-non-existent-package",
|
|
Version: "1.0.0",
|
|
Transport: model.Transport{Type: "stdio"},
|
|
},
|
|
},
|
|
}
|
|
|
|
// Create active server (with validation disabled)
|
|
service.(*registryServiceImpl).cfg.EnableRegistryValidation = false
|
|
_, err = service.CreateServer(ctx, activeServer)
|
|
require.NoError(t, err)
|
|
service.(*registryServiceImpl).cfg.EnableRegistryValidation = originalConfig
|
|
|
|
// Update server and set to deleted in same operation - should skip validation
|
|
newDeletedStatus := string(model.StatusDeleted)
|
|
result2, err := service.UpdateServer(ctx, "com.example/being-deleted-test", "1.0.0", activeServer, &newDeletedStatus)
|
|
assert.NoError(t, err, "updating server being set to deleted should skip registry validation")
|
|
assert.NotNil(t, result2)
|
|
assert.Equal(t, model.StatusDeleted, result2.Meta.Official.Status)
|
|
}
|
|
|
|
func TestListServers(t *testing.T) {
|
|
ctx := context.Background()
|
|
testDB := database.NewTestDB(t)
|
|
service := NewRegistryService(testDB, &config.Config{EnableRegistryValidation: false})
|
|
|
|
// Create test servers
|
|
testServers := []struct {
|
|
name string
|
|
version string
|
|
description string
|
|
}{
|
|
{"com.example/server-alpha", "1.0.0", "Alpha server"},
|
|
{"com.example/server-beta", "1.0.0", "Beta server"},
|
|
{"com.example/server-gamma", "2.0.0", "Gamma server"},
|
|
}
|
|
|
|
for _, server := range testServers {
|
|
_, err := service.CreateServer(ctx, &apiv0.ServerJSON{
|
|
Name: server.name,
|
|
Description: server.description,
|
|
Version: server.version,
|
|
})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
filter *database.ServerFilter
|
|
cursor string
|
|
limit int
|
|
expectedCount int
|
|
expectError bool
|
|
}{
|
|
{
|
|
name: "list all servers",
|
|
filter: nil,
|
|
limit: 10,
|
|
expectedCount: 3,
|
|
},
|
|
{
|
|
name: "filter by name",
|
|
filter: &database.ServerFilter{
|
|
Name: stringPtr("com.example/server-alpha"),
|
|
},
|
|
limit: 10,
|
|
expectedCount: 1,
|
|
},
|
|
{
|
|
name: "filter by version",
|
|
filter: &database.ServerFilter{
|
|
Version: stringPtr("1.0.0"),
|
|
},
|
|
limit: 10,
|
|
expectedCount: 2,
|
|
},
|
|
{
|
|
name: "pagination with limit",
|
|
filter: nil,
|
|
limit: 2,
|
|
expectedCount: 2,
|
|
},
|
|
{
|
|
name: "cursor pagination",
|
|
filter: nil,
|
|
cursor: "com.example/server-alpha",
|
|
limit: 10,
|
|
// Should return servers after 'server-alpha' alphabetically
|
|
expectedCount: 2,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
results, nextCursor, err := service.ListServers(ctx, tt.filter, tt.cursor, tt.limit)
|
|
|
|
if tt.expectError {
|
|
assert.Error(t, err)
|
|
return
|
|
}
|
|
|
|
assert.NoError(t, err)
|
|
assert.Len(t, results, tt.expectedCount)
|
|
|
|
// Test cursor behavior
|
|
if tt.limit < len(testServers) && len(results) == tt.limit {
|
|
assert.NotEmpty(t, nextCursor, "Should return next cursor when results are limited")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestVersionComparison(t *testing.T) {
|
|
ctx := context.Background()
|
|
testDB := database.NewTestDB(t)
|
|
service := NewRegistryService(testDB, &config.Config{EnableRegistryValidation: false})
|
|
|
|
serverName := "com.example/version-comparison-server"
|
|
|
|
// Create versions in non-chronological order to test version comparison logic
|
|
versions := []struct {
|
|
version string
|
|
description string
|
|
delay time.Duration // Delay to simulate different publish times
|
|
}{
|
|
{"2.0.0", "Version 2.0.0", 0},
|
|
{"1.0.0", "Version 1.0.0", 10 * time.Millisecond},
|
|
{"2.1.0", "Version 2.1.0", 20 * time.Millisecond},
|
|
{"1.5.0", "Version 1.5.0", 30 * time.Millisecond},
|
|
}
|
|
|
|
for _, v := range versions {
|
|
if v.delay > 0 {
|
|
time.Sleep(v.delay)
|
|
}
|
|
_, err := service.CreateServer(ctx, &apiv0.ServerJSON{
|
|
Name: serverName,
|
|
Description: v.description,
|
|
Version: v.version,
|
|
})
|
|
require.NoError(t, err, "Failed to create version %s", v.version)
|
|
}
|
|
|
|
// Get the latest version - should be 2.1.0 based on semantic versioning
|
|
latest, err := service.GetServerByName(ctx, serverName)
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, "2.1.0", latest.Server.Version, "Latest version should be 2.1.0")
|
|
assert.True(t, latest.Meta.Official.IsLatest)
|
|
|
|
// Verify only one version is marked as latest
|
|
allVersions, err := service.GetAllVersionsByServerName(ctx, serverName)
|
|
require.NoError(t, err)
|
|
|
|
latestCount := 0
|
|
for _, version := range allVersions {
|
|
if version.Meta.Official.IsLatest {
|
|
latestCount++
|
|
}
|
|
}
|
|
assert.Equal(t, 1, latestCount, "Exactly one version should be marked as latest")
|
|
}
|
|
|
|
// Helper functions
|
|
func stringPtr(s string) *string {
|
|
return &s
|
|
} |