registry/internal/database/import_test.go

package database_test

import (
	"context"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"os"
	"testing"
	"time"

	"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"
)

func TestReadSeedFile_LocalFile(t *testing.T) {
	// Create a temporary seed file in extension wrapper format
	tempFile := "/tmp/test_seed.json"
	seedData := []apiv0.ServerJSON{
		{
			Name:        "com.example/test-server-1",
			Description: "Test server 1",
			Repository: model.Repository{
				URL:    "https://github.com/test/repo1",
				Source: "github",
				ID:     "123",
			},
			VersionDetail: model.VersionDetail{
				Version: "1.0.0",
			},
			Remotes: []model.Remote{
				{
					URL: "https://example.com/remote",
				},
			},
			Meta: &apiv0.ServerMeta{
				IOModelContextProtocolRegistry: &apiv0.RegistryExtensions{
					ID:          "test-id-1",
					PublishedAt: time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC),
					IsLatest:    true,
					ReleaseDate: "2023-01-01T00:00:00Z",
				},
			},
		},
	}

	// Write seed data to temp file
	data, err := json.Marshal(seedData)
	assert.NoError(t, err)

	err = func() error {
		f, err := os.Create(tempFile)
		if err != nil {
			return err
		}
		defer f.Close()
		_, err = f.Write(data)
		return err
	}()
	assert.NoError(t, err)
	defer os.Remove(tempFile)

	// Test reading the file
	result, err := database.ReadSeedFile(context.Background(), tempFile)
	assert.NoError(t, err)
	assert.Len(t, result, 1)
	assert.Equal(t, "com.example/test-server-1", result[0].Name)
}

func TestReadSeedFile_DirectHTTPURL(t *testing.T) {
	// Create a test HTTP server that serves seed JSON directly in extension wrapper format
	seedData := []apiv0.ServerJSON{
		{
			Name:        "com.example/test-server-1",
			Description: "Test server 1",
			Remotes: []model.Remote{
				{
					URL: "https://example.com/remote",
				},
			},
			Meta: &apiv0.ServerMeta{
				IOModelContextProtocolRegistry: &apiv0.RegistryExtensions{
					ID:          "test-id-1",
					PublishedAt: time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC),
					IsLatest:    true,
					ReleaseDate: "2023-01-01T00:00:00Z",
				},
			},
		},
	}

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		if err := json.NewEncoder(w).Encode(seedData); err != nil {
			http.Error(w, "Failed to encode JSON", http.StatusInternalServerError)
		}
	}))
	defer server.Close()

	// Test reading from HTTP URL ending in .json
	result, err := database.ReadSeedFile(context.Background(), server.URL+"/seed.json")
	assert.NoError(t, err)
	assert.Len(t, result, 1)
	assert.Equal(t, "com.example/test-server-1", result[0].Name)
}

