feat(lidarr): ask Lidarr for release groups; repair stored release-id requests (M483 #5244)

Lidarr's metadata is keyed by MusicBrainz release group, but re-acquisition
requested albums by their release id, so every add came back "not found".

- Sweeper requests an album by its tag-supplied release group, else the one
  MusicBrainz names (cached onto the album). An album MusicBrainz cannot name
  is skipped and counted, with no attempt spent.
- Reconciler: an add refused as not found re-reads the request's album id as
  a release (library first, then MusicBrainz), rewrites the request to the
  group and adds again. This repairs the requests already stored.
- Completion matches an album by release id or release group, and only once a
  track of it is on disk, so a re-acquisition request no longer completes
  against the row of the album it is trying to bring back.

Closes #5241.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/reacquisition/sweeper_test.go

@@ -0,0 +1,163 @@
+package reacquisition
+
+import (
+	"context"
+	"io"
+	"log/slog"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"git.fabledsword.com/bvandeusen/minstrel/internal/db"
+	"git.fabledsword.com/bvandeusen/minstrel/internal/db/dbq"
+	"git.fabledsword.com/bvandeusen/minstrel/internal/dbtest"
+	"git.fabledsword.com/bvandeusen/minstrel/internal/lidarrconfig"
+	"git.fabledsword.com/bvandeusen/minstrel/internal/lidarrrequests"
+	"git.fabledsword.com/bvandeusen/minstrel/internal/tags"
+)
+
+func newSweepPool(t *testing.T) *pgxpool.Pool {
+	t.Helper()
+	if testing.Short() {
+		t.Skip("skipping integration test in -short mode")
+	}
+	dsn := os.Getenv("MINSTREL_TEST_DATABASE_URL")
+	if dsn == "" {
+		t.Skip("MINSTREL_TEST_DATABASE_URL not set")
+	}
+	if err := db.Migrate(dsn, slog.New(slog.NewTextHandler(io.Discard, nil))); err != nil {
+		t.Fatalf("migrate: %v", err)
+	}
+	pool, err := pgxpool.New(context.Background(), dsn)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	t.Cleanup(pool.Close)
+	dbtest.ResetDB(t, pool)
+	if _, err := pool.Exec(context.Background(), "DELETE FROM lidarr_requests"); err != nil {
+		t.Fatalf("reset requests: %v", err)
+	}
+	return pool
+}
+
+// lostAlbum seeds an album whose only track has been missing for two days,
+// named by MusicBrainz release id and (when group is set) release group.
+func lostAlbum(t *testing.T, pool *pgxpool.Pool, title, release, group string) pgtype.UUID {
+	t.Helper()
+	ctx := context.Background()
+	q := dbq.New(pool)
+	artistMBID := "artist-" + release
+	ar, err := q.UpsertArtist(ctx, dbq.UpsertArtistParams{Name: title + " Artist", SortName: title, Mbid: &artistMBID})
+	if err != nil {
+		t.Fatal(err)
+	}
+	params := dbq.UpsertAlbumParams{Title: title, SortTitle: title, ArtistID: ar.ID, Mbid: &release}
+	if group != "" {
+		params.ReleaseGroupMbid = &group
+	}
+	al, err := q.UpsertAlbum(ctx, params)
+	if err != nil {
+		t.Fatal(err)
+	}
+	tr, err := q.UpsertTrack(ctx, dbq.UpsertTrackParams{
+		Title: "Lost", AlbumID: al.ID, ArtistID: ar.ID, DurationMs: 180000,
+		FilePath: "/music/" + release + "/01.flac", FileSize: 1, FileFormat: "flac",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := pool.Exec(ctx, "UPDATE tracks SET missing_since = now() - interval '2 days' WHERE id = $1", tr.ID); err != nil {
+		t.Fatal(err)
+	}
+	return al.ID
+}
+
+// #5241: re-acquisition asks Lidarr for the album's release group, never its
+// release id. A tag-supplied group is used as is; otherwise MusicBrainz names
+// it and the answer is cached onto the album; an album MusicBrainz cannot
+// name is skipped without spending an attempt.
+func TestSweep_RequestsAlbumsByReleaseGroup_Integration(t *testing.T) {
+	pool := newSweepPool(t)
+	ctx := context.Background()
+	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+	q := dbq.New(pool)
+
+	if _, err := q.CreateUser(ctx, dbq.CreateUserParams{
+		Username: dbtest.TestUserPrefix + "sweepadmin", PasswordHash: "x", ApiTokenHash: "x", IsAdmin: true,
+	}); err != nil {
+		t.Fatal(err)
+	}
+	settings, err := NewSettingsService(ctx, pool, logger)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := Defaults
+	cfg.AutoApprove = false
+	if _, err := settings.Set(ctx, cfg); err != nil {
+		t.Fatal(err)
+	}
+
+	tagged := lostAlbum(t, pool, "Tagged", "release-tagged", "group-tagged")
+	resolved := lostAlbum(t, pool, "Resolved", "release-resolved", "")
+	unknown := lostAlbum(t, pool, "Unknown", "release-unknown", "")
+
+	requests := lidarrrequests.NewService(pool, lidarrconfig.New(pool), nil, nil)
+	s := NewSweeper(pool, settings, requests, logger)
+	asked := map[string]int{}
+	s.releaseGroup = func(_ context.Context, release string) (string, error) {
+		asked[release]++
+		if release == "release-resolved" {
+			return "group-resolved", nil
+		}
+		return "", tags.ErrNotFound
+	}
+	if err := s.SweepOnce(ctx); err != nil {
+		t.Fatalf("sweep: %v", err)
+	}
+
+	requested := func(album pgtype.UUID) (string, bool) {
+		t.Helper()
+		var mbid *string
+		err := pool.QueryRow(ctx, `
+SELECT lr.lidarr_album_mbid
+  FROM missing_reacquisitions r
+  JOIN lidarr_requests lr ON lr.id = r.last_request_id
+ WHERE r.album_id = $1`, album).Scan(&mbid)
+		if err != nil || mbid == nil {
+			return "", false
+		}
+		return *mbid, true
+	}
+	if got, ok := requested(tagged); !ok || got != "group-tagged" {
+		t.Errorf("tagged album requested as %q (ok=%v), want group-tagged", got, ok)
+	}
+	if asked["release-tagged"] != 0 {
+		t.Error("MusicBrainz asked about an album whose tags named its group")
+	}
+	if got, ok := requested(resolved); !ok || got != "group-resolved" {
+		t.Errorf("resolved album requested as %q (ok=%v), want group-resolved", got, ok)
+	}
+	var cached *string
+	if err := pool.QueryRow(ctx, "SELECT release_group_mbid FROM albums WHERE id = $1", resolved).Scan(&cached); err != nil {
+		t.Fatal(err)
+	}
+	if cached == nil || *cached != "group-resolved" {
+		t.Errorf("resolved group not cached on the album: %v", cached)
+	}
+	var attempts int
+	if err := pool.QueryRow(ctx, "SELECT count(*) FROM missing_reacquisitions WHERE album_id = $1", unknown).Scan(&attempts); err != nil {
+		t.Fatal(err)
+	}
+	if attempts != 0 {
+		t.Errorf("unresolvable album spent an attempt (%d state rows)", attempts)
+	}
+	var stray int
+	if err := pool.QueryRow(ctx, "SELECT count(*) FROM lidarr_requests WHERE lidarr_album_mbid LIKE 'release-%'").Scan(&stray); err != nil {
+		t.Fatal(err)
+	}
+	if stray != 0 {
+		t.Errorf("%d request(s) named an album by its release id", stray)
+	}
+}