tests: treat only deleted servers as reusable for remote URL validation

internal/service/registry_service.go

@@ -176,8 +176,11 @@ func (s *registryServiceImpl) validateNoDuplicateRemoteURLs(ctx context.Context,
 			return fmt.Errorf("failed to check remote URL conflict: %w", err)
 		}
 
-		// Check if any conflicting server has a different name
+		// Only active servers reserve remote URLs.
 		for _, conflictingServer := range conflictingServers {
+			if conflictingServer.Meta.Official != nil && conflictingServer.Meta.Official.Status != model.StatusActive {
+				continue
+			}
 			if conflictingServer.Server.Name != serverDetail.Name {
 				return fmt.Errorf("remote URL %s is already used by server %s", remote.URL, conflictingServer.Server.Name)
 			}
@@ -269,10 +272,10 @@ func (s *registryServiceImpl) updateServerStatusInTransaction(ctx context.Contex
 		return nil, err
 	}
 
-	// When transitioning to active from deleted, validate remote URLs don't conflict
+	// When transitioning to active from a non-active status, validate remote URLs don't conflict.
 	if statusChange.NewStatus == model.StatusActive &&
 		currentServer.Meta.Official != nil &&
-		currentServer.Meta.Official.Status == model.StatusDeleted {
+		currentServer.Meta.Official.Status != model.StatusActive {
 		if err := s.validateNoDuplicateRemoteURLs(ctx, tx, currentServer.Server); err != nil {
 			return nil, err
 		}
@@ -297,11 +300,10 @@ func (s *registryServiceImpl) updateAllVersionsStatusInTransaction(ctx context.C
 		return nil, err
 	}
 
-	// When transitioning to active, validate remote URLs for any versions currently deleted
+	// When transitioning to active, validate remote URLs for any versions that are currently non-active.
 	if statusChange.NewStatus == model.StatusActive {
 		includeDeleted := true
 
-		// When transitioning to active, it means the current status is either deprecated or deleted, so it should include deleted server also
 		filter := &database.ServerFilter{Name: &serverName, IncludeDeleted: &includeDeleted}
 		versions, _, err := s.db.ListServers(ctx, tx, filter, "", 1000)
 		if err != nil {
@@ -310,7 +312,7 @@ func (s *registryServiceImpl) updateAllVersionsStatusInTransaction(ctx context.C
 
 		for _, version := range versions {
 			if version.Meta.Official != nil &&
-				version.Meta.Official.Status == model.StatusDeleted {
+				version.Meta.Official.Status != model.StatusActive {
 				if err := s.validateNoDuplicateRemoteURLs(ctx, tx, version.Server); err != nil {
 					return nil, err
 				}

internal/service/registry_service_test.go

@@ -52,6 +52,22 @@ func TestValidateNoDuplicateRemoteURLs(t *testing.T) {
 		require.NoError(t, err, "failed to create server: %v", err)
 	}
 
+	deprecatedServer := &apiv0.ServerJSON{
+		Schema:      model.CurrentSchemaURL,
+		Name:        "com.example/deprecated-server",
+		Description: "A deprecated server",
+		Version:     "1.0.0",
+		Remotes: []model.Transport{
+			{Type: "streamable-http", URL: "https://deprecated.example.com/mcp"},
+		},
+	}
+	_, err := service.CreateServer(ctx, deprecatedServer)
+	require.NoError(t, err)
+	_, err = service.UpdateServerStatus(ctx, deprecatedServer.Name, deprecatedServer.Version, &StatusChangeRequest{
+		NewStatus: model.StatusDeprecated,
+	})
+	require.NoError(t, err)
+
 	tests := []struct {
 		name         string
 		serverDetail apiv0.ServerJSON
@@ -97,6 +113,19 @@ func TestValidateNoDuplicateRemoteURLs(t *testing.T) {
 			expectError: true,
 			errorMsg:    "remote URL https://api.example.com/mcp is already used by server com.example/existing-server",
 		},
+		{
+			name: "duplicate remote URL used only by deprecated server - should pass",
+			serverDetail: apiv0.ServerJSON{
+				Schema:      model.CurrentSchemaURL,
+				Name:        "com.example/new-server-with-deprecated-conflict",
+				Description: "A new server reusing a deprecated remote URL",
+				Version:     "1.0.0",
+				Remotes: []model.Transport{
+					{Type: "streamable-http", URL: "https://deprecated.example.com/mcp"},
+				},
+			},
+			expectError: false,
+		},
 		{
 			name: "updating same server with same URLs - should pass",
 			serverDetail: apiv0.ServerJSON{
@@ -889,6 +918,53 @@ func TestUpdateServerStatus_ValidateRemoteURLsOnRestoreFromDeleted(t *testing.T)
 	assert.Contains(t, err.Error(), "already used by server")
 }
 
+func TestUpdateServerStatus_ValidateRemoteURLsOnRestoreFromDeprecated(t *testing.T) {
+	ctx := context.Background()
+	testDB := database.NewTestDB(t)
+	service := NewRegistryService(testDB, &config.Config{EnableRegistryValidation: false})
+
+	remoteURL := "https://api.deprecated.com/mcp"
+
+	// Create Server A with a remote URL and deprecate it.
+	serverA := &apiv0.ServerJSON{
+		Schema:      model.CurrentSchemaURL,
+		Name:        "com.example/deprecated-server",
+		Description: "Server to be deprecated",
+		Version:     "1.0.0",
+		Remotes: []model.Transport{
+			{Type: "streamable-http", URL: remoteURL},
+		},
+	}
+	_, err := service.CreateServer(ctx, serverA)
+	require.NoError(t, err)
+
+	_, err = service.UpdateServerStatus(ctx, "com.example/deprecated-server", "1.0.0", &StatusChangeRequest{
+		NewStatus: model.StatusDeprecated,
+	})
+	require.NoError(t, err)
+
+	// Create Server B with the same remote URL (should succeed since A is deprecated).
+	serverB := &apiv0.ServerJSON{
+		Schema:      model.CurrentSchemaURL,
+		Name:        "com.example/replacement-server",
+		Description: "Replacement server with same remote URL",
+		Version:     "1.0.0",
+		Remotes: []model.Transport{
+			{Type: "streamable-http", URL: remoteURL},
+		},
+	}
+	_, err = service.CreateServer(ctx, serverB)
+	require.NoError(t, err)
+
+	// Try to restore deprecated server to active - should fail due to URL conflict.
+	_, err = service.UpdateServerStatus(ctx, "com.example/deprecated-server", "1.0.0", &StatusChangeRequest{
+		NewStatus: model.StatusActive,
+	})
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "remote URL")
+	assert.Contains(t, err.Error(), "already used by server")
+}
+
 func TestUpdateAllVersionsStatus_ValidateRemoteURLsOnRestoreToActive(t *testing.T) {
 	ctx := context.Background()
 	testDB := database.NewTestDB(t)
@@ -949,6 +1025,66 @@ func TestUpdateAllVersionsStatus_ValidateRemoteURLsOnRestoreToActive(t *testing.
 	assert.Contains(t, err.Error(), "already used by server")
 }
 
+func TestUpdateAllVersionsStatus_ValidateRemoteURLsOnRestoreFromDeprecatedToActive(t *testing.T) {
+	ctx := context.Background()
+	testDB := database.NewTestDB(t)
+	service := NewRegistryService(testDB, &config.Config{EnableRegistryValidation: false})
+
+	remoteURL := "https://api.allversions-deprecated.com/mcp"
+
+	// Create Server A with multiple versions.
+	serverAv1 := &apiv0.ServerJSON{
+		Schema:      model.CurrentSchemaURL,
+		Name:        "com.example/deprecated-multi-version-server",
+		Description: "Server A version 1",
+		Version:     "1.0.0",
+		Remotes: []model.Transport{
+			{Type: "streamable-http", URL: remoteURL},
+		},
+	}
+	_, err := service.CreateServer(ctx, serverAv1)
+	require.NoError(t, err)
+
+	serverAv2 := &apiv0.ServerJSON{
+		Schema:      model.CurrentSchemaURL,
+		Name:        "com.example/deprecated-multi-version-server",
+		Description: "Server A version 2",
+		Version:     "2.0.0",
+		Remotes: []model.Transport{
+			{Type: "streamable-http", URL: remoteURL},
+		},
+	}
+	_, err = service.CreateServer(ctx, serverAv2)
+	require.NoError(t, err)
+
+	// Deprecate all versions of Server A.
+	_, err = service.UpdateAllVersionsStatus(ctx, "com.example/deprecated-multi-version-server", &StatusChangeRequest{
+		NewStatus: model.StatusDeprecated,
+	})
+	require.NoError(t, err)
+
+	// Create Server B with the same remote URL (should succeed since A is deprecated).
+	serverB := &apiv0.ServerJSON{
+		Schema:      model.CurrentSchemaURL,
+		Name:        "com.example/active-conflicting-server",
+		Description: "Server B with same remote URL",
+		Version:     "1.0.0",
+		Remotes: []model.Transport{
+			{Type: "streamable-http", URL: remoteURL},
+		},
+	}
+	_, err = service.CreateServer(ctx, serverB)
+	require.NoError(t, err)
+
+	// Try to restore all versions of Server A to active - should fail.
+	_, err = service.UpdateAllVersionsStatus(ctx, "com.example/deprecated-multi-version-server", &StatusChangeRequest{
+		NewStatus: model.StatusActive,
+	})
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "remote URL")
+	assert.Contains(t, err.Error(), "already used by server")
+}
+
 func TestUpdateServerStatus_NoConflictWhenRestoringWithUniqueURLs(t *testing.T) {
 	ctx := context.Background()
 	testDB := database.NewTestDB(t)