internal/server/statistics_handler_test.go

@@ -0,0 +1,174 @@
+package server
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"music-server/internal/backend"
+	"music-server/internal/db"
+	"music-server/internal/db/repository"
+
+	"github.com/labstack/echo/v5"
+	"github.com/stretchr/testify/require"
+)
+
+// TestStatisticsEndpoints tests the statistics API endpoints
+func TestStatisticsEndpoints(t *testing.T) {
+	// Skip if test database not configured
+	e := StartTestServer(t)
+	if e == nil {
+		t.Skip("Test database not configured")
+	}
+
+	// Get token first
+	token := getTestToken(t, e)
+	if token == "" {
+		t.Skip("Could not get test token")
+	}
+
+	// Test /api/v1/statistics/summary
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/statistics/summary", nil)
+	req.Header.Set("Authorization", "Bearer "+token)
+	rec := httptest.NewRecorder()
+	e.ServeHTTP(rec, req)
+
+	require.Equal(t, http.StatusOK, rec.Code)
+
+	var summary backend.StatisticsSummary
+	err := json.Unmarshal(rec.Body.Bytes(), &summary)
+	require.NoError(t, err)
+	require.NotNil(t, summary)
+}
+
+// TestPartialMigrationThenSyncThenComplete tests migration workflow
+// Note: This test requires the database to be in a specific state
+// It tests: partial migration → data insert → sync → complete migration
+func TestPartialMigrationThenSyncThenComplete(t *testing.T) {
+	// This test is complex and requires careful setup
+	// For now, we test the final state: all migrations + sync
+
+	e := StartTestServer(t)
+	if e == nil {
+		t.Skip("Test database not configured")
+	}
+
+	// Get token
+	token := getTestToken(t, e)
+	if token == "" {
+		t.Skip("Could not get test token")
+	}
+
+	// Insert test data manually (5 soundtracks with songs)
+	insertTestData(t)
+
+	// Run sync to ensure data is properly loaded
+	req := httptest.NewRequest(http.MethodGet, "/sync/new", nil)
+	req.Header.Set("Authorization", "Bearer "+token)
+	rec := httptest.NewRecorder()
+	e.ServeHTTP(rec, req)
+
+	require.Equal(t, http.StatusOK, rec.Code)
+
+	// Verify data via statistics endpoint
+	req = httptest.NewRequest(http.MethodGet, "/api/v1/statistics/summary", nil)
+	req.Header.Set("Authorization", "Bearer "+token)
+	rec = httptest.NewRecorder()
+	e.ServeHTTP(rec, req)
+
+	require.Equal(t, http.StatusOK, rec.Code)
+
+	var summary backend.StatisticsSummary
+	err := json.Unmarshal(rec.Body.Bytes(), &summary)
+	require.NoError(t, err)
+
+	// We inserted 5 soundtracks, so total should be at least 5
+	// (there might be existing data)
+	require.GreaterOrEqual(t, summary.TotalGames, int64(5))
+}
+
+// insertTestData inserts 5 test soundtracks with songs into the database
+func insertTestData(t *testing.T) {
+	if db.TestDatabase == nil || db.TestDatabase.Pool == nil {
+		t.Skip("Test database not initialized")
+		return
+	}
+
+	ctx := context.Background()
+	queries := repository.New(db.TestDatabase.Pool)
+
+	// Insert 5 soundtracks
+	soundtracks := []struct {
+		name string
+		path string
+	}{
+		{"Test Soundtrack 1", "/path/to/soundtrack1"},
+		{"Test Soundtrack 2", "/path/to/soundtrack2"},
+		{"Test Soundtrack 3", "/path/to/soundtrack3"},
+		{"Test Soundtrack 4", "/path/to/soundtrack4"},
+		{"Test Soundtrack 5", "/path/to/soundtrack5"},
+	}
+
+	for _, st := range soundtracks {
+		_, err := queries.InsertSoundtrack(ctx, repository.InsertSoundtrackParams{
+			SoundtrackName: st.name,
+			Path:          st.path,
+			Hash:          "test-hash-" + st.name,
+		})
+		require.NoError(t, err, "Failed to insert soundtrack: %s", st.name)
+	}
+
+	// Get soundtrack IDs
+	soundtrackIDs, err := queries.FindAllSoundtracks(ctx)
+	require.NoError(t, err)
+	require.GreaterOrEqual(t, len(soundtrackIDs), 5)
+
+	// Insert songs for each soundtrack
+	songData := []struct {
+		soundtrackID int32
+		songs        []string
+	}{
+		{soundtrackIDs[0].ID, []string{"Song A", "Song B"}},
+		{soundtrackIDs[1].ID, []string{"Song C", "Song D"}},
+		{soundtrackIDs[2].ID, []string{"Song E"}},
+		{soundtrackIDs[3].ID, []string{"Song F", "Song G", "Song H"}},
+		{soundtrackIDs[4].ID, []string{"Song I"}},
+	}
+
+	for _, sd := range songData {
+		for _, songName := range sd.songs {
+			err := queries.AddSong(ctx, repository.AddSongParams{
+				SoundtrackID: sd.soundtrackID,
+				SongName:     songName,
+				Path:         "/path/to/" + songName + ".mp3",
+			})
+			require.NoError(t, err, "Failed to insert song: %s", songName)
+		}
+	}
+
+	t.Logf("Inserted %d soundtracks with %d total songs", len(soundtracks), 8)
+}
+
+// getTestToken gets a valid token for testing
+func getTestToken(t *testing.T, e *echo.Echo) string {
+	reqBody := `{"client_type": "test"}`
+	req := httptest.NewRequest(http.MethodPost, "/api/v1/token", strings.NewReader(reqBody))
+	req.Header.Set("Content-Type", "application/json")
+	rec := httptest.NewRecorder()
+	e.ServeHTTP(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Logf("Failed to get token: %s", rec.Body.String())
+		return ""
+	}
+
+	var resp struct {
+		Token string `json:"token"`
+	}
+	err := json.Unmarshal(rec.Body.Bytes(), &resp)
+	require.NoError(t, err)
+	return resp.Token
+}

