mirror of
https://github.com/navidrome/navidrome.git
synced 2026-08-01 07:21:17 +00:00
05105e91d9
* feat(scanner): add Scanner.IgnoreDotFolders to allow scanning dot folders
Adds a new Scanner.IgnoreDotFolders option (default true, preserving current
behavior) that, when disabled, lets the scanner traverse folders whose names
start with a dot, such as albums like ".Hack Sign Original Soundtrack".
Previously every dot-prefixed entry was skipped unconditionally before the
directory check, so such album folders were never indexed. The walk loop now
determines whether an entry is a directory first, then skips dot-prefixed files
always and dot-prefixed folders only when IgnoreDotFolders is enabled. Special
system directories are still ignored in all cases via the ignoredDirs blocklist,
which now also lists .git explicitly (it was previously caught only by the
generic dot-prefix rule). isDirIgnored is reduced to a pure blocklist check and
the name-only predicate is renamed from isEntryIgnored to isDotEntry.
* refactor(scanner): centralize entry ignore policy in isIgnoredEntry
Consolidates the directory-entry ignore decision into a single isIgnoredEntry
helper so the walk loop reads as pure dispatch (recurse into directories,
classify files) instead of interleaving ignore policy with traversal.
The dot-prefix rule and the ignoredDirs blocklist were previously checked in two
separate places inside loadDir's loop. They are now combined behind one helper
that takes the entry name and whether it is a directory. isDirIgnored remains a
standalone blocklist predicate because the file watcher (isIgnoredPath) calls it
directly. Adds focused unit tests for isIgnoredEntry covering both states of
Scanner.IgnoreDotFolders. No behavior change.
* fix(scanner): stop watcher from scanning ignored dot folders
A filesystem change inside a dot-prefixed folder (e.g. ".Hidden Album/track.mp3")
previously triggered a targeted scan of that folder, because isIgnoredPath let
all media files through and only checked the changed path's parent against the
ignore list (which never matched for nested paths due to the trailing separator).
With Scanner.IgnoreDotFolders enabled this caused the folder to be indexed even
though a full scan would skip it.
The watcher now ignores any change located inside an ignored directory via a new
isUnderIgnoredDir helper that reuses the same isIgnoredEntry policy as the scan
walk, and checks the entry itself with isIgnoredEntry instead of the parent dir.
This keeps the watcher and the scanner in agreement for both dot-folders (gated
by the flag) and the ignoredDirs blocklist. Adds direct table tests for
isIgnoredPath covering both states of the option.
* fix(scanner): exclude '.' from isDotEntry and ignore dot media files in watcher
Addresses code review feedback:
- isDotEntry now excludes the literal "." reference, matching its documentation.
Previously isDotEntry(".") returned true, which could mark a path component as
a dot-entry in the watcher.
- isIgnoredPath now ignores dot-prefixed media files (e.g. ".hidden.mp3") so the
watcher matches the scanner, which always skips dot files. Non-media leaves
still fall through to the directory-assumption check, so dot-folders continue
to follow Scanner.IgnoreDotFolders.
Adds unit tests for isDotEntry and watcher coverage for dot-prefixed media files.
* docs(scanner): clarify isDotEntry multi-dot exclusion and add test
Expand the isDotEntry comment to explain why names with two or more
leading dots (".."/"..foo"/"...Album") are not treated as hidden, which
surprised a reviewer testing dot-folder scanning. Add a "..foo" test case
to make the two-leading-dots behavior explicit.
Claude-Session: https://claude.ai/code/session_012STiDTyhZAdH8JNtdNe8L1
538 lines
17 KiB
Go
538 lines
17 KiB
Go
package scanner
|
|
|
|
import (
|
|
"context"
|
|
"io/fs"
|
|
"path/filepath"
|
|
"testing/fstest"
|
|
"time"
|
|
|
|
"github.com/navidrome/navidrome/conf"
|
|
"github.com/navidrome/navidrome/conf/configtest"
|
|
"github.com/navidrome/navidrome/model"
|
|
"github.com/navidrome/navidrome/tests"
|
|
. "github.com/onsi/ginkgo/v2"
|
|
. "github.com/onsi/gomega"
|
|
)
|
|
|
|
var _ = Describe("Watcher", func() {
|
|
var ctx context.Context
|
|
var cancel context.CancelFunc
|
|
var mockScanner *tests.MockScanner
|
|
var mockDS *tests.MockDataStore
|
|
var w *watcher
|
|
var lib *model.Library
|
|
|
|
BeforeEach(func() {
|
|
DeferCleanup(configtest.SetupConfig())
|
|
conf.Server.Scanner.WatcherWait = 50 * time.Millisecond // Short wait for tests
|
|
|
|
ctx, cancel = context.WithCancel(GinkgoT().Context())
|
|
DeferCleanup(cancel)
|
|
|
|
lib = &model.Library{
|
|
ID: 1,
|
|
Name: "Test Library",
|
|
Path: "/test/library",
|
|
}
|
|
|
|
// Set up mocks
|
|
mockScanner = tests.NewMockScanner()
|
|
mockDS = &tests.MockDataStore{}
|
|
mockLibRepo := &tests.MockLibraryRepo{}
|
|
mockLibRepo.SetData(model.Libraries{*lib})
|
|
mockDS.MockedLibrary = mockLibRepo
|
|
|
|
// Create a new watcher instance (not singleton) for testing
|
|
w = &watcher{
|
|
ds: mockDS,
|
|
scanner: mockScanner,
|
|
triggerWait: conf.Server.Scanner.WatcherWait,
|
|
watcherNotify: make(chan scanNotification, 10),
|
|
libraryWatchers: make(map[int]*libraryWatcherInstance),
|
|
mainCtx: ctx,
|
|
}
|
|
})
|
|
|
|
Describe("Watch before Run", func() {
|
|
It("returns nil and does not panic when mainCtx is nil", func() {
|
|
w.mainCtx = nil
|
|
err := w.Watch(ctx, lib)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(w.libraryWatchers).To(BeEmpty())
|
|
})
|
|
})
|
|
|
|
Describe("Target Collection and Deduplication", func() {
|
|
BeforeEach(func() {
|
|
// Start watcher in background
|
|
go func() {
|
|
_ = w.Run(ctx)
|
|
}()
|
|
|
|
// Give watcher time to initialize
|
|
time.Sleep(10 * time.Millisecond)
|
|
})
|
|
|
|
It("creates separate targets for different folders", FlakeAttempts(3), func() {
|
|
// Send notifications for different folders
|
|
w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1"}
|
|
w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist2"}
|
|
|
|
// Wait for a scan that collected both targets
|
|
Eventually(func() []model.ScanTarget {
|
|
calls := mockScanner.GetScanFoldersCalls()
|
|
if len(calls) == 0 {
|
|
return nil
|
|
}
|
|
return calls[0].Targets
|
|
}, 500*time.Millisecond, 10*time.Millisecond).Should(HaveLen(2))
|
|
|
|
// Verify targets
|
|
calls := mockScanner.GetScanFoldersCalls()
|
|
folderPaths := make(map[string]bool)
|
|
for _, target := range calls[0].Targets {
|
|
Expect(target.LibraryID).To(Equal(1))
|
|
folderPaths[target.FolderPath] = true
|
|
}
|
|
Expect(folderPaths).To(HaveKey("artist1"))
|
|
Expect(folderPaths).To(HaveKey("artist2"))
|
|
})
|
|
|
|
It("handles different folder paths correctly", func() {
|
|
// Send notification for nested folder
|
|
w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1/album1"}
|
|
|
|
// Wait for watcher to process and trigger scan
|
|
Eventually(func() int {
|
|
return mockScanner.GetScanFoldersCallCount()
|
|
}, 500*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
|
|
|
|
// Verify the target
|
|
calls := mockScanner.GetScanFoldersCalls()
|
|
Expect(calls).To(HaveLen(1))
|
|
Expect(calls[0].Targets).To(HaveLen(1))
|
|
Expect(calls[0].Targets[0].FolderPath).To(Equal("artist1/album1"))
|
|
})
|
|
|
|
It("deduplicates folder and file within same folder", func() {
|
|
// Send multiple notifications for the same folder
|
|
w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1/album1"}
|
|
w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1/album1"}
|
|
w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1/album1"}
|
|
|
|
// Wait for watcher to process and trigger scan
|
|
Eventually(func() int {
|
|
return mockScanner.GetScanFoldersCallCount()
|
|
}, 500*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
|
|
|
|
// Verify only one target despite multiple file/folder changes
|
|
calls := mockScanner.GetScanFoldersCalls()
|
|
Expect(calls).To(HaveLen(1))
|
|
Expect(calls[0].Targets).To(HaveLen(1))
|
|
Expect(calls[0].Targets[0].FolderPath).To(Equal("artist1/album1"))
|
|
})
|
|
})
|
|
|
|
Describe("Timer Behavior", func() {
|
|
BeforeEach(func() {
|
|
// Start watcher in background
|
|
go func() {
|
|
_ = w.Run(ctx)
|
|
}()
|
|
|
|
// Give watcher time to initialize
|
|
time.Sleep(10 * time.Millisecond)
|
|
})
|
|
|
|
It("resets timer on each change (debouncing)", FlakeAttempts(3), func() {
|
|
// Send first notification
|
|
w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1"}
|
|
|
|
// Verify no scan fires during a window shorter than the debounce wait
|
|
Consistently(func() int {
|
|
return mockScanner.GetScanFoldersCallCount()
|
|
}, 20*time.Millisecond, 5*time.Millisecond).Should(Equal(0))
|
|
|
|
// Send another notification (resets timer)
|
|
w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1"}
|
|
|
|
// Again, no scan should fire within a short window
|
|
Consistently(func() int {
|
|
return mockScanner.GetScanFoldersCallCount()
|
|
}, 20*time.Millisecond, 5*time.Millisecond).Should(Equal(0))
|
|
|
|
// Now wait for the debounce timer to expire and trigger scan
|
|
Eventually(func() int {
|
|
return mockScanner.GetScanFoldersCallCount()
|
|
}, 500*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
|
|
})
|
|
|
|
It("triggers scan after quiet period", func() {
|
|
// Send notification
|
|
w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1"}
|
|
|
|
// No scan immediately
|
|
Expect(mockScanner.GetScanFoldersCallCount()).To(Equal(0))
|
|
|
|
// Wait for quiet period
|
|
Eventually(func() int {
|
|
return mockScanner.GetScanFoldersCallCount()
|
|
}, 500*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
|
|
})
|
|
})
|
|
|
|
Describe("Empty and Root Paths", func() {
|
|
BeforeEach(func() {
|
|
// Start watcher in background
|
|
go func() {
|
|
_ = w.Run(ctx)
|
|
}()
|
|
|
|
// Give watcher time to initialize
|
|
time.Sleep(10 * time.Millisecond)
|
|
})
|
|
|
|
It("handles empty folder path (library root)", func() {
|
|
// Send notification with empty folder path
|
|
w.watcherNotify <- scanNotification{Library: lib, FolderPath: ""}
|
|
|
|
// Wait for scan
|
|
Eventually(func() int {
|
|
return mockScanner.GetScanFoldersCallCount()
|
|
}, 500*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
|
|
|
|
// Should scan the library root
|
|
calls := mockScanner.GetScanFoldersCalls()
|
|
Expect(calls).To(HaveLen(1))
|
|
Expect(calls[0].Targets).To(HaveLen(1))
|
|
Expect(calls[0].Targets[0].FolderPath).To(Equal(""))
|
|
})
|
|
|
|
It("deduplicates empty and dot paths", func() {
|
|
// Send notifications with empty and dot paths
|
|
w.watcherNotify <- scanNotification{Library: lib, FolderPath: ""}
|
|
w.watcherNotify <- scanNotification{Library: lib, FolderPath: ""}
|
|
|
|
// Wait for scan
|
|
Eventually(func() int {
|
|
return mockScanner.GetScanFoldersCallCount()
|
|
}, 500*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
|
|
|
|
// Should have only one target
|
|
calls := mockScanner.GetScanFoldersCalls()
|
|
Expect(calls).To(HaveLen(1))
|
|
Expect(calls[0].Targets).To(HaveLen(1))
|
|
})
|
|
})
|
|
|
|
Describe("Multiple Libraries", func() {
|
|
var lib2 *model.Library
|
|
|
|
BeforeEach(func() {
|
|
// Create second library
|
|
lib2 = &model.Library{
|
|
ID: 2,
|
|
Name: "Test Library 2",
|
|
Path: "/test/library2",
|
|
}
|
|
|
|
mockLibRepo := mockDS.MockedLibrary.(*tests.MockLibraryRepo)
|
|
mockLibRepo.SetData(model.Libraries{*lib, *lib2})
|
|
|
|
// Start watcher in background
|
|
go func() {
|
|
_ = w.Run(ctx)
|
|
}()
|
|
|
|
// Give watcher time to initialize
|
|
time.Sleep(10 * time.Millisecond)
|
|
})
|
|
|
|
It("creates separate targets for different libraries", func() {
|
|
// Send notifications for both libraries
|
|
w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1"}
|
|
w.watcherNotify <- scanNotification{Library: lib2, FolderPath: "artist2"}
|
|
|
|
// Wait for a scan that collected both targets
|
|
Eventually(func() []model.ScanTarget {
|
|
calls := mockScanner.GetScanFoldersCalls()
|
|
if len(calls) == 0 {
|
|
return nil
|
|
}
|
|
return calls[0].Targets
|
|
}, 500*time.Millisecond, 10*time.Millisecond).Should(HaveLen(2))
|
|
|
|
// Verify library IDs are different
|
|
calls := mockScanner.GetScanFoldersCalls()
|
|
libraryIDs := make(map[int]bool)
|
|
for _, target := range calls[0].Targets {
|
|
libraryIDs[target.LibraryID] = true
|
|
}
|
|
Expect(libraryIDs).To(HaveKey(1))
|
|
Expect(libraryIDs).To(HaveKey(2))
|
|
})
|
|
})
|
|
|
|
Describe(".ndignore handling", func() {
|
|
var ctx context.Context
|
|
var cancel context.CancelFunc
|
|
var w *watcher
|
|
var mockFS *mockMusicFS
|
|
var lib *model.Library
|
|
var eventChan chan string
|
|
var absLibPath string
|
|
|
|
BeforeEach(func() {
|
|
ctx, cancel = context.WithCancel(GinkgoT().Context())
|
|
DeferCleanup(cancel)
|
|
|
|
// Set up library
|
|
var err error
|
|
absLibPath, err = filepath.Abs(".")
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
lib = &model.Library{
|
|
ID: 1,
|
|
Name: "Test Library",
|
|
Path: absLibPath,
|
|
}
|
|
|
|
// Create watcher with notification channel
|
|
w = &watcher{
|
|
watcherNotify: make(chan scanNotification, 10),
|
|
}
|
|
|
|
eventChan = make(chan string, 10)
|
|
})
|
|
|
|
// Helper to send an event - converts relative path to absolute
|
|
sendEvent := func(relativePath string) {
|
|
path := filepath.Join(absLibPath, relativePath)
|
|
eventChan <- path
|
|
}
|
|
|
|
// Helper to start the real event processing loop
|
|
startEventProcessing := func() {
|
|
go func() {
|
|
defer GinkgoRecover()
|
|
// Call the actual processLibraryEvents method - testing the real implementation!
|
|
_ = w.processLibraryEvents(ctx, lib, mockFS, eventChan, absLibPath)
|
|
}()
|
|
}
|
|
|
|
Context("when a folder matching .ndignore is deleted", func() {
|
|
BeforeEach(func() {
|
|
// Create filesystem with .ndignore containing _TEMP pattern
|
|
// The deleted folder (_TEMP) will NOT exist in the filesystem
|
|
mockFS = &mockMusicFS{
|
|
FS: fstest.MapFS{
|
|
"rock": &fstest.MapFile{Mode: fs.ModeDir},
|
|
"rock/.ndignore": &fstest.MapFile{Data: []byte("_TEMP\n")},
|
|
"rock/valid_album": &fstest.MapFile{Mode: fs.ModeDir},
|
|
"rock/valid_album/track.mp3": &fstest.MapFile{Data: []byte("audio")},
|
|
},
|
|
}
|
|
})
|
|
|
|
It("should NOT send scan notification when deleted folder matches .ndignore", func() {
|
|
startEventProcessing()
|
|
|
|
// Simulate deletion event for rock/_TEMP
|
|
sendEvent("rock/_TEMP")
|
|
|
|
// Wait a bit to ensure event is processed
|
|
time.Sleep(50 * time.Millisecond)
|
|
|
|
// No notification should have been sent
|
|
Consistently(eventChan, 100*time.Millisecond).Should(BeEmpty())
|
|
})
|
|
|
|
It("should send scan notification for valid folder deletion", func() {
|
|
startEventProcessing()
|
|
|
|
// Simulate deletion event for rock/other_folder (not in .ndignore and doesn't exist)
|
|
// Since it doesn't exist in mockFS, resolveFolderPath will walk up to "rock"
|
|
sendEvent("rock/other_folder")
|
|
|
|
// Should receive notification for parent folder
|
|
Eventually(w.watcherNotify, 200*time.Millisecond).Should(Receive(Equal(scanNotification{
|
|
Library: lib,
|
|
FolderPath: "rock",
|
|
})))
|
|
})
|
|
})
|
|
|
|
Context("with nested folder patterns", func() {
|
|
BeforeEach(func() {
|
|
mockFS = &mockMusicFS{
|
|
FS: fstest.MapFS{
|
|
"music": &fstest.MapFile{Mode: fs.ModeDir},
|
|
"music/.ndignore": &fstest.MapFile{Data: []byte("**/temp\n**/cache\n")},
|
|
"music/rock": &fstest.MapFile{Mode: fs.ModeDir},
|
|
"music/rock/artist": &fstest.MapFile{Mode: fs.ModeDir},
|
|
},
|
|
}
|
|
})
|
|
|
|
It("should NOT send notification when nested ignored folder is deleted", func() {
|
|
tests.SkipOnWindows("path separator bug (#TBD-path-sep-scanner)")
|
|
startEventProcessing()
|
|
|
|
// Simulate deletion of music/rock/artist/temp (matches **/temp)
|
|
sendEvent("music/rock/artist/temp")
|
|
|
|
// Wait to ensure event is processed
|
|
time.Sleep(50 * time.Millisecond)
|
|
|
|
// No notification should be sent
|
|
Expect(w.watcherNotify).To(BeEmpty(), "Expected no scan notification for nested ignored folder")
|
|
})
|
|
|
|
It("should send notification for non-ignored nested folder", func() {
|
|
tests.SkipOnWindows("path separator bug (#TBD-path-sep-scanner)")
|
|
startEventProcessing()
|
|
|
|
// Simulate change in music/rock/artist (doesn't match any pattern)
|
|
sendEvent("music/rock/artist")
|
|
|
|
// Should receive notification
|
|
Eventually(w.watcherNotify, 200*time.Millisecond).Should(Receive(Equal(scanNotification{
|
|
Library: lib,
|
|
FolderPath: "music/rock/artist",
|
|
})))
|
|
})
|
|
})
|
|
|
|
Context("with file events in ignored folders", func() {
|
|
BeforeEach(func() {
|
|
mockFS = &mockMusicFS{
|
|
FS: fstest.MapFS{
|
|
"rock": &fstest.MapFile{Mode: fs.ModeDir},
|
|
"rock/.ndignore": &fstest.MapFile{Data: []byte("_TEMP\n")},
|
|
},
|
|
}
|
|
})
|
|
|
|
It("should NOT send notification for file changes in ignored folders", func() {
|
|
tests.SkipOnWindows("path separator bug (#TBD-path-sep-scanner)")
|
|
startEventProcessing()
|
|
|
|
// Simulate file change in rock/_TEMP/file.mp3
|
|
sendEvent("rock/_TEMP/file.mp3")
|
|
|
|
// Wait to ensure event is processed
|
|
time.Sleep(50 * time.Millisecond)
|
|
|
|
// No notification should be sent
|
|
Expect(w.watcherNotify).To(BeEmpty(), "Expected no scan notification for file in ignored folder")
|
|
})
|
|
})
|
|
|
|
})
|
|
})
|
|
|
|
var _ = Describe("isIgnoredPath", func() {
|
|
BeforeEach(func() {
|
|
DeferCleanup(configtest.SetupConfig())
|
|
})
|
|
|
|
Context("with IgnoreDotFolders enabled (default)", func() {
|
|
BeforeEach(func() {
|
|
conf.Server.Scanner.IgnoreDotFolders = true
|
|
})
|
|
|
|
DescribeTable("returns expected result",
|
|
func(p string, expected bool) {
|
|
Expect(isIgnoredPath(context.Background(), nil, filepath.FromSlash(p))).To(Equal(expected))
|
|
},
|
|
Entry("media file in normal folder", "rock/Album/track.mp3", false),
|
|
Entry("dot-prefixed media file", "rock/Album/.hidden.mp3", true),
|
|
Entry("media file inside a dot-folder", "rock/.Hidden Album/track.mp3", true),
|
|
Entry("media file inside a blocklisted folder", "rock/.streams/stream.mp3", true),
|
|
Entry("media file inside .git", "rock/.git/track.mp3", true),
|
|
Entry("dot-folder itself", "rock/.Hidden Album", true),
|
|
Entry("normal folder itself", "rock/Album", false),
|
|
Entry(".DS_Store file", "rock/Album/.DS_Store", true),
|
|
)
|
|
})
|
|
|
|
Context("with IgnoreDotFolders disabled", func() {
|
|
BeforeEach(func() {
|
|
conf.Server.Scanner.IgnoreDotFolders = false
|
|
})
|
|
|
|
DescribeTable("returns expected result",
|
|
func(p string, expected bool) {
|
|
Expect(isIgnoredPath(context.Background(), nil, filepath.FromSlash(p))).To(Equal(expected))
|
|
},
|
|
Entry("media file inside a dot-folder is allowed", "rock/.Hidden Album/track.mp3", false),
|
|
Entry("dot-prefixed media file is still ignored", "rock/Album/.hidden.mp3", true),
|
|
Entry("dot-folder itself is allowed", "rock/.Hidden Album", false),
|
|
Entry("blocklisted folder still ignored", "rock/.streams/stream.mp3", true),
|
|
Entry(".git still ignored", "rock/.git/config", true),
|
|
)
|
|
})
|
|
})
|
|
|
|
var _ = Describe("resolveFolderPath", func() {
|
|
var mockFS fs.FS
|
|
|
|
BeforeEach(func() {
|
|
// Create a mock filesystem with some directories and files
|
|
mockFS = fstest.MapFS{
|
|
"artist1": &fstest.MapFile{Mode: fs.ModeDir},
|
|
"artist1/album1": &fstest.MapFile{Mode: fs.ModeDir},
|
|
"artist1/album1/track1.mp3": &fstest.MapFile{Data: []byte("audio")},
|
|
"artist1/album1/track2.mp3": &fstest.MapFile{Data: []byte("audio")},
|
|
"artist1/album2": &fstest.MapFile{Mode: fs.ModeDir},
|
|
"artist1/album2/song.flac": &fstest.MapFile{Data: []byte("audio")},
|
|
"artist2": &fstest.MapFile{Mode: fs.ModeDir},
|
|
"artist2/cover.jpg": &fstest.MapFile{Data: []byte("image")},
|
|
}
|
|
})
|
|
|
|
It("returns directory path when given a directory", func() {
|
|
result := resolveFolderPath(mockFS, "artist1/album1")
|
|
Expect(result).To(Equal("artist1/album1"))
|
|
})
|
|
|
|
It("walks up to parent directory when given a file path", func() {
|
|
tests.SkipOnWindows("path separator bug (#TBD-path-sep-scanner)")
|
|
result := resolveFolderPath(mockFS, "artist1/album1/track1.mp3")
|
|
Expect(result).To(Equal("artist1/album1"))
|
|
})
|
|
|
|
It("walks up multiple levels if needed", func() {
|
|
tests.SkipOnWindows("path separator bug (#TBD-path-sep-scanner)")
|
|
result := resolveFolderPath(mockFS, "artist1/album1/nonexistent/file.mp3")
|
|
Expect(result).To(Equal("artist1/album1"))
|
|
})
|
|
|
|
It("returns empty string for non-existent paths at root", func() {
|
|
result := resolveFolderPath(mockFS, "nonexistent/path/file.mp3")
|
|
Expect(result).To(Equal(""))
|
|
})
|
|
|
|
It("returns empty string for dot path", func() {
|
|
result := resolveFolderPath(mockFS, ".")
|
|
Expect(result).To(Equal(""))
|
|
})
|
|
|
|
It("returns empty string for empty path", func() {
|
|
result := resolveFolderPath(mockFS, "")
|
|
Expect(result).To(Equal(""))
|
|
})
|
|
|
|
It("handles nested file paths correctly", func() {
|
|
tests.SkipOnWindows("path separator bug (#TBD-path-sep-scanner)")
|
|
result := resolveFolderPath(mockFS, "artist1/album2/song.flac")
|
|
Expect(result).To(Equal("artist1/album2"))
|
|
})
|
|
|
|
It("resolves to top-level directory", func() {
|
|
result := resolveFolderPath(mockFS, "artist2/cover.jpg")
|
|
Expect(result).To(Equal("artist2"))
|
|
})
|
|
})
|