func TestReadSeedFile_RegistryURL(t *testing.T) {
	// Create mock registry responses
	server1 := apiv0.ServerJSON{
		Name:        "Test Server 1",
		Description: "First test server",
		Packages: []model.Package{
			{
				RegistryType:    "npm",
				RegistryBaseURL: "https://registry.npmjs.org",
				Identifier:      "test-package-1",
				Version:         "1.0.0",
			},
		},
		Meta: &apiv0.ServerMeta{
			IOModelContextProtocolRegistry: &apiv0.RegistryExtensions{
				ID:          "server-1",
				PublishedAt: time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC),
				IsLatest:    true,
				ReleaseDate: "2023-01-01T00:00:00Z",
			},
		},
	}
	server2 := apiv0.ServerJSON{
		Name:        "Test Server 2",
		Description: "Second test server",
		Packages: []model.Package{
			{
				RegistryType:    "npm",
				RegistryBaseURL: "https://registry.npmjs.org",
				Identifier:      "test-package-2",
				Version:         "2.0.0",
			},
		},
		Meta: &apiv0.ServerMeta{
			IOModelContextProtocolRegistry: &apiv0.RegistryExtensions{
				ID:          "server-2",
				PublishedAt: time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC),
				IsLatest:    true,
				ReleaseDate: "2023-01-01T00:00:00Z",
			},
		},
	}

	serverDetail1 := apiv0.ServerJSON{
		Name:        "Test Server 1",
		Description: "First test server",
		Packages: []model.Package{
			{
				RegistryType:    "npm",
				RegistryBaseURL: "https://registry.npmjs.org",
				Identifier:      "test-package-1",
				Version:         "1.0.0",
			},
		},
	}
	serverDetail2 := apiv0.ServerJSON{
		Name:        "Test Server 2",
		Description: "Second test server",
		Packages: []model.Package{
			{
				RegistryType:    "npm",
				RegistryBaseURL: "https://registry.npmjs.org",
				Identifier:      "test-package-2",
				Version:         "2.0.0",
			},
		},
	}

	// Create a test HTTP server that simulates the registry API
	mux := http.NewServeMux()

	// Handle /v0/servers endpoint (paginated)
	mux.HandleFunc("/v0/servers", func(w http.ResponseWriter, r *http.Request) {
		cursor := r.URL.Query().Get("cursor")

		type Metadata struct {
			NextCursor string `json:"next_cursor,omitempty"`
			Count      int    `json:"count,omitempty"`
		}

		type PaginatedResponse struct {
			Servers  []apiv0.ServerJSON `json:"servers"`
			Metadata *Metadata          `json:"metadata,omitempty"`
		}

		var response PaginatedResponse
		switch cursor {
		case "":
			// First page
			response = PaginatedResponse{
				Servers: []apiv0.ServerJSON{server1},
				Metadata: &Metadata{
					NextCursor: "next-cursor-1",
					Count:      1,
				},
			}
		case "next-cursor-1":
			// Second page
			response = PaginatedResponse{
				Servers: []apiv0.ServerJSON{server2},
				Metadata: &Metadata{
					Count: 1,
					// No NextCursor means end of pagination
				},
			}
		default:
			// No more pages
			response = PaginatedResponse{
				Servers:  []apiv0.ServerJSON{},
				Metadata: &Metadata{},
			}
		}

		w.Header().Set("Content-Type", "application/json")
		if err := json.NewEncoder(w).Encode(response); err != nil {
			http.Error(w, "Failed to encode JSON", http.StatusInternalServerError)
		}
	})

	// Handle individual server detail endpoints
	mux.HandleFunc("/v0/servers/server-1", func(w http.ResponseWriter, _ *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		if err := json.NewEncoder(w).Encode(serverDetail1); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
	})

	mux.HandleFunc("/v0/servers/server-2", func(w http.ResponseWriter, _ *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		if err := json.NewEncoder(w).Encode(serverDetail2); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
	})

	server := httptest.NewServer(mux)
	defer server.Close()

	// Test reading from registry root URL (this should trigger pagination)
	result, err := database.ReadSeedFile(context.Background(), server.URL+"/v0/servers")
	assert.NoError(t, err)
	assert.Len(t, result, 2)

	// Verify the servers were imported correctly
	assert.Equal(t, "Test Server 1", result[0].Name)
	assert.Equal(t, "Test Server 2", result[1].Name)

	// Verify packages were imported with new schema
	assert.Len(t, result[0].Packages, 1)
	assert.Equal(t, "npm", result[0].Packages[0].RegistryType)
	assert.Equal(t, "https://registry.npmjs.org", result[0].Packages[0].RegistryBaseURL)
	assert.Equal(t, "test-package-1", result[0].Packages[0].Identifier)
	assert.Len(t, result[1].Packages, 1)
	assert.Equal(t, "npm", result[1].Packages[0].RegistryType)
	assert.Equal(t, "https://registry.npmjs.org", result[1].Packages[0].RegistryBaseURL)
	assert.Equal(t, "test-package-2", result[1].Packages[0].Identifier)

	// Verify metadata was extracted
	assert.Equal(t, "server-1", result[0].Meta.IOModelContextProtocolRegistry.ID)
	assert.Equal(t, "server-2", result[1].Meta.IOModelContextProtocolRegistry.ID)
}