internal/server/sync_handler_test.go

@@ -76,7 +76,7 @@ func TestSyncPopulatesDatabase(t *testing.T) {
 
 	// Before sync - should have no games
 	repo := repository.New(backend.BackendPool())
-	gamesBefore, err := repo.FindAllGames(backend.BackendCtx())
+	gamesBefore, err := repo.FindAllSoundtracks(backend.BackendCtx())
 	assert.NoError(t, err)
 	beforeCount := len(gamesBefore)
 	t.Logf("Games before sync: %d", beforeCount)
@@ -92,7 +92,7 @@ func TestSyncPopulatesDatabase(t *testing.T) {
 	}
 
 	// After sync - should have games
-	gamesAfter, err := repo.FindAllGames(backend.BackendCtx())
+	gamesAfter, err := repo.FindAllSoundtracks(backend.BackendCtx())
 	assert.NoError(t, err)
 	afterCount := len(gamesAfter)
 	t.Logf("Games after sync: %d", afterCount)
@@ -113,7 +113,7 @@ func TestSyncMakesDifference(t *testing.T) {
 
 	// Before sync - should have no games
 	repo := repository.New(backend.BackendPool())
-	gamesBefore, err := repo.FindAllGames(backend.BackendCtx())
+	gamesBefore, err := repo.FindAllSoundtracks(backend.BackendCtx())
 	assert.NoError(t, err)
 	assert.Equal(t, 0, len(gamesBefore), "Should have no games before sync")
 
@@ -127,7 +127,7 @@ func TestSyncMakesDifference(t *testing.T) {
 	}
 
 	// After sync - should have games
-	gamesAfter, err := repo.FindAllGames(backend.BackendCtx())
+	gamesAfter, err := repo.FindAllSoundtracks(backend.BackendCtx())
 	assert.NoError(t, err)
 	assert.True(t, len(gamesAfter) > 0, "Should have games after sync")
 }
@@ -200,7 +200,7 @@ func TestSyncGamesNewOnlyChanges(t *testing.T) {
 
 	// Get initial count
 	repo := repository.New(backend.BackendPool())
-	gamesBefore, _ := repo.FindAllGames(backend.BackendCtx())
+	gamesBefore, _ := repo.FindAllSoundtracks(backend.BackendCtx())
 	beforeCount := len(gamesBefore)
 
 	// Run incremental sync (should not change count if nothing changed)
@@ -211,7 +211,7 @@ func TestSyncGamesNewOnlyChanges(t *testing.T) {
 	time.Sleep(2 * time.Second)
 
 	// Count should be the same
-	gamesAfter, _ := repo.FindAllGames(backend.BackendCtx())
+	gamesAfter, _ := repo.FindAllSoundtracks(backend.BackendCtx())
 	afterCount := len(gamesAfter)
 
 	// Note: This might not be exactly equal due to timing, but should be close
@@ -228,7 +228,7 @@ func TestResetGames(t *testing.T) {
 
 	// First ensure we have data
 	repo := repository.New(backend.BackendPool())
-	gamesBefore, _ := repo.FindAllGames(backend.BackendCtx())
+	gamesBefore, _ := repo.FindAllSoundtracks(backend.BackendCtx())
 	beforeCount := len(gamesBefore)
 
 	if beforeCount == 0 {
@@ -238,7 +238,7 @@ func TestResetGames(t *testing.T) {
 			t.Error("Sync did not complete within timeout")
 			return
 		}
-		gamesBefore, _ = repo.FindAllGames(backend.BackendCtx())
+		gamesBefore, _ = repo.FindAllSoundtracks(backend.BackendCtx())
 		beforeCount = len(gamesBefore)
 	}
 
@@ -253,7 +253,7 @@ func TestResetGames(t *testing.T) {
 	// Note: reset might take a moment to propagate
 	time.Sleep(1 * time.Second)
 
-	gamesAfter, _ := repo.FindAllGames(backend.BackendCtx())
+	gamesAfter, _ := repo.FindAllSoundtracks(backend.BackendCtx())
 	afterCount := len(gamesAfter)
 
 	t.Logf("Games after reset: %d", afterCount)
@@ -282,7 +282,7 @@ func TestSyncGamesNewFull(t *testing.T) {
 
 	// Verify database is populated
 	repo := repository.New(backend.BackendPool())
-	games, err := repo.FindAllGames(backend.BackendCtx())
+	games, err := repo.FindAllSoundtracks(backend.BackendCtx())
 	assert.NoError(t, err)
 	assert.True(t, len(games) > 0, "Database should be populated after full sync")
 	t.Logf("Full sync populated %d games", len(games))

internal/server/zz_music_handler_test.go

@@ -16,7 +16,7 @@ import (
 // ensureSyncRan ensures that sync has been run before testing music endpoints
 func ensureSyncRan(t *testing.T, e *echo.Echo) {
 	repo := repository.New(backend.BackendPool())
-	games, err := repo.FindAllGames(backend.BackendCtx())
+	games, err := repo.FindAllSoundtracks(backend.BackendCtx())
 	assert.NoError(t, err)
 
 	if len(games) == 0 {