sonda/internal/library/scanner_test.go
tgiachi 6d004c4225 feat(library): count unsupported audio formats and skip NAS system folders
- feat: the scan summary has an unsupported counter for audio files in formats
  Sonda cannot read yet (m4a, ogg, opus, wav, wma, ...); they are counted and
  never opened, instead of disappearing without a trace. Video containers such
  as .mpg are not counted
- feat: folders named .@__thumb, @Recycle, #recycle, @eaDir, $RECYCLE.BIN and
  System Volume Information are skipped, matched by exact name ignoring case,
  so a NAS recycle bin does not end up in the library; a library whose own
  folder carries one of these names is still scanned, and files indexed before
  from such a folder are flagged missing like any vanished file
- docs: the README lists the new counter and the skipped folders
- test: system folders at any depth, near-miss names, a library inside a
  system-named folder, entries flagged missing, unsupported counting

Closes #14
2026-11-11 14:25:33 +01:00

878 lines
24 KiB
Go

package library
import (
"context"
"errors"
"os"
"path/filepath"
"sync"
"sync/atomic"
"testing"
"time"
)
// ---- fakes ----
type fakeRow struct {
ExistingFile
Parsed ParsedFile
}
type fakeStore struct {
mu sync.Mutex
nextID int64
rows map[int64]map[string]*fakeRow // library id -> rel path -> row
saves int
}
func newFakeStore() *fakeStore { return &fakeStore{rows: map[int64]map[string]*fakeRow{}} }
func (s *fakeStore) byID(id int64) *fakeRow {
for _, files := range s.rows {
for _, r := range files {
if r.ID == id {
return r
}
}
}
return nil
}
func (s *fakeStore) ExistingFiles(_ context.Context, libraryID int64) ([]ExistingFile, error) {
s.mu.Lock()
defer s.mu.Unlock()
var out []ExistingFile
for _, r := range s.rows[libraryID] {
out = append(out, r.ExistingFile)
}
return out, nil
}
func (s *fakeStore) SaveFile(_ context.Context, libraryID int64, f ParsedFile, existingID int64) (bool, error) {
s.mu.Lock()
defer s.mu.Unlock()
s.saves++
if existingID != 0 {
r := s.byID(existingID)
r.Size, r.MTimeUnix, r.Missing, r.Parsed = f.Size, f.MTimeUnix, false, f
return false, nil
}
if s.rows[libraryID] == nil {
s.rows[libraryID] = map[string]*fakeRow{}
}
s.nextID++
s.rows[libraryID][f.RelPath] = &fakeRow{
ExistingFile: ExistingFile{ID: s.nextID, FileInfo: f.FileInfo},
Parsed: f,
}
return true, nil
}
func (s *fakeStore) RenameFile(_ context.Context, id int64, newRel string) error {
s.mu.Lock()
defer s.mu.Unlock()
for _, files := range s.rows {
for old, r := range files {
if r.ID == id {
delete(files, old)
r.RelPath, r.Missing = newRel, false
files[newRel] = r
return nil
}
}
}
return errors.New("no such file id")
}
func (s *fakeStore) MarkMissing(_ context.Context, ids []int64, _ time.Time) error {
s.mu.Lock()
defer s.mu.Unlock()
for _, id := range ids {
s.byID(id).Missing = true
}
return nil
}
func (s *fakeStore) Restore(_ context.Context, ids []int64) error {
s.mu.Lock()
defer s.mu.Unlock()
for _, id := range ids {
s.byID(id).Missing = false
}
return nil
}
// row looks a file up by the library path used in the test.
func (s *fakeStore) row(root, rel string) *fakeRow {
s.mu.Lock()
defer s.mu.Unlock()
return s.rows[libOf(root).ID][rel]
}
// ---- libraries ----
var (
libMu sync.Mutex
libIDs = map[string]int64{}
)
// libOf gives every directory used in a test a stable library.
func libOf(root string) Library {
libMu.Lock()
defer libMu.Unlock()
id, ok := libIDs[root]
if !ok {
id = int64(len(libIDs) + 1)
libIDs[root] = id
}
return Library{ID: id, Name: filepath.Base(root), Path: root}
}
func libsOf(roots ...string) []Library {
out := make([]Library, len(roots))
for i, r := range roots {
out[i] = libOf(r)
}
return out
}
// fakeSource is a LibrarySource over a fixed list.
type fakeSource struct{ libs []Library }
func (f fakeSource) ListLibraries(context.Context) ([]Library, error) { return f.libs, nil }
func (f fakeSource) GetLibrary(_ context.Context, id int64) (Library, error) {
for _, l := range f.libs {
if l.ID == id {
return l, nil
}
}
return Library{}, ErrLibraryNotFound
}
// fakeReader returns metadata derived from the file name and counts calls.
type fakeReader struct {
calls atomic.Int64
delay time.Duration
fail map[string]bool // base names that fail
running atomic.Int64
peak atomic.Int64
}
func (r *fakeReader) Read(path string) (Metadata, error) {
r.calls.Add(1)
n := r.running.Add(1)
for {
p := r.peak.Load()
if n <= p || r.peak.CompareAndSwap(p, n) {
break
}
}
defer r.running.Add(-1)
if r.delay > 0 {
time.Sleep(r.delay)
}
if r.fail[filepath.Base(path)] {
return Metadata{}, ErrUnreadable
}
return Metadata{
Tags: Tags{Title: filepath.Base(path), Artists: []string{"Artist"}},
Properties: Properties{Format: "mp3", DurationMs: 1000, SampleRate: 44100},
}, nil
}
// ---- helpers ----
func write(t *testing.T, path, content string) {
t.Helper()
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
t.Fatal(err)
}
}
func newScanner(store Store, reader TagReader, workers int) (*Scanner, *Hub) {
hub := NewHub()
return NewScanner(store, reader, hub, workers), hub
}
func mustScan(t *testing.T, s *Scanner, roots ...string) Summary {
t.Helper()
sum, err := s.Scan(context.Background(), libsOf(roots...))
if err != nil {
t.Fatal(err)
}
return sum
}
// ---- tests ----
func TestScanIndexesAudioFilesOnly(t *testing.T) {
root := t.TempDir()
write(t, filepath.Join(root, "a/one.mp3"), "1")
write(t, filepath.Join(root, "a/two.FLAC"), "22")
write(t, filepath.Join(root, "a/cover.jpg"), "x")
write(t, filepath.Join(root, "notes.txt"), "x")
store := newFakeStore()
s, _ := newScanner(store, &fakeReader{}, 2)
sum := mustScan(t, s, root)
if sum.Found != 2 || sum.Added != 2 || sum.Failed != 0 {
t.Fatalf("summary = %+v", sum)
}
if store.row(root, "a/one.mp3") == nil || store.row(root, "a/two.FLAC") == nil {
t.Error("audio files not stored with root-relative slash paths")
}
if store.row(root, "a/cover.jpg") != nil {
t.Error("non-audio file was stored")
}
}
func TestScanSkipsSymlinks(t *testing.T) {
root := t.TempDir()
outside := t.TempDir()
write(t, filepath.Join(outside, "secret.mp3"), "s")
write(t, filepath.Join(root, "real.mp3"), "r")
if err := os.Symlink(filepath.Join(outside, "secret.mp3"), filepath.Join(root, "link.mp3")); err != nil {
t.Skip("symlinks not supported:", err)
}
if err := os.Symlink(outside, filepath.Join(root, "dirlink")); err != nil {
t.Skip("symlinks not supported:", err)
}
store := newFakeStore()
s, _ := newScanner(store, &fakeReader{}, 2)
sum := mustScan(t, s, root)
if sum.Found != 1 || store.row(root, "real.mp3") == nil {
t.Fatalf("summary = %+v", sum)
}
if sum.Skipped < 1 {
t.Errorf("skipped = %d, want symlinks counted", sum.Skipped)
}
}
func TestRescanSkipsUnchangedFiles(t *testing.T) {
root := t.TempDir()
write(t, filepath.Join(root, "a.mp3"), "1")
write(t, filepath.Join(root, "b.mp3"), "22")
store, reader := newFakeStore(), &fakeReader{}
s, _ := newScanner(store, reader, 2)
mustScan(t, s, root)
before := reader.calls.Load()
sum := mustScan(t, s, root)
if sum.Unchanged != 2 || sum.Added != 0 || sum.Updated != 0 {
t.Fatalf("rescan summary = %+v", sum)
}
if reader.calls.Load() != before {
t.Error("unchanged files were parsed again")
}
if store.saves != 2 {
t.Errorf("saves = %d, want 2 (no duplicates)", store.saves)
}
}
func TestRescanUpdatesChangedFile(t *testing.T) {
root := t.TempDir()
p := filepath.Join(root, "a.mp3")
write(t, p, "1")
store := newFakeStore()
s, _ := newScanner(store, &fakeReader{}, 1)
mustScan(t, s, root)
id := store.row(root, "a.mp3").ID
write(t, p, "longer content")
later := time.Now().Add(time.Hour)
if err := os.Chtimes(p, later, later); err != nil {
t.Fatal(err)
}
sum := mustScan(t, s, root)
if sum.Updated != 1 || sum.Added != 0 {
t.Fatalf("summary = %+v", sum)
}
if got := store.row(root, "a.mp3").ID; got != id {
t.Errorf("id changed %d -> %d", id, got)
}
}
func TestRenamedFileKeepsIdentity(t *testing.T) {
root := t.TempDir()
write(t, filepath.Join(root, "old.mp3"), "content")
store, reader := newFakeStore(), &fakeReader{}
s, _ := newScanner(store, reader, 1)
mustScan(t, s, root)
id := store.row(root, "old.mp3").ID
calls := reader.calls.Load()
if err := os.MkdirAll(filepath.Join(root, "sub"), 0o755); err != nil {
t.Fatal(err)
}
if err := os.Rename(filepath.Join(root, "old.mp3"), filepath.Join(root, "sub/new.mp3")); err != nil {
t.Fatal(err)
}
sum := mustScan(t, s, root)
if sum.Renamed != 1 || sum.Added != 0 || sum.Missing != 0 {
t.Fatalf("summary = %+v", sum)
}
r := store.row(root, "sub/new.mp3")
if r == nil || r.ID != id {
t.Fatalf("renamed row = %+v, want id %d", r, id)
}
if reader.calls.Load() != calls {
t.Error("renamed file was parsed again")
}
}
func TestAmbiguousRenameIsNotGuessed(t *testing.T) {
root := t.TempDir()
ts := time.Unix(1_700_000_000, 0)
for _, n := range []string{"a.mp3", "b.mp3"} {
p := filepath.Join(root, n)
write(t, p, "same")
_ = os.Chtimes(p, ts, ts)
}
store := newFakeStore()
s, _ := newScanner(store, &fakeReader{}, 1)
mustScan(t, s, root)
// Both vanish and two look-alike files appear: size and mtime cannot tell which is which.
_ = os.Remove(filepath.Join(root, "a.mp3"))
_ = os.Remove(filepath.Join(root, "b.mp3"))
for _, n := range []string{"c.mp3", "d.mp3"} {
p := filepath.Join(root, n)
write(t, p, "same")
_ = os.Chtimes(p, ts, ts)
}
sum := mustScan(t, s, root)
if sum.Renamed != 0 || sum.Added != 2 || sum.Missing != 2 {
t.Fatalf("summary = %+v", sum)
}
}
func TestMissingFileIsMarkedThenRestored(t *testing.T) {
root := t.TempDir()
p := filepath.Join(root, "a.mp3")
write(t, p, "1")
write(t, filepath.Join(root, "keep.mp3"), "22") // the library must not become empty
ts := time.Unix(1_700_000_000, 0)
_ = os.Chtimes(p, ts, ts)
store := newFakeStore()
s, _ := newScanner(store, &fakeReader{}, 1)
mustScan(t, s, root)
if err := os.Remove(p); err != nil {
t.Fatal(err)
}
sum := mustScan(t, s, root)
if sum.Missing != 1 {
t.Fatalf("summary = %+v", sum)
}
r := store.row(root, "a.mp3")
if r == nil || !r.Missing {
t.Fatal("row should be kept and marked missing, not deleted")
}
// A second scan must not count it as newly missing.
if sum = mustScan(t, s, root); sum.Missing != 0 {
t.Errorf("already-missing file counted again: %+v", sum)
}
write(t, p, "1")
_ = os.Chtimes(p, ts, ts)
sum = mustScan(t, s, root)
if sum.Restored != 1 || store.row(root, "a.mp3").Missing {
t.Fatalf("summary = %+v, row = %+v", sum, store.row(root, "a.mp3"))
}
}
func TestUnreadableRootDoesNotMarkFilesMissing(t *testing.T) {
root := t.TempDir()
write(t, filepath.Join(root, "a.mp3"), "1")
store := newFakeStore()
s, _ := newScanner(store, &fakeReader{}, 1)
mustScan(t, s, root)
// Simulate an unmounted NAS: the root path no longer exists.
if err := os.RemoveAll(root); err != nil {
t.Fatal(err)
}
if _, err := s.Scan(context.Background(), libsOf(root)); err == nil {
t.Fatal("expected an error for an unreadable root")
}
if store.row(root, "a.mp3").Missing {
t.Fatal("files were marked missing although the root could not be read")
}
}
func TestSymlinkedRootIsFollowed(t *testing.T) {
real := t.TempDir()
write(t, filepath.Join(real, "a.mp3"), "1")
write(t, filepath.Join(real, "sub/b.mp3"), "22")
link := filepath.Join(t.TempDir(), "music")
if err := os.Symlink(real, link); err != nil {
t.Skip("symlinks not supported:", err)
}
store := newFakeStore()
s, _ := newScanner(store, &fakeReader{}, 2)
sum := mustScan(t, s, link)
if sum.Found != 2 || sum.Added != 2 {
t.Fatalf("first scan through a symlinked root: %+v", sum)
}
if store.row(link, "sub/b.mp3") == nil {
t.Error("files must be stored under the configured root path")
}
// A rescan must see the same files, not an empty tree.
sum = mustScan(t, s, link)
if sum.Unchanged != 2 || sum.Missing != 0 {
t.Fatalf("rescan through a symlinked root: %+v", sum)
}
}
func TestSymlinkRootToAFileIsRejected(t *testing.T) {
dir := t.TempDir()
write(t, filepath.Join(dir, "x.mp3"), "1")
link := filepath.Join(t.TempDir(), "music")
if err := os.Symlink(filepath.Join(dir, "x.mp3"), link); err != nil {
t.Skip("symlinks not supported:", err)
}
s, _ := newScanner(newFakeStore(), &fakeReader{}, 1)
if _, err := s.Scan(context.Background(), libsOf(link)); err == nil {
t.Fatal("a root that is not a directory must be an error")
}
}
func TestEmptyRootDoesNotMarkIndexedFilesMissing(t *testing.T) {
root := t.TempDir()
write(t, filepath.Join(root, "a.mp3"), "1")
write(t, filepath.Join(root, "b.mp3"), "22")
store := newFakeStore()
s, _ := newScanner(store, &fakeReader{}, 1)
mustScan(t, s, root)
// An unmounted NAS typically leaves an empty, perfectly readable folder.
_ = os.Remove(filepath.Join(root, "a.mp3"))
_ = os.Remove(filepath.Join(root, "b.mp3"))
sum, err := s.Scan(context.Background(), libsOf(root))
if err == nil {
t.Fatal("expected an error: root is empty but files are indexed")
}
if sum.Missing != 0 || store.row(root, "a.mp3").Missing || store.row(root, "b.mp3").Missing {
t.Fatalf("an empty root must not flag the library as missing: %+v", sum)
}
}
func TestEmptyRootWithNothingIndexedIsFine(t *testing.T) {
s, _ := newScanner(newFakeStore(), &fakeReader{}, 1)
sum, err := s.Scan(context.Background(), libsOf(t.TempDir()))
if err != nil || sum.Found != 0 {
t.Fatalf("fresh empty library: %+v err=%v", sum, err)
}
}
func TestUnreadableSubdirDoesNotMarkItsFilesMissing(t *testing.T) {
if os.Geteuid() == 0 {
t.Skip("permissions are not enforced for root")
}
root := t.TempDir()
write(t, filepath.Join(root, "ok.mp3"), "1")
write(t, filepath.Join(root, "locked/hidden.mp3"), "22")
store := newFakeStore()
s, _ := newScanner(store, &fakeReader{}, 1)
mustScan(t, s, root)
locked := filepath.Join(root, "locked")
if err := os.Chmod(locked, 0); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = os.Chmod(locked, 0o755) })
sum := mustScan(t, s, root)
if sum.Failed < 1 {
t.Errorf("failed = %d, want the unreadable dir reported", sum.Failed)
}
if sum.Missing != 0 || store.row(root, "locked/hidden.mp3").Missing {
t.Fatalf("file in unreadable dir marked missing: %+v", sum)
}
}
func TestUnreadableFileIsReportedAndScanContinues(t *testing.T) {
root := t.TempDir()
write(t, filepath.Join(root, "good.mp3"), "1")
write(t, filepath.Join(root, "bad.mp3"), "22")
store := newFakeStore()
s, hub := newScanner(store, &fakeReader{fail: map[string]bool{"bad.mp3": true}}, 2)
events, cancel := hub.Subscribe(64)
defer cancel()
sum := mustScan(t, s, root)
if sum.Added != 1 || sum.Failed != 1 {
t.Fatalf("summary = %+v", sum)
}
if store.row(root, "bad.mp3") != nil {
t.Error("unreadable file was stored")
}
var failed *Event
for len(events) > 0 {
if e := <-events; e.Type == FileFailed {
failed = &e
}
}
if failed == nil || failed.RelPath != "bad.mp3" || failed.Error == "" {
t.Fatalf("file_failed event = %+v", failed)
}
}
func TestScanRunsWorkersInParallel(t *testing.T) {
root := t.TempDir()
for i := 0; i < 12; i++ {
write(t, filepath.Join(root, string(rune('a'+i))+".mp3"), string(rune('a'+i)))
}
reader := &fakeReader{delay: 30 * time.Millisecond}
s, _ := newScanner(newFakeStore(), reader, 4)
start := time.Now()
mustScan(t, s, root)
elapsed := time.Since(start)
if reader.peak.Load() < 2 {
t.Errorf("peak concurrency = %d, want parallel reads", reader.peak.Load())
}
if reader.peak.Load() > 4 {
t.Errorf("peak concurrency = %d, exceeds 4 workers", reader.peak.Load())
}
if elapsed > 12*30*time.Millisecond {
t.Errorf("scan took %v, no faster than sequential", elapsed)
}
}
func TestCancelledScanDoesNotMarkMissing(t *testing.T) {
root := t.TempDir()
write(t, filepath.Join(root, "a.mp3"), "1")
store := newFakeStore()
s, _ := newScanner(store, &fakeReader{}, 1)
mustScan(t, s, root)
_ = os.Remove(filepath.Join(root, "a.mp3"))
ctx, cancel := context.WithCancel(context.Background())
cancel()
if _, err := s.Scan(ctx, libsOf(root)); !errors.Is(err, context.Canceled) {
t.Fatalf("err = %v, want context.Canceled", err)
}
if store.row(root, "a.mp3").Missing {
t.Fatal("an interrupted scan must not mark files missing")
}
}
func TestScanPublishesProgressEvents(t *testing.T) {
root := t.TempDir()
write(t, filepath.Join(root, "a.mp3"), "1")
write(t, filepath.Join(root, "b.mp3"), "22")
s, hub := newScanner(newFakeStore(), &fakeReader{}, 2)
events, cancel := hub.Subscribe(64)
defer cancel()
mustScan(t, s, root)
var types []EventType
var last Event
scanned := 0
for len(events) > 0 {
e := <-events
types = append(types, e.Type)
if e.Type == FileScanned {
scanned++
if e.Total != 2 || e.Done < 1 || e.Done > 2 {
t.Errorf("progress = %d/%d", e.Done, e.Total)
}
}
last = e
}
if types[0] != ScanStarted || last.Type != ScanFinished || scanned != 2 {
t.Fatalf("event types = %v", types)
}
if last.Summary == nil || last.Summary.Added != 2 {
t.Errorf("final summary = %+v", last.Summary)
}
}
func TestMultipleRootsAreIndependent(t *testing.T) {
a, b := t.TempDir(), t.TempDir()
write(t, filepath.Join(a, "same/name.mp3"), "1")
write(t, filepath.Join(b, "same/name.mp3"), "1")
store := newFakeStore()
s, _ := newScanner(store, &fakeReader{}, 2)
sum := mustScan(t, s, a, b)
if sum.Added != 2 || sum.Libraries != 2 {
t.Fatalf("summary = %+v", sum)
}
if store.row(a, "same/name.mp3") == nil || store.row(b, "same/name.mp3") == nil {
t.Error("same relative path under two roots must be two files")
}
}
func TestOneBadRootDoesNotStopTheOthers(t *testing.T) {
good := t.TempDir()
write(t, filepath.Join(good, "a.mp3"), "1")
bad := filepath.Join(t.TempDir(), "gone")
store := newFakeStore()
s, _ := newScanner(store, &fakeReader{}, 1)
sum, err := s.Scan(context.Background(), libsOf(bad, good))
if err == nil {
t.Fatal("expected an error mentioning the bad root")
}
if sum.Added != 1 || store.row(good, "a.mp3") == nil {
t.Fatalf("good root not scanned: %+v", sum)
}
}
// ---- hub ----
func TestHubSlowSubscriberDoesNotBlock(t *testing.T) {
hub := NewHub()
slow, cancelSlow := hub.Subscribe(1)
defer cancelSlow()
fast, cancelFast := hub.Subscribe(100)
defer cancelFast()
done := make(chan struct{})
go func() {
for i := 0; i < 50; i++ {
hub.Publish(Event{Type: FileScanned, Done: i})
}
close(done)
}()
select {
case <-done:
case <-time.After(2 * time.Second):
t.Fatal("Publish blocked on a slow subscriber")
}
if len(fast) != 50 {
t.Errorf("fast subscriber got %d events, want 50", len(fast))
}
if len(slow) != 1 {
t.Errorf("slow subscriber buffer = %d, want 1 (rest dropped)", len(slow))
}
}
func TestHubCancelClosesChannel(t *testing.T) {
hub := NewHub()
ch, cancel := hub.Subscribe(1)
cancel()
cancel() // idempotent
if _, ok := <-ch; ok {
t.Fatal("channel should be closed after cancel")
}
hub.Publish(Event{Type: FileScanned}) // must not panic
}
// ---- manager ----
func TestManagerRunsOneScanAtATime(t *testing.T) {
root := t.TempDir()
write(t, filepath.Join(root, "a.mp3"), "1")
reader := &fakeReader{delay: 100 * time.Millisecond}
s, _ := newScanner(newFakeStore(), reader, 1)
m := NewManager(s, fakeSource{libs: libsOf(root)})
if err := m.Start(context.Background()); err != nil {
t.Fatal(err)
}
if err := m.Start(context.Background()); !errors.Is(err, ErrScanRunning) {
t.Fatalf("second Start: err = %v, want ErrScanRunning", err)
}
if !m.Status().Running {
t.Error("status should report running")
}
deadline := time.Now().Add(3 * time.Second)
for m.Status().Running && time.Now().Before(deadline) {
time.Sleep(10 * time.Millisecond)
}
st := m.Status()
if st.Running || st.Last == nil || st.Last.Added != 1 || st.LastError != "" {
t.Fatalf("status = %+v", st)
}
if err := m.Start(context.Background()); err != nil {
t.Fatalf("Start after finish: %v", err)
}
}
func TestManagerCallsOnFinishOnce(t *testing.T) {
root := t.TempDir()
write(t, filepath.Join(root, "a.mp3"), "1")
s, _ := newScanner(newFakeStore(), &fakeReader{}, 1)
m := NewManager(s, fakeSource{libs: libsOf(root)})
type finished struct {
sum Summary
err error
}
got := make(chan finished, 4)
m.OnFinish(func(sum Summary, err error) { got <- finished{sum, err} })
if err := m.Start(context.Background()); err != nil {
t.Fatal(err)
}
select {
case f := <-got:
if f.err != nil || f.sum.Added != 1 {
t.Fatalf("finished = %+v", f)
}
case <-time.After(3 * time.Second):
t.Fatal("OnFinish was not called")
}
select {
case <-got:
t.Fatal("OnFinish called twice for one scan")
case <-time.After(100 * time.Millisecond):
}
}
func TestManagerWithoutLibraries(t *testing.T) {
s, _ := newScanner(newFakeStore(), &fakeReader{}, 1)
m := NewManager(s, fakeSource{})
if err := m.Start(context.Background()); !errors.Is(err, ErrNoLibraries) {
t.Fatalf("err = %v, want ErrNoLibraries", err)
}
if m.Status().Running {
t.Error("a scan that could not start must not look running")
}
}
func TestManagerScansOneLibrary(t *testing.T) {
a, b := t.TempDir(), t.TempDir()
write(t, filepath.Join(a, "a.mp3"), "1")
write(t, filepath.Join(b, "b.mp3"), "22")
store := newFakeStore()
s, _ := newScanner(store, &fakeReader{}, 1)
m := NewManager(s, fakeSource{libs: libsOf(a, b)})
if err := m.StartLibrary(context.Background(), 999); !errors.Is(err, ErrLibraryNotFound) {
t.Fatalf("unknown library: err = %v", err)
}
if m.Status().Running {
t.Fatal("an unknown library must not start a scan")
}
if err := m.StartLibrary(context.Background(), libOf(a).ID); err != nil {
t.Fatal(err)
}
deadline := time.Now().Add(3 * time.Second)
for m.Status().Running && time.Now().Before(deadline) {
time.Sleep(10 * time.Millisecond)
}
if store.row(a, "a.mp3") == nil {
t.Error("the requested library was not scanned")
}
if store.row(b, "b.mp3") != nil {
t.Error("another library was scanned too")
}
if st := m.Status(); st.Last == nil || st.Last.Libraries != 1 {
t.Errorf("status = %+v", st)
}
}
func TestScanSkipsNASSystemFolders(t *testing.T) {
root := t.TempDir()
write(t, filepath.Join(root, "Album/real.mp3"), "1")
for _, dir := range []string{".@__thumb", "@Recycle", "#recycle", "@eaDir", "$RECYCLE.BIN", "System Volume Information", "@recycle"} {
write(t, filepath.Join(root, dir, "ghost.mp3"), "2")
}
write(t, filepath.Join(root, "Album/@eaDir/thumb.mp3"), "3") // nested, too
write(t, filepath.Join(root, "Album/.@__thumb/thumb.flac"), "4")
// Only the exact folder name is special.
write(t, filepath.Join(root, "My @Recycle stuff/kept.mp3"), "5")
write(t, filepath.Join(root, "recycle bin/kept2.mp3"), "6")
store := newFakeStore()
s, _ := newScanner(store, &fakeReader{}, 2)
sum := mustScan(t, s, root)
if sum.Found != 3 || sum.Added != 3 {
t.Fatalf("summary = %+v, want the 3 real files only", sum)
}
for _, rel := range []string{"Album/real.mp3", "My @Recycle stuff/kept.mp3", "recycle bin/kept2.mp3"} {
if store.row(root, rel) == nil {
t.Errorf("%s was not indexed", rel)
}
}
if store.row(root, "@Recycle/ghost.mp3") != nil || store.row(root, "Album/@eaDir/thumb.mp3") != nil {
t.Error("a file inside a system folder was indexed")
}
}
// The check is about folders inside a library. A library may well live in a
// folder that carries one of these names.
func TestLibraryInsideASystemNamedFolderIsStillScanned(t *testing.T) {
root := filepath.Join(t.TempDir(), "@Recycle")
write(t, filepath.Join(root, "song.mp3"), "1")
s, _ := newScanner(newFakeStore(), &fakeReader{}, 1)
if sum := mustScan(t, s, root); sum.Found != 1 {
t.Fatalf("summary = %+v, want the library's own folder to be scanned", sum)
}
}
// Files that were indexed before a folder became "system" are no longer part of
// the library: they are flagged missing like any other vanished file.
func TestFilesInASkippedFolderAreFlaggedMissing(t *testing.T) {
root := t.TempDir()
write(t, filepath.Join(root, "keep.mp3"), "1")
write(t, filepath.Join(root, "@Recycle/old.mp3"), "22")
store := newFakeStore()
s, _ := newScanner(store, &fakeReader{}, 1)
if _, err := store.SaveFile(context.Background(), libOf(root).ID,
ParsedFile{FileInfo: FileInfo{RelPath: "@Recycle/old.mp3", Size: 2, MTimeUnix: 1}}, 0); err != nil {
t.Fatal(err)
}
sum := mustScan(t, s, root)
if sum.Missing != 1 || !store.row(root, "@Recycle/old.mp3").Missing {
t.Fatalf("summary = %+v, want the old recycle-bin entry flagged missing", sum)
}
}
func TestScanCountsUnsupportedAudioFormats(t *testing.T) {
root := t.TempDir()
write(t, filepath.Join(root, "a.mp3"), "1")
for _, name := range []string{"b.m4a", "c.OGG", "d.wav", "e.opus", "sub/f.wma", "g.Aiff"} {
write(t, filepath.Join(root, name), "x")
}
for _, name := range []string{"notes.txt", "cover.jpg", "album.nfo", "Thumbs.db", "clip.mpg"} {
write(t, filepath.Join(root, name), "x") // not audio, or not audio Sonda knows
}
reader := &fakeReader{}
store := newFakeStore()
s, _ := newScanner(store, reader, 1)
sum := mustScan(t, s, root)
if sum.Found != 1 || sum.Unsupported != 6 {
t.Fatalf("summary = %+v, want 1 supported and 6 unsupported", sum)
}
if reader.calls.Load() != 1 {
t.Errorf("reader called %d times: unsupported files must not be opened", reader.calls.Load())
}
}