NaviWatcher/internal/database/external_releases_test.go

package database

import (
	"database/sql"
	"errors"
	"testing"
	"time"
)

// insertTestArtist inserts a minimal artist_settings row for use in tests that need FK satisfaction.
func insertTestArtist(db *DB, id string) error {
	_, err := db.Conn().Exec(
		"INSERT OR IGNORE INTO artist_settings (id, name) VALUES (?, ?)",
		id, "Test Artist "+id,
	)
	return err
}

// TestGetExternalRelease_Found verifies retrieving an existing release.
func TestGetExternalRelease_Found(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	if err := insertTestArtist(db, "artist-1"); err != nil {
		t.Fatalf("insertTestArtist: %v", err)
	}
	_, err = db.Conn().Exec(
		"INSERT INTO external_releases (rgid, artist_id, title, type, release_date, is_ignored) VALUES (?, ?, ?, ?, ?, ?)",
		"rgid-1", "artist-1", "Test Album", "album", "2024-01-01", false,
	)
	if err != nil {
		t.Fatalf("insert: %v", err)
	}

	r, err := GetExternalRelease(db, "rgid-1")
	if err != nil {
		t.Fatalf("GetExternalRelease() error: %v", err)
	}

	if r.RGID != "rgid-1" {
		t.Errorf("expected RGID 'rgid-1', got %q", r.RGID)
	}
	if r.ArtistID != "artist-1" {
		t.Errorf("expected ArtistID 'artist-1', got %q", r.ArtistID)
	}
	if r.Title != "Test Album" {
		t.Errorf("expected Title 'Test Album', got %q", r.Title)
	}
	if r.Type != "album" {
		t.Errorf("expected Type 'album', got %q", r.Type)
	}
	if r.ReleaseDate != "2024-01-01" {
		t.Errorf("expected ReleaseDate '2024-01-01', got %q", r.ReleaseDate)
	}
	if r.IsIgnored {
		t.Error("expected IsIgnored false")
	}
}

// TestGetExternalRelease_NotFound verifies that a missing release returns an error
// that wraps sql.ErrNoRows.
func TestGetExternalRelease_NotFound(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	_, err = GetExternalRelease(db, "nonexistent")
	if !errors.Is(err, sql.ErrNoRows) {
		t.Errorf("expected error wrapping sql.ErrNoRows, got %v", err)
	}
}

// TestSaveExternalRelease_Insert verifies inserting a new release.
func TestSaveExternalRelease_Insert(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	r := &ExternalRelease{
		RGID:        "rgid-1",
		ArtistID:    "artist-1",
		Title:       "New Album",
		Type:        "album",
		ReleaseDate: "2024-06-15",
		IsIgnored:   false,
	}

	if err := insertTestArtist(db, "artist-1"); err != nil {
		t.Fatalf("insertTestArtist: %v", err)
	}
	if err := SaveExternalRelease(db, r); err != nil {
		t.Fatalf("SaveExternalRelease() error: %v", err)
	}

	got, err := GetExternalRelease(db, "rgid-1")
	if err != nil {
		t.Fatalf("GetExternalRelease() error: %v", err)
	}
	if got.Title != "New Album" {
		t.Errorf("expected Title 'New Album', got %q", got.Title)
	}
	if got.ReleaseDate != "2024-06-15" {
		t.Errorf("expected ReleaseDate '2024-06-15', got %q", got.ReleaseDate)
	}
}

// TestSaveExternalRelease_Update verifies that SaveExternalRelease replaces an existing row.
func TestSaveExternalRelease_Update(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	if err := insertTestArtist(db, "artist-1"); err != nil {
		t.Fatalf("insertTestArtist: %v", err)
	}

	// Insert initial row.
	r1 := &ExternalRelease{
		RGID:        "rgid-1",
		ArtistID:    "artist-1",
		Title:       "Original Title",
		Type:        "album",
		ReleaseDate: "2024-01-01",
		IsIgnored:   false,
	}
	if err := SaveExternalRelease(db, r1); err != nil {
		t.Fatalf("first SaveExternalRelease() error: %v", err)
	}

	// Update the row.
	r2 := &ExternalRelease{
		RGID:        "rgid-1",
		ArtistID:    "artist-1",
		Title:       "Updated Title",
		Type:        "single",
		ReleaseDate: "2024-12-25",
		IsIgnored:   true,
	}
	if err := SaveExternalRelease(db, r2); err != nil {
		t.Fatalf("second SaveExternalRelease() error: %v", err)
	}

	got, err := GetExternalRelease(db, "rgid-1")
	if err != nil {
		t.Fatalf("GetExternalRelease() error: %v", err)
	}
	if got.Title != "Updated Title" {
		t.Errorf("expected Title 'Updated Title', got %q", got.Title)
	}
	if got.Type != "single" {
		t.Errorf("expected Type 'single', got %q", got.Type)
	}
	if got.ReleaseDate != "2024-12-25" {
		t.Errorf("expected ReleaseDate '2024-12-25', got %q", got.ReleaseDate)
	}
	if !got.IsIgnored {
		t.Error("expected IsIgnored true")
	}
}

// TestGetExternalReleasesByArtist_Empty verifies empty result for unknown artist.
func TestGetExternalReleasesByArtist_Empty(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	results, err := GetExternalReleasesByArtist(db, "unknown-artist")
	if err != nil {
		t.Fatalf("GetExternalReleasesByArtist() error: %v", err)
	}
	if len(results) != 0 {
		t.Errorf("expected 0 results, got %d", len(results))
	}
}

// TestGetExternalReleasesByArtist_Populated verifies filtering by artist_id.
func TestGetExternalReleasesByArtist_Populated(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	releases := []ExternalRelease{
		{RGID: "rg1", ArtistID: "artist-a", Title: "Album A1", Type: "album", ReleaseDate: "2024-01-01"},
		{RGID: "rg2", ArtistID: "artist-a", Title: "Album A2", Type: "album", ReleaseDate: "2024-06-01"},
		{RGID: "rg3", ArtistID: "artist-b", Title: "Album B1", Type: "single", ReleaseDate: "2024-03-01"},
	}

	if err := insertTestArtist(db, "artist-a"); err != nil {
		t.Fatalf("insertTestArtist(artist-a): %v", err)
	}
	if err := insertTestArtist(db, "artist-b"); err != nil {
		t.Fatalf("insertTestArtist(artist-b): %v", err)
	}
	for _, r := range releases {
		if err := SaveExternalRelease(db, &r); err != nil {
			t.Fatalf("SaveExternalRelease(%s) error: %v", r.RGID, err)
		}
	}

	// Query for artist-a.
	results, err := GetExternalReleasesByArtist(db, "artist-a")
	if err != nil {
		t.Fatalf("GetExternalReleasesByArtist() error: %v", err)
	}
	if len(results) != 2 {
		t.Fatalf("expected 2 results for artist-a, got %d", len(results))
	}

	// Verify all belong to artist-a.
	for _, r := range results {
		if r.ArtistID != "artist-a" {
			t.Errorf("expected ArtistID 'artist-a', got %q", r.ArtistID)
		}
	}

	// Query for artist-b.
	results, err = GetExternalReleasesByArtist(db, "artist-b")
	if err != nil {
		t.Fatalf("GetExternalReleasesByArtist() error: %v", err)
	}
	if len(results) != 1 {
		t.Fatalf("expected 1 result for artist-b, got %d", len(results))
	}
	if results[0].Title != "Album B1" {
		t.Errorf("expected Title 'Album B1', got %q", results[0].Title)
	}
}

// TestGetIgnoredReleases_Empty verifies empty result when no ignored releases.
func TestGetIgnoredReleases_Empty(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	results, err := GetIgnoredReleases(db)
	if err != nil {
		t.Fatalf("GetIgnoredReleases() error: %v", err)
	}
	if len(results) != 0 {
		t.Errorf("expected 0 results, got %d", len(results))
	}
}

// TestGetIgnoredReleases_Populated verifies only ignored releases are returned.
func TestGetIgnoredReleases_Populated(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	releases := []ExternalRelease{
		{RGID: "rg1", ArtistID: "a1", Title: "Ignored Album", IsIgnored: true},
		{RGID: "rg2", ArtistID: "a1", Title: "Normal Album", IsIgnored: false},
		{RGID: "rg3", ArtistID: "a2", Title: "Another Ignored", IsIgnored: true},
	}

	if err := insertTestArtist(db, "a1"); err != nil {
		t.Fatalf("insertTestArtist(a1): %v", err)
	}
	if err := insertTestArtist(db, "a2"); err != nil {
		t.Fatalf("insertTestArtist(a2): %v", err)
	}
	for _, r := range releases {
		if err := SaveExternalRelease(db, &r); err != nil {
			t.Fatalf("SaveExternalRelease(%s) error: %v", r.RGID, err)
		}
	}

	results, err := GetIgnoredReleases(db)
	if err != nil {
		t.Fatalf("GetIgnoredReleases() error: %v", err)
	}
	if len(results) != 2 {
		t.Fatalf("expected 2 ignored releases, got %d", len(results))
	}

	// Verify all returned are ignored.
	for _, r := range results {
		if !r.IsIgnored {
			t.Errorf("expected IsIgnored=true for %s, got false", r.RGID)
		}
	}
}

// TestSetReleaseIgnored_SetTrue verifies setting is_ignored to true.
func TestSetReleaseIgnored_SetTrue(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	r := &ExternalRelease{
		RGID:      "rgid-1",
		ArtistID:  "artist-1",
		Title:     "Test Album",
		IsIgnored: false,
	}
	if err := insertTestArtist(db, "artist-1"); err != nil {
		t.Fatalf("insertTestArtist: %v", err)
	}
	if err := SaveExternalRelease(db, r); err != nil {
		t.Fatalf("SaveExternalRelease() error: %v", err)
	}

	if err := SetReleaseIgnored(db, "rgid-1", true); err != nil {
		t.Fatalf("SetReleaseIgnored() error: %v", err)
	}

	got, err := GetExternalRelease(db, "rgid-1")
	if err != nil {
		t.Fatalf("GetExternalRelease() error: %v", err)
	}
	if !got.IsIgnored {
		t.Error("expected IsIgnored true after SetReleaseIgnored(true)")
	}
}

// TestSetReleaseIgnored_SetFalse verifies setting is_ignored back to false.
func TestSetReleaseIgnored_SetFalse(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	r := &ExternalRelease{
		RGID:      "rgid-1",
		ArtistID:  "artist-1",
		Title:     "Test Album",
		IsIgnored: true,
	}
	if err := insertTestArtist(db, "artist-1"); err != nil {
		t.Fatalf("insertTestArtist: %v", err)
	}
	if err := SaveExternalRelease(db, r); err != nil {
		t.Fatalf("SaveExternalRelease() error: %v", err)
	}

	if err := SetReleaseIgnored(db, "rgid-1", false); err != nil {
		t.Fatalf("SetReleaseIgnored() error: %v", err)
	}

	got, err := GetExternalRelease(db, "rgid-1")
	if err != nil {
		t.Fatalf("GetExternalRelease() error: %v", err)
	}
	if got.IsIgnored {
		t.Error("expected IsIgnored false after SetReleaseIgnored(false)")
	}
}

// TestSetReleaseIgnored_NotFound verifies error for nonexistent RGID.
func TestSetReleaseIgnored_NotFound(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()

	err = SetReleaseIgnored(db, "nonexistent", true)
	if err == nil {
		t.Error("expected error for nonexistent RGID, got nil")
	}
}

// TestSecondaryTypesRoundTrip verifies that the comma-joined secondary_types
// column round-trips through save + read with the same slice, so the cache-hit
// type filtering (ignore_singles / ignore_compilations) sees the same data as
// the cache-miss path.
func TestSecondaryTypesRoundTrip(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()
	if err := insertTestArtist(db, "artist-1"); err != nil {
		t.Fatalf("insertTestArtist: %v", err)
	}

	cases := []struct {
		name     string
		in       []string
		want     []string
	}{
		{"empty", nil, nil},
		{"single", []string{"Compilation"}, []string{"Compilation"}},
		{"multiple", []string{"Compilation", "Live", "EP"}, []string{"Compilation", "Live", "EP"}},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			r := &ExternalRelease{
				RGID:          "rgid-" + c.name,
				ArtistID:      "artist-1",
				Title:         "Title " + c.name,
				Type:          "Album",
				SecondaryTypes: c.in,
			}
			if err := SaveExternalRelease(db, r); err != nil {
				t.Fatalf("SaveExternalRelease() error: %v", err)
			}
			got, err := GetExternalRelease(db, r.RGID)
			if err != nil {
				t.Fatalf("GetExternalRelease() error: %v", err)
			}
			if len(got.SecondaryTypes) != len(c.want) {
				t.Fatalf("secondary types = %v, want %v", got.SecondaryTypes, c.want)
			}
			for i := range c.want {
				if got.SecondaryTypes[i] != c.want[i] {
					t.Errorf("secondary types[%d] = %q, want %q", i, got.SecondaryTypes[i], c.want[i])
				}
			}
		})
	}
}

// TestArtistCacheFresh covers the two-signal freshness logic: a fresh
// external_releases row, a fresh last_synced marker (empty discography), a stale
// state, and the ttl<=0 guard.
func TestArtistCacheFresh(t *testing.T) {
	db, err := New(":memory:")
	if err != nil {
		t.Fatalf("New() error: %v", err)
	}
	defer db.Close()
	if err := insertTestArtist(db, "artist-1"); err != nil {
		t.Fatalf("insertTestArtist: %v", err)
	}

	const ttl = 24 * time.Hour

	// No rows at all => not fresh.
	if fresh, err := ArtistCacheFresh(db, "artist-1", ttl); err != nil || fresh {
		t.Fatalf("empty state: fresh=%v err=%v, want (false, nil)", fresh, err)
	}

	// ttl <= 0 => never fresh.
	if fresh, err := ArtistCacheFresh(db, "artist-1", 0); err != nil || fresh {
		t.Fatalf("ttl=0: fresh=%v err=%v, want (false, nil)", fresh, err)
	}

	// Fresh release row => fresh, even with an empty last_synced.
	if _, err := db.Conn().Exec(
		"INSERT INTO external_releases (rgid, artist_id, title, cached_at) VALUES (?, ?, ?, ?)",
		"rgid-1", "artist-1", "Album", FormatCachedAt(time.Now().UTC()),
	); err != nil {
		t.Fatalf("insert release: %v", err)
	}
	if fresh, err := ArtistCacheFresh(db, "artist-1", ttl); err != nil || !fresh {
		t.Fatalf("fresh release: fresh=%v err=%v, want (true, nil)", fresh, err)
	}

	// Remove the release row, set a fresh last_synced (empty discography still cached).
	if _, err := db.Conn().Exec("DELETE FROM external_releases WHERE artist_id = ?", "artist-1"); err != nil {
		t.Fatalf("delete releases: %v", err)
	}
	if _, err := db.Conn().Exec("UPDATE artist_settings SET last_synced = ? WHERE id = ?", FormatCachedAt(time.Now().UTC()), "artist-1"); err != nil {
		t.Fatalf("touch synced: %v", err)
	}
	if fresh, err := ArtistCacheFresh(db, "artist-1", ttl); err != nil || !fresh {
		t.Fatalf("fresh last_synced: fresh=%v err=%v, want (true, nil)", fresh, err)
	}

	// Stale both signals => not fresh.
	db.Conn().Exec("UPDATE artist_settings SET last_synced = ? WHERE id = ?", FormatCachedAt(time.Now().UTC().Add(-2*ttl)), "artist-1")
	if fresh, err := ArtistCacheFresh(db, "artist-1", ttl); err != nil || fresh {
		t.Fatalf("stale both: fresh=%v err=%v, want (false, nil)", fresh, err)
	}
}