mirror of
https://github.com/navidrome/navidrome.git
synced 2026-11-20 17:09:54 +01:00
Establishes a behavioral baseline for getLyricsBySongId (v2 structured)
and getLyrics (legacy) before the lyrics parser refactor. Covers embedded
formats (LRC synced, plain text, TTML) and sidecar formats (LRC, SRT,
YAML), all isolated under a Lyrics/ fixture folder so the new fixtures
do not perturb existing test behavior beyond fixture counts.
Sidecar files are injected as raw &fstest.MapFile{Data: []byte(...)}
entries; the scanner skips non-audio extensions (.lrc, .srt, .yaml) so
they are invisible to scanning but reachable via the fake FS at request
time through fromExternalFile/storage.For.
Update album/artist/song counts in the album-list, multi-library, and
search3 empty-query tests to reflect the six new tracks (1 new artist,
1 new album, 6 new songs).
274 lines
8.9 KiB
Go
274 lines
8.9 KiB
Go
package e2e
|
|
|
|
import (
|
|
"github.com/google/uuid"
|
|
"github.com/navidrome/navidrome/conf"
|
|
"github.com/navidrome/navidrome/conf/configtest"
|
|
"github.com/navidrome/navidrome/server/subsonic/responses"
|
|
. "github.com/onsi/ginkgo/v2"
|
|
. "github.com/onsi/gomega"
|
|
)
|
|
|
|
var _ = Describe("Search Endpoints", func() {
|
|
BeforeEach(func() {
|
|
setupTestDB()
|
|
})
|
|
|
|
Describe("Search2", func() {
|
|
It("finds artists by name", func() {
|
|
resp := doReq("search2", "query", "Beatles")
|
|
|
|
Expect(resp.Status).To(Equal(responses.StatusOK))
|
|
Expect(resp.SearchResult2).ToNot(BeNil())
|
|
Expect(resp.SearchResult2.Artist).ToNot(BeEmpty())
|
|
|
|
found := false
|
|
for _, a := range resp.SearchResult2.Artist {
|
|
if a.Name == "The Beatles" {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
Expect(found).To(BeTrue(), "expected to find artist 'The Beatles'")
|
|
})
|
|
|
|
It("finds albums by name", func() {
|
|
resp := doReq("search2", "query", "Abbey Road")
|
|
|
|
Expect(resp.SearchResult2).ToNot(BeNil())
|
|
Expect(resp.SearchResult2.Album).ToNot(BeEmpty())
|
|
|
|
found := false
|
|
for _, a := range resp.SearchResult2.Album {
|
|
if a.Title == "Abbey Road" {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
Expect(found).To(BeTrue(), "expected to find album 'Abbey Road'")
|
|
})
|
|
|
|
It("finds songs by title", func() {
|
|
resp := doReq("search2", "query", "Come Together")
|
|
|
|
Expect(resp.SearchResult2).ToNot(BeNil())
|
|
Expect(resp.SearchResult2.Song).ToNot(BeEmpty())
|
|
|
|
found := false
|
|
for _, s := range resp.SearchResult2.Song {
|
|
if s.Title == "Come Together" {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
Expect(found).To(BeTrue(), "expected to find song 'Come Together'")
|
|
})
|
|
|
|
It("respects artistCount/albumCount/songCount limits", func() {
|
|
resp := doReq("search2", "query", "Beatles",
|
|
"artistCount", "1", "albumCount", "1", "songCount", "1")
|
|
|
|
Expect(resp.SearchResult2).ToNot(BeNil())
|
|
Expect(len(resp.SearchResult2.Artist)).To(BeNumerically("<=", 1))
|
|
Expect(len(resp.SearchResult2.Album)).To(BeNumerically("<=", 1))
|
|
Expect(len(resp.SearchResult2.Song)).To(BeNumerically("<=", 1))
|
|
})
|
|
|
|
It("supports offset parameters", func() {
|
|
// First get all results for Beatles
|
|
resp1 := doReq("search2", "query", "Beatles", "songCount", "500")
|
|
allSongs := resp1.SearchResult2.Song
|
|
|
|
if len(allSongs) > 1 {
|
|
// Get with offset to skip the first song
|
|
resp2 := doReq("search2", "query", "Beatles", "songOffset", "1", "songCount", "500")
|
|
|
|
Expect(resp2.SearchResult2).ToNot(BeNil())
|
|
Expect(len(resp2.SearchResult2.Song)).To(Equal(len(allSongs) - 1))
|
|
}
|
|
})
|
|
|
|
It("returns empty results for non-matching query", func() {
|
|
resp := doReq("search2", "query", "ZZZZNONEXISTENT99999")
|
|
|
|
Expect(resp.SearchResult2).ToNot(BeNil())
|
|
Expect(resp.SearchResult2.Artist).To(BeEmpty())
|
|
Expect(resp.SearchResult2.Album).To(BeEmpty())
|
|
Expect(resp.SearchResult2.Song).To(BeEmpty())
|
|
})
|
|
})
|
|
|
|
Describe("Search3", func() {
|
|
It("returns results in ID3 format", func() {
|
|
resp := doReq("search3", "query", "Beatles")
|
|
|
|
Expect(resp.Status).To(Equal(responses.StatusOK))
|
|
Expect(resp.SearchResult3).ToNot(BeNil())
|
|
// Verify ID3 format: Artist should be ArtistID3 with Name and AlbumCount
|
|
Expect(resp.SearchResult3.Artist).ToNot(BeEmpty())
|
|
Expect(resp.SearchResult3.Artist[0].Name).ToNot(BeEmpty())
|
|
Expect(resp.SearchResult3.Artist[0].Id).ToNot(BeEmpty())
|
|
})
|
|
|
|
It("returns all results when query is empty (OpenSubsonic)", func() {
|
|
resp := doReq("search3", "query", "")
|
|
|
|
Expect(resp.Status).To(Equal(responses.StatusOK))
|
|
Expect(resp.SearchResult3).ToNot(BeNil())
|
|
Expect(resp.SearchResult3.Artist).To(HaveLen(7))
|
|
Expect(resp.SearchResult3.Album).To(HaveLen(8))
|
|
Expect(resp.SearchResult3.Song).To(HaveLen(20))
|
|
})
|
|
|
|
It("finds across all entity types simultaneously", func() {
|
|
// "Beatles" should match artist, albums, and songs by The Beatles
|
|
resp := doReq("search3", "query", "Beatles")
|
|
|
|
Expect(resp.SearchResult3).ToNot(BeNil())
|
|
|
|
// Should find at least the artist "The Beatles"
|
|
artistFound := false
|
|
for _, a := range resp.SearchResult3.Artist {
|
|
if a.Name == "The Beatles" {
|
|
artistFound = true
|
|
break
|
|
}
|
|
}
|
|
Expect(artistFound).To(BeTrue(), "expected to find artist 'The Beatles'")
|
|
|
|
// Should find albums by The Beatles (albums contain "Beatles" in artist field)
|
|
// Albums are returned as AlbumID3 type
|
|
for _, a := range resp.SearchResult3.Album {
|
|
Expect(a.Id).ToNot(BeEmpty())
|
|
Expect(a.Name).ToNot(BeEmpty())
|
|
}
|
|
|
|
// Songs are returned as Child type
|
|
for _, s := range resp.SearchResult3.Song {
|
|
Expect(s.Id).ToNot(BeEmpty())
|
|
Expect(s.Title).ToNot(BeEmpty())
|
|
}
|
|
})
|
|
|
|
Describe("MBID search", func() {
|
|
It("finds songs by mbz_recording_id", func() {
|
|
resp := doReq("search3", "query", mbidComeTogetherRec)
|
|
|
|
Expect(resp.Status).To(Equal(responses.StatusOK))
|
|
Expect(resp.SearchResult3).ToNot(BeNil())
|
|
Expect(resp.SearchResult3.Song).To(HaveLen(1))
|
|
Expect(resp.SearchResult3.Song[0].Title).To(Equal("Come Together"))
|
|
})
|
|
|
|
It("finds songs by mbz_release_track_id", func() {
|
|
resp := doReq("search3", "query", mbidSomething)
|
|
|
|
Expect(resp.Status).To(Equal(responses.StatusOK))
|
|
Expect(resp.SearchResult3).ToNot(BeNil())
|
|
Expect(resp.SearchResult3.Song).To(HaveLen(1))
|
|
Expect(resp.SearchResult3.Song[0].Title).To(Equal("Something"))
|
|
})
|
|
|
|
It("finds albums by mbz_album_id", func() {
|
|
resp := doReq("search3", "query", mbidAbbeyRoadAlbum)
|
|
|
|
Expect(resp.Status).To(Equal(responses.StatusOK))
|
|
Expect(resp.SearchResult3).ToNot(BeNil())
|
|
Expect(resp.SearchResult3.Album).To(HaveLen(1))
|
|
Expect(resp.SearchResult3.Album[0].Name).To(Equal("Abbey Road"))
|
|
})
|
|
|
|
It("finds albums by mbz_release_group_id", func() {
|
|
resp := doReq("search3", "query", mbidAbbeyRoadRelGroup)
|
|
|
|
Expect(resp.Status).To(Equal(responses.StatusOK))
|
|
Expect(resp.SearchResult3).ToNot(BeNil())
|
|
Expect(resp.SearchResult3.Album).To(HaveLen(1))
|
|
Expect(resp.SearchResult3.Album[0].Name).To(Equal("Abbey Road"))
|
|
})
|
|
|
|
It("finds artists by mbz_artist_id", func() {
|
|
resp := doReq("search3", "query", mbidBeatlesArtist)
|
|
|
|
Expect(resp.Status).To(Equal(responses.StatusOK))
|
|
Expect(resp.SearchResult3).ToNot(BeNil())
|
|
Expect(resp.SearchResult3.Artist).To(HaveLen(1))
|
|
Expect(resp.SearchResult3.Artist[0].Name).To(Equal("The Beatles"))
|
|
})
|
|
|
|
It("returns empty results for non-matching UUID", func() {
|
|
nonMatchingUUID := uuid.NewString()
|
|
resp := doReq("search3", "query", nonMatchingUUID)
|
|
|
|
Expect(resp.Status).To(Equal(responses.StatusOK))
|
|
Expect(resp.SearchResult3).ToNot(BeNil())
|
|
Expect(resp.SearchResult3.Artist).To(BeEmpty())
|
|
Expect(resp.SearchResult3.Album).To(BeEmpty())
|
|
Expect(resp.SearchResult3.Song).To(BeEmpty())
|
|
})
|
|
|
|
It("does not return songs for artist MBID", func() {
|
|
// media_file MBID search only checks mbz_recording_id and mbz_release_track_id,
|
|
// so an artist MBID should return only the artist, not songs
|
|
resp := doReq("search3", "query", mbidBeatlesArtist)
|
|
|
|
Expect(resp.Status).To(Equal(responses.StatusOK))
|
|
Expect(resp.SearchResult3).ToNot(BeNil())
|
|
Expect(resp.SearchResult3.Artist).To(HaveLen(1))
|
|
Expect(resp.SearchResult3.Artist[0].Name).To(Equal("The Beatles"))
|
|
Expect(resp.SearchResult3.Song).To(BeEmpty())
|
|
})
|
|
})
|
|
|
|
Describe("CJK search", func() {
|
|
It("finds songs by CJK title", func() {
|
|
resp := doReq("search3", "query", "プラチナ")
|
|
|
|
Expect(resp.Status).To(Equal(responses.StatusOK))
|
|
Expect(resp.SearchResult3).ToNot(BeNil())
|
|
Expect(resp.SearchResult3.Song).To(HaveLen(1))
|
|
Expect(resp.SearchResult3.Song[0].Title).To(Equal("プラチナ・ジェット"))
|
|
})
|
|
|
|
It("finds artists by CJK name", func() {
|
|
resp := doReq("search3", "query", "シートベルツ")
|
|
|
|
Expect(resp.Status).To(Equal(responses.StatusOK))
|
|
Expect(resp.SearchResult3).ToNot(BeNil())
|
|
Expect(resp.SearchResult3.Artist).To(HaveLen(1))
|
|
Expect(resp.SearchResult3.Artist[0].Name).To(Equal("シートベルツ"))
|
|
})
|
|
|
|
It("finds albums by CJK artist name", func() {
|
|
resp := doReq("search3", "query", "シートベルツ")
|
|
|
|
Expect(resp.Status).To(Equal(responses.StatusOK))
|
|
Expect(resp.SearchResult3).ToNot(BeNil())
|
|
Expect(resp.SearchResult3.Album).To(HaveLen(1))
|
|
Expect(resp.SearchResult3.Album[0].Name).To(Equal("COWBOY BEBOP"))
|
|
})
|
|
})
|
|
|
|
Describe("Legacy backend", func() {
|
|
It("returns results using legacy LIKE-based search when configured", func() {
|
|
DeferCleanup(configtest.SetupConfig())
|
|
conf.Server.Search.Backend = "legacy"
|
|
|
|
resp := doReq("search3", "query", "Beatles")
|
|
|
|
Expect(resp.Status).To(Equal(responses.StatusOK))
|
|
Expect(resp.SearchResult3).ToNot(BeNil())
|
|
Expect(resp.SearchResult3.Artist).ToNot(BeEmpty())
|
|
|
|
found := false
|
|
for _, a := range resp.SearchResult3.Artist {
|
|
if a.Name == "The Beatles" {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
Expect(found).To(BeTrue(), "expected to find artist 'The Beatles' with legacy backend")
|
|
})
|
|
})
|
|
})
|
|
})
|