diff --git a/docs/plans/2026-05-20-foundation-layer.md b/docs/plans/2026-05-20-foundation-layer.md index 24a91f1..8ad1c2e 100644 --- a/docs/plans/2026-05-20-foundation-layer.md +++ b/docs/plans/2026-05-20-foundation-layer.md @@ -97,14 +97,14 @@ Build the foundation layer of NaviWatcher: a greenfield Go project with zero exi - [x] run tests — must pass before task 5 ### Task 5: Database layer — CRUD operations for external_releases -- [ ] implement `GetExternalRelease(db *DB, rgid string) (*ExternalRelease, error)` -- [ ] implement `SaveExternalRelease(db *DB, release *ExternalRelease) error` -- [ ] implement `GetExternalReleasesByArtist(db *DB, artistID string) ([]ExternalRelease, error)` -- [ ] implement `GetIgnoredReleases(db *DB) ([]ExternalRelease, error)` -- [ ] implement `SetReleaseIgnored(db *DB, rgid string, ignored bool) error` -- [ ] write tests for all CRUD operations (success and error cases) -- [ ] write tests for cache TTL logic (if implemented at this layer) -- [ ] run tests — must pass before task 6 +- [x] implement `GetExternalRelease(db *DB, rgid string) (*ExternalRelease, error)` +- [x] implement `SaveExternalRelease(db *DB, release *ExternalRelease) error` +- [x] implement `GetExternalReleasesByArtist(db *DB, artistID string) ([]ExternalRelease, error)` +- [x] implement `GetIgnoredReleases(db *DB) ([]ExternalRelease, error)` +- [x] implement `SetReleaseIgnored(db *DB, rgid string, ignored bool) error` +- [x] write tests for all CRUD operations (success and error cases) +- [x] write tests for cache TTL logic (if implemented at this layer) +- [x] run tests — must pass before task 6 ### Task 6: Database layer — CRUD operations for notifications_sent - [ ] implement `MarkNotificationSent(db *DB, rgid string) error` diff --git a/internal/database/external_releases.go b/internal/database/external_releases.go new file mode 100644 index 0000000..4a045ec --- /dev/null +++ b/internal/database/external_releases.go @@ -0,0 +1,101 @@ +package database + +import ( + "fmt" +) + +// GetExternalRelease retrieves an external_release row by RGID. +// Returns sql.ErrNoRows if the release is not found. +func GetExternalRelease(db *DB, rgid string) (*ExternalRelease, error) { + var r ExternalRelease + err := db.Conn().QueryRow( + "SELECT rgid, artist_id, title, type, release_date, is_ignored FROM external_releases WHERE rgid = ?", + rgid, + ).Scan(&r.RGID, &r.ArtistID, &r.Title, &r.Type, &r.ReleaseDate, &r.IsIgnored) + if err != nil { + return nil, err + } + return &r, nil +} + +// SaveExternalRelease inserts or replaces an external_release row. +func SaveExternalRelease(db *DB, release *ExternalRelease) error { + _, err := db.Conn().Exec( + "INSERT OR REPLACE INTO external_releases (rgid, artist_id, title, type, release_date, is_ignored) VALUES (?, ?, ?, ?, ?, ?)", + release.RGID, release.ArtistID, release.Title, release.Type, release.ReleaseDate, release.IsIgnored, + ) + if err != nil { + return fmt.Errorf("save external release: %w", err) + } + return nil +} + +// GetExternalReleasesByArtist returns all external_release rows for a given artist_id. +func GetExternalReleasesByArtist(db *DB, artistID string) ([]ExternalRelease, error) { + rows, err := db.Conn().Query( + "SELECT rgid, artist_id, title, type, release_date, is_ignored FROM external_releases WHERE artist_id = ?", + artistID, + ) + if err != nil { + return nil, fmt.Errorf("query external releases by artist: %w", err) + } + defer rows.Close() + + var results []ExternalRelease + for rows.Next() { + var r ExternalRelease + if err := rows.Scan(&r.RGID, &r.ArtistID, &r.Title, &r.Type, &r.ReleaseDate, &r.IsIgnored); err != nil { + return nil, fmt.Errorf("scan external release: %w", err) + } + results = append(results, r) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("iterate external releases: %w", err) + } + return results, nil +} + +// GetIgnoredReleases returns all external_release rows where is_ignored = 1. +func GetIgnoredReleases(db *DB) ([]ExternalRelease, error) { + rows, err := db.Conn().Query( + "SELECT rgid, artist_id, title, type, release_date, is_ignored FROM external_releases WHERE is_ignored = 1", + ) + if err != nil { + return nil, fmt.Errorf("query ignored releases: %w", err) + } + defer rows.Close() + + var results []ExternalRelease + for rows.Next() { + var r ExternalRelease + if err := rows.Scan(&r.RGID, &r.ArtistID, &r.Title, &r.Type, &r.ReleaseDate, &r.IsIgnored); err != nil { + return nil, fmt.Errorf("scan ignored release: %w", err) + } + results = append(results, r) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("iterate ignored releases: %w", err) + } + return results, nil +} + +// SetReleaseIgnored updates the is_ignored flag for a given RGID. +func SetReleaseIgnored(db *DB, rgid string, ignored bool) error { + result, err := db.Conn().Exec( + "UPDATE external_releases SET is_ignored = ? WHERE rgid = ?", + ignored, rgid, + ) + if err != nil { + return fmt.Errorf("set release ignored: %w", err) + } + + rowsAffected, err := result.RowsAffected() + if err != nil { + return fmt.Errorf("rows affected: %w", err) + } + if rowsAffected == 0 { + return fmt.Errorf("release not found: %s", rgid) + } + + return nil +} diff --git a/internal/database/external_releases_test.go b/internal/database/external_releases_test.go new file mode 100644 index 0000000..ea93596 --- /dev/null +++ b/internal/database/external_releases_test.go @@ -0,0 +1,342 @@ +package database + +import ( + "database/sql" + "testing" +) + +// 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() + + // Insert a row directly. + _, 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 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 err != sql.ErrNoRows { + t.Errorf("expected 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 := 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() + + // 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"}, + } + + 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}, + } + + 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 := 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 := 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") + } +}