Changes on the server.json format and the API (#562)
This commit is contained in:
parent
4962609697
commit
b21c6f564d
3 changed files with 4056 additions and 5608 deletions
|
|
@ -6,12 +6,12 @@ import (
|
|||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/modelcontextprotocol/registry/internal/config"
|
||||
"github.com/modelcontextprotocol/registry/internal/database"
|
||||
"github.com/modelcontextprotocol/registry/internal/validators"
|
||||
apiv0 "github.com/modelcontextprotocol/registry/pkg/api/v0"
|
||||
"github.com/modelcontextprotocol/registry/pkg/model"
|
||||
)
|
||||
|
||||
const maxServerVersionsPerServer = 10000
|
||||
|
|
@ -30,219 +30,136 @@ func NewRegistryService(db database.Database, cfg *config.Config) RegistryServic
|
|||
}
|
||||
}
|
||||
|
||||
// List returns registry entries with cursor-based pagination and optional filtering
|
||||
func (s *registryServiceImpl) List(filter *database.ServerFilter, cursor string, limit int) ([]apiv0.ServerJSON, string, error) {
|
||||
// Create a timeout context for the database operation
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
|
||||
// ListServers returns registry entries with cursor-based pagination and optional filtering
|
||||
func (s *registryServiceImpl) ListServers(ctx context.Context, filter *database.ServerFilter, cursor string, limit int) ([]*apiv0.ServerResponse, string, error) {
|
||||
// If limit is not set or negative, use a default limit
|
||||
if limit <= 0 {
|
||||
limit = 30
|
||||
}
|
||||
|
||||
// Use the database's ListServers method with pagination and filtering
|
||||
serverRecords, nextCursor, err := s.db.List(ctx, nil, filter, cursor, limit)
|
||||
serverRecords, nextCursor, err := s.db.ListServers(ctx, nil, filter, cursor, limit)
|
||||
if err != nil {
|
||||
return nil, "", err
|
||||
}
|
||||
|
||||
// Return ServerJSONs directly
|
||||
result := make([]apiv0.ServerJSON, len(serverRecords))
|
||||
for i, record := range serverRecords {
|
||||
result[i] = *record
|
||||
}
|
||||
|
||||
return result, nextCursor, nil
|
||||
return serverRecords, nextCursor, nil
|
||||
}
|
||||
|
||||
// GetByVersionID retrieves a specific server by its registry metadata version ID
|
||||
func (s *registryServiceImpl) GetByVersionID(versionID string) (*apiv0.ServerJSON, error) {
|
||||
// Create a timeout context for the database operation
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
|
||||
serverRecord, err := s.db.GetByVersionID(ctx, nil, versionID)
|
||||
// GetServerByName retrieves the latest version of a server by its server name
|
||||
func (s *registryServiceImpl) GetServerByName(ctx context.Context, serverName string) (*apiv0.ServerResponse, error) {
|
||||
serverRecord, err := s.db.GetServerByName(ctx, nil, serverName)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Return the server record directly
|
||||
return serverRecord, nil
|
||||
}
|
||||
|
||||
// GetByServerID retrieves the latest version of a server by its server ID
|
||||
func (s *registryServiceImpl) GetByServerID(serverID string) (*apiv0.ServerJSON, error) {
|
||||
// Create a timeout context for the database operation
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
|
||||
serverRecord, err := s.db.GetByServerID(ctx, nil, serverID)
|
||||
// GetServerByNameAndVersion retrieves a specific version of a server by server name and version
|
||||
func (s *registryServiceImpl) GetServerByNameAndVersion(ctx context.Context, serverName string, version string) (*apiv0.ServerResponse, error) {
|
||||
serverRecord, err := s.db.GetServerByNameAndVersion(ctx, nil, serverName, version)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Return the server record directly
|
||||
return serverRecord, nil
|
||||
}
|
||||
|
||||
// GetByServerIDAndVersion retrieves a specific version of a server by server ID and version
|
||||
func (s *registryServiceImpl) GetByServerIDAndVersion(serverID string, version string) (*apiv0.ServerJSON, error) {
|
||||
// Create a timeout context for the database operation
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
|
||||
serverRecord, err := s.db.GetByServerIDAndVersion(ctx, nil, serverID, version)
|
||||
// GetAllVersionsByServerName retrieves all versions of a server by server name
|
||||
func (s *registryServiceImpl) GetAllVersionsByServerName(ctx context.Context, serverName string) ([]*apiv0.ServerResponse, error) {
|
||||
serverRecords, err := s.db.GetAllVersionsByServerName(ctx, nil, serverName)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Return the server record directly
|
||||
return serverRecord, nil
|
||||
return serverRecords, nil
|
||||
}
|
||||
|
||||
// GetAllVersionsByServerID retrieves all versions of a server by server ID
|
||||
func (s *registryServiceImpl) GetAllVersionsByServerID(serverID string) ([]apiv0.ServerJSON, error) {
|
||||
// Create a timeout context for the database operation
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
|
||||
serverRecords, err := s.db.GetAllVersionsByServerID(ctx, nil, serverID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Return ServerJSONs directly
|
||||
result := make([]apiv0.ServerJSON, len(serverRecords))
|
||||
for i, record := range serverRecords {
|
||||
result[i] = *record
|
||||
}
|
||||
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// Publish publishes a server with flattened _meta extensions
|
||||
func (s *registryServiceImpl) Publish(req apiv0.ServerJSON) (*apiv0.ServerJSON, error) {
|
||||
// Create a timeout context for the database operation
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
|
||||
// Validate the request
|
||||
if err := validators.ValidatePublishRequest(req, s.cfg); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
result, err := database.InTransactionT(ctx, s.db, func(txCtx context.Context, tx pgx.Tx) (*apiv0.ServerJSON, error) {
|
||||
publishTime := time.Now()
|
||||
serverJSON := req
|
||||
|
||||
// Acquire advisory lock to prevent concurrent publishes of the same server
|
||||
if err := s.db.AcquirePublishLock(txCtx, tx, serverJSON.Name); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Check for duplicate remote URLs
|
||||
if err := s.validateNoDuplicateRemoteURLs(txCtx, tx, serverJSON); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
filter := &database.ServerFilter{Name: &serverJSON.Name}
|
||||
existingServerVersions, _, err := s.db.List(txCtx, tx, filter, "", maxServerVersionsPerServer)
|
||||
if err != nil && !errors.Is(err, database.ErrNotFound) {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Check we haven't exceeded the maximum versions allowed for a server
|
||||
if len(existingServerVersions) >= maxServerVersionsPerServer {
|
||||
return nil, database.ErrMaxServersReached
|
||||
}
|
||||
|
||||
// Check this isn't a duplicate version
|
||||
for _, server := range existingServerVersions {
|
||||
existingVersion := server.Version
|
||||
if existingVersion == serverJSON.Version {
|
||||
return nil, database.ErrInvalidVersion
|
||||
}
|
||||
}
|
||||
|
||||
// Determine if this version should be marked as latest
|
||||
existingLatest := s.getCurrentLatestVersion(existingServerVersions)
|
||||
isNewLatest := true
|
||||
if existingLatest != nil {
|
||||
var existingPublishedAt time.Time
|
||||
if existingLatest.Meta != nil && existingLatest.Meta.Official != nil {
|
||||
existingPublishedAt = existingLatest.Meta.Official.PublishedAt
|
||||
}
|
||||
isNewLatest = CompareVersions(
|
||||
serverJSON.Version,
|
||||
existingLatest.Version,
|
||||
publishTime,
|
||||
existingPublishedAt,
|
||||
) > 0
|
||||
}
|
||||
|
||||
// Unmark old latest version if needed
|
||||
if isNewLatest && existingLatest != nil {
|
||||
if existingLatest.Meta != nil && existingLatest.Meta.Official != nil {
|
||||
existingLatest.Meta.Official.IsLatest = false
|
||||
if _, err := s.db.UpdateServer(txCtx, tx, existingLatest.Meta.Official.VersionID, existingLatest); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Create complete server with metadata
|
||||
server := s.createServerWithMetadata(serverJSON, existingServerVersions, publishTime, isNewLatest)
|
||||
|
||||
// Insert new server version
|
||||
return s.db.CreateServer(txCtx, tx, &server)
|
||||
// CreateServer creates a new server version
|
||||
func (s *registryServiceImpl) CreateServer(ctx context.Context, req *apiv0.ServerJSON) (*apiv0.ServerResponse, error) {
|
||||
// Wrap the entire operation in a transaction
|
||||
return database.InTransactionT(ctx, s.db, func(ctx context.Context, tx pgx.Tx) (*apiv0.ServerResponse, error) {
|
||||
return s.createServerInTransaction(ctx, tx, req)
|
||||
})
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
// createServerInTransaction contains the actual CreateServer logic within a transaction
|
||||
func (s *registryServiceImpl) createServerInTransaction(ctx context.Context, tx pgx.Tx, req *apiv0.ServerJSON) (*apiv0.ServerResponse, error) {
|
||||
// Validate the request
|
||||
if err := validators.ValidatePublishRequest(ctx, *req, s.cfg); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return result, nil
|
||||
}
|
||||
publishTime := time.Now()
|
||||
serverJSON := *req
|
||||
|
||||
// createServerWithMetadata creates a server with proper metadata including server_id and version_id
|
||||
func (s *registryServiceImpl) createServerWithMetadata(
|
||||
serverJSON apiv0.ServerJSON,
|
||||
existingServerVersions []*apiv0.ServerJSON,
|
||||
publishTime time.Time,
|
||||
isNewLatest bool,
|
||||
) apiv0.ServerJSON {
|
||||
server := serverJSON // Copy the input
|
||||
|
||||
// Initialize meta if not present
|
||||
if server.Meta == nil {
|
||||
server.Meta = &apiv0.ServerMeta{}
|
||||
// Acquire advisory lock to prevent concurrent publishes of the same server
|
||||
if err := s.db.AcquirePublishLock(ctx, tx, serverJSON.Name); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Determine server_id - either from existing versions or generate new one
|
||||
var serverID string
|
||||
if len(existingServerVersions) > 0 {
|
||||
// Use existing server_id from any existing version
|
||||
firstExisting := existingServerVersions[0]
|
||||
if firstExisting.Meta != nil && firstExisting.Meta.Official != nil {
|
||||
serverID = firstExisting.Meta.Official.ServerID
|
||||
// Check for duplicate remote URLs
|
||||
if err := s.validateNoDuplicateRemoteURLs(ctx, tx, serverJSON); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Check we haven't exceeded the maximum versions allowed for a server
|
||||
versionCount, err := s.db.CountServerVersions(ctx, tx, serverJSON.Name)
|
||||
if err != nil && !errors.Is(err, database.ErrNotFound) {
|
||||
return nil, err
|
||||
}
|
||||
if versionCount >= maxServerVersionsPerServer {
|
||||
return nil, database.ErrMaxServersReached
|
||||
}
|
||||
|
||||
// Check this isn't a duplicate version
|
||||
versionExists, err := s.db.CheckVersionExists(ctx, tx, serverJSON.Name, serverJSON.Version)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if versionExists {
|
||||
return nil, database.ErrInvalidVersion
|
||||
}
|
||||
|
||||
// Get current latest version to determine if new version should be latest
|
||||
currentLatest, err := s.db.GetCurrentLatestVersion(ctx, tx, serverJSON.Name)
|
||||
if err != nil && !errors.Is(err, database.ErrNotFound) {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Determine if this version should be marked as latest
|
||||
isNewLatest := true
|
||||
if currentLatest != nil {
|
||||
var existingPublishedAt time.Time
|
||||
if currentLatest.Meta.Official != nil {
|
||||
existingPublishedAt = currentLatest.Meta.Official.PublishedAt
|
||||
}
|
||||
isNewLatest = CompareVersions(
|
||||
serverJSON.Version,
|
||||
currentLatest.Server.Version,
|
||||
publishTime,
|
||||
existingPublishedAt,
|
||||
) > 0
|
||||
}
|
||||
|
||||
// Unmark old latest version if needed
|
||||
if isNewLatest && currentLatest != nil {
|
||||
if err := s.db.UnmarkAsLatest(ctx, tx, serverJSON.Name); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
if serverID == "" {
|
||||
// This is the first version of a new server
|
||||
serverID = uuid.New().String()
|
||||
}
|
||||
|
||||
// Set registry metadata
|
||||
server.Meta.Official = &apiv0.RegistryExtensions{
|
||||
ServerID: serverID,
|
||||
VersionID: uuid.New().String(),
|
||||
// Create metadata for the new server
|
||||
officialMeta := &apiv0.RegistryExtensions{
|
||||
Status: model.StatusActive, /* New versions are active by default */
|
||||
PublishedAt: publishTime,
|
||||
UpdatedAt: publishTime,
|
||||
IsLatest: isNewLatest,
|
||||
}
|
||||
|
||||
return server
|
||||
// Insert new server version
|
||||
return s.db.CreateServer(ctx, tx, &serverJSON, officialMeta)
|
||||
}
|
||||
|
||||
// validateNoDuplicateRemoteURLs checks that no other server is using the same remote URLs
|
||||
|
|
@ -252,15 +169,15 @@ func (s *registryServiceImpl) validateNoDuplicateRemoteURLs(ctx context.Context,
|
|||
// Use filter to find servers with this remote URL
|
||||
filter := &database.ServerFilter{RemoteURL: &remote.URL}
|
||||
|
||||
conflictingServers, _, err := s.db.List(ctx, tx, filter, "", 1000)
|
||||
conflictingServers, _, err := s.db.ListServers(ctx, tx, filter, "", 1000)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to check remote URL conflict: %w", err)
|
||||
}
|
||||
|
||||
// Check if any conflicting server has a different name
|
||||
for _, conflictingServer := range conflictingServers {
|
||||
if conflictingServer.Name != serverDetail.Name {
|
||||
return fmt.Errorf("remote URL %s is already used by server %s", remote.URL, conflictingServer.Name)
|
||||
if conflictingServer.Server.Name != serverDetail.Name {
|
||||
return fmt.Errorf("remote URL %s is already used by server %s", remote.URL, conflictingServer.Server.Name)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -268,62 +185,83 @@ func (s *registryServiceImpl) validateNoDuplicateRemoteURLs(ctx context.Context,
|
|||
return nil
|
||||
}
|
||||
|
||||
// getCurrentLatestVersion finds the current latest version from existing server versions
|
||||
func (s *registryServiceImpl) getCurrentLatestVersion(existingServerVersions []*apiv0.ServerJSON) *apiv0.ServerJSON {
|
||||
for _, server := range existingServerVersions {
|
||||
if server.Meta != nil && server.Meta.Official != nil &&
|
||||
server.Meta.Official.IsLatest {
|
||||
return server
|
||||
}
|
||||
}
|
||||
return nil
|
||||
// UpdateServer updates an existing server with new details
|
||||
func (s *registryServiceImpl) UpdateServer(ctx context.Context, serverName, version string, req *apiv0.ServerJSON, newStatus *string) (*apiv0.ServerResponse, error) {
|
||||
// Wrap the entire operation in a transaction
|
||||
return database.InTransactionT(ctx, s.db, func(ctx context.Context, tx pgx.Tx) (*apiv0.ServerResponse, error) {
|
||||
return s.updateServerInTransaction(ctx, tx, serverName, version, req, newStatus)
|
||||
})
|
||||
}
|
||||
|
||||
// EditServer updates an existing server with new details (admin operation)
|
||||
func (s *registryServiceImpl) EditServer(versionID string, req apiv0.ServerJSON) (*apiv0.ServerJSON, error) {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
|
||||
// Validate the request
|
||||
if err := validators.ValidatePublishRequest(req, s.cfg); err != nil {
|
||||
// updateServerInTransaction contains the actual UpdateServer logic within a transaction
|
||||
func (s *registryServiceImpl) updateServerInTransaction(ctx context.Context, tx pgx.Tx, serverName, version string, req *apiv0.ServerJSON, newStatus *string) (*apiv0.ServerResponse, error) {
|
||||
// Get current server to check if it's deleted or being deleted
|
||||
currentServer, err := s.db.GetServerByNameAndVersion(ctx, tx, serverName, version)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return database.InTransactionT(ctx, s.db, func(txCtx context.Context, tx pgx.Tx) (*apiv0.ServerJSON, error) {
|
||||
// Get the current server to preserve metadata
|
||||
currentServer, err := s.db.GetByVersionID(txCtx, tx, versionID)
|
||||
// Skip registry validation if:
|
||||
// 1. Server is currently deleted, OR
|
||||
// 2. Server is being set to deleted status
|
||||
currentlyDeleted := currentServer.Meta.Official != nil && currentServer.Meta.Official.Status == model.StatusDeleted
|
||||
beingDeleted := newStatus != nil && *newStatus == string(model.StatusDeleted)
|
||||
skipRegistryValidation := currentlyDeleted || beingDeleted
|
||||
|
||||
// Validate the request, potentially skipping registry validation for deleted servers
|
||||
if err := s.validateUpdateRequest(ctx, *req, skipRegistryValidation); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Acquire advisory lock to prevent concurrent edits of servers with same name
|
||||
if err := s.db.AcquirePublishLock(ctx, tx, serverName); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Merge the request with the current server, preserving metadata
|
||||
updatedServer := *req
|
||||
|
||||
// Check for duplicate remote URLs using the updated server
|
||||
if err := s.validateNoDuplicateRemoteURLs(ctx, tx, updatedServer); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Update server in database
|
||||
updatedServerResponse, err := s.db.UpdateServer(ctx, tx, serverName, version, &updatedServer)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Handle status change if provided
|
||||
if newStatus != nil {
|
||||
updatedWithStatus, err := s.db.SetServerStatus(ctx, tx, serverName, version, *newStatus)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return updatedWithStatus, nil
|
||||
}
|
||||
|
||||
// Acquire advisory lock to prevent concurrent edits of servers with same name
|
||||
if err := s.db.AcquirePublishLock(txCtx, tx, currentServer.Name); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Merge the request with the current server, preserving metadata
|
||||
updatedServer := *currentServer
|
||||
|
||||
// Update only the user-modifiable fields from the request
|
||||
updatedServer.Name = req.Name
|
||||
updatedServer.Description = req.Description
|
||||
updatedServer.Version = req.Version
|
||||
updatedServer.Status = req.Status
|
||||
updatedServer.Repository = req.Repository
|
||||
updatedServer.Remotes = req.Remotes
|
||||
updatedServer.Packages = req.Packages
|
||||
|
||||
// Update the UpdatedAt timestamp in metadata
|
||||
if updatedServer.Meta != nil && updatedServer.Meta.Official != nil {
|
||||
updatedServer.Meta.Official.UpdatedAt = time.Now()
|
||||
}
|
||||
|
||||
// Check for duplicate remote URLs using the updated server
|
||||
if err := s.validateNoDuplicateRemoteURLs(txCtx, tx, updatedServer); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Update server in database
|
||||
return s.db.UpdateServer(txCtx, tx, versionID, &updatedServer)
|
||||
})
|
||||
return updatedServerResponse, nil
|
||||
}
|
||||
|
||||
// validateUpdateRequest validates an update request with optional registry validation skipping
|
||||
func (s *registryServiceImpl) validateUpdateRequest(ctx context.Context, req apiv0.ServerJSON, skipRegistryValidation bool) error {
|
||||
// Always validate the server JSON structure
|
||||
if err := validators.ValidateServerJSON(&req); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Skip registry validation if requested (for deleted servers)
|
||||
if skipRegistryValidation || !s.cfg.EnableRegistryValidation {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Perform registry validation for all packages
|
||||
for i, pkg := range req.Packages {
|
||||
if err := validators.ValidatePackage(ctx, pkg, req.Name); err != nil {
|
||||
return fmt.Errorf("registry validation failed for package %d (%s): %w", i, pkg.Identifier, err)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,15 +6,19 @@ import (
|
|||
"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": {
|
||||
|
|
@ -39,11 +43,10 @@ func TestValidateNoDuplicateRemoteURLs(t *testing.T) {
|
|||
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.Publish(*server)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to publish server: %v", err)
|
||||
}
|
||||
_, err := service.CreateServer(ctx, server)
|
||||
require.NoError(t, err, "failed to create server: %v", err)
|
||||
}
|
||||
|
||||
tests := []struct {
|
||||
|
|
@ -65,7 +68,7 @@ func TestValidateNoDuplicateRemoteURLs(t *testing.T) {
|
|||
{
|
||||
name: "new unique remote URLs - should pass",
|
||||
serverDetail: apiv0.ServerJSON{
|
||||
Name: "com.example/new-server",
|
||||
Name: "com.example/new-server-unique",
|
||||
Description: "A new server",
|
||||
Version: "1.0.0",
|
||||
Remotes: []model.Transport{
|
||||
|
|
@ -78,7 +81,7 @@ func TestValidateNoDuplicateRemoteURLs(t *testing.T) {
|
|||
{
|
||||
name: "duplicate remote URL - should fail",
|
||||
serverDetail: apiv0.ServerJSON{
|
||||
Name: "com.example/new-server",
|
||||
Name: "com.example/new-server-duplicate",
|
||||
Description: "A new server with duplicate URL",
|
||||
Version: "1.0.0",
|
||||
Remotes: []model.Transport{
|
||||
|
|
@ -93,7 +96,7 @@ func TestValidateNoDuplicateRemoteURLs(t *testing.T) {
|
|||
serverDetail: apiv0.ServerJSON{
|
||||
Name: "com.example/existing-server", // Same name as existing
|
||||
Description: "Updated existing server",
|
||||
Version: "1.1.0",
|
||||
Version: "1.1.0", // Different version
|
||||
Remotes: []model.Transport{
|
||||
{Type: "streamable-http", URL: "https://api.example.com/mcp"}, // Same URL as before
|
||||
},
|
||||
|
|
@ -104,7 +107,6 @@ func TestValidateNoDuplicateRemoteURLs(t *testing.T) {
|
|||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
impl := service.(*registryServiceImpl)
|
||||
|
||||
err := impl.validateNoDuplicateRemoteURLs(ctx, nil, tt.serverDetail)
|
||||
|
|
@ -119,59 +121,55 @@ func TestValidateNoDuplicateRemoteURLs(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
func TestGetByServerID(t *testing.T) {
|
||||
func TestGetServerByName(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
testDB := database.NewTestDB(t)
|
||||
service := NewRegistryService(testDB, &config.Config{EnableRegistryValidation: false})
|
||||
|
||||
// Publish multiple versions of the same server
|
||||
server1, err := service.Publish(apiv0.ServerJSON{
|
||||
// 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",
|
||||
})
|
||||
assert.NoError(t, err)
|
||||
require.NoError(t, err)
|
||||
|
||||
_, err = service.Publish(apiv0.ServerJSON{
|
||||
_, err = service.CreateServer(ctx, &apiv0.ServerJSON{
|
||||
Name: "com.example/test-server",
|
||||
Description: "Test server v2",
|
||||
Version: "2.0.0",
|
||||
})
|
||||
assert.NoError(t, err)
|
||||
require.NoError(t, err)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
serverID string
|
||||
serverName string
|
||||
expectError bool
|
||||
errorMsg string
|
||||
checkResult func(*testing.T, *apiv0.ServerJSON)
|
||||
checkResult func(*testing.T, *apiv0.ServerResponse)
|
||||
}{
|
||||
{
|
||||
name: "get latest version by server ID",
|
||||
serverID: server1.Meta.Official.ServerID,
|
||||
name: "get latest version by server name",
|
||||
serverName: "com.example/test-server",
|
||||
expectError: false,
|
||||
checkResult: func(t *testing.T, result *apiv0.ServerJSON) {
|
||||
checkResult: func(t *testing.T, result *apiv0.ServerResponse) {
|
||||
t.Helper()
|
||||
assert.Equal(t, "2.0.0", result.Version) // Should get latest version
|
||||
assert.Equal(t, "Test server v2", result.Description)
|
||||
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",
|
||||
serverID: "00000000-0000-0000-0000-000000000000",
|
||||
serverName: "com.example/non-existent",
|
||||
expectError: true,
|
||||
errorMsg: "record not found",
|
||||
},
|
||||
{
|
||||
name: "invalid server ID format",
|
||||
serverID: "invalid-uuid",
|
||||
expectError: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result, err := service.GetByServerID(tt.serverID)
|
||||
result, err := service.GetServerByName(ctx, tt.serverName)
|
||||
|
||||
if tt.expectError {
|
||||
assert.Error(t, err)
|
||||
|
|
@ -190,82 +188,79 @@ func TestGetByServerID(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
func TestGetByServerIDAndVersion(t *testing.T) {
|
||||
func TestGetServerByNameAndVersion(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
testDB := database.NewTestDB(t)
|
||||
service := NewRegistryService(testDB, &config.Config{EnableRegistryValidation: false})
|
||||
|
||||
// Publish multiple versions of the same server
|
||||
server1, err := service.Publish(apiv0.ServerJSON{
|
||||
Name: "com.example/versioned-server",
|
||||
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",
|
||||
})
|
||||
assert.NoError(t, err)
|
||||
require.NoError(t, err)
|
||||
|
||||
_, err = service.Publish(apiv0.ServerJSON{
|
||||
Name: "com.example/versioned-server",
|
||||
_, err = service.CreateServer(ctx, &apiv0.ServerJSON{
|
||||
Name: serverName,
|
||||
Description: "Versioned server v2",
|
||||
Version: "2.0.0",
|
||||
})
|
||||
assert.NoError(t, err)
|
||||
require.NoError(t, err)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
serverID string
|
||||
serverName string
|
||||
version string
|
||||
expectError bool
|
||||
errorMsg string
|
||||
checkResult func(*testing.T, *apiv0.ServerJSON)
|
||||
checkResult func(*testing.T, *apiv0.ServerResponse)
|
||||
}{
|
||||
{
|
||||
name: "get specific version 1.0.0",
|
||||
serverID: server1.Meta.Official.ServerID,
|
||||
serverName: serverName,
|
||||
version: "1.0.0",
|
||||
expectError: false,
|
||||
checkResult: func(t *testing.T, result *apiv0.ServerJSON) {
|
||||
checkResult: func(t *testing.T, result *apiv0.ServerResponse) {
|
||||
t.Helper()
|
||||
assert.Equal(t, "1.0.0", result.Version)
|
||||
assert.Equal(t, "Versioned server v1", result.Description)
|
||||
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",
|
||||
serverID: server1.Meta.Official.ServerID,
|
||||
serverName: serverName,
|
||||
version: "2.0.0",
|
||||
expectError: false,
|
||||
checkResult: func(t *testing.T, result *apiv0.ServerJSON) {
|
||||
checkResult: func(t *testing.T, result *apiv0.ServerResponse) {
|
||||
t.Helper()
|
||||
assert.Equal(t, "2.0.0", result.Version)
|
||||
assert.Equal(t, "Versioned server v2", result.Description)
|
||||
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",
|
||||
serverID: server1.Meta.Official.ServerID,
|
||||
serverName: serverName,
|
||||
version: "3.0.0",
|
||||
expectError: true,
|
||||
errorMsg: "record not found",
|
||||
},
|
||||
{
|
||||
name: "server not found",
|
||||
serverID: "00000000-0000-0000-0000-000000000000",
|
||||
serverName: "com.example/non-existent",
|
||||
version: "1.0.0",
|
||||
expectError: true,
|
||||
errorMsg: "record not found",
|
||||
},
|
||||
{
|
||||
name: "invalid server ID format",
|
||||
serverID: "invalid-uuid",
|
||||
version: "1.0.0",
|
||||
expectError: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result, err := service.GetByServerIDAndVersion(tt.serverID, tt.version)
|
||||
result, err := service.GetServerByNameAndVersion(ctx, tt.serverName, tt.version)
|
||||
|
||||
if tt.expectError {
|
||||
assert.Error(t, err)
|
||||
|
|
@ -284,44 +279,47 @@ func TestGetByServerIDAndVersion(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
func TestGetAllVersionsByServerID(t *testing.T) {
|
||||
func TestGetAllVersionsByServerName(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
testDB := database.NewTestDB(t)
|
||||
service := NewRegistryService(testDB, &config.Config{EnableRegistryValidation: false})
|
||||
|
||||
// Publish multiple versions of the same server
|
||||
server1, err := service.Publish(apiv0.ServerJSON{
|
||||
Name: "com.example/multi-version-server",
|
||||
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",
|
||||
})
|
||||
assert.NoError(t, err)
|
||||
require.NoError(t, err)
|
||||
|
||||
_, err = service.Publish(apiv0.ServerJSON{
|
||||
Name: "com.example/multi-version-server",
|
||||
_, err = service.CreateServer(ctx, &apiv0.ServerJSON{
|
||||
Name: serverName,
|
||||
Description: "Multi-version server v2",
|
||||
Version: "2.0.0",
|
||||
})
|
||||
assert.NoError(t, err)
|
||||
require.NoError(t, err)
|
||||
|
||||
_, err = service.Publish(apiv0.ServerJSON{
|
||||
Name: "com.example/multi-version-server",
|
||||
_, err = service.CreateServer(ctx, &apiv0.ServerJSON{
|
||||
Name: serverName,
|
||||
Description: "Multi-version server v2.1",
|
||||
Version: "2.1.0",
|
||||
})
|
||||
assert.NoError(t, err)
|
||||
require.NoError(t, err)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
serverID string
|
||||
serverName string
|
||||
expectError bool
|
||||
errorMsg string
|
||||
checkResult func(*testing.T, []apiv0.ServerJSON)
|
||||
checkResult func(*testing.T, []*apiv0.ServerResponse)
|
||||
}{
|
||||
{
|
||||
name: "get all versions of server",
|
||||
serverID: server1.Meta.Official.ServerID,
|
||||
serverName: serverName,
|
||||
expectError: false,
|
||||
checkResult: func(t *testing.T, result []apiv0.ServerJSON) {
|
||||
checkResult: func(t *testing.T, result []*apiv0.ServerResponse) {
|
||||
t.Helper()
|
||||
assert.Len(t, result, 3)
|
||||
|
||||
|
|
@ -329,9 +327,8 @@ func TestGetAllVersionsByServerID(t *testing.T) {
|
|||
versions := make([]string, 0, len(result))
|
||||
latestCount := 0
|
||||
for _, server := range result {
|
||||
versions = append(versions, server.Version)
|
||||
assert.Equal(t, server1.Meta.Official.ServerID, server.Meta.Official.ServerID)
|
||||
assert.Equal(t, "com.example/multi-version-server", server.Name)
|
||||
versions = append(versions, server.Server.Version)
|
||||
assert.Equal(t, serverName, server.Server.Name)
|
||||
if server.Meta.Official.IsLatest {
|
||||
latestCount++
|
||||
}
|
||||
|
|
@ -348,20 +345,15 @@ func TestGetAllVersionsByServerID(t *testing.T) {
|
|||
},
|
||||
{
|
||||
name: "server not found",
|
||||
serverID: "00000000-0000-0000-0000-000000000000",
|
||||
serverName: "com.example/non-existent",
|
||||
expectError: true,
|
||||
errorMsg: "record not found",
|
||||
},
|
||||
{
|
||||
name: "invalid server ID format",
|
||||
serverID: "invalid-uuid",
|
||||
expectError: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result, err := service.GetAllVersionsByServerID(tt.serverID)
|
||||
result, err := service.GetAllVersionsByServerName(ctx, tt.serverName)
|
||||
|
||||
if tt.expectError {
|
||||
assert.Error(t, err)
|
||||
|
|
@ -380,21 +372,23 @@ func TestGetAllVersionsByServerID(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
func TestPublishConcurrentVersionsNoRace(t *testing.T) {
|
||||
func TestCreateServerConcurrentVersionsNoRace(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
testDB := database.NewTestDB(t)
|
||||
service := NewRegistryService(testDB, &config.Config{EnableRegistryValidation: false})
|
||||
|
||||
const concurrency = 100
|
||||
results := make([]*apiv0.ServerJSON, concurrency)
|
||||
serverName := "com.example/test-concurrent"
|
||||
results := make([]*apiv0.ServerResponse, concurrency)
|
||||
errors := make([]error, concurrency)
|
||||
|
||||
var wg sync.WaitGroup
|
||||
for i := range concurrency {
|
||||
for i := 0; i < concurrency; i++ {
|
||||
wg.Add(1)
|
||||
go func(idx int) {
|
||||
defer wg.Done()
|
||||
result, err := service.Publish(apiv0.ServerJSON{
|
||||
Name: "com.example/test-concurrent",
|
||||
result, err := service.CreateServer(ctx, &apiv0.ServerJSON{
|
||||
Name: serverName,
|
||||
Description: fmt.Sprintf("Version %d", idx),
|
||||
Version: fmt.Sprintf("1.0.%d", idx),
|
||||
})
|
||||
|
|
@ -404,40 +398,372 @@ func TestPublishConcurrentVersionsNoRace(t *testing.T) {
|
|||
}
|
||||
wg.Wait()
|
||||
|
||||
// All publishes should succeed
|
||||
for i, err := range errors {
|
||||
assert.NoError(t, err, "publish %d failed", i)
|
||||
assert.NoError(t, err, "create server %d failed", i)
|
||||
}
|
||||
|
||||
var sharedServerID string
|
||||
// All results should have the same server name
|
||||
for i, result := range results {
|
||||
if result != nil && result.Meta != nil && result.Meta.Official != nil {
|
||||
if sharedServerID == "" {
|
||||
sharedServerID = result.Meta.Official.ServerID
|
||||
}
|
||||
assert.Equal(t, sharedServerID, result.Meta.Official.ServerID,
|
||||
"version %d has different serverID", i)
|
||||
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 publishes complete
|
||||
// This is necessary because the returned results reflect state at publish time,
|
||||
// but concurrent publishes may have updated the latest flag since then
|
||||
filter := &database.ServerFilter{Name: strPtr("com.example/test-concurrent")}
|
||||
dbResults, _, err := testDB.List(context.Background(), nil, filter, "", 1000)
|
||||
assert.NoError(t, err, "failed to query database")
|
||||
// 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 dbResults {
|
||||
if r.Meta != nil && r.Meta.Official != nil && r.Meta.Official.IsLatest {
|
||||
for _, r := range allVersions {
|
||||
if r.Meta.Official.IsLatest {
|
||||
latestCount++
|
||||
latestVersion = r.Version
|
||||
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 strPtr(s string) *string {
|
||||
return &s
|
||||
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
|
||||
}
|
||||
|
|
@ -1,24 +1,24 @@
|
|||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/modelcontextprotocol/registry/internal/database"
|
||||
apiv0 "github.com/modelcontextprotocol/registry/pkg/api/v0"
|
||||
)
|
||||
|
||||
// RegistryService defines the interface for registry operations
|
||||
type RegistryService interface {
|
||||
// Retrieve all servers with optional filtering
|
||||
List(filter *database.ServerFilter, cursor string, limit int) ([]apiv0.ServerJSON, string, error)
|
||||
// Retrieve a single server by registry metadata version ID
|
||||
GetByVersionID(versionID string) (*apiv0.ServerJSON, error)
|
||||
// Retrieve latest version of a server by server ID
|
||||
GetByServerID(serverID string) (*apiv0.ServerJSON, error)
|
||||
// Retrieve specific version of a server by server ID and version
|
||||
GetByServerIDAndVersion(serverID string, version string) (*apiv0.ServerJSON, error)
|
||||
// Retrieve all versions of a server by server ID
|
||||
GetAllVersionsByServerID(serverID string) ([]apiv0.ServerJSON, error)
|
||||
// Publish a server
|
||||
Publish(req apiv0.ServerJSON) (*apiv0.ServerJSON, error)
|
||||
// Update an existing server
|
||||
EditServer(id string, req apiv0.ServerJSON) (*apiv0.ServerJSON, error)
|
||||
// ListServers retrieve all servers with optional filtering
|
||||
ListServers(ctx context.Context, filter *database.ServerFilter, cursor string, limit int) ([]*apiv0.ServerResponse, string, error)
|
||||
// GetServerByName retrieve latest version of a server by server name
|
||||
GetServerByName(ctx context.Context, serverName string) (*apiv0.ServerResponse, error)
|
||||
// GetServerByNameAndVersion retrieve specific version of a server by server name and version
|
||||
GetServerByNameAndVersion(ctx context.Context, serverName string, version string) (*apiv0.ServerResponse, error)
|
||||
// GetAllVersionsByServerName retrieve all versions of a server by server name
|
||||
GetAllVersionsByServerName(ctx context.Context, serverName string) ([]*apiv0.ServerResponse, error)
|
||||
// CreateServer creates a new server version
|
||||
CreateServer(ctx context.Context, req *apiv0.ServerJSON) (*apiv0.ServerResponse, error)
|
||||
// UpdateServer updates an existing server and optionally its status
|
||||
UpdateServer(ctx context.Context, serverName, version string, req *apiv0.ServerJSON, newStatus *string) (*apiv0.ServerResponse, error)
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue