navidrome/scanner/scanner_multilibrary_test.go

package scanner_test

import (
	"context"
	"errors"
	"path/filepath"
	"testing/fstest"
	"time"

	"github.com/Masterminds/squirrel"
	"github.com/navidrome/navidrome/conf"
	"github.com/navidrome/navidrome/conf/configtest"
	"github.com/navidrome/navidrome/consts"
	"github.com/navidrome/navidrome/core"
	"github.com/navidrome/navidrome/core/artwork"
	"github.com/navidrome/navidrome/core/metrics"
	"github.com/navidrome/navidrome/core/storage/storagetest"
	"github.com/navidrome/navidrome/db"
	"github.com/navidrome/navidrome/log"
	"github.com/navidrome/navidrome/model"
	"github.com/navidrome/navidrome/model/request"
	"github.com/navidrome/navidrome/persistence"
	"github.com/navidrome/navidrome/scanner"
	"github.com/navidrome/navidrome/server/events"
	"github.com/navidrome/navidrome/tests"
	"github.com/navidrome/navidrome/utils/slice"
	. "github.com/onsi/ginkgo/v2"
	. "github.com/onsi/gomega"
)

var _ = Describe("Scanner - Multi-Library", Ordered, func() {
	var ctx context.Context
	var lib1, lib2 model.Library
	var ds *tests.MockDataStore
	var s scanner.Scanner

	createFS := func(path string, files fstest.MapFS) storagetest.FakeFS {
		fs := storagetest.FakeFS{}
		fs.SetFiles(files)
		storagetest.Register(path, &fs)
		return fs
	}

	BeforeAll(func() {
		ctx = request.WithUser(GinkgoT().Context(), model.User{ID: "123", IsAdmin: true})
		tmpDir := GinkgoT().TempDir()
		conf.Server.DbPath = filepath.Join(tmpDir, "test-scanner-multilibrary.db?_journal_mode=WAL")
		log.Warn("Using DB at " + conf.Server.DbPath)
		db.Db().SetMaxOpenConns(1)
	})

	BeforeEach(func() {
		DeferCleanup(configtest.SetupConfig())
		conf.Server.DevExternalScanner = false

		db.Init(ctx)
		DeferCleanup(func() {
			Expect(tests.ClearDB()).To(Succeed())
		})

		ds = &tests.MockDataStore{RealDS: persistence.New(db.Db())}

		// Create the admin user in the database to match the context
		adminUser := model.User{
			ID:          "123",
			UserName:    "admin",
			Name:        "Admin User",
			IsAdmin:     true,
			NewPassword: "password",
		}
		Expect(ds.User(ctx).Put(&adminUser)).To(Succeed())

		s = scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),
			core.NewPlaylists(ds), metrics.NewNoopInstance())

		// Create two test libraries (let DB auto-assign IDs)
		lib1 = model.Library{Name: "Rock Collection", Path: "rock:///music"}
		lib2 = model.Library{Name: "Jazz Collection", Path: "jazz:///music"}
		Expect(ds.Library(ctx).Put(&lib1)).To(Succeed())
		Expect(ds.Library(ctx).Put(&lib2)).To(Succeed())
	})

	runScanner := func(ctx context.Context, fullScan bool) error {
		_, err := s.ScanAll(ctx, fullScan)
		return err
	}

	Context("Two Libraries with Different Content", func() {
		BeforeEach(func() {
			// Rock library content
			beatles := template(_t{"albumartist": "The Beatles", "album": "Abbey Road", "year": 1969, "genre": "Rock"})
			zeppelin := template(_t{"albumartist": "Led Zeppelin", "album": "IV", "year": 1971, "genre": "Rock"})

			_ = createFS("rock", fstest.MapFS{
				"The Beatles/Abbey Road/01 - Come Together.mp3": beatles(track(1, "Come Together")),
				"The Beatles/Abbey Road/02 - Something.mp3":     beatles(track(2, "Something")),
				"Led Zeppelin/IV/01 - Black Dog.mp3":            zeppelin(track(1, "Black Dog")),
				"Led Zeppelin/IV/02 - Rock and Roll.mp3":        zeppelin(track(2, "Rock and Roll")),
			})

			// Jazz library content
			miles := template(_t{"albumartist": "Miles Davis", "album": "Kind of Blue", "year": 1959, "genre": "Jazz"})
			coltrane := template(_t{"albumartist": "John Coltrane", "album": "Giant Steps", "year": 1960, "genre": "Jazz"})

			_ = createFS("jazz", fstest.MapFS{
				"Miles Davis/Kind of Blue/01 - So What.mp3":            miles(track(1, "So What")),
				"Miles Davis/Kind of Blue/02 - Freddie Freeloader.mp3": miles(track(2, "Freddie Freeloader")),
				"John Coltrane/Giant Steps/01 - Giant Steps.mp3":       coltrane(track(1, "Giant Steps")),
				"John Coltrane/Giant Steps/02 - Cousin Mary.mp3":       coltrane(track(2, "Cousin Mary")),
			})
		})

		When("scanning both libraries", func() {
			It("should import files with correct library_id", func() {
				Expect(runScanner(ctx, true)).To(Succeed())

				// Check Rock library media files
				rockFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib1.ID},
					Sort:    "title",
				})
				Expect(err).ToNot(HaveOccurred())
				Expect(rockFiles).To(HaveLen(4))

				rockTitles := slice.Map(rockFiles, func(f model.MediaFile) string { return f.Title })
				Expect(rockTitles).To(ContainElements("Come Together", "Something", "Black Dog", "Rock and Roll"))

				// Verify all rock files have correct library_id
				for _, mf := range rockFiles {
					Expect(mf.LibraryID).To(Equal(lib1.ID), "Rock file %s should have library_id %d", mf.Title, lib1.ID)
				}

				// Check Jazz library media files
				jazzFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib2.ID},
					Sort:    "title",
				})
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzFiles).To(HaveLen(4))

				jazzTitles := slice.Map(jazzFiles, func(f model.MediaFile) string { return f.Title })
				Expect(jazzTitles).To(ContainElements("So What", "Freddie Freeloader", "Giant Steps", "Cousin Mary"))

				// Verify all jazz files have correct library_id
				for _, mf := range jazzFiles {
					Expect(mf.LibraryID).To(Equal(lib2.ID), "Jazz file %s should have library_id %d", mf.Title, lib2.ID)
				}
			})

			It("should create albums with correct library_id", func() {
				Expect(runScanner(ctx, true)).To(Succeed())

				// Check Rock library albums
				rockAlbums, err := ds.Album(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib1.ID},
					Sort:    "name",
				})
				Expect(err).ToNot(HaveOccurred())
				Expect(rockAlbums).To(HaveLen(2))
				Expect(rockAlbums[0].Name).To(Equal("Abbey Road"))
				Expect(rockAlbums[0].LibraryID).To(Equal(lib1.ID))
				Expect(rockAlbums[0].SongCount).To(Equal(2))
				Expect(rockAlbums[1].Name).To(Equal("IV"))
				Expect(rockAlbums[1].LibraryID).To(Equal(lib1.ID))
				Expect(rockAlbums[1].SongCount).To(Equal(2))

				// Check Jazz library albums
				jazzAlbums, err := ds.Album(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib2.ID},
					Sort:    "name",
				})
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzAlbums).To(HaveLen(2))
				Expect(jazzAlbums[0].Name).To(Equal("Giant Steps"))
				Expect(jazzAlbums[0].LibraryID).To(Equal(lib2.ID))
				Expect(jazzAlbums[0].SongCount).To(Equal(2))
				Expect(jazzAlbums[1].Name).To(Equal("Kind of Blue"))
				Expect(jazzAlbums[1].LibraryID).To(Equal(lib2.ID))
				Expect(jazzAlbums[1].SongCount).To(Equal(2))
			})

			It("should create folders with correct library_id", func() {
				Expect(runScanner(ctx, true)).To(Succeed())

				// Check Rock library folders
				rockFolders, err := ds.Folder(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib1.ID},
				})
				Expect(err).ToNot(HaveOccurred())
				Expect(rockFolders).To(HaveLen(5)) // ., The Beatles, Led Zeppelin, Abbey Road, IV

				for _, folder := range rockFolders {
					Expect(folder.LibraryID).To(Equal(lib1.ID), "Rock folder %s should have library_id %d", folder.Name, lib1.ID)
				}

				// Check Jazz library folders
				jazzFolders, err := ds.Folder(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib2.ID},
				})
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzFolders).To(HaveLen(5)) // ., Miles Davis, John Coltrane, Kind of Blue, Giant Steps

				for _, folder := range jazzFolders {
					Expect(folder.LibraryID).To(Equal(lib2.ID), "Jazz folder %s should have library_id %d", folder.Name, lib2.ID)
				}
			})

			It("should create library-artist associations correctly", func() {
				Expect(runScanner(ctx, true)).To(Succeed())

				// Check library-artist associations

				// Get all artists and check library associations
				allArtists, err := ds.Artist(ctx).GetAll()
				Expect(err).ToNot(HaveOccurred())

				rockArtistNames := []string{}
				jazzArtistNames := []string{}

				for _, artist := range allArtists {
					// Check if artist is associated with rock library
					var count int64
					err := db.Db().QueryRow(
						"SELECT COUNT(*) FROM library_artist WHERE library_id = ? AND artist_id = ?",
						lib1.ID, artist.ID,
					).Scan(&count)
					Expect(err).ToNot(HaveOccurred())
					if count > 0 {
						rockArtistNames = append(rockArtistNames, artist.Name)
					}

					// Check if artist is associated with jazz library
					err = db.Db().QueryRow(
						"SELECT COUNT(*) FROM library_artist WHERE library_id = ? AND artist_id = ?",
						lib2.ID, artist.ID,
					).Scan(&count)
					Expect(err).ToNot(HaveOccurred())
					if count > 0 {
						jazzArtistNames = append(jazzArtistNames, artist.Name)
					}
				}

				Expect(rockArtistNames).To(ContainElements("The Beatles", "Led Zeppelin"))
				Expect(jazzArtistNames).To(ContainElements("Miles Davis", "John Coltrane"))

				// Artists should not be shared between libraries (except [Unknown Artist])
				for _, name := range rockArtistNames {
					if name != "[Unknown Artist]" {
						Expect(jazzArtistNames).ToNot(ContainElement(name))
					}
				}
			})

			It("should update library statistics correctly", func() {
				Expect(runScanner(ctx, true)).To(Succeed())

				// Check Rock library stats
				rockLib, err := ds.Library(ctx).Get(lib1.ID)
				Expect(err).ToNot(HaveOccurred())
				Expect(rockLib.TotalSongs).To(Equal(4))
				Expect(rockLib.TotalAlbums).To(Equal(2))

				Expect(rockLib.TotalArtists).To(Equal(3)) // The Beatles, Led Zeppelin, [Unknown Artist]
				Expect(rockLib.TotalFolders).To(Equal(2)) // Abbey Road, IV (only folders with audio files)

				// Check Jazz library stats
				jazzLib, err := ds.Library(ctx).Get(lib2.ID)
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzLib.TotalSongs).To(Equal(4))
				Expect(jazzLib.TotalAlbums).To(Equal(2))
				Expect(jazzLib.TotalArtists).To(Equal(3)) // Miles Davis, John Coltrane, [Unknown Artist]
				Expect(jazzLib.TotalFolders).To(Equal(2)) // Kind of Blue, Giant Steps (only folders with audio files)
			})
		})

		When("libraries have different content", func() {
			It("should maintain separate statistics per library", func() {
				Expect(runScanner(ctx, true)).To(Succeed())

				// Verify rock library stats
				rockLib, err := ds.Library(ctx).Get(lib1.ID)
				Expect(err).ToNot(HaveOccurred())
				Expect(rockLib.TotalSongs).To(Equal(4))
				Expect(rockLib.TotalAlbums).To(Equal(2))

				// Verify jazz library stats
				jazzLib, err := ds.Library(ctx).Get(lib2.ID)
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzLib.TotalSongs).To(Equal(4))
				Expect(jazzLib.TotalAlbums).To(Equal(2))

				// Verify that libraries don't interfere with each other
				rockFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib1.ID},
				})
				Expect(err).ToNot(HaveOccurred())
				Expect(rockFiles).To(HaveLen(4))

				jazzFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib2.ID},
				})
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzFiles).To(HaveLen(4))
			})
		})

		When("verifying library isolation", func() {
			It("should keep library data completely separate", func() {
				Expect(runScanner(ctx, true)).To(Succeed())

				// Verify that rock library only contains rock content
				rockAlbums, err := ds.Album(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib1.ID},
				})
				Expect(err).ToNot(HaveOccurred())
				rockAlbumNames := slice.Map(rockAlbums, func(a model.Album) string { return a.Name })
				Expect(rockAlbumNames).To(ContainElements("Abbey Road", "IV"))
				Expect(rockAlbumNames).ToNot(ContainElements("Kind of Blue", "Giant Steps"))

				// Verify that jazz library only contains jazz content
				jazzAlbums, err := ds.Album(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib2.ID},
				})
				Expect(err).ToNot(HaveOccurred())
				jazzAlbumNames := slice.Map(jazzAlbums, func(a model.Album) string { return a.Name })
				Expect(jazzAlbumNames).To(ContainElements("Kind of Blue", "Giant Steps"))
				Expect(jazzAlbumNames).ToNot(ContainElements("Abbey Road", "IV"))
			})
		})

		When("same artist appears in different libraries", func() {
			It("should associate artist with both libraries correctly", func() {
				// Create libraries with Jeff Beck albums in both
				jeffRock := template(_t{"albumartist": "Jeff Beck", "album": "Truth", "year": 1968, "genre": "Rock"})
				jeffJazz := template(_t{"albumartist": "Jeff Beck", "album": "Blow by Blow", "year": 1975, "genre": "Jazz"})
				beatles := template(_t{"albumartist": "The Beatles", "album": "Abbey Road", "year": 1969, "genre": "Rock"})
				miles := template(_t{"albumartist": "Miles Davis", "album": "Kind of Blue", "year": 1959, "genre": "Jazz"})

				// Create rock library with Jeff Beck's Truth album
				_ = createFS("rock", fstest.MapFS{
					"The Beatles/Abbey Road/01 - Come Together.mp3": beatles(track(1, "Come Together")),
					"The Beatles/Abbey Road/02 - Something.mp3":     beatles(track(2, "Something")),
					"Jeff Beck/Truth/01 - Beck's Bolero.mp3":        jeffRock(track(1, "Beck's Bolero")),
					"Jeff Beck/Truth/02 - Ol' Man River.mp3":        jeffRock(track(2, "Ol' Man River")),
				})

				// Create jazz library with Jeff Beck's Blow by Blow album
				_ = createFS("jazz", fstest.MapFS{
					"Miles Davis/Kind of Blue/01 - So What.mp3":            miles(track(1, "So What")),
					"Miles Davis/Kind of Blue/02 - Freddie Freeloader.mp3": miles(track(2, "Freddie Freeloader")),
					"Jeff Beck/Blow by Blow/01 - You Know What I Mean.mp3": jeffJazz(track(1, "You Know What I Mean")),
					"Jeff Beck/Blow by Blow/02 - She's a Woman.mp3":        jeffJazz(track(2, "She's a Woman")),
				})

				Expect(runScanner(ctx, true)).To(Succeed())

				// Jeff Beck should be associated with both libraries
				var rockCount, jazzCount int64

				// Get Jeff Beck artist ID
				jeffArtists, err := ds.Artist(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"name": "Jeff Beck"},
				})
				Expect(err).ToNot(HaveOccurred())
				Expect(jeffArtists).To(HaveLen(1))
				jeffID := jeffArtists[0].ID

				// Check rock library association
				err = db.Db().QueryRow(
					"SELECT COUNT(*) FROM library_artist WHERE library_id = ? AND artist_id = ?",
					lib1.ID, jeffID,
				).Scan(&rockCount)
				Expect(err).ToNot(HaveOccurred())
				Expect(rockCount).To(Equal(int64(1)))

				// Check jazz library association
				err = db.Db().QueryRow(
					"SELECT COUNT(*) FROM library_artist WHERE library_id = ? AND artist_id = ?",
					lib2.ID, jeffID,
				).Scan(&jazzCount)
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzCount).To(Equal(int64(1)))

				// Verify Jeff Beck albums are in correct libraries
				rockAlbums, err := ds.Album(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib1.ID, "album_artist": "Jeff Beck"},
				})
				Expect(err).ToNot(HaveOccurred())
				Expect(rockAlbums).To(HaveLen(1))
				Expect(rockAlbums[0].Name).To(Equal("Truth"))

				jazzAlbums, err := ds.Album(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib2.ID, "album_artist": "Jeff Beck"},
				})
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzAlbums).To(HaveLen(1))
				Expect(jazzAlbums[0].Name).To(Equal("Blow by Blow"))
			})
		})
	})

	Context("Incremental Scan Behavior", func() {
		BeforeEach(func() {
			// Start with minimal content in both libraries
			rock := template(_t{"albumartist": "Queen", "album": "News of the World", "year": 1977, "genre": "Rock"})
			jazz := template(_t{"albumartist": "Bill Evans", "album": "Waltz for Debby", "year": 1961, "genre": "Jazz"})

			createFS("rock", fstest.MapFS{
				"Queen/News of the World/01 - We Will Rock You.mp3": rock(track(1, "We Will Rock You")),
			})

			createFS("jazz", fstest.MapFS{
				"Bill Evans/Waltz for Debby/01 - My Foolish Heart.mp3": jazz(track(1, "My Foolish Heart")),
			})
		})

		It("should handle incremental scans per library correctly", func() {
			// Initial full scan
			Expect(runScanner(ctx, true)).To(Succeed())

			// Verify initial state
			rockFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
				Filters: squirrel.Eq{"library_id": lib1.ID},
			})
			Expect(err).ToNot(HaveOccurred())
			Expect(rockFiles).To(HaveLen(1))

			jazzFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
				Filters: squirrel.Eq{"library_id": lib2.ID},
			})
			Expect(err).ToNot(HaveOccurred())
			Expect(jazzFiles).To(HaveLen(1))

			// Incremental scan should not duplicate existing files
			Expect(runScanner(ctx, false)).To(Succeed())

			// Verify counts remain the same
			rockFiles, err = ds.MediaFile(ctx).GetAll(model.QueryOptions{
				Filters: squirrel.Eq{"library_id": lib1.ID},
			})
			Expect(err).ToNot(HaveOccurred())
			Expect(rockFiles).To(HaveLen(1))

			jazzFiles, err = ds.MediaFile(ctx).GetAll(model.QueryOptions{
				Filters: squirrel.Eq{"library_id": lib2.ID},
			})
			Expect(err).ToNot(HaveOccurred())
			Expect(jazzFiles).To(HaveLen(1))
		})
	})

	Context("Missing Files Handling", func() {
		var rockFS storagetest.FakeFS

		BeforeEach(func() {
			rock := template(_t{"albumartist": "AC/DC", "album": "Back in Black", "year": 1980, "genre": "Rock"})

			rockFS = createFS("rock", fstest.MapFS{
				"AC-DC/Back in Black/01 - Hells Bells.mp3":     rock(track(1, "Hells Bells")),
				"AC-DC/Back in Black/02 - Shoot to Thrill.mp3": rock(track(2, "Shoot to Thrill")),
			})

			createFS("jazz", fstest.MapFS{
				"Herbie Hancock/Head Hunters/01 - Chameleon.mp3": template(_t{
					"albumartist": "Herbie Hancock", "album": "Head Hunters", "year": 1973, "genre": "Jazz",
				})(track(1, "Chameleon")),
			})
		})

		It("should mark missing files correctly per library", func() {
			// Initial scan
			Expect(runScanner(ctx, true)).To(Succeed())

			// Remove one file from rock library only
			rockFS.Remove("AC-DC/Back in Black/02 - Shoot to Thrill.mp3")

			// Rescan
			Expect(runScanner(ctx, false)).To(Succeed())

			// Check that only the rock library file is marked as missing
			missingRockFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
				Filters: squirrel.And{
					squirrel.Eq{"library_id": lib1.ID},
					squirrel.Eq{"missing": true},
				},
			})
			Expect(err).ToNot(HaveOccurred())
			Expect(missingRockFiles).To(HaveLen(1))
			Expect(missingRockFiles[0].Title).To(Equal("Shoot to Thrill"))

			// Check that jazz library files are not affected
			missingJazzFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
				Filters: squirrel.And{
					squirrel.Eq{"library_id": lib2.ID},
					squirrel.Eq{"missing": true},
				},
			})
			Expect(err).ToNot(HaveOccurred())
			Expect(missingJazzFiles).To(HaveLen(0))

			// Verify non-missing files
			presentRockFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
				Filters: squirrel.And{
					squirrel.Eq{"library_id": lib1.ID},
					squirrel.Eq{"missing": false},
				},
			})
			Expect(err).ToNot(HaveOccurred())
			Expect(presentRockFiles).To(HaveLen(1))
			Expect(presentRockFiles[0].Title).To(Equal("Hells Bells"))
		})
	})

	Context("Error Handling - Multi-Library", func() {
		Context("Filesystem errors affecting one library", func() {
			var rockFS storagetest.FakeFS

			BeforeEach(func() {
				// Set up content for both libraries
				rock := template(_t{"albumartist": "AC/DC", "album": "Back in Black", "year": 1980, "genre": "Rock"})
				jazz := template(_t{"albumartist": "Miles Davis", "album": "Kind of Blue", "year": 1959, "genre": "Jazz"})

				rockFS = createFS("rock", fstest.MapFS{
					"AC-DC/Back in Black/01 - Hells Bells.mp3":     rock(track(1, "Hells Bells")),
					"AC-DC/Back in Black/02 - Shoot to Thrill.mp3": rock(track(2, "Shoot to Thrill")),
				})

				createFS("jazz", fstest.MapFS{
					"Miles Davis/Kind of Blue/01 - So What.mp3":            jazz(track(1, "So What")),
					"Miles Davis/Kind of Blue/02 - Freddie Freeloader.mp3": jazz(track(2, "Freddie Freeloader")),
				})
			})

			It("should not affect scanning of other libraries", func() {
				// Inject filesystem read error in rock library only
				rockFS.SetError("AC-DC/Back in Black/01 - Hells Bells.mp3", errors.New("filesystem read error"))

				// Scan should succeed overall and return warnings
				warnings, err := s.ScanAll(ctx, true)
				Expect(err).ToNot(HaveOccurred())
				Expect(warnings).ToNot(BeEmpty(), "Should have warnings for filesystem errors")

				// Jazz library should have been scanned successfully
				jazzFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib2.ID},
				})
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzFiles).To(HaveLen(2))
				Expect(jazzFiles[0].Title).To(BeElementOf("So What", "Freddie Freeloader"))
				Expect(jazzFiles[1].Title).To(BeElementOf("So What", "Freddie Freeloader"))

				// Rock library may have partial content (depending on scanner implementation)
				rockFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib1.ID},
				})
				Expect(err).ToNot(HaveOccurred())
				// No specific expectation - some files may have been imported despite errors
				_ = rockFiles

				// Verify jazz library stats are correct
				jazzLib, err := ds.Library(ctx).Get(lib2.ID)
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzLib.TotalSongs).To(Equal(2))

				// Error should be empty (warnings don't count as scan errors)
				lastError, err := ds.Property(ctx).DefaultGet(consts.LastScanErrorKey, "unset")
				Expect(err).ToNot(HaveOccurred())
				Expect(lastError).To(BeEmpty())
			})

			It("should continue with warnings for affected library", func() {
				// Inject read errors on multiple files in rock library
				rockFS.SetError("AC-DC/Back in Black/01 - Hells Bells.mp3", errors.New("read error 1"))
				rockFS.SetError("AC-DC/Back in Black/02 - Shoot to Thrill.mp3", errors.New("read error 2"))

				// Scan should complete with warnings for multiple filesystem errors
				warnings, err := s.ScanAll(ctx, true)
				Expect(err).ToNot(HaveOccurred())
				Expect(warnings).ToNot(BeEmpty(), "Should have warnings for multiple filesystem errors")

				// Jazz library should be completely unaffected
				jazzFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib2.ID},
				})
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzFiles).To(HaveLen(2))

				// Jazz library statistics should be accurate
				jazzLib, err := ds.Library(ctx).Get(lib2.ID)
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzLib.TotalSongs).To(Equal(2))
				Expect(jazzLib.TotalAlbums).To(Equal(1))

				// Error should be empty (warnings don't count as scan errors)
				lastError, err := ds.Property(ctx).DefaultGet(consts.LastScanErrorKey, "unset")
				Expect(err).ToNot(HaveOccurred())
				Expect(lastError).To(BeEmpty())
			})
		})

		Context("Database errors during multi-library scanning", func() {
			BeforeEach(func() {
				// Set up content for both libraries
				rock := template(_t{"albumartist": "Queen", "album": "News of the World", "year": 1977, "genre": "Rock"})
				jazz := template(_t{"albumartist": "Bill Evans", "album": "Waltz for Debby", "year": 1961, "genre": "Jazz"})

				createFS("rock", fstest.MapFS{
					"Queen/News of the World/01 - We Will Rock You.mp3": rock(track(1, "We Will Rock You")),
				})

				createFS("jazz", fstest.MapFS{
					"Bill Evans/Waltz for Debby/01 - My Foolish Heart.mp3": jazz(track(1, "My Foolish Heart")),
				})
			})

			It("should propagate database errors and stop scanning", func() {
				// Install mock repo that injects DB error
				mfRepo := &mockMediaFileRepo{
					MediaFileRepository:        ds.RealDS.MediaFile(ctx),
					GetMissingAndMatchingError: errors.New("database connection failed"),
				}
				ds.MockedMediaFile = mfRepo

				// Scan should return the database error
				Expect(runScanner(ctx, false)).To(MatchError(ContainSubstring("database connection failed")))

				// Error should be recorded in scanner properties
				lastError, err := ds.Property(ctx).DefaultGet(consts.LastScanErrorKey, "")
				Expect(err).ToNot(HaveOccurred())
				Expect(lastError).To(ContainSubstring("database connection failed"))
			})

			It("should preserve error information in scanner properties", func() {
				// Install mock repo that injects DB error
				mfRepo := &mockMediaFileRepo{
					MediaFileRepository:        ds.RealDS.MediaFile(ctx),
					GetMissingAndMatchingError: errors.New("critical database error"),
				}
				ds.MockedMediaFile = mfRepo

				// Attempt scan (should fail)
				Expect(runScanner(ctx, false)).To(HaveOccurred())

				// Check that error is recorded in scanner properties
				lastError, err := ds.Property(ctx).DefaultGet(consts.LastScanErrorKey, "")
				Expect(err).ToNot(HaveOccurred())
				Expect(lastError).To(ContainSubstring("critical database error"))

				// Scan type should still be recorded
				scanType, _ := ds.Property(ctx).DefaultGet(consts.LastScanTypeKey, "")
				Expect(scanType).To(BeElementOf("incremental", "quick"))
			})
		})

		Context("Mixed error scenarios", func() {
			var rockFS storagetest.FakeFS

			BeforeEach(func() {
				// Set up rock library with filesystem that can error
				rock := template(_t{"albumartist": "Metallica", "album": "Master of Puppets", "year": 1986, "genre": "Metal"})
				rockFS = createFS("rock", fstest.MapFS{
					"Metallica/Master of Puppets/01 - Battery.mp3":           rock(track(1, "Battery")),
					"Metallica/Master of Puppets/02 - Master of Puppets.mp3": rock(track(2, "Master of Puppets")),
				})

				// Set up jazz library normally
				jazz := template(_t{"albumartist": "Herbie Hancock", "album": "Head Hunters", "year": 1973, "genre": "Jazz"})
				createFS("jazz", fstest.MapFS{
					"Herbie Hancock/Head Hunters/01 - Chameleon.mp3": jazz(track(1, "Chameleon")),
				})
			})

			It("should handle filesystem errors in one library while other succeeds", func() {
				// Inject filesystem error in rock library
				rockFS.SetError("Metallica/Master of Puppets/01 - Battery.mp3", errors.New("disk read error"))

				// Scan should complete with warnings (not hard error)
				warnings, err := s.ScanAll(ctx, true)
				Expect(err).ToNot(HaveOccurred())
				Expect(warnings).ToNot(BeEmpty(), "Should have warnings for filesystem error")

				// Jazz library should scan completely successfully
				jazzFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib2.ID},
				})
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzFiles).To(HaveLen(1))
				Expect(jazzFiles[0].Title).To(Equal("Chameleon"))

				// Jazz library statistics should be accurate
				jazzLib, err := ds.Library(ctx).Get(lib2.ID)
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzLib.TotalSongs).To(Equal(1))
				Expect(jazzLib.TotalAlbums).To(Equal(1))

				// Rock library may have partial content (depending on scanner implementation)
				rockFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib1.ID},
				})
				Expect(err).ToNot(HaveOccurred())
				// No specific expectation - some files may have been imported despite errors
				_ = rockFiles

				// Error should be empty (warnings don't count as scan errors)
				lastError, err := ds.Property(ctx).DefaultGet(consts.LastScanErrorKey, "unset")
				Expect(err).ToNot(HaveOccurred())
				Expect(lastError).To(BeEmpty())
			})

			It("should handle partial failures gracefully", func() {
				// Create a scenario where rock has filesystem issues and jazz has normal content
				rockFS.SetError("Metallica/Master of Puppets/01 - Battery.mp3", errors.New("file corruption"))

				// Do an initial scan with filesystem error
				warnings, err := s.ScanAll(ctx, true)
				Expect(err).ToNot(HaveOccurred())
				Expect(warnings).ToNot(BeEmpty(), "Should have warnings for file corruption")

				// Verify that the working parts completed successfully
				jazzFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib2.ID},
				})
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzFiles).To(HaveLen(1))

				// Scanner properties should reflect successful completion despite warnings
				scanType, _ := ds.Property(ctx).DefaultGet(consts.LastScanTypeKey, "")
				Expect(scanType).To(Equal("full"))

				// Start time should be recorded
				startTimeStr, _ := ds.Property(ctx).DefaultGet(consts.LastScanStartTimeKey, "")
				Expect(startTimeStr).ToNot(BeEmpty())

				// Error should be empty (warnings don't count as scan errors)
				lastError, err := ds.Property(ctx).DefaultGet(consts.LastScanErrorKey, "unset")
				Expect(err).ToNot(HaveOccurred())
				Expect(lastError).To(BeEmpty())
			})
		})

		Context("Error recovery in multi-library context", func() {
			It("should recover from previous library-specific errors", func() {
				// Set up initial content
				rock := template(_t{"albumartist": "Iron Maiden", "album": "The Number of the Beast", "year": 1982, "genre": "Metal"})
				jazz := template(_t{"albumartist": "John Coltrane", "album": "Giant Steps", "year": 1960, "genre": "Jazz"})

				rockFS := createFS("rock", fstest.MapFS{
					"Iron Maiden/The Number of the Beast/01 - Invaders.mp3": rock(track(1, "Invaders")),
				})

				createFS("jazz", fstest.MapFS{
					"John Coltrane/Giant Steps/01 - Giant Steps.mp3": jazz(track(1, "Giant Steps")),
				})

				// First scan with filesystem error in rock
				rockFS.SetError("Iron Maiden/The Number of the Beast/01 - Invaders.mp3", errors.New("temporary disk error"))
				warnings, err := s.ScanAll(ctx, true)
				Expect(err).ToNot(HaveOccurred()) // Should succeed with warnings
				Expect(warnings).ToNot(BeEmpty(), "Should have warnings for temporary disk error")

				// Clear the error and add more content - recreate the filesystem completely
				rockFS.ClearError("Iron Maiden/The Number of the Beast/01 - Invaders.mp3")

				// Create a new filesystem with both files
				createFS("rock", fstest.MapFS{
					"Iron Maiden/The Number of the Beast/01 - Invaders.mp3":               rock(track(1, "Invaders")),
					"Iron Maiden/The Number of the Beast/02 - Children of the Damned.mp3": rock(track(2, "Children of the Damned")),
				})

				// Second scan should recover and import all rock content
				warnings, err = s.ScanAll(ctx, true)
				Expect(err).ToNot(HaveOccurred())
				Expect(warnings).ToNot(BeEmpty(), "Should have warnings for temporary disk error")

				// Verify both libraries now have content (at least jazz should work)
				rockFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib1.ID},
				})
				Expect(err).ToNot(HaveOccurred())
				// The scanner should recover and import both rock files
				Expect(len(rockFiles)).To(Equal(2))

				jazzFiles, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
					Filters: squirrel.Eq{"library_id": lib2.ID},
				})
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzFiles).To(HaveLen(1))

				// Both libraries should have correct content counts
				rockLib, err := ds.Library(ctx).Get(lib1.ID)
				Expect(err).ToNot(HaveOccurred())
				Expect(rockLib.TotalSongs).To(Equal(2))

				jazzLib, err := ds.Library(ctx).Get(lib2.ID)
				Expect(err).ToNot(HaveOccurred())
				Expect(jazzLib.TotalSongs).To(Equal(1))

				// Error should be empty (successful recovery)
				lastError, err := ds.Property(ctx).DefaultGet(consts.LastScanErrorKey, "unset")
				Expect(err).ToNot(HaveOccurred())
				Expect(lastError).To(BeEmpty())
			})
		})
	})

	Context("Scanner Properties", func() {
		It("should persist last scan type, start time and error properties", func() {
			// trivial FS setup
			rock := template(_t{"albumartist": "AC/DC", "album": "Back in Black", "year": 1980, "genre": "Rock"})
			_ = createFS("rock", fstest.MapFS{
				"AC-DC/Back in Black/01 - Hells Bells.mp3": rock(track(1, "Hells Bells")),
			})

			// Run a full scan
			Expect(runScanner(ctx, true)).To(Succeed())

			// Validate properties
			scanType, _ := ds.Property(ctx).DefaultGet(consts.LastScanTypeKey, "")
			Expect(scanType).To(Equal("full"))

			startTimeStr, _ := ds.Property(ctx).DefaultGet(consts.LastScanStartTimeKey, "")
			Expect(startTimeStr).ToNot(BeEmpty())
			_, err := time.Parse(time.RFC3339, startTimeStr)
			Expect(err).ToNot(HaveOccurred())

			lastError, err := ds.Property(ctx).DefaultGet(consts.LastScanErrorKey, "unset")
			Expect(err).ToNot(HaveOccurred())
			Expect(lastError).To(BeEmpty())
		})
	})
})