#9 Major routes refactor and expansion, #15 Added API for statistics, Added search cache backend and functionality tests, Backend sync improvements

2026-09-26 16:48:40 +02:00
1 parent e86c0f8e04
commit a8a2602f50
@@ -0,0 +1,411 @@
+package server
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/testcontainers/testcontainers-go"
+	"github.com/testcontainers/testcontainers-go/wait"
+)
+
+// saveEnvVars saves the current state of relevant environment variables
+func saveEnvVars() map[string]string {
+	vars := []string{
+		"DB_HOST", "DB_PORT", "DB_USERNAME", "DB_PASSWORD", "DB_NAME",
+		"MUSIC_PATH", "CHARACTERS_PATH", "PORT", "DISABLE_SESSION_AUTH", "LOG_LEVEL",
+	}
+	saved := make(map[string]string)
+	for _, v := range vars {
+		saved[v] = os.Getenv(v)
+	}
+	return saved
+}
+
+// restoreEnvVars restores environment variables from a saved state
+func restoreEnvVars(saved map[string]string) {
+	for k, v := range saved {
+		if v == "" {
+			os.Unsetenv(k)
+		} else {
+			os.Setenv(k, v)
+		}
+	}
+}
+
+// checkTableExists returns true if the specified table exists in the database
+func checkTableExists(ctx context.Context, pool *pgxpool.Pool, tableName string) (bool, error) {
+	var exists bool
+	err := pool.QueryRow(ctx, `
+		SELECT EXISTS (
+			SELECT FROM information_schema.tables 
+			WHERE table_schema = 'public' AND table_name = $1
+		)
+	`, tableName).Scan(&exists)
+	return exists, err
+}
+
+// loadSQLDumpIntoDatabase loads a SQL dump file into a PostgreSQL database
+func loadSQLDumpIntoDatabase(t *testing.T, ctx context.Context, container testcontainers.Container, dbname, dumpPath string) error {
+	// Copy the SQL dump file to the container
+	basename := filepath.Base(dumpPath)
+	targetPath := "/tmp/" + basename
+	if err := container.CopyFileToContainer(ctx, dumpPath, targetPath, 0644); err != nil {
+		return fmt.Errorf("failed to copy dump file to container: %w", err)
+	}
+
+	// Execute psql to load the dump as the postgres superuser
+	// We execute psql inside the container, so we use localhost and port 5432 (the container's internal port)
+	// The postgres user is the superuser created by the Docker image
+	// Use sh instead of bash as postgres:15-alpine uses Alpine Linux
+	cmd := []string{"sh", "-c", "PGPASSWORD=postgres psql -h localhost -U postgres -d " + dbname + " -f " + targetPath + " -v ON_ERROR_STOP=1"}
+
+	exitCode, reader, err := container.Exec(ctx, cmd)
+	if err != nil {
+		return fmt.Errorf("failed to execute psql: %w", err)
+	}
+
+	// Read the output
+	output, err := io.ReadAll(reader)
+	if err != nil {
+		return fmt.Errorf("failed to read psql output: %w", err)
+	}
+
+	if exitCode != 0 {
+		return fmt.Errorf("psql exited with code %d, output: %s", exitCode, string(output))
+	}
+
+	t.Logf("Successfully loaded SQL dump from %s into database %s", dumpPath, dbname)
+	return nil
+}
+
+// createRoleInContainer creates a role in the PostgreSQL container
+func createRoleInContainer(t *testing.T, ctx context.Context, container testcontainers.Container, roleName, superuserPassword string) error {
+	// Get the mapped port for the container
+	mappedPort, err := container.MappedPort(ctx, "5432")
+	if err != nil {
+		return fmt.Errorf("failed to get mapped port: %w", err)
+	}
+
+	// Connect to the postgres database to create the role
+	connStr := fmt.Sprintf("host=localhost port=%s user=postgres password=postgres dbname=postgres sslmode=disable",
+		mappedPort.Port())
+
+	pool, err := pgxpool.New(ctx, connStr)
+	if err != nil {
+		return fmt.Errorf("failed to connect to postgres database: %w", err)
+	}
+	defer pool.Close()
+
+	// Check if role already exists
+	var exists bool
+	err = pool.QueryRow(ctx, "SELECT 1 FROM pg_roles WHERE rolname = $1", roleName).Scan(&exists)
+	if err == nil && exists {
+		return nil // Role already exists
+	}
+
+	// Clear any error from the role check (role might not exist, which is expected)
+	// Create the role
+	_, err = pool.Exec(ctx, fmt.Sprintf("CREATE ROLE %s WITH LOGIN PASSWORD 'testpass'", roleName))
+	if err != nil {
+		return fmt.Errorf("failed to create role %s: %w", roleName, err)
+	}
+
+	return nil
+}
+
+// createDatabaseInContainer creates a new database in the PostgreSQL container
+func createDatabaseInContainer(t *testing.T, ctx context.Context, container testcontainers.Container, dbname string) error {
+	// Get the mapped port for the container
+	mappedPort, err := container.MappedPort(ctx, "5432")
+	if err != nil {
+		return fmt.Errorf("failed to get mapped port: %w", err)
+	}
+
+	// Add a small delay to ensure PostgreSQL is fully ready
+	time.Sleep(2 * time.Second)
+
+	// Connect to the default 'postgres' database to create the new database
+	// Use localhost and the mapped port
+	connStr := fmt.Sprintf("host=localhost port=%s user=postgres password=postgres dbname=postgres sslmode=disable",
+		mappedPort.Port())
+
+	pool, err := pgxpool.New(ctx, connStr)
+	if err != nil {
+		return fmt.Errorf("failed to connect to postgres database: %w", err)
+	}
+	defer pool.Close()
+
+	// Check if database already exists and drop it if so
+	var exists int
+	err = pool.QueryRow(ctx, "SELECT 1 FROM pg_database WHERE datname = $1", dbname).Scan(&exists)
+	if err == nil && exists == 1 {
+		_, err = pool.Exec(ctx, "DROP DATABASE "+dbname+" WITH (FORCE)")
+		if err != nil {
+			return fmt.Errorf("failed to drop existing database: %w", err)
+		}
+		t.Logf("Dropped existing database %s", dbname)
+	}
+
+	// Create the new database
+	_, err = pool.Exec(ctx, "CREATE DATABASE "+dbname)
+	if err != nil {
+		return fmt.Errorf("failed to create database: %w", err)
+	}
+
+	t.Logf("Created database %s", dbname)
+	return nil
+}
+
+// startPostgreSQLContainer starts a PostgreSQL container and returns it
+func startPostgreSQLContainer(t *testing.T, ctx context.Context) (testcontainers.Container, error) {
+	req := testcontainers.ContainerRequest{
+		Image:        "postgres:15-alpine",
+		ExposedPorts: []string{"5432/tcp"},
+		Env: map[string]string{
+			"POSTGRES_PASSWORD": "postgres",
+			"POSTGRES_DB":       "postgres",
+		},
+		WaitingFor: wait.ForLog("database system is ready to accept connections"),
+	}
+
+	container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
+		ContainerRequest: req,
+		Started:          true,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to start container: %w", err)
+	}
+
+	return container, nil
+}
+
+// TestMusicRefDump tests that the application can start with music_ref_dump.sql and migrations work
+func TestMusicRefDump(t *testing.T) {
+	testSQLDump(t, "music_ref_dump.sql", "music_server_ref_test")
+}
+
+// TestMusicTestDump tests that the application can start with music_test_dump.sql and migrations work
+func TestMusicTestDump(t *testing.T) {
+	testSQLDump(t, "music_test_dump.sql", "music_server_test_dump_test")
+}
+
+// TestMusicProdDump tests that the application can start with music_prod_dump.sql and migrations work
+func TestMusicProdDump(t *testing.T) {
+	testSQLDump(t, "music_prod_dump.sql", "music_server_prod_test")
+}
+
+// testSQLDump is the common test function for all SQL dump tests
+func testSQLDump(t *testing.T, dumpFile, dbname string) {
+	ctx := context.Background()
+
+	// Save original environment variables
+	originalEnv := saveEnvVars()
+	defer restoreEnvVars(originalEnv)
+
+	// Start PostgreSQL container
+	t.Log("Starting PostgreSQL container...")
+	container, err := startPostgreSQLContainer(t, ctx)
+	require.NoError(t, err)
+	defer func() {
+		t.Log("Stopping container...")
+		container.Terminate(ctx)
+	}()
+
+	// Get container connection details
+	endpoint, err := container.Endpoint(ctx, "")
+	require.NoError(t, err)
+	t.Logf("Container running at: %s", endpoint)
+
+	// Create database for this test
+	t.Logf("Creating database %s...", dbname)
+	err = createDatabaseInContainer(t, ctx, container, dbname)
+	require.NoError(t, err)
+
+	// Create common roles that might be referenced in dump files
+	err = createRoleInContainer(t, ctx, container, "sansan", "postgres")
+	if err != nil {
+		t.Logf("Note: Could not create role 'sansan': %v (may not be needed)", err)
+	}
+
+	// Load the SQL dump
+	// The dump files are in the project root
+	// Get the absolute path to the dump file
+	absDumpPath, err := filepath.Abs(filepath.Join("..", "..", dumpFile))
+	require.NoError(t, err)
+	if _, err := os.Stat(absDumpPath); os.IsNotExist(err) {
+		// Try relative to current working directory
+		absDumpPath = filepath.Join(".", dumpFile)
+		if _, err := os.Stat(absDumpPath); os.IsNotExist(err) {
+			absDumpPath = dumpFile // Try as-is
+		}
+	}
+
+	t.Logf("Loading SQL dump from: %s", absDumpPath)
+	err = loadSQLDumpIntoDatabase(t, ctx, container, dbname, absDumpPath)
+	require.NoError(t, err)
+
+	// ============================================
+	// PRE-MIGRATION CHECK
+	// ============================================
+	t.Log("Running pre-migration checks...")
+
+	// For connecting to the database from the test, we need to use the container's endpoint
+	// But the container's endpoint might be localhost:random_port
+	// We need to parse it to get host and port
+	// endpoint format: "host:port" e.g., "localhost:12345" or "127.0.0.1:23456"
+	// Actually, for testcontainers with Docker, the endpoint should be localhost:mapped_port
+	// Let's extract the mapped port
+
+	// Get the mapped port from the container
+	mappedPort, err := container.MappedPort(ctx, "5432")
+	require.NoError(t, err)
+	t.Logf("Container mapped port: %s", mappedPort)
+
+	// Use localhost as the host since we're on the same machine
+	dbHost := "localhost"
+	dbPort := mappedPort.Port()
+
+	// Create a connection to the database to check pre-migration state
+	connStr := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=disable",
+		dbHost, dbPort, "postgres", "postgres", dbname)
+
+	pool, err := pgxpool.New(ctx, connStr)
+	require.NoError(t, err)
+	defer pool.Close()
+
+	// Check that game table exists (pre-migration state)
+	gameExists, err := checkTableExists(ctx, pool, "game")
+	require.NoError(t, err)
+	assert.True(t, gameExists, "Before migration: game table should exist")
+
+	// Check that soundtrack table does NOT exist
+	soundtrackExists, err := checkTableExists(ctx, pool, "soundtrack")
+	require.NoError(t, err)
+	assert.False(t, soundtrackExists, "Before migration: soundtrack table should NOT exist")
+
+	t.Log("✓ Pre-migration check passed: game table exists, soundtrack table does not")
+
+	// ============================================
+	// START APPLICATION (triggers migrations)
+	// ============================================
+	t.Log("Starting application...")
+
+	// Set environment variables for the server
+	// The application needs to connect to the container's mapped port
+	os.Setenv("DB_HOST", dbHost)
+	os.Setenv("DB_PORT", dbPort)
+	os.Setenv("DB_USERNAME", "postgres")
+	os.Setenv("DB_PASSWORD", "postgres")
+	os.Setenv("DB_NAME", dbname)
+	os.Setenv("MUSIC_PATH", "./testMusic")
+	os.Setenv("CHARACTERS_PATH", "./testCharacters")
+
+	// Use different ports for each test to allow for sequential execution
+	// and to make port detection reliable
+	portMap := map[string]string{
+		"music_server_ref_test":       "8082",
+		"music_server_test_dump_test": "8083",
+		"music_server_prod_test":      "8084",
+	}
+	appPort := portMap[dbname]
+	if appPort == "" {
+		appPort = "8085" // fallback
+	}
+	os.Setenv("PORT", appPort)
+
+	os.Setenv("DISABLE_SESSION_AUTH", "true")
+	os.Setenv("LOG_LEVEL", "error")
+
+	// Create server instance (this runs migrations automatically)
+	serverInstance := NewServerInstance()
+	httpServer := serverInstance.HTTPServer()
+
+	// Start HTTP server in background
+	go func() {
+		if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			t.Logf("Server error: %v", err)
+		}
+	}()
+
+	defer func() {
+		t.Log("Stopping HTTP server...")
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		httpServer.Shutdown(ctx)
+	}()
+
+	// Wait for server to start by polling /health endpoint
+	// Use the fixed port we configured for the application
+	healthURL := fmt.Sprintf("http://localhost:%s/health", appPort)
+
+	maxAttempts := 30
+	for attempt := 1; attempt <= maxAttempts; attempt++ {
+		resp, err := http.Get(healthURL)
+		if err == nil {
+			defer resp.Body.Close()
+			if resp.StatusCode == http.StatusOK {
+				var healthData map[string]string
+				json.NewDecoder(resp.Body).Decode(&healthData)
+				if healthData["status"] == "up" {
+					t.Logf("Server is healthy on %s after %d attempts", healthURL, attempt)
+					break
+				}
+			}
+		}
+		if attempt == maxAttempts {
+			require.Fail(t, "Server did not become healthy within timeout")
+		}
+		time.Sleep(500 * time.Millisecond)
+	}
+
+	// ============================================
+	// POST-MIGRATION CHECK
+	// ============================================
+	t.Log("Running post-migration checks...")
+
+	// Check that game table no longer exists
+	gameExistsAfter, err := checkTableExists(ctx, pool, "game")
+	require.NoError(t, err)
+	assert.False(t, gameExistsAfter, "After migration: game table should NOT exist")
+
+	// Check that soundtrack table now exists
+	soundtrackExistsAfter, err := checkTableExists(ctx, pool, "soundtrack")
+	require.NoError(t, err)
+	assert.True(t, soundtrackExistsAfter, "After migration: soundtrack table should exist")
+
+	// Verify data was preserved
+	var soundtrackCount int
+	err = pool.QueryRow(ctx, "SELECT COUNT(*) FROM soundtrack").Scan(&soundtrackCount)
+	require.NoError(t, err)
+	assert.Greater(t, soundtrackCount, 0, "Migration should preserve data: soundtrack count should be > 0")
+	t.Logf("✓ Post-migration check passed: game table gone, soundtrack table exists with %d records", soundtrackCount)
+
+	// ============================================
+	// HEALTH CHECK
+	// ============================================
+	t.Log("Running health check...")
+
+	resp, err := http.Get(healthURL)
+	require.NoError(t, err)
+	defer resp.Body.Close()
+
+	assert.Equal(t, http.StatusOK, resp.StatusCode)
+
+	var healthData map[string]string
+	err = json.NewDecoder(resp.Body).Decode(&healthData)
+	require.NoError(t, err)
+	assert.Equal(t, "up", healthData["status"])
+
+	t.Log("✓ Health check passed")
+	t.Log("✓ Test completed successfully!")
+}