mirror of
https://github.com/navidrome/navidrome.git
synced 2026-10-08 10:27:08 +02:00
b293b96256* refactor(persistence): adopt generic deluan/rest repository API Pin deluan/rest to the refactor branch. REST-facing repository methods take a context and return typed values. Drop DataStore.Resource and ResourceRepository; the native API names typed repositories directly through a per-request adapter that later commits remove. * refactor(persistence): base repository helpers take a context * refactor(persistence): LibraryRepository takes a context per call * refactor(persistence): PropertyRepository takes a context per call * refactor(persistence): UserPropsRepository takes a context per call * refactor(persistence): TranscodingRepository takes a context per call * refactor(persistence): ShareRepository takes a context per call * refactor(persistence): PlayerRepository takes a context per call * refactor(persistence): RadioRepository takes a context per call * refactor(persistence): PlayQueueRepository takes a context per call * refactor(persistence): Tag and Genre repositories take a context per call * refactor(persistence): PluginRepository takes a context per call * refactor(persistence): Scrobble repositories take a context per call * refactor(persistence): FolderRepository takes a context per call * refactor(persistence): Artwork repositories take a context per call * refactor(persistence): UserRepository takes a context per call * refactor(persistence): ArtistRepository takes a context per call ReadAll no longer rewrites the shared sort mappings for the role filter; it works on a per-call copy. * test(persistence): assert artist role sort sanitization in ReadAll * refactor(persistence): AlbumRepository takes a context per call * test(persistence): pass the test context to album repository helpers * refactor(persistence): MediaFileRepository takes a context per call * refactor(persistence): Playlist repositories take a context per call * refactor(persistence): build all repositories once per store * refactor(core): REST repository wrappers are built once * refactor(persistence): repositories are stateless Remove the context field from the base repository and the per-request REST adapter. Enable the containedctx linter so no repository can hold a request context again. * chore(lint): skip containedctx in test files * refactor: share simplifications from the stateless repositories sweep Add deleteOwnedAll on sqlRepository and use it in player/share Delete to remove the duplicated bulk-delete loop; have Share.Repository() return model.ShareRepository so subsonic sharing.go drops its repeated type assertions. * chore(core): assert REST wrappers implement Persistable * chore: reformat imports * perf(persistence): build repositories on first use Each transaction store used to construct all 21 repositories up front, paying for filter and sort mapping setup the block never touched. Fields are now sync.OnceValue thunks, so a store only builds what it uses. * fix(persistence): clean plugin references per deleted user A bulk user delete that fails on a later id had already removed the earlier rows but skipped their plugin cleanup. Cleanup now runs right after each successful delete. * fix(core): unload disabled plugins even when a user delete fails A bulk delete can fail on a later id after earlier users were removed and their plugins auto-disabled. The wrapper returned before unloading, leaving those plugins running until the next successful delete or a restart. * chore(deps): pin deluan/rest to v1.0.1 Replaces the pseudo-version of the refactor branch with the tagged release. REST error messages now name the bare type (Artist, not model.Artist). * test: use the spec context instead of context.Background() Replace the context.Background()/context.TODO() calls this branch added to tests with the spec's ctx, GinkgoT().Context(), or t/b.Context(), so repository calls are bound to the running spec's lifetime. * test: declare the spec context once per Describe Set ctx from GinkgoT().Context() first in each top-level BeforeEach and reuse it, building user contexts on top of it instead of repeating inline calls.
1073 lines
37 KiB
Go
1073 lines
37 KiB
Go
package scanner
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"maps"
|
|
"time"
|
|
|
|
"github.com/navidrome/navidrome/conf"
|
|
"github.com/navidrome/navidrome/consts"
|
|
"github.com/navidrome/navidrome/model"
|
|
"github.com/navidrome/navidrome/tests"
|
|
. "github.com/onsi/ginkgo/v2"
|
|
. "github.com/onsi/gomega"
|
|
)
|
|
|
|
var _ = Describe("phaseMissingTracks", func() {
|
|
var (
|
|
phase *phaseMissingTracks
|
|
ctx context.Context
|
|
ds model.DataStore
|
|
mr *tests.MockMediaFileRepo
|
|
lr *tests.MockLibraryRepo
|
|
state *scanState
|
|
)
|
|
|
|
BeforeEach(func() {
|
|
ctx = context.Background()
|
|
mr = tests.CreateMockMediaFileRepo()
|
|
lr = &tests.MockLibraryRepo{}
|
|
lr.SetData(model.Libraries{{ID: 1, LastScanStartedAt: time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)}})
|
|
ds = &tests.MockDataStore{MockedMediaFile: mr, MockedLibrary: lr}
|
|
state = &scanState{
|
|
libraries: model.Libraries{{ID: 1, LastScanStartedAt: time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)}},
|
|
totalLibraryCount: 1,
|
|
}
|
|
phase = createPhaseMissingTracks(ctx, state, ds)
|
|
})
|
|
|
|
Describe("produceMissingTracks", func() {
|
|
var (
|
|
put func(tracks *missingTracks)
|
|
produced []*missingTracks
|
|
)
|
|
|
|
BeforeEach(func() {
|
|
produced = nil
|
|
put = func(tracks *missingTracks) {
|
|
produced = append(produced, tracks)
|
|
}
|
|
})
|
|
|
|
When("there are no missing tracks", func() {
|
|
It("should not call put", func() {
|
|
mr.SetData(model.MediaFiles{
|
|
{ID: "1", PID: "A", Missing: false},
|
|
{ID: "2", PID: "A", Missing: false},
|
|
})
|
|
|
|
err := phase.produce(put)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(produced).To(BeEmpty())
|
|
})
|
|
})
|
|
|
|
When("there are missing tracks", func() {
|
|
It("should call put for any missing tracks with corresponding matches", func() {
|
|
mr.SetData(model.MediaFiles{
|
|
{ID: "1", PID: "A", Missing: true, LibraryID: 1},
|
|
{ID: "2", PID: "B", Missing: true, LibraryID: 1},
|
|
{ID: "3", PID: "A", Missing: false, LibraryID: 1},
|
|
})
|
|
|
|
err := phase.produce(put)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(produced).To(HaveLen(2))
|
|
// PID A should have both missing and matched tracks
|
|
var pidA *missingTracks
|
|
for _, p := range produced {
|
|
if p.pid == "A" {
|
|
pidA = p
|
|
break
|
|
}
|
|
}
|
|
Expect(pidA).ToNot(BeNil())
|
|
Expect(pidA.missing).To(HaveLen(1))
|
|
Expect(pidA.matched).To(HaveLen(1))
|
|
// PID B should have only missing tracks
|
|
var pidB *missingTracks
|
|
for _, p := range produced {
|
|
if p.pid == "B" {
|
|
pidB = p
|
|
break
|
|
}
|
|
}
|
|
Expect(pidB).ToNot(BeNil())
|
|
Expect(pidB.missing).To(HaveLen(1))
|
|
Expect(pidB.matched).To(HaveLen(0))
|
|
})
|
|
It("should call put for any missing tracks even without matches", func() {
|
|
mr.SetData(model.MediaFiles{
|
|
{ID: "1", PID: "A", Missing: true, LibraryID: 1},
|
|
{ID: "2", PID: "B", Missing: true, LibraryID: 1},
|
|
{ID: "3", PID: "C", Missing: false, LibraryID: 1},
|
|
})
|
|
|
|
err := phase.produce(put)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(produced).To(HaveLen(2))
|
|
// Both PID A and PID B should be produced even without matches
|
|
var pidA, pidB *missingTracks
|
|
for _, p := range produced {
|
|
if p.pid == "A" {
|
|
pidA = p
|
|
} else if p.pid == "B" {
|
|
pidB = p
|
|
}
|
|
}
|
|
Expect(pidA).ToNot(BeNil())
|
|
Expect(pidA.missing).To(HaveLen(1))
|
|
Expect(pidA.matched).To(HaveLen(0))
|
|
Expect(pidB).ToNot(BeNil())
|
|
Expect(pidB.missing).To(HaveLen(1))
|
|
Expect(pidB.matched).To(HaveLen(0))
|
|
})
|
|
})
|
|
})
|
|
|
|
Describe("processMissingTracks", func() {
|
|
It("should move the matched track when the missing track is the exact same", func() {
|
|
missingTrack := model.MediaFile{ID: "1", PID: "A", Path: "dir1/path1.mp3", Tags: model.Tags{"title": []string{"title1"}}, Size: 100}
|
|
matchedTrack := model.MediaFile{ID: "2", PID: "A", Path: "dir2/path2.mp3", Tags: model.Tags{"title": []string{"title1"}}, Size: 100}
|
|
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &matchedTrack)
|
|
|
|
in := &missingTracks{
|
|
missing: []model.MediaFile{missingTrack},
|
|
matched: []model.MediaFile{matchedTrack},
|
|
}
|
|
|
|
_, err := phase.processMissingTracks(in)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(phase.totalMatched.Load()).To(Equal(uint32(1)))
|
|
Expect(state.changesDetected.Load()).To(BeTrue())
|
|
|
|
movedTrack, _ := ds.MediaFile().Get(ctx, "1")
|
|
Expect(movedTrack.Path).To(Equal(matchedTrack.Path))
|
|
})
|
|
|
|
Context("claiming the album annotation reassignment", func() {
|
|
var probe *probeTxDS
|
|
missingTrack := model.MediaFile{ID: "1", PID: "A", AlbumID: "old-album", Path: "dir1/path1.mp3", Tags: model.Tags{"title": []string{"title1"}}, Size: 100}
|
|
matchedTrack := model.MediaFile{ID: "2", PID: "A", AlbumID: "new-album", Path: "dir2/path2.mp3", Tags: model.Tags{"title": []string{"title1"}}, Size: 100}
|
|
BeforeEach(func() {
|
|
probe = &probeTxDS{MockDataStore: ds.(*tests.MockDataStore)}
|
|
probe.MockedAlbum = tests.CreateMockAlbumRepo()
|
|
phase = createPhaseMissingTracks(ctx, state, probe)
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &matchedTrack)
|
|
})
|
|
|
|
It("claims the target album before the transaction, so a concurrent move skips it", func() {
|
|
probe.during = func() {
|
|
phase.annotationMutex.RLock()
|
|
defer phase.annotationMutex.RUnlock()
|
|
Expect(phase.processedAlbumAnnotations).To(HaveKeyWithValue("new-album", true))
|
|
}
|
|
Expect(phase.moveMatched(matchedTrack, missingTrack)).To(Succeed())
|
|
})
|
|
|
|
It("releases the claim when the move fails, so a later move can reassign", func() {
|
|
probe.err = errors.New("boom")
|
|
Expect(phase.moveMatched(matchedTrack, missingTrack)).To(MatchError("boom"))
|
|
Expect(phase.processedAlbumAnnotations).ToNot(HaveKey("new-album"))
|
|
})
|
|
})
|
|
|
|
Context("when the move transaction is rerun after a busy rollback", func() {
|
|
var rerunDS *rerunTxDS
|
|
BeforeEach(func() {
|
|
rerunDS = &rerunTxDS{MockDataStore: ds.(*tests.MockDataStore)}
|
|
rerunDS.snapshot = func() func() {
|
|
saved := maps.Clone(mr.Data)
|
|
return func() { mr.Data = saved }
|
|
}
|
|
phase = createPhaseMissingTracks(ctx, state, rerunDS)
|
|
})
|
|
|
|
It("keeps the moved track", func() {
|
|
missingTrack := model.MediaFile{ID: "1", PID: "A", Path: "dir1/path1.mp3", Tags: model.Tags{"title": []string{"title1"}}, Size: 100}
|
|
matchedTrack := model.MediaFile{ID: "2", PID: "A", Path: "dir2/path2.mp3", Tags: model.Tags{"title": []string{"title1"}}, Size: 100}
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &matchedTrack)
|
|
|
|
_, err := phase.processMissingTracks(&missingTracks{
|
|
missing: []model.MediaFile{missingTrack},
|
|
matched: []model.MediaFile{matchedTrack},
|
|
})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
|
|
movedTrack, err := ds.MediaFile().Get(ctx, "1")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(movedTrack.Path).To(Equal(matchedTrack.Path))
|
|
})
|
|
|
|
It("reassigns the album annotations in the attempt that commits", func() {
|
|
albumRepo := tests.CreateMockAlbumRepo()
|
|
rerunDS.MockedAlbum = albumRepo
|
|
restoreTracks := rerunDS.snapshot
|
|
rerunDS.snapshot = func() func() {
|
|
restore := restoreTracks()
|
|
return func() {
|
|
restore()
|
|
albumRepo.ReassignAnnotationCalls = nil
|
|
}
|
|
}
|
|
missingTrack := model.MediaFile{ID: "1", PID: "A", AlbumID: "old-album", Path: "dir1/path1.mp3", Tags: model.Tags{"title": []string{"title1"}}, Size: 100}
|
|
matchedTrack := model.MediaFile{ID: "2", PID: "A", AlbumID: "new-album", Path: "dir2/path2.mp3", Tags: model.Tags{"title": []string{"title1"}}, Size: 100}
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &matchedTrack)
|
|
|
|
_, err := phase.processMissingTracks(&missingTracks{
|
|
missing: []model.MediaFile{missingTrack},
|
|
matched: []model.MediaFile{matchedTrack},
|
|
})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(albumRepo.ReassignAnnotationCalls).To(HaveKeyWithValue("old-album", "new-album"))
|
|
})
|
|
})
|
|
|
|
It("should move the matched track when the missing track has the same tags and filename", func() {
|
|
missingTrack := model.MediaFile{ID: "1", PID: "A", Path: "path1.mp3", Tags: model.Tags{"title": []string{"title1"}}, Size: 100}
|
|
matchedTrack := model.MediaFile{ID: "2", PID: "A", Path: "path1.flac", Tags: model.Tags{"title": []string{"title1"}}, Size: 200}
|
|
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &matchedTrack)
|
|
|
|
in := &missingTracks{
|
|
missing: []model.MediaFile{missingTrack},
|
|
matched: []model.MediaFile{matchedTrack},
|
|
}
|
|
|
|
_, err := phase.processMissingTracks(in)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(phase.totalMatched.Load()).To(Equal(uint32(1)))
|
|
Expect(state.changesDetected.Load()).To(BeTrue())
|
|
|
|
movedTrack, _ := ds.MediaFile().Get(ctx, "1")
|
|
Expect(movedTrack.Path).To(Equal(matchedTrack.Path))
|
|
Expect(movedTrack.Size).To(Equal(matchedTrack.Size))
|
|
})
|
|
|
|
It("should move the matched track when there's only one missing track and one matched track (same PID)", func() {
|
|
missingTrack := model.MediaFile{ID: "1", PID: "A", Path: "dir1/path1.mp3", Tags: model.Tags{"title": []string{"title1"}}, Size: 100}
|
|
matchedTrack := model.MediaFile{ID: "2", PID: "A", Path: "dir2/path2.flac", Tags: model.Tags{"title": []string{"different title"}}, Size: 200}
|
|
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &matchedTrack)
|
|
|
|
in := &missingTracks{
|
|
missing: []model.MediaFile{missingTrack},
|
|
matched: []model.MediaFile{matchedTrack},
|
|
}
|
|
|
|
_, err := phase.processMissingTracks(in)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(phase.totalMatched.Load()).To(Equal(uint32(1)))
|
|
Expect(state.changesDetected.Load()).To(BeTrue())
|
|
|
|
movedTrack, _ := ds.MediaFile().Get(ctx, "1")
|
|
Expect(movedTrack.Path).To(Equal(matchedTrack.Path))
|
|
Expect(movedTrack.Size).To(Equal(matchedTrack.Size))
|
|
})
|
|
|
|
It("should prioritize exact matches", func() {
|
|
missingTrack := model.MediaFile{ID: "1", PID: "A", Path: "dir1/file1.mp3", Tags: model.Tags{"title": []string{"title1"}}, Size: 100}
|
|
matchedEquivalent := model.MediaFile{ID: "2", PID: "A", Path: "dir1/file1.flac", Tags: model.Tags{"title": []string{"title1"}}, Size: 200}
|
|
matchedExact := model.MediaFile{ID: "3", PID: "A", Path: "dir2/file2.mp3", Tags: model.Tags{"title": []string{"title1"}}, Size: 100}
|
|
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &matchedEquivalent)
|
|
_ = ds.MediaFile().Put(ctx, &matchedExact)
|
|
|
|
in := &missingTracks{
|
|
missing: []model.MediaFile{missingTrack},
|
|
// Note that equivalent comes before the exact match
|
|
matched: []model.MediaFile{matchedEquivalent, matchedExact},
|
|
}
|
|
|
|
_, err := phase.processMissingTracks(in)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(phase.totalMatched.Load()).To(Equal(uint32(1)))
|
|
Expect(state.changesDetected.Load()).To(BeTrue())
|
|
|
|
movedTrack, _ := ds.MediaFile().Get(ctx, "1")
|
|
Expect(movedTrack.Path).To(Equal(matchedExact.Path))
|
|
Expect(movedTrack.Size).To(Equal(matchedExact.Size))
|
|
})
|
|
|
|
It("should not move anything if there's more than one match and they don't are not exact nor equivalent", func() {
|
|
missingTrack := model.MediaFile{ID: "1", PID: "A", Path: "dir1/file1.mp3", Title: "title1", Size: 100}
|
|
matched1 := model.MediaFile{ID: "2", PID: "A", Path: "dir1/file2.flac", Title: "another title", Size: 200}
|
|
matched2 := model.MediaFile{ID: "3", PID: "A", Path: "dir2/file3.mp3", Title: "different title", Size: 100}
|
|
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &matched1)
|
|
_ = ds.MediaFile().Put(ctx, &matched2)
|
|
|
|
in := &missingTracks{
|
|
missing: []model.MediaFile{missingTrack},
|
|
matched: []model.MediaFile{matched1, matched2},
|
|
}
|
|
|
|
_, err := phase.processMissingTracks(in)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(phase.totalMatched.Load()).To(Equal(uint32(0)))
|
|
Expect(state.changesDetected.Load()).To(BeFalse())
|
|
|
|
// The missing track should still be the same
|
|
movedTrack, _ := ds.MediaFile().Get(ctx, "1")
|
|
Expect(movedTrack.Path).To(Equal(missingTrack.Path))
|
|
Expect(movedTrack.Title).To(Equal(missingTrack.Title))
|
|
Expect(movedTrack.Size).To(Equal(missingTrack.Size))
|
|
})
|
|
|
|
It("should not match the same target to multiple missing tracks (prevents duplicate paths)", func() {
|
|
// Simulate a scenario where two missing tracks from different locations have the same
|
|
// base filename and match the same newly imported track via IsEquivalent.
|
|
// Without deduplication, both missing tracks would be "moved" to the same target,
|
|
// creating two non-missing records with the same path.
|
|
missingTrack1 := model.MediaFile{ID: "1", PID: "A", Path: "old_dir1/song.mp3", Title: "title1", Size: 100}
|
|
missingTrack2 := model.MediaFile{ID: "2", PID: "A", Path: "old_dir2/song.mp3", Title: "title1", Size: 100}
|
|
matchedTrack := model.MediaFile{ID: "3", PID: "A", Path: "new_dir/song.mp3", Title: "title1", Size: 200}
|
|
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack1)
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack2)
|
|
_ = ds.MediaFile().Put(ctx, &matchedTrack)
|
|
|
|
in := &missingTracks{
|
|
missing: []model.MediaFile{missingTrack1, missingTrack2},
|
|
matched: []model.MediaFile{matchedTrack},
|
|
}
|
|
|
|
_, err := phase.processMissingTracks(in)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
// Only one of the missing tracks should be matched
|
|
Expect(phase.totalMatched.Load()).To(Equal(uint32(1)))
|
|
Expect(state.changesDetected.Load()).To(BeTrue())
|
|
|
|
// The matched track should have been consumed by the first missing track
|
|
movedTrack, _ := ds.MediaFile().Get(ctx, "1")
|
|
Expect(movedTrack.Path).To(Equal(matchedTrack.Path))
|
|
|
|
// The second missing track should remain unchanged
|
|
unmatchedTrack, _ := ds.MediaFile().Get(ctx, "2")
|
|
Expect(unmatchedTrack.Path).To(Equal(missingTrack2.Path))
|
|
})
|
|
|
|
It("should return an error when there's an error moving the matched track", func() {
|
|
missingTrack := model.MediaFile{ID: "1", PID: "A", Path: "path1.mp3", Tags: model.Tags{"title": []string{"title1"}}}
|
|
matchedTrack := model.MediaFile{ID: "2", PID: "A", Path: "path1.mp3", Tags: model.Tags{"title": []string{"title1"}}}
|
|
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &matchedTrack)
|
|
|
|
in := &missingTracks{
|
|
missing: []model.MediaFile{missingTrack},
|
|
matched: []model.MediaFile{matchedTrack},
|
|
}
|
|
|
|
// Simulate an error when moving the matched track by deleting the track from the DB
|
|
_ = ds.MediaFile().Delete(ctx, "2")
|
|
|
|
_, err := phase.processMissingTracks(in)
|
|
Expect(err).To(HaveOccurred())
|
|
Expect(state.changesDetected.Load()).To(BeFalse())
|
|
})
|
|
})
|
|
|
|
Describe("finalize", func() {
|
|
It("should return nil if no error", func() {
|
|
err := phase.finalize(nil)
|
|
Expect(err).To(BeNil())
|
|
Expect(state.changesDetected.Load()).To(BeFalse())
|
|
})
|
|
|
|
It("should return the error if provided", func() {
|
|
err := phase.finalize(context.DeadlineExceeded)
|
|
Expect(err).To(Equal(context.DeadlineExceeded))
|
|
Expect(state.changesDetected.Load()).To(BeFalse())
|
|
})
|
|
|
|
When("PurgeMissing is 'always'", func() {
|
|
BeforeEach(func() {
|
|
conf.Server.Scanner.PurgeMissing = consts.PurgeMissingAlways
|
|
mr.SetCountAll(3)
|
|
mr.DeleteAllMissingValue = 3
|
|
})
|
|
It("should purge missing files", func() {
|
|
Expect(state.changesDetected.Load()).To(BeFalse())
|
|
err := phase.finalize(nil)
|
|
Expect(err).To(BeNil())
|
|
Expect(state.changesDetected.Load()).To(BeTrue())
|
|
})
|
|
})
|
|
|
|
When("PurgeMissing is 'full'", func() {
|
|
BeforeEach(func() {
|
|
conf.Server.Scanner.PurgeMissing = consts.PurgeMissingFull
|
|
mr.SetCountAll(2)
|
|
mr.DeleteAllMissingValue = 2
|
|
})
|
|
It("should not purge missing files if not a full scan", func() {
|
|
state.fullScan = false
|
|
err := phase.finalize(nil)
|
|
Expect(err).To(BeNil())
|
|
Expect(state.changesDetected.Load()).To(BeFalse())
|
|
})
|
|
It("should purge missing files if full scan", func() {
|
|
Expect(state.changesDetected.Load()).To(BeFalse())
|
|
state.fullScan = true
|
|
err := phase.finalize(nil)
|
|
Expect(err).To(BeNil())
|
|
Expect(state.changesDetected.Load()).To(BeTrue())
|
|
})
|
|
})
|
|
|
|
When("PurgeMissing is 'never'", func() {
|
|
BeforeEach(func() {
|
|
conf.Server.Scanner.PurgeMissing = consts.PurgeMissingNever
|
|
mr.SetCountAll(1)
|
|
mr.DeleteAllMissingValue = 1
|
|
})
|
|
It("should not purge missing files", func() {
|
|
err := phase.finalize(nil)
|
|
Expect(err).To(BeNil())
|
|
Expect(state.changesDetected.Load()).To(BeFalse())
|
|
})
|
|
})
|
|
})
|
|
|
|
Describe("processCrossLibraryMoves", func() {
|
|
It("should skip processing if input is nil", func() {
|
|
result, err := phase.processCrossLibraryMoves(nil)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(result).To(BeNil())
|
|
})
|
|
|
|
It("should skip cross-library move detection when only one library is configured", func() {
|
|
// Default BeforeEach sets up single library, so we just need to verify skip behavior
|
|
Expect(state.totalLibraryCount).To(Equal(1))
|
|
|
|
missingTrack := model.MediaFile{
|
|
ID: "missing1",
|
|
LibraryID: 1,
|
|
MbzReleaseTrackID: "mbz-track-123",
|
|
Title: "Test Track",
|
|
Size: 1000,
|
|
Suffix: "mp3",
|
|
Path: "/lib1/track.mp3",
|
|
Missing: true,
|
|
CreatedAt: time.Now().Add(-30 * time.Minute),
|
|
}
|
|
|
|
in := &missingTracks{
|
|
lib: model.Library{ID: 1, Name: "Library 1"},
|
|
missing: []model.MediaFile{missingTrack},
|
|
}
|
|
|
|
result, err := phase.processCrossLibraryMoves(in)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
// Should return input unchanged (no processing done)
|
|
Expect(result).To(Equal(in))
|
|
// No matches should be found since cross-library search was skipped
|
|
Expect(phase.totalMatched.Load()).To(Equal(uint32(0)))
|
|
// No changes should be detected
|
|
Expect(state.changesDetected.Load()).To(BeFalse())
|
|
})
|
|
|
|
Context("with multiple libraries", func() {
|
|
BeforeEach(func() {
|
|
// Set up multiple libraries for cross-library move tests
|
|
state.libraries = model.Libraries{
|
|
{ID: 1, LastScanStartedAt: time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)},
|
|
{ID: 2, LastScanStartedAt: time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)},
|
|
}
|
|
state.totalLibraryCount = 2
|
|
})
|
|
|
|
It("should process cross-library moves using MusicBrainz Track ID", func() {
|
|
scanStartTime := time.Now().Add(-1 * time.Hour)
|
|
missingTrack := model.MediaFile{
|
|
ID: "missing1",
|
|
LibraryID: 1,
|
|
MbzReleaseTrackID: "mbz-track-123",
|
|
Title: "Test Track",
|
|
Size: 1000,
|
|
Suffix: "mp3",
|
|
Path: "/lib1/track.mp3",
|
|
Missing: true,
|
|
CreatedAt: scanStartTime.Add(-30 * time.Minute),
|
|
}
|
|
|
|
movedTrack := model.MediaFile{
|
|
ID: "moved1",
|
|
LibraryID: 2,
|
|
MbzReleaseTrackID: "mbz-track-123",
|
|
Title: "Test Track",
|
|
Size: 1000,
|
|
Suffix: "mp3",
|
|
Path: "/lib2/track.mp3",
|
|
Missing: false,
|
|
CreatedAt: scanStartTime.Add(-10 * time.Minute),
|
|
}
|
|
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &movedTrack)
|
|
|
|
in := &missingTracks{
|
|
lib: model.Library{ID: 1, Name: "Library 1"},
|
|
missing: []model.MediaFile{missingTrack},
|
|
}
|
|
|
|
result, err := phase.processCrossLibraryMoves(in)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(result).To(Equal(in))
|
|
Expect(phase.totalMatched.Load()).To(Equal(uint32(1)))
|
|
Expect(state.changesDetected.Load()).To(BeTrue())
|
|
|
|
// Verify the move was performed
|
|
updatedTrack, _ := ds.MediaFile().Get(ctx, "missing1")
|
|
Expect(updatedTrack.Path).To(Equal("/lib2/track.mp3"))
|
|
Expect(updatedTrack.LibraryID).To(Equal(2))
|
|
})
|
|
|
|
It("should fall back to intrinsic properties when MBZ Track ID is empty", func() {
|
|
scanStartTime := time.Now().Add(-1 * time.Hour)
|
|
missingTrack := model.MediaFile{
|
|
ID: "missing2",
|
|
LibraryID: 1,
|
|
MbzReleaseTrackID: "",
|
|
Title: "Test Track 2",
|
|
Size: 2000,
|
|
Suffix: "flac",
|
|
DiscNumber: 1,
|
|
TrackNumber: 1,
|
|
Album: "Test Album",
|
|
Path: "/lib1/track2.flac",
|
|
Missing: true,
|
|
CreatedAt: scanStartTime.Add(-30 * time.Minute),
|
|
}
|
|
|
|
movedTrack := model.MediaFile{
|
|
ID: "moved2",
|
|
LibraryID: 2,
|
|
MbzReleaseTrackID: "",
|
|
Title: "Test Track 2",
|
|
Size: 2000,
|
|
Suffix: "flac",
|
|
DiscNumber: 1,
|
|
TrackNumber: 1,
|
|
Album: "Test Album",
|
|
Path: "/lib2/track2.flac",
|
|
Missing: false,
|
|
CreatedAt: scanStartTime.Add(-10 * time.Minute),
|
|
}
|
|
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &movedTrack)
|
|
|
|
in := &missingTracks{
|
|
lib: model.Library{ID: 1, Name: "Library 1"},
|
|
missing: []model.MediaFile{missingTrack},
|
|
}
|
|
|
|
result, err := phase.processCrossLibraryMoves(in)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(result).To(Equal(in))
|
|
Expect(phase.totalMatched.Load()).To(Equal(uint32(1)))
|
|
Expect(state.changesDetected.Load()).To(BeTrue())
|
|
|
|
// Verify the move was performed
|
|
updatedTrack, _ := ds.MediaFile().Get(ctx, "missing2")
|
|
Expect(updatedTrack.Path).To(Equal("/lib2/track2.flac"))
|
|
Expect(updatedTrack.LibraryID).To(Equal(2))
|
|
})
|
|
|
|
It("should not match files in the same library", func() {
|
|
scanStartTime := time.Now().Add(-1 * time.Hour)
|
|
missingTrack := model.MediaFile{
|
|
ID: "missing3",
|
|
LibraryID: 1,
|
|
MbzReleaseTrackID: "mbz-track-456",
|
|
Title: "Test Track 3",
|
|
Size: 3000,
|
|
Suffix: "mp3",
|
|
Path: "/lib1/track3.mp3",
|
|
Missing: true,
|
|
CreatedAt: scanStartTime.Add(-30 * time.Minute),
|
|
}
|
|
|
|
sameLibTrack := model.MediaFile{
|
|
ID: "same1",
|
|
LibraryID: 1, // Same library
|
|
MbzReleaseTrackID: "mbz-track-456",
|
|
Title: "Test Track 3",
|
|
Size: 3000,
|
|
Suffix: "mp3",
|
|
Path: "/lib1/other/track3.mp3",
|
|
Missing: false,
|
|
CreatedAt: scanStartTime.Add(-10 * time.Minute),
|
|
}
|
|
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &sameLibTrack)
|
|
|
|
in := &missingTracks{
|
|
lib: model.Library{ID: 1, Name: "Library 1"},
|
|
missing: []model.MediaFile{missingTrack},
|
|
}
|
|
|
|
result, err := phase.processCrossLibraryMoves(in)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(result).To(Equal(in))
|
|
Expect(phase.totalMatched.Load()).To(Equal(uint32(0)))
|
|
Expect(state.changesDetected.Load()).To(BeFalse())
|
|
})
|
|
|
|
It("should prioritize MBZ Track ID over intrinsic properties", func() {
|
|
scanStartTime := time.Now().Add(-1 * time.Hour)
|
|
missingTrack := model.MediaFile{
|
|
ID: "missing4",
|
|
LibraryID: 1,
|
|
MbzReleaseTrackID: "mbz-track-789",
|
|
Title: "Test Track 4",
|
|
Size: 4000,
|
|
Suffix: "mp3",
|
|
Path: "/lib1/track4.mp3",
|
|
Missing: true,
|
|
CreatedAt: scanStartTime.Add(-30 * time.Minute),
|
|
}
|
|
|
|
// Track with same MBZ ID
|
|
mbzTrack := model.MediaFile{
|
|
ID: "mbz1",
|
|
LibraryID: 2,
|
|
MbzReleaseTrackID: "mbz-track-789",
|
|
Title: "Test Track 4",
|
|
Size: 4000,
|
|
Suffix: "mp3",
|
|
Path: "/lib2/track4.mp3",
|
|
Missing: false,
|
|
CreatedAt: scanStartTime.Add(-10 * time.Minute),
|
|
}
|
|
|
|
// Track with same intrinsic properties but no MBZ ID
|
|
intrinsicTrack := model.MediaFile{
|
|
ID: "intrinsic1",
|
|
LibraryID: 3,
|
|
MbzReleaseTrackID: "",
|
|
Title: "Test Track 4",
|
|
Size: 4000,
|
|
Suffix: "mp3",
|
|
DiscNumber: 1,
|
|
TrackNumber: 1,
|
|
Album: "Test Album",
|
|
Path: "/lib3/track4.mp3",
|
|
Missing: false,
|
|
CreatedAt: scanStartTime.Add(-5 * time.Minute),
|
|
}
|
|
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &mbzTrack)
|
|
_ = ds.MediaFile().Put(ctx, &intrinsicTrack)
|
|
|
|
in := &missingTracks{
|
|
lib: model.Library{ID: 1, Name: "Library 1"},
|
|
missing: []model.MediaFile{missingTrack},
|
|
}
|
|
|
|
result, err := phase.processCrossLibraryMoves(in)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(result).To(Equal(in))
|
|
Expect(phase.totalMatched.Load()).To(Equal(uint32(1)))
|
|
Expect(state.changesDetected.Load()).To(BeTrue())
|
|
|
|
// Verify the MBZ track was chosen (not the intrinsic one)
|
|
updatedTrack, _ := ds.MediaFile().Get(ctx, "missing4")
|
|
Expect(updatedTrack.Path).To(Equal("/lib2/track4.mp3"))
|
|
Expect(updatedTrack.LibraryID).To(Equal(2))
|
|
})
|
|
|
|
It("should handle equivalent matches correctly", func() {
|
|
scanStartTime := time.Now().Add(-1 * time.Hour)
|
|
missingTrack := model.MediaFile{
|
|
ID: "missing5",
|
|
LibraryID: 1,
|
|
MbzReleaseTrackID: "",
|
|
Title: "Test Track 5",
|
|
Size: 5000,
|
|
Suffix: "mp3",
|
|
Path: "/lib1/path/track5.mp3",
|
|
Missing: true,
|
|
CreatedAt: scanStartTime.Add(-30 * time.Minute),
|
|
}
|
|
|
|
// Equivalent match (same filename, different directory)
|
|
equivalentTrack := model.MediaFile{
|
|
ID: "equiv1",
|
|
LibraryID: 2,
|
|
MbzReleaseTrackID: "",
|
|
Title: "Test Track 5",
|
|
Size: 5000,
|
|
Suffix: "mp3",
|
|
Path: "/lib2/different/track5.mp3",
|
|
Missing: false,
|
|
CreatedAt: scanStartTime.Add(-10 * time.Minute),
|
|
}
|
|
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &equivalentTrack)
|
|
|
|
in := &missingTracks{
|
|
lib: model.Library{ID: 1, Name: "Library 1"},
|
|
missing: []model.MediaFile{missingTrack},
|
|
}
|
|
|
|
result, err := phase.processCrossLibraryMoves(in)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(result).To(Equal(in))
|
|
Expect(phase.totalMatched.Load()).To(Equal(uint32(1)))
|
|
Expect(state.changesDetected.Load()).To(BeTrue())
|
|
|
|
// Verify the equivalent match was accepted
|
|
updatedTrack, _ := ds.MediaFile().Get(ctx, "missing5")
|
|
Expect(updatedTrack.Path).To(Equal("/lib2/different/track5.mp3"))
|
|
Expect(updatedTrack.LibraryID).To(Equal(2))
|
|
})
|
|
|
|
It("should skip matching when multiple matches are found but none are exact", func() {
|
|
scanStartTime := time.Now().Add(-1 * time.Hour)
|
|
missingTrack := model.MediaFile{
|
|
ID: "missing6",
|
|
LibraryID: 1,
|
|
MbzReleaseTrackID: "",
|
|
Title: "Test Track 6",
|
|
Size: 6000,
|
|
Suffix: "mp3",
|
|
DiscNumber: 1,
|
|
TrackNumber: 1,
|
|
Album: "Test Album",
|
|
Path: "/lib1/track6.mp3",
|
|
Missing: true,
|
|
CreatedAt: scanStartTime.Add(-30 * time.Minute),
|
|
}
|
|
|
|
// Multiple matches with different metadata (not exact matches)
|
|
match1 := model.MediaFile{
|
|
ID: "match1",
|
|
LibraryID: 2,
|
|
MbzReleaseTrackID: "",
|
|
Title: "Test Track 6",
|
|
Size: 6000,
|
|
Suffix: "mp3",
|
|
DiscNumber: 1,
|
|
TrackNumber: 1,
|
|
Album: "Test Album",
|
|
Path: "/lib2/different_track.mp3",
|
|
Artist: "Different Artist", // This makes it non-exact
|
|
Missing: false,
|
|
CreatedAt: scanStartTime.Add(-10 * time.Minute),
|
|
}
|
|
|
|
match2 := model.MediaFile{
|
|
ID: "match2",
|
|
LibraryID: 3,
|
|
MbzReleaseTrackID: "",
|
|
Title: "Test Track 6",
|
|
Size: 6000,
|
|
Suffix: "mp3",
|
|
DiscNumber: 1,
|
|
TrackNumber: 1,
|
|
Album: "Test Album",
|
|
Path: "/lib3/another_track.mp3",
|
|
Artist: "Another Artist", // This makes it non-exact
|
|
Missing: false,
|
|
CreatedAt: scanStartTime.Add(-5 * time.Minute),
|
|
}
|
|
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &match1)
|
|
_ = ds.MediaFile().Put(ctx, &match2)
|
|
|
|
in := &missingTracks{
|
|
lib: model.Library{ID: 1, Name: "Library 1"},
|
|
missing: []model.MediaFile{missingTrack},
|
|
}
|
|
|
|
result, err := phase.processCrossLibraryMoves(in)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(result).To(Equal(in))
|
|
Expect(phase.totalMatched.Load()).To(Equal(uint32(0)))
|
|
Expect(state.changesDetected.Load()).To(BeFalse())
|
|
|
|
// Verify no move was performed
|
|
unchangedTrack, _ := ds.MediaFile().Get(ctx, "missing6")
|
|
Expect(unchangedTrack.Path).To(Equal("/lib1/track6.mp3"))
|
|
Expect(unchangedTrack.LibraryID).To(Equal(1))
|
|
})
|
|
|
|
It("should handle errors gracefully", func() {
|
|
// Set up mock to return error
|
|
mr.Err = true
|
|
|
|
missingTrack := model.MediaFile{
|
|
ID: "missing7",
|
|
LibraryID: 1,
|
|
MbzReleaseTrackID: "mbz-track-error",
|
|
Title: "Test Track 7",
|
|
Size: 7000,
|
|
Suffix: "mp3",
|
|
Path: "/lib1/track7.mp3",
|
|
Missing: true,
|
|
CreatedAt: time.Now().Add(-30 * time.Minute),
|
|
}
|
|
|
|
in := &missingTracks{
|
|
lib: model.Library{ID: 1, Name: "Library 1"},
|
|
missing: []model.MediaFile{missingTrack},
|
|
}
|
|
|
|
// Should not fail completely, just skip the problematic file
|
|
result, err := phase.processCrossLibraryMoves(in)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(result).To(Equal(in))
|
|
Expect(phase.totalMatched.Load()).To(Equal(uint32(0)))
|
|
Expect(state.changesDetected.Load()).To(BeFalse())
|
|
})
|
|
}) // End of Context "with multiple libraries"
|
|
})
|
|
|
|
Describe("CreatedAt preservation (#5050)", func() {
|
|
var albumRepo *tests.MockAlbumRepo
|
|
|
|
BeforeEach(func() {
|
|
albumRepo = ds.Album().(*tests.MockAlbumRepo)
|
|
albumRepo.ReassignAnnotationCalls = make(map[string]string)
|
|
albumRepo.CopyAttributesCalls = make(map[string]string)
|
|
})
|
|
|
|
It("should preserve the missing track's created_at when moving within a library", func() {
|
|
originalTime := time.Date(2020, 3, 15, 10, 0, 0, 0, time.UTC)
|
|
missingTrack := model.MediaFile{
|
|
ID: "1", PID: "A", Path: "old/song.mp3",
|
|
AlbumID: "album-1",
|
|
LibraryID: 1,
|
|
CreatedAt: originalTime,
|
|
Tags: model.Tags{"title": []string{"My Song"}},
|
|
Size: 100,
|
|
}
|
|
matchedTrack := model.MediaFile{
|
|
ID: "2", PID: "A", Path: "new/song.mp3",
|
|
AlbumID: "album-1", // Same album
|
|
LibraryID: 1,
|
|
CreatedAt: time.Now(), // Much newer
|
|
Tags: model.Tags{"title": []string{"My Song"}},
|
|
Size: 100,
|
|
}
|
|
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &matchedTrack)
|
|
|
|
in := &missingTracks{
|
|
missing: []model.MediaFile{missingTrack},
|
|
matched: []model.MediaFile{matchedTrack},
|
|
}
|
|
|
|
_, err := phase.processMissingTracks(in)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
|
|
movedTrack, _ := ds.MediaFile().Get(ctx, "1")
|
|
Expect(movedTrack.Path).To(Equal("new/song.mp3"))
|
|
Expect(movedTrack.CreatedAt).To(Equal(originalTime))
|
|
})
|
|
|
|
It("should preserve created_at during cross-library moves with album change", func() {
|
|
originalTime := time.Date(2019, 6, 1, 12, 0, 0, 0, time.UTC)
|
|
missingTrack := model.MediaFile{
|
|
ID: "missing-ca", PID: "B", Path: "lib1/song.mp3",
|
|
AlbumID: "old-album",
|
|
LibraryID: 1,
|
|
CreatedAt: originalTime,
|
|
}
|
|
matchedTrack := model.MediaFile{
|
|
ID: "matched-ca", PID: "B", Path: "lib2/song.mp3",
|
|
AlbumID: "new-album",
|
|
LibraryID: 2,
|
|
CreatedAt: time.Now(),
|
|
}
|
|
|
|
// Set up albums so CopyAttributes can find them
|
|
albumRepo.SetData(model.Albums{
|
|
{ID: "old-album", LibraryID: 1, CreatedAt: originalTime},
|
|
{ID: "new-album", LibraryID: 2, CreatedAt: time.Now()},
|
|
})
|
|
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &matchedTrack)
|
|
|
|
err := phase.moveMatched(matchedTrack, missingTrack)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
|
|
// Track's created_at should be preserved from the missing file
|
|
movedTrack, _ := ds.MediaFile().Get(ctx, "missing-ca")
|
|
Expect(movedTrack.CreatedAt).To(Equal(originalTime))
|
|
|
|
// Album's created_at should be copied from old to new
|
|
Expect(albumRepo.CopyAttributesCalls).To(HaveKeyWithValue("old-album", "new-album"))
|
|
|
|
// Verify the new album's CreatedAt was actually updated
|
|
newAlbum, err := albumRepo.Get(ctx, "new-album")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(newAlbum.CreatedAt).To(Equal(originalTime))
|
|
})
|
|
|
|
It("should not copy album created_at when album ID does not change", func() {
|
|
originalTime := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
|
|
missingTrack := model.MediaFile{
|
|
ID: "missing-same", PID: "C", Path: "dir1/song.mp3",
|
|
AlbumID: "same-album",
|
|
LibraryID: 1,
|
|
CreatedAt: originalTime,
|
|
}
|
|
matchedTrack := model.MediaFile{
|
|
ID: "matched-same", PID: "C", Path: "dir2/song.mp3",
|
|
AlbumID: "same-album", // Same album
|
|
LibraryID: 1,
|
|
CreatedAt: time.Now(),
|
|
}
|
|
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &matchedTrack)
|
|
|
|
err := phase.moveMatched(matchedTrack, missingTrack)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
|
|
// Track's created_at should still be preserved
|
|
movedTrack, _ := ds.MediaFile().Get(ctx, "missing-same")
|
|
Expect(movedTrack.CreatedAt).To(Equal(originalTime))
|
|
|
|
// CopyAttributes should NOT have been called (same album)
|
|
Expect(albumRepo.CopyAttributesCalls).To(BeEmpty())
|
|
})
|
|
})
|
|
|
|
Describe("Album Annotation Reassignment", func() {
|
|
var (
|
|
albumRepo *tests.MockAlbumRepo
|
|
missingTrack model.MediaFile
|
|
matchedTrack model.MediaFile
|
|
oldAlbumID string
|
|
newAlbumID string
|
|
)
|
|
|
|
BeforeEach(func() {
|
|
albumRepo = ds.Album().(*tests.MockAlbumRepo)
|
|
albumRepo.ReassignAnnotationCalls = make(map[string]string)
|
|
|
|
oldAlbumID = "old-album-id"
|
|
newAlbumID = "new-album-id"
|
|
|
|
missingTrack = model.MediaFile{
|
|
ID: "missing-track-id",
|
|
PID: "same-pid",
|
|
Path: "old/path.mp3",
|
|
AlbumID: oldAlbumID,
|
|
LibraryID: 1,
|
|
Missing: true,
|
|
Annotations: model.Annotations{
|
|
PlayCount: 5,
|
|
Rating: 4,
|
|
Starred: true,
|
|
},
|
|
}
|
|
|
|
matchedTrack = model.MediaFile{
|
|
ID: "matched-track-id",
|
|
PID: "same-pid",
|
|
Path: "new/path.mp3",
|
|
AlbumID: newAlbumID,
|
|
LibraryID: 2, // Different library
|
|
Missing: false,
|
|
Annotations: model.Annotations{
|
|
PlayCount: 2,
|
|
Rating: 3,
|
|
Starred: false,
|
|
},
|
|
}
|
|
|
|
// Store both tracks in the database
|
|
_ = ds.MediaFile().Put(ctx, &missingTrack)
|
|
_ = ds.MediaFile().Put(ctx, &matchedTrack)
|
|
})
|
|
|
|
When("album ID changes during cross-library move", func() {
|
|
It("should reassign album annotations when AlbumID changes", func() {
|
|
err := phase.moveMatched(matchedTrack, missingTrack)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
|
|
// Verify that ReassignAnnotation was called
|
|
Expect(albumRepo.ReassignAnnotationCalls).To(HaveKeyWithValue(oldAlbumID, newAlbumID))
|
|
})
|
|
|
|
It("should not reassign annotations when AlbumID is the same", func() {
|
|
missingTrack.AlbumID = newAlbumID // Same album
|
|
|
|
err := phase.moveMatched(matchedTrack, missingTrack)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
|
|
// Verify that ReassignAnnotation was NOT called
|
|
Expect(albumRepo.ReassignAnnotationCalls).To(BeEmpty())
|
|
})
|
|
})
|
|
|
|
When("error handling", func() {
|
|
It("should handle ReassignAnnotation errors gracefully", func() {
|
|
// Make the album repo return an error
|
|
albumRepo.SetError(true)
|
|
|
|
// The move should still succeed even if annotation reassignment fails
|
|
err := phase.moveMatched(matchedTrack, missingTrack)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
|
|
// Verify that the track was still moved (ID should be updated)
|
|
movedTrack, err := ds.MediaFile().Get(ctx, missingTrack.ID)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(movedTrack.Path).To(Equal(matchedTrack.Path))
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
// rerunTxDS runs every WithTxRetry block twice, as a retry after a rolled-back busy attempt would.
|
|
// The mock is not transactional, so snapshot returns the function that plays the rollback.
|
|
type rerunTxDS struct {
|
|
*tests.MockDataStore
|
|
snapshot func() (rollback func())
|
|
}
|
|
|
|
func (d *rerunTxDS) WithTxRetry(ctx context.Context, block func(context.Context, model.DataStore) error, _ ...string) error {
|
|
rollback := d.snapshot()
|
|
_ = block(ctx, d.MockDataStore)
|
|
rollback()
|
|
return block(ctx, d.MockDataStore)
|
|
}
|
|
|
|
// probeTxDS runs a hook inside each WithTxRetry block, and can fail the transaction after it.
|
|
type probeTxDS struct {
|
|
*tests.MockDataStore
|
|
during func()
|
|
err error
|
|
}
|
|
|
|
func (d *probeTxDS) WithTxRetry(ctx context.Context, block func(context.Context, model.DataStore) error, _ ...string) error {
|
|
if err := block(ctx, d.MockDataStore); err != nil {
|
|
return err
|
|
}
|
|
if d.during != nil {
|
|
d.during()
|
|
}
|
|
return d.err
|
|
}
|