fix: every library album is matched to MusicBrainz before it is listed, by its tags, its artist's discography or a search, and checked against its tracks (M502 #5569)

The one-time listing took only albums whose tags already named their
release group and artist, and left 340 off the list. The rest are now
matched: the release their tags name, else the artist's release groups
called what the album is called, else a MusicBrainz search by artist and
title. A group found by name is taken only when its tracks agree with the
album's (by disc and number, then title; length and title, or recording),
so a partial copy still matches and a same-titled other album does not.

library_album_matches records each album the listing decided, listed or
unmatched with why, so an album taken off the list is never re-listed. The
albums no match was found for are named on the Held tab. Album rows with
no tracks are no longer counted.

The length and title checks move from the importer to release, shared by
both.

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

internal/wanted/wanted_test.go

@@ -9,6 +9,7 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"os"
+	"strings"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -226,6 +227,13 @@ func newFakeMB(t *testing.T) *fakeMB {
 				            {"position": 3, "number": "3", "title": "Bonus", "recording": {"id": "rec-3"}}]}]}]}`)
 		case r.URL.Path == "/release":
 			_, _ = fmt.Fprint(w, `{"release-count": 0, "releases": []}`)
+		case r.URL.Path == "/release-group" && strings.Contains(r.URL.Query().Get("query"), "releasegroup:"):
+			// The library listing's search by artist and title (#5569).
+			found := ""
+			if strings.Contains(r.URL.Query().Get("query"), "Ballad") {
+				found = group(theBallad, "The Ballad of Darren", "Album", "", "2023-07-21")
+			}
+			_, _ = fmt.Fprintf(w, `{"release-groups": [%s]}`, found)
 		default:
 			w.WriteHeader(http.StatusNotFound)
 		}
@@ -455,135 +463,3 @@ func seedUser(t *testing.T, pool *pgxpool.Pool) pgtype.UUID {
 	}
 	return u.ID
 }
-
-// startListing clears the reset's "already listed", as a fresh install has it.
-func startListing(t *testing.T, pool *pgxpool.Pool) {
-	t.Helper()
-	if _, err := pool.Exec(context.Background(), `
-		UPDATE acquisition_settings SET library_listing_started_at = NULL, library_listed_at = NULL, library_unlisted = 0`); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// The library's albums go on the list as held, once (#5567). An album the
-// tags name by release only is named through MusicBrainz first; one nothing
-// names is counted, not listed. Taken off the list, an album stays off, and
-// one added to the library afterwards is never listed.
-func TestListLibrary_OnceAndThenTheListIsTheTruth_Integration(t *testing.T) {
-	pool := newPool(t)
-	ctx := context.Background()
-	q := dbq.New(pool)
-	s := newService(t, pool, newFakeMB(t))
-	s.releaseGroup = func(_ context.Context, release string) (string, error) {
-		if release == "rel-parklife" {
-			return "rg-parklife", nil
-		}
-		return "", tags.ErrNotFound
-	}
-	blurAlbum := seedHeld(t, q, "Blur", "rel-blur", "rg-blur", 3)
-	parklife := seedHeld(t, q, "Parklife", "rel-parklife", "", 2)
-	_ = seedHeld(t, q, "Bootleg", "rel-bootleg", "", 1)
-	// An album with a track gone: held from before the loss, so
-	// re-acquisition still fetches it back.
-	lost := seedHeld(t, q, "13", "rel-13", "rg-13", 2)
-	if _, err := pool.Exec(ctx, `UPDATE tracks SET missing_since = now() - interval '1 day'
-	                               WHERE album_id = $1 AND track_number = 1`, lost.ID); err != nil {
-		t.Fatal(err)
-	}
-	startListing(t, pool)
-
-	if err := s.listLibrary(ctx, &PassResult{}); err != nil {
-		t.Fatal(err)
-	}
-	for group, album := range map[string]pgtype.UUID{"rg-blur": blurAlbum.ID, "rg-parklife": parklife.ID, "rg-13": lost.ID} {
-		w, err := q.GetWantByReleaseGroup(ctx, group)
-		if err != nil {
-			t.Fatalf("%s not listed: %v", group, err)
-		}
-		if w.Reason != ReasonLibrary || !w.FulfilledAt.Valid || w.AlbumID != album {
-			t.Errorf("%s = %+v: a held library want about the album", group, w)
-		}
-	}
-	if w, _ := q.GetWantByReleaseGroup(ctx, "rg-13"); !w.FulfilledAt.Time.Before(time.Now().Add(-23 * time.Hour)) {
-		t.Errorf("an album missing a track is held from %v, not from before the loss", w.FulfilledAt.Time)
-	}
-	state, err := q.GetLibraryListing(ctx)
-	if err != nil || !state.LibraryListedAt.Valid || state.LibraryUnlisted != 1 {
-		t.Fatalf("listing = %+v %v: done, with the bootleg unlisted", state, err)
-	}
-
-	// Off the list stays off; an album added later is never listed.
-	w, _ := q.GetWantByReleaseGroup(ctx, "rg-blur")
-	if _, err := s.RemoveWant(ctx, w.ID); err != nil {
-		t.Fatal(err)
-	}
-	_ = seedHeld(t, q, "Think Tank", "rel-think", "rg-think", 2)
-	if _, err := s.Pass(ctx); err != nil {
-		t.Fatal(err)
-	}
-	for _, group := range []string{"rg-blur", "rg-think"} {
-		if _, err := q.GetWantByReleaseGroup(ctx, group); err == nil {
-			t.Errorf("%s is on the list", group)
-		}
-	}
-}
-
-// While MusicBrainz is switched off nothing can be named, so the listing
-// finishes with what it has rather than waiting for ever.
-func TestListLibrary_MusicBrainzOffFinishesWithWhatIsNamed_Integration(t *testing.T) {
-	pool := newPool(t)
-	ctx := context.Background()
-	q := dbq.New(pool)
-	s := newService(t, pool, newFakeMB(t))
-	s.releaseGroup = func(context.Context, string) (string, error) { return "", tags.ErrSwitchedOff }
-	_ = seedHeld(t, q, "Blur", "rel-blur", "rg-blur", 1)
-	_ = seedHeld(t, q, "Parklife", "rel-parklife", "", 1)
-	startListing(t, pool)
-	if err := s.listLibrary(ctx, &PassResult{}); err != nil {
-		t.Fatal(err)
-	}
-	state, _ := q.GetLibraryListing(ctx)
-	if !state.LibraryListedAt.Valid || state.LibraryUnlisted != 1 {
-		t.Errorf("listing = %+v", state)
-	}
-	var named *string
-	if err := pool.QueryRow(ctx, `SELECT release_group_mbid FROM albums WHERE title = 'Parklife'`).Scan(&named); err != nil {
-		t.Fatal(err)
-	}
-	if named != nil {
-		t.Errorf("an album was marked unnameable while MusicBrainz was off: %q", *named)
-	}
-}
-
-// A MusicBrainz that does not answer pauses the naming; the next pass goes on.
-func TestListLibrary_UnreachablePausesTheNaming_Integration(t *testing.T) {
-	pool := newPool(t)
-	ctx := context.Background()
-	q := dbq.New(pool)
-	s := newService(t, pool, newFakeMB(t))
-	down := true
-	s.releaseGroup = func(context.Context, string) (string, error) {
-		if down {
-			return "", tags.ErrTransient
-		}
-		return "rg-parklife", nil
-	}
-	_ = seedHeld(t, q, "Parklife", "rel-parklife", "", 1)
-	startListing(t, pool)
-	if err := s.listLibrary(ctx, &PassResult{}); err != nil {
-		t.Fatal(err)
-	}
-	if state, _ := q.GetLibraryListing(ctx); state.LibraryListedAt.Valid {
-		t.Fatal("finished while an album was still to be named")
-	}
-	down = false
-	if err := s.listLibrary(ctx, &PassResult{}); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := q.GetWantByReleaseGroup(ctx, "rg-parklife"); err != nil {
-		t.Errorf("not listed once named: %v", err)
-	}
-	if state, _ := q.GetLibraryListing(ctx); !state.LibraryListedAt.Valid {
-		t.Error("not finished")
-	}
-}