feat(library): adopt moved files instead of forking their history — #2528
Track identity was file_path, so a file that came back renamed or in a different directory looked like a deletion plus an unrelated new track: the old row kept the like and every play_event while a fresh zero-history row appeared, and nothing connected them. A liked song read as unliked, its play count reset, and Rediscover could offer it as a discovery — silently. Renumbering an album was enough, which is what happened to the operator's copy of Minutes to Midnight. Adoption re-points the existing row's file_path at the new location and clears its missing mark. The normal UpsertTrack then conflicts on file_path and updates THAT row, so the track id survives and likes, plays and playlist memberships travel with it — and clients see an update rather than a delete-and-create, so no cache churn either. Matching is MBID first (identifies the recording, so it survives a re-encode), then file_size + duration_ms for untagged files. Both fingerprint components must be non-zero: duration_ms is 0 when ffprobe failed, and matching 0 against 0 would pair up unrelated broken files. Only rows already marked missing are eligible — a row whose file is present elsewhere is a duplicate, not a move, and re-pointing it would corrupt the copy that still exists. An ambiguous match inserts fresh rather than adopting one arbitrarily: a fork is recoverable later, a wrong merge isn't. Scan is now three phases, and the order is the point. Adoption can only claim a row that is ALREADY marked missing, but reconcile previously ran after processing — so a rename performed while the server was down surfaced the deletion and the addition in the same scan, the new path inserted first, and the fork became permanent. Enumeration is therefore separated from processing so reconcile can run between them: walk (paths only, no tag reads or probes) -> reconcile -> process in walk order. Consequence worth knowing: when reconcile refuses (an absent root, or a reorganisation exceeding the 25% mark cap) adoption cannot fire and renamed files fork as before. That's the pre-#2528 behaviour rather than a new failure, and the warning now names it. The old outer walk-error branch was unreachable — the callback always returned nil, so WalkDir never surfaced an error — and verifyRootsPresent is the real protection, so enumerate counts walk errors instead of pretending to abort on them.
This commit is contained in:
@@ -0,0 +1,295 @@
|
||||
package library
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgtype"
|
||||
|
||||
"git.fabledsword.com/bvandeusen/minstrel/internal/db/dbq"
|
||||
)
|
||||
|
||||
type fakeAdopter struct {
|
||||
byMbid []dbq.FindMissingTrackByMbidRow
|
||||
byFingerprint []dbq.FindMissingTrackByFingerprintRow
|
||||
|
||||
mbidErr error
|
||||
fingerprintErr error
|
||||
adoptErr error
|
||||
adoptRows int64
|
||||
|
||||
mbidQueried []string
|
||||
fingerprintQueried []dbq.FindMissingTrackByFingerprintParams
|
||||
adopted []dbq.AdoptTrackPathParams
|
||||
}
|
||||
|
||||
func (f *fakeAdopter) FindMissingTrackByMbid(_ context.Context, mbid string) ([]dbq.FindMissingTrackByMbidRow, error) {
|
||||
f.mbidQueried = append(f.mbidQueried, mbid)
|
||||
return f.byMbid, f.mbidErr
|
||||
}
|
||||
|
||||
func (f *fakeAdopter) FindMissingTrackByFingerprint(
|
||||
_ context.Context, arg dbq.FindMissingTrackByFingerprintParams,
|
||||
) ([]dbq.FindMissingTrackByFingerprintRow, error) {
|
||||
f.fingerprintQueried = append(f.fingerprintQueried, arg)
|
||||
return f.byFingerprint, f.fingerprintErr
|
||||
}
|
||||
|
||||
func (f *fakeAdopter) AdoptTrackPath(_ context.Context, arg dbq.AdoptTrackPathParams) (int64, error) {
|
||||
f.adopted = append(f.adopted, arg)
|
||||
if f.adoptErr != nil {
|
||||
return 0, f.adoptErr
|
||||
}
|
||||
return f.adoptRows, nil
|
||||
}
|
||||
|
||||
// The narrowed interface must not drift from the real queries.
|
||||
var _ trackAdopter = (*dbq.Queries)(nil)
|
||||
|
||||
func mbidRow(n byte, path string) dbq.FindMissingTrackByMbidRow {
|
||||
return dbq.FindMissingTrackByMbidRow{ID: testUUID(n), FilePath: path}
|
||||
}
|
||||
|
||||
func fpRow(n byte, path string) dbq.FindMissingTrackByFingerprintRow {
|
||||
return dbq.FindMissingTrackByFingerprintRow{ID: testUUID(n), FilePath: path}
|
||||
}
|
||||
|
||||
const (
|
||||
oldPath = "/music/Linkin Park/Minutes to Midnight/02 - Bleed It Out.mp3"
|
||||
newPath = "/music/Linkin Park/Minutes to Midnight/04 - Bleed It Out.mp3"
|
||||
)
|
||||
|
||||
func TestAdoptMovedTrack_MatchesByMbid(t *testing.T) {
|
||||
s := testScanner(t)
|
||||
q := &fakeAdopter{byMbid: []dbq.FindMissingTrackByMbidRow{mbidRow(7, oldPath)}, adoptRows: 1}
|
||||
|
||||
if !s.adoptMovedTrack(context.Background(), q, newPath, 5_000_000, 200_000, "rec-mbid") {
|
||||
t.Fatal("expected the moved track to be adopted")
|
||||
}
|
||||
if len(q.adopted) != 1 {
|
||||
t.Fatalf("adopted %d rows, want 1", len(q.adopted))
|
||||
}
|
||||
if q.adopted[0].ID != testUUID(7) {
|
||||
t.Errorf("adopted the wrong row: %v", q.adopted[0].ID)
|
||||
}
|
||||
if q.adopted[0].FilePath != newPath {
|
||||
t.Errorf("adopted FilePath = %q, want %q", q.adopted[0].FilePath, newPath)
|
||||
}
|
||||
// MBID matched, so the weaker signal should not have been consulted.
|
||||
if len(q.fingerprintQueried) != 0 {
|
||||
t.Errorf("queried the fingerprint despite an MBID match")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdoptMovedTrack_FallsBackToFingerprint(t *testing.T) {
|
||||
s := testScanner(t)
|
||||
q := &fakeAdopter{byFingerprint: []dbq.FindMissingTrackByFingerprintRow{fpRow(3, oldPath)}, adoptRows: 1}
|
||||
|
||||
// No MBID: an untagged file, which is exactly what the fallback is for.
|
||||
if !s.adoptMovedTrack(context.Background(), q, newPath, 4_200_000, 187_000, "") {
|
||||
t.Fatal("expected adoption via fingerprint")
|
||||
}
|
||||
if len(q.mbidQueried) != 0 {
|
||||
t.Errorf("queried by MBID with no MBID available")
|
||||
}
|
||||
if len(q.fingerprintQueried) != 1 {
|
||||
t.Fatalf("fingerprint queried %d times, want 1", len(q.fingerprintQueried))
|
||||
}
|
||||
got := q.fingerprintQueried[0]
|
||||
if got.FileSize != 4_200_000 || got.DurationMs != 187_000 {
|
||||
t.Errorf("fingerprint = %+v, want size 4200000 duration 187000", got)
|
||||
}
|
||||
if len(q.adopted) != 1 || q.adopted[0].ID != testUUID(3) {
|
||||
t.Errorf("adopted = %+v, want row 3", q.adopted)
|
||||
}
|
||||
}
|
||||
|
||||
// Two missing rows carrying the same recording MBID means real duplicates.
|
||||
// Adopting one arbitrarily would attach this file's future history to a coin
|
||||
// flip, so it must insert fresh instead.
|
||||
func TestAdoptMovedTrack_RefusesAmbiguousMbidMatch(t *testing.T) {
|
||||
s := testScanner(t)
|
||||
q := &fakeAdopter{byMbid: []dbq.FindMissingTrackByMbidRow{
|
||||
mbidRow(1, "/music/a.mp3"),
|
||||
mbidRow(2, "/music/b.mp3"),
|
||||
}, adoptRows: 1}
|
||||
|
||||
if s.adoptMovedTrack(context.Background(), q, newPath, 0, 0, "rec-mbid") {
|
||||
t.Fatal("expected refusal on an ambiguous MBID match")
|
||||
}
|
||||
if len(q.adopted) != 0 {
|
||||
t.Errorf("adopted despite ambiguity: %+v", q.adopted)
|
||||
}
|
||||
}
|
||||
|
||||
// An ambiguous MBID may still be resolvable by the fingerprint, which is a
|
||||
// narrower signal — so falling through is allowed to succeed.
|
||||
func TestAdoptMovedTrack_AmbiguousMbidFallsThroughToFingerprint(t *testing.T) {
|
||||
s := testScanner(t)
|
||||
q := &fakeAdopter{
|
||||
byMbid: []dbq.FindMissingTrackByMbidRow{
|
||||
mbidRow(1, "/music/a.mp3"),
|
||||
mbidRow(2, "/music/b.mp3"),
|
||||
},
|
||||
byFingerprint: []dbq.FindMissingTrackByFingerprintRow{fpRow(2, "/music/b.mp3")},
|
||||
adoptRows: 1,
|
||||
}
|
||||
|
||||
if !s.adoptMovedTrack(context.Background(), q, newPath, 1000, 2000, "rec-mbid") {
|
||||
t.Fatal("expected the fingerprint to disambiguate")
|
||||
}
|
||||
if len(q.adopted) != 1 || q.adopted[0].ID != testUUID(2) {
|
||||
t.Errorf("adopted = %+v, want row 2", q.adopted)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdoptMovedTrack_RefusesAmbiguousFingerprintMatch(t *testing.T) {
|
||||
s := testScanner(t)
|
||||
q := &fakeAdopter{byFingerprint: []dbq.FindMissingTrackByFingerprintRow{
|
||||
fpRow(1, "/music/a.mp3"),
|
||||
fpRow(2, "/music/b.mp3"),
|
||||
}, adoptRows: 1}
|
||||
|
||||
if s.adoptMovedTrack(context.Background(), q, newPath, 1000, 2000, "") {
|
||||
t.Fatal("expected refusal on an ambiguous fingerprint match")
|
||||
}
|
||||
if len(q.adopted) != 0 {
|
||||
t.Errorf("adopted despite ambiguity: %+v", q.adopted)
|
||||
}
|
||||
}
|
||||
|
||||
// duration_ms is 0 when ffprobe failed. Matching 0 against 0 would pair up
|
||||
// unrelated broken files, so the fingerprint must not be attempted.
|
||||
func TestAdoptMovedTrack_SkipsFingerprintWithoutRealValues(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
size int64
|
||||
duration int32
|
||||
}{
|
||||
{"no duration", 1000, 0},
|
||||
{"no size", 0, 2000},
|
||||
{"neither", 0, 0},
|
||||
}
|
||||
for _, tc := range tests {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
s := testScanner(t)
|
||||
q := &fakeAdopter{
|
||||
byFingerprint: []dbq.FindMissingTrackByFingerprintRow{fpRow(1, oldPath)},
|
||||
adoptRows: 1,
|
||||
}
|
||||
if s.adoptMovedTrack(context.Background(), q, newPath, tc.size, tc.duration, "") {
|
||||
t.Error("adopted on an unusable fingerprint")
|
||||
}
|
||||
if len(q.fingerprintQueried) != 0 {
|
||||
t.Error("queried the fingerprint with unusable values")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdoptMovedTrack_NoCandidates(t *testing.T) {
|
||||
s := testScanner(t)
|
||||
q := &fakeAdopter{adoptRows: 1}
|
||||
|
||||
if s.adoptMovedTrack(context.Background(), q, newPath, 1000, 2000, "rec-mbid") {
|
||||
t.Fatal("expected no adoption when nothing matches")
|
||||
}
|
||||
if len(q.adopted) != 0 {
|
||||
t.Errorf("adopted with no candidates: %+v", q.adopted)
|
||||
}
|
||||
}
|
||||
|
||||
// The row's mark was cleared between lookup and update — another file adopted it
|
||||
// first. AdoptTrackPath's `missing_since IS NOT NULL` predicate reports 0 rows.
|
||||
func TestAdoptMovedTrack_LostRaceReportsNotAdopted(t *testing.T) {
|
||||
s := testScanner(t)
|
||||
q := &fakeAdopter{
|
||||
byMbid: []dbq.FindMissingTrackByMbidRow{mbidRow(5, oldPath)},
|
||||
adoptRows: 0,
|
||||
}
|
||||
|
||||
if s.adoptMovedTrack(context.Background(), q, newPath, 1000, 2000, "rec-mbid") {
|
||||
t.Fatal("expected not-adopted when the update matched no rows")
|
||||
}
|
||||
}
|
||||
|
||||
// Failing to detect a move must never fail the file: the caller falls back to
|
||||
// inserting a fresh row, which is the pre-#2528 behaviour.
|
||||
func TestAdoptMovedTrack_ToleratesQueryErrors(t *testing.T) {
|
||||
sentinel := errors.New("db down")
|
||||
tests := []struct {
|
||||
name string
|
||||
q *fakeAdopter
|
||||
}{
|
||||
{"mbid lookup fails", &fakeAdopter{mbidErr: sentinel}},
|
||||
{"fingerprint lookup fails", &fakeAdopter{fingerprintErr: sentinel}},
|
||||
{"adopt fails", &fakeAdopter{
|
||||
byMbid: []dbq.FindMissingTrackByMbidRow{mbidRow(1, oldPath)},
|
||||
adoptErr: sentinel,
|
||||
}},
|
||||
}
|
||||
for _, tc := range tests {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
s := testScanner(t)
|
||||
if s.adoptMovedTrack(context.Background(), tc.q, newPath, 1000, 2000, "rec-mbid") {
|
||||
t.Error("reported adoption despite a query error")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// A failed MBID lookup must not stop the fingerprint from being tried.
|
||||
func TestAdoptMovedTrack_MbidErrorStillTriesFingerprint(t *testing.T) {
|
||||
s := testScanner(t)
|
||||
q := &fakeAdopter{
|
||||
mbidErr: errors.New("db hiccup"),
|
||||
byFingerprint: []dbq.FindMissingTrackByFingerprintRow{fpRow(9, oldPath)},
|
||||
adoptRows: 1,
|
||||
}
|
||||
|
||||
if !s.adoptMovedTrack(context.Background(), q, newPath, 1000, 2000, "rec-mbid") {
|
||||
t.Fatal("expected the fingerprint to be tried after an MBID lookup error")
|
||||
}
|
||||
if len(q.adopted) != 1 || q.adopted[0].ID != testUUID(9) {
|
||||
t.Errorf("adopted = %+v, want row 9", q.adopted)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUniqueMatch(t *testing.T) {
|
||||
s := testScanner(t)
|
||||
if _, ok := s.uniqueMatch(nil, newPath, "mbid"); ok {
|
||||
t.Error("empty candidate set matched")
|
||||
}
|
||||
c, ok := s.uniqueMatch([]candidate{{id: testUUID(4), filePath: oldPath}}, newPath, "mbid")
|
||||
if !ok {
|
||||
t.Fatal("single candidate did not match")
|
||||
}
|
||||
if c.id != testUUID(4) || c.filePath != oldPath {
|
||||
t.Errorf("candidate = %+v, want id 4 at %q", c, oldPath)
|
||||
}
|
||||
if _, ok := s.uniqueMatch([]candidate{
|
||||
{id: testUUID(1)}, {id: testUUID(2)},
|
||||
}, newPath, "mbid"); ok {
|
||||
t.Error("multiple candidates matched")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRowConverters(t *testing.T) {
|
||||
got := rowsFromMbid([]dbq.FindMissingTrackByMbidRow{mbidRow(1, "/a"), mbidRow(2, "/b")})
|
||||
if len(got) != 2 || got[0].id != testUUID(1) || got[1].filePath != "/b" {
|
||||
t.Errorf("rowsFromMbid = %+v", got)
|
||||
}
|
||||
got = rowsFromFingerprint([]dbq.FindMissingTrackByFingerprintRow{fpRow(3, "/c")})
|
||||
if len(got) != 1 || got[0].id != testUUID(3) || got[0].filePath != "/c" {
|
||||
t.Errorf("rowsFromFingerprint = %+v", got)
|
||||
}
|
||||
}
|
||||
|
||||
// pgtype.UUID zero value must not be mistaken for a real id.
|
||||
func TestUniqueMatch_ZeroUUIDNotValid(t *testing.T) {
|
||||
var zero pgtype.UUID
|
||||
if zero.Valid {
|
||||
t.Fatal("zero pgtype.UUID should not be Valid")
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user