Apps can play and browse: stream and download send the original file (Range, HEAD), getCoverArt serves the cover of an album, an artist or the album of a song (300 pixels or less is the small one), getAlbumList2 knows every kind of list, getRandomSongs and getSongsByGenre list songs, search3 finds artists, albums and songs, and the starred calls answer with nothing so apps do not break. - catalog.Filter has IDs to read albums and songs by id - storage.SubsonicRepo answers the album and song lists (random, newest, frequent, recent, by name, by artist, by year, by genre)
615 lines
23 KiB
Go
615 lines
23 KiB
Go
package storage
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/uptrace/bun"
|
|
|
|
"git.kmalloc.org/squid/sonda/internal/catalog"
|
|
"git.kmalloc.org/squid/sonda/internal/library"
|
|
)
|
|
|
|
// seeded describes the library built by seedCatalog.
|
|
type seeded struct {
|
|
rock, jazz int64 // library ids
|
|
track map[string]int64 // track id by title
|
|
repo *CatalogRepo
|
|
}
|
|
|
|
func pf(rel, title, album, albumArtist string, trackNo, discNo int, format string, artists ...string) library.ParsedFile {
|
|
return library.ParsedFile{
|
|
FileInfo: library.FileInfo{RelPath: rel, Size: 100, MTimeUnix: 1},
|
|
Metadata: library.Metadata{
|
|
Tags: library.Tags{
|
|
Title: title, Album: album, AlbumArtist: albumArtist,
|
|
Artists: artists, TrackNo: trackNo, DiscNo: discNo,
|
|
},
|
|
Properties: library.Properties{Format: format, DurationMs: 60000, SampleRate: 44100},
|
|
},
|
|
}
|
|
}
|
|
|
|
// seedCatalog builds two libraries:
|
|
//
|
|
// rock: Radiohead - OK Computer (Airbag, Paranoid Android, Karma Police, and
|
|
// Ghost whose only file is missing), Björk - Post and a loose track,
|
|
// "100% Pure", "Under_score", "Ünïcode Trck", and an album of only
|
|
// missing files.
|
|
// jazz: Miles Davis - Kind of Blue (tracks listed out of order), a
|
|
// compilation "Various Hits" credited to two artists, and a second
|
|
// encoding of Airbag.
|
|
func seedCatalog(t *testing.T, db *bun.DB) seeded {
|
|
t.Helper()
|
|
ctx := context.Background()
|
|
lib := NewLibraryRepo(db)
|
|
s := seeded{track: map[string]int64{}, repo: NewCatalogRepo(db)}
|
|
|
|
rock, err := lib.CreateLibrary(ctx, "rock", "/lib/rock")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
jazz, err := lib.CreateLibrary(ctx, "jazz", "/lib/jazz")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s.rock, s.jazz = rock.ID, jazz.ID
|
|
|
|
save := func(libID int64, f library.ParsedFile) {
|
|
t.Helper()
|
|
if _, err := lib.SaveFile(ctx, libID, f, 0); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
save(s.rock, pf("r/1.flac", "Airbag", "OK Computer", "Radiohead", 1, 1, "flac", "Radiohead"))
|
|
save(s.rock, pf("r/2.flac", "Paranoid Android", "OK Computer", "Radiohead", 2, 1, "flac", "Radiohead"))
|
|
save(s.rock, pf("r/3.flac", "Karma Police", "OK Computer", "Radiohead", 3, 1, "flac", "Radiohead"))
|
|
save(s.rock, pf("r/4.flac", "Ghost", "OK Computer", "Radiohead", 4, 1, "flac", "Radiohead"))
|
|
save(s.rock, pf("b/1.flac", "Army of Me", "Post", "Björk", 1, 1, "flac", "Björk"))
|
|
save(s.rock, pf("b/2.flac", "Loose Song", "", "", 0, 0, "flac", "Björk"))
|
|
save(s.rock, pf("c/1.flac", "100% Pure", "", "", 0, 0, "flac", "Wild Cards"))
|
|
save(s.rock, pf("c/2.flac", "Under_score", "", "", 0, 0, "flac", "Wild Cards"))
|
|
save(s.rock, pf("c/3.flac", "Ünïcode Trck", "", "", 0, 0, "flac", "Ünïcode Band"))
|
|
save(s.rock, pf("h/1.flac", "Hidden Song", "Hidden Album", "Only Missing", 1, 1, "flac", "Only Missing"))
|
|
|
|
save(s.jazz, pf("m/3.mp3", "Blue in Green", "Kind of Blue", "Miles Davis", 3, 1, "mpeg", "Miles Davis"))
|
|
save(s.jazz, pf("m/1.mp3", "So What", "Kind of Blue", "Miles Davis", 1, 1, "mpeg", "Miles Davis"))
|
|
save(s.jazz, pf("m/2.mp3", "Freddie Freeloader", "Kind of Blue", "Miles Davis", 2, 1, "mpeg", "Miles Davis"))
|
|
save(s.jazz, pf("v/1.mp3", "Song A", "Various Hits", "Various Artists", 1, 1, "mpeg", "Artist A"))
|
|
save(s.jazz, pf("v/2.mp3", "Song B", "Various Hits", "Various Artists", 2, 1, "mpeg", "Artist B"))
|
|
|
|
rows, err := db.Query("SELECT id, title FROM tracks")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for rows.Next() {
|
|
var id int64
|
|
var title string
|
|
if err := rows.Scan(&id, &title); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s.track[title] = id
|
|
}
|
|
_ = rows.Close()
|
|
|
|
// A second encoding of Airbag in the jazz library.
|
|
if _, err := db.Exec(`INSERT INTO audio_files (track_id, library_id, rel_path, format, size_bytes, mtime_unix)
|
|
VALUES (?, ?, 'airbag.mp3', 'mpeg', 1, 1)`, s.track["Airbag"], s.jazz); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Files that are gone: Ghost and the whole hidden album.
|
|
if _, err := db.Exec(`UPDATE audio_files SET missing_at = ? WHERE track_id IN (?, ?)`,
|
|
time.Now().Unix(), s.track["Ghost"], s.track["Hidden Song"]); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return s
|
|
}
|
|
|
|
func artistNames(p catalog.Page[catalog.Artist]) []string {
|
|
var out []string
|
|
for _, a := range p.Items {
|
|
out = append(out, a.Name)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func trackTitles(p catalog.Page[catalog.Track]) []string {
|
|
var out []string
|
|
for _, tr := range p.Items {
|
|
out = append(out, tr.Title)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func albumTitles(p catalog.Page[catalog.Album]) []string {
|
|
var out []string
|
|
for _, a := range p.Items {
|
|
out = append(out, a.Title)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func equal(a, b []string) bool {
|
|
if len(a) != len(b) {
|
|
return false
|
|
}
|
|
for i := range a {
|
|
if a[i] != b[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func page(limit int) catalog.Filter { return catalog.Filter{Limit: limit} }
|
|
|
|
// ---- artists ----
|
|
|
|
func TestCatalogArtists(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
s := seedCatalog(t, db)
|
|
got, err := s.repo.ListArtists(context.Background(), page(50))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Sorted by name in plain byte order, the same on both databases (so
|
|
// the accented name comes last). "Only Missing" has nothing playable;
|
|
// "Various Artists" is only an album artist but its album is playable.
|
|
want := []string{"Artist A", "Artist B", "Björk", "Miles Davis", "Radiohead", "Various Artists", "Wild Cards", "Ünïcode Band"}
|
|
if !equal(artistNames(got), want) || got.Total != len(want) {
|
|
t.Fatalf("artists = %v (total %d), want %v", artistNames(got), got.Total, want)
|
|
}
|
|
|
|
byName := map[string]catalog.Artist{}
|
|
for _, a := range got.Items {
|
|
byName[a.Name] = a
|
|
}
|
|
if r := byName["Radiohead"]; r.TrackCount != 3 || r.AlbumCount != 1 {
|
|
t.Errorf("Radiohead = %+v, want 3 tracks (Ghost is missing) and 1 album", r)
|
|
}
|
|
if v := byName["Various Artists"]; v.TrackCount != 0 || v.AlbumCount != 1 {
|
|
t.Errorf("Various Artists = %+v, want 0 credited tracks and 1 album", v)
|
|
}
|
|
if b := byName["Björk"]; b.TrackCount != 2 || b.AlbumCount != 1 {
|
|
t.Errorf("Björk = %+v, want 2 tracks (one without album) and 1 album", b)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestCatalogPaging(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
s := seedCatalog(t, db)
|
|
ctx := context.Background()
|
|
|
|
first, _ := s.repo.ListArtists(ctx, catalog.Filter{Limit: 3})
|
|
second, _ := s.repo.ListArtists(ctx, catalog.Filter{Limit: 3, Offset: 3})
|
|
if len(first.Items) != 3 || len(second.Items) != 3 || first.Total != 8 || second.Total != 8 {
|
|
t.Fatalf("pages: %d and %d items, totals %d/%d", len(first.Items), len(second.Items), first.Total, second.Total)
|
|
}
|
|
if first.Items[2].ID == second.Items[0].ID {
|
|
t.Error("pages overlap")
|
|
}
|
|
if first.Limit != 3 || second.Offset != 3 {
|
|
t.Errorf("limit/offset not echoed: %d %d", first.Limit, second.Offset)
|
|
}
|
|
|
|
past, err := s.repo.ListArtists(ctx, catalog.Filter{Limit: 3, Offset: 100})
|
|
if err != nil || past.Items == nil || len(past.Items) != 0 || past.Total != 8 {
|
|
t.Errorf("past the end: %+v err=%v (want an empty, non-nil slice and the real total)", past, err)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestCatalogSearch(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
s := seedCatalog(t, db)
|
|
ctx := context.Background()
|
|
search := func(q string) catalog.Filter { return catalog.Filter{Query: q, Limit: 50} }
|
|
|
|
// Case folding, accented letters included, is the same on both databases.
|
|
for _, q := range []string{"björk", "BJÖRK", "jö"} {
|
|
if got, _ := s.repo.ListArtists(ctx, search(q)); !equal(artistNames(got), []string{"Björk"}) {
|
|
t.Errorf("artists %q = %v", q, artistNames(got))
|
|
}
|
|
}
|
|
if got, _ := s.repo.ListArtists(ctx, search("ÜNÏ")); !equal(artistNames(got), []string{"Ünïcode Band"}) {
|
|
t.Errorf("artists ÜNÏ = %v", artistNames(got))
|
|
}
|
|
if got, _ := s.repo.ListTracks(ctx, search("ÜNÏCODE")); !equal(trackTitles(got), []string{"Ünïcode Trck"}) {
|
|
t.Errorf("tracks ÜNÏCODE = %v", trackTitles(got))
|
|
}
|
|
if got, _ := s.repo.ListAlbums(ctx, search("kind OF")); !equal(albumTitles(got), []string{"Kind of Blue"}) {
|
|
t.Errorf("albums kind OF = %v", albumTitles(got))
|
|
}
|
|
if got, _ := s.repo.ListArtists(ctx, search("zzz")); got.Total != 0 || len(got.Items) != 0 {
|
|
t.Errorf("no match: %+v", got)
|
|
}
|
|
|
|
// LIKE wildcards in the query are plain characters.
|
|
if got, _ := s.repo.ListTracks(ctx, search("100%")); !equal(trackTitles(got), []string{"100% Pure"}) {
|
|
t.Errorf(`"100%%" = %v, want only the title containing a percent sign`, trackTitles(got))
|
|
}
|
|
if got, _ := s.repo.ListTracks(ctx, search("%")); !equal(trackTitles(got), []string{"100% Pure"}) {
|
|
t.Errorf(`"%%" = %v, must not match everything`, trackTitles(got))
|
|
}
|
|
if got, _ := s.repo.ListTracks(ctx, search("_")); !equal(trackTitles(got), []string{"Under_score"}) {
|
|
t.Errorf(`"_" = %v, must not match every one-character position`, trackTitles(got))
|
|
}
|
|
if got, _ := s.repo.ListTracks(ctx, search("!")); got.Total != 0 {
|
|
t.Errorf(`"!" (the escape character) = %v`, trackTitles(got))
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestCatalogLibraryFilter(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
s := seedCatalog(t, db)
|
|
ctx := context.Background()
|
|
|
|
jazz, _ := s.repo.ListArtists(ctx, catalog.Filter{LibraryID: s.jazz, Limit: 50})
|
|
// Radiohead is here only because Airbag also has a file in this library.
|
|
want := []string{"Artist A", "Artist B", "Miles Davis", "Radiohead", "Various Artists"}
|
|
if !equal(artistNames(jazz), want) {
|
|
t.Fatalf("jazz artists = %v, want %v", artistNames(jazz), want)
|
|
}
|
|
for _, a := range jazz.Items {
|
|
if a.Name == "Radiohead" && (a.TrackCount != 1 || a.AlbumCount != 1) {
|
|
t.Errorf("counts must follow the filter: Radiohead = %+v, want 1 track", a)
|
|
}
|
|
}
|
|
|
|
tracks, _ := s.repo.ListTracks(ctx, catalog.Filter{LibraryID: s.jazz, Limit: 50})
|
|
if tracks.Total != 6 { // 3 + 2 + Airbag
|
|
t.Errorf("jazz tracks = %d, want 6: %v", tracks.Total, trackTitles(tracks))
|
|
}
|
|
albums, _ := s.repo.ListAlbums(ctx, catalog.Filter{LibraryID: s.jazz, Limit: 50})
|
|
if !equal(albumTitles(albums), []string{"Kind of Blue", "OK Computer", "Various Hits"}) {
|
|
t.Errorf("jazz albums = %v", albumTitles(albums))
|
|
}
|
|
for _, a := range albums.Items {
|
|
if a.Title == "OK Computer" && a.TrackCount != 1 {
|
|
t.Errorf("OK Computer in jazz = %+v, want only Airbag", a)
|
|
}
|
|
}
|
|
|
|
if none, _ := s.repo.ListTracks(ctx, catalog.Filter{LibraryID: 999, Limit: 50}); none.Total != 0 {
|
|
t.Errorf("unknown library: %d tracks", none.Total)
|
|
}
|
|
})
|
|
}
|
|
|
|
// ---- albums ----
|
|
|
|
func TestCatalogAlbums(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
s := seedCatalog(t, db)
|
|
ctx := context.Background()
|
|
|
|
got, err := s.repo.ListAlbums(ctx, page(50))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// "Hidden Album" has only missing files.
|
|
if want := []string{"Kind of Blue", "OK Computer", "Post", "Various Hits"}; !equal(albumTitles(got), want) || got.Total != 4 {
|
|
t.Fatalf("albums = %v (total %d), want %v", albumTitles(got), got.Total, want)
|
|
}
|
|
|
|
by := map[string]catalog.Album{}
|
|
for _, a := range got.Items {
|
|
by[a.Title] = a
|
|
}
|
|
ok := by["OK Computer"]
|
|
if ok.TrackCount != 3 || ok.DurationMs != 180000 || ok.Artist == nil || ok.Artist.Name != "Radiohead" {
|
|
t.Errorf("OK Computer = %+v, want 3 tracks, 3 minutes, Radiohead", ok)
|
|
}
|
|
if v := by["Various Hits"]; v.Artist == nil || v.Artist.Name != "Various Artists" || v.TrackCount != 2 {
|
|
t.Errorf("Various Hits = %+v", v)
|
|
}
|
|
|
|
byArtist, _ := s.repo.ListAlbums(ctx, catalog.Filter{ArtistID: ok.Artist.ID, Limit: 50})
|
|
if !equal(albumTitles(byArtist), []string{"OK Computer"}) {
|
|
t.Errorf("albums of Radiohead = %v", albumTitles(byArtist))
|
|
}
|
|
})
|
|
}
|
|
|
|
// ---- tracks ----
|
|
|
|
func TestCatalogTracks(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
s := seedCatalog(t, db)
|
|
ctx := context.Background()
|
|
|
|
all, err := s.repo.ListTracks(ctx, page(50))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
titles := trackTitles(all)
|
|
count := map[string]int{}
|
|
for _, ti := range titles {
|
|
count[ti]++
|
|
}
|
|
if count["Airbag"] != 1 {
|
|
t.Errorf("Airbag appears %d times: a track with two files must be listed once", count["Airbag"])
|
|
}
|
|
if count["Ghost"] != 0 || count["Hidden Song"] != 0 {
|
|
t.Errorf("tracks without a playable file were listed: %v", titles)
|
|
}
|
|
if all.Total != 13 || len(all.Items) != 13 {
|
|
t.Errorf("total = %d, items = %d, want 13: %v", all.Total, len(all.Items), titles)
|
|
}
|
|
|
|
// Albums in title order; inside an album by disc, track number, title.
|
|
var kind []string
|
|
for _, tr := range all.Items {
|
|
if tr.Album != nil && tr.Album.Title == "Kind of Blue" {
|
|
kind = append(kind, tr.Title)
|
|
}
|
|
}
|
|
if !equal(kind, []string{"So What", "Freddie Freeloader", "Blue in Green"}) {
|
|
t.Errorf("Kind of Blue order = %v", kind)
|
|
}
|
|
|
|
by := map[string]catalog.Track{}
|
|
for _, tr := range all.Items {
|
|
by[tr.Title] = tr
|
|
}
|
|
airbag := by["Airbag"]
|
|
if airbag.Album == nil || airbag.Album.Title != "OK Computer" || len(airbag.Artists) != 1 ||
|
|
airbag.Artists[0].Name != "Radiohead" || airbag.TrackNo != 1 || airbag.DiscNo != 1 || airbag.DurationMs != 60000 {
|
|
t.Errorf("Airbag = %+v", airbag)
|
|
}
|
|
if airbag.Format != "flac" {
|
|
t.Errorf("Airbag format = %q, want the first playable file's (flac)", airbag.Format)
|
|
}
|
|
if f := by["So What"].Format; f != "mp3" {
|
|
t.Errorf("format = %q, want mpeg shown as mp3", f)
|
|
}
|
|
if loose := by["Loose Song"]; loose.Album != nil || loose.TrackNo != 0 || len(loose.Artists) != 1 {
|
|
t.Errorf("a track without album: %+v", loose)
|
|
}
|
|
if a := by["Song A"].Artists; len(a) != 1 || a[0].Name != "Artist A" {
|
|
t.Errorf("compilation track credits = %+v", a)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestCatalogTrackFilters(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
s := seedCatalog(t, db)
|
|
ctx := context.Background()
|
|
|
|
albums, _ := s.repo.ListAlbums(ctx, catalog.Filter{Query: "ok comp", Limit: 5})
|
|
ok := albums.Items[0]
|
|
byAlbum, _ := s.repo.ListTracks(ctx, catalog.Filter{AlbumID: ok.ID, Limit: 50})
|
|
if !equal(trackTitles(byAlbum), []string{"Airbag", "Paranoid Android", "Karma Police"}) {
|
|
t.Errorf("tracks of OK Computer = %v", trackTitles(byAlbum))
|
|
}
|
|
|
|
artists, _ := s.repo.ListArtists(ctx, catalog.Filter{Query: "artist a", Limit: 5})
|
|
byArtist, _ := s.repo.ListTracks(ctx, catalog.Filter{ArtistID: artists.Items[0].ID, Limit: 50})
|
|
if !equal(trackTitles(byArtist), []string{"Song A"}) {
|
|
t.Errorf("tracks of Artist A = %v", trackTitles(byArtist))
|
|
}
|
|
|
|
both, _ := s.repo.ListTracks(ctx, catalog.Filter{AlbumID: ok.ID, Query: "karma", Limit: 50})
|
|
if !equal(trackTitles(both), []string{"Karma Police"}) {
|
|
t.Errorf("filters combine with AND: %v", trackTitles(both))
|
|
}
|
|
if none, _ := s.repo.ListTracks(ctx, catalog.Filter{AlbumID: 999, Limit: 50}); none.Total != 0 {
|
|
t.Errorf("unknown album: %d tracks", none.Total)
|
|
}
|
|
})
|
|
}
|
|
|
|
// ---- details ----
|
|
|
|
func TestCatalogDetails(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
s := seedCatalog(t, db)
|
|
ctx := context.Background()
|
|
|
|
tr, err := s.repo.GetTrack(ctx, s.track["Airbag"])
|
|
if err != nil || tr.Title != "Airbag" || tr.Album == nil || len(tr.Artists) != 1 || tr.Format != "flac" {
|
|
t.Fatalf("GetTrack = %+v err=%v", tr, err)
|
|
}
|
|
if _, err := s.repo.GetTrack(ctx, s.track["Ghost"]); !errors.Is(err, catalog.ErrNotFound) {
|
|
t.Errorf("a track with only missing files: err = %v, want ErrNotFound", err)
|
|
}
|
|
if _, err := s.repo.GetTrack(ctx, 99999); !errors.Is(err, catalog.ErrNotFound) {
|
|
t.Errorf("unknown track: err = %v", err)
|
|
}
|
|
|
|
artists, _ := s.repo.ListArtists(ctx, catalog.Filter{Query: "various", Limit: 5})
|
|
va, err := s.repo.GetArtist(ctx, artists.Items[0].ID)
|
|
if err != nil || va.Name != "Various Artists" || va.AlbumCount != 1 {
|
|
t.Errorf("an album artist without credits: %+v err=%v", va, err)
|
|
}
|
|
var hiddenArtist int64
|
|
if err := db.QueryRow("SELECT id FROM artists WHERE name = 'Only Missing'").Scan(&hiddenArtist); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := s.repo.GetArtist(ctx, hiddenArtist); !errors.Is(err, catalog.ErrNotFound) {
|
|
t.Errorf("an artist with nothing playable: err = %v, want ErrNotFound", err)
|
|
}
|
|
|
|
var hiddenAlbum, okAlbum int64
|
|
_ = db.QueryRow("SELECT id FROM albums WHERE title = 'Hidden Album'").Scan(&hiddenAlbum)
|
|
_ = db.QueryRow("SELECT id FROM albums WHERE title = 'OK Computer'").Scan(&okAlbum)
|
|
if _, err := s.repo.GetAlbum(ctx, hiddenAlbum); !errors.Is(err, catalog.ErrNotFound) {
|
|
t.Errorf("an album with nothing playable: err = %v", err)
|
|
}
|
|
al, err := s.repo.GetAlbum(ctx, okAlbum)
|
|
if err != nil || al.TrackCount != 3 || al.Artist == nil {
|
|
t.Errorf("GetAlbum = %+v err=%v", al, err)
|
|
}
|
|
})
|
|
}
|
|
|
|
// A page must cost a fixed number of queries, never one per row.
|
|
func TestCatalogListsDoNotQueryPerRow(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
s := seedCatalog(t, db)
|
|
var queries atomic.Int64
|
|
db.AddQueryHook(countingHook{&queries})
|
|
|
|
for name, run := range map[string]func() error{
|
|
"artists": func() error { _, err := s.repo.ListArtists(context.Background(), page(50)); return err },
|
|
"albums": func() error { _, err := s.repo.ListAlbums(context.Background(), page(50)); return err },
|
|
"tracks": func() error { _, err := s.repo.ListTracks(context.Background(), page(50)); return err },
|
|
} {
|
|
queries.Store(0)
|
|
if err := run(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if n := queries.Load(); n > 6 {
|
|
t.Errorf("%s: %d queries for one page, want a small constant", name, n)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
type countingHook struct{ n *atomic.Int64 }
|
|
|
|
func (countingHook) BeforeQuery(ctx context.Context, _ *bun.QueryEvent) context.Context { return ctx }
|
|
func (h countingHook) AfterQuery(context.Context, *bun.QueryEvent) { h.n.Add(1) }
|
|
|
|
// Two albums can share a title ("Greatest Hits", "Live"). Their tracks must not
|
|
// interleave in a listing.
|
|
func TestCatalogKeepsAlbumsWithTheSameTitleApart(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
ctx := context.Background()
|
|
lib := NewLibraryRepo(db)
|
|
l, err := lib.CreateLibrary(ctx, "m", "/lib/m")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for i, f := range []library.ParsedFile{
|
|
pf("a1.flac", "A one", "Greatest Hits", "Artist A", 1, 1, "flac", "Artist A"),
|
|
pf("b1.flac", "B one", "Greatest Hits", "Artist B", 1, 1, "flac", "Artist B"),
|
|
pf("a2.flac", "A two", "Greatest Hits", "Artist A", 2, 1, "flac", "Artist A"),
|
|
pf("b2.flac", "B two", "Greatest Hits", "Artist B", 2, 1, "flac", "Artist B"),
|
|
} {
|
|
if _, err := lib.SaveFile(ctx, l.ID, f, 0); err != nil {
|
|
t.Fatalf("file %d: %v", i, err)
|
|
}
|
|
}
|
|
repo := NewCatalogRepo(db)
|
|
|
|
all, err := repo.ListTracks(ctx, page(50))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := trackTitles(all)
|
|
a := []string{"A one", "A two", "B one", "B two"}
|
|
b := []string{"B one", "B two", "A one", "A two"}
|
|
if !equal(got, a) && !equal(got, b) {
|
|
t.Fatalf("tracks = %v, want each album's tracks together", got)
|
|
}
|
|
|
|
// The same holds across a page boundary.
|
|
first, _ := repo.ListTracks(ctx, catalog.Filter{Limit: 2})
|
|
second, _ := repo.ListTracks(ctx, catalog.Filter{Limit: 2, Offset: 2})
|
|
if got := append(trackTitles(first), trackTitles(second)...); !equal(got, a) && !equal(got, b) {
|
|
t.Errorf("paged tracks = %v", got)
|
|
}
|
|
})
|
|
}
|
|
|
|
// The album count of an artist and the albums listed for that artist must be
|
|
// the same set, otherwise "3 albums" leads to an empty or shorter list.
|
|
func TestCatalogArtistAlbumCountMatchesTheirAlbumList(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
s := seedCatalog(t, db)
|
|
ctx := context.Background()
|
|
|
|
for _, libraryID := range []int64{0, s.rock, s.jazz} {
|
|
artists, err := s.repo.ListArtists(ctx, catalog.Filter{LibraryID: libraryID, Limit: 50})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, a := range artists.Items {
|
|
albums, err := s.repo.ListAlbums(ctx, catalog.Filter{ArtistID: a.ID, LibraryID: libraryID, Limit: 50})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if albums.Total != a.AlbumCount {
|
|
t.Errorf("library %d, %s: album_count = %d but /albums?artist_id lists %d (%v)",
|
|
libraryID, a.Name, a.AlbumCount, albums.Total, albumTitles(albums))
|
|
}
|
|
}
|
|
}
|
|
|
|
// The compilation is reachable from a credited artist, not only from the album artist.
|
|
artistA, _ := s.repo.ListArtists(ctx, catalog.Filter{Query: "artist a", Limit: 5})
|
|
albums, _ := s.repo.ListAlbums(ctx, catalog.Filter{ArtistID: artistA.Items[0].ID, Limit: 50})
|
|
if !equal(albumTitles(albums), []string{"Various Hits"}) {
|
|
t.Errorf("albums of a credited artist = %v", albumTitles(albums))
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestCatalogAlbumsCanComeNewestFirst(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
s := seedCatalog(t, db)
|
|
ctx := context.Background()
|
|
// The date of the newest file that is there: Kind of Blue is the newest, then Various Hits, then Post, then OK Computer.
|
|
// Ghost is a file of OK Computer that is gone: its date, the newest of all, does not count.
|
|
for prefix, mtime := range map[string]int64{"m/%": 4000, "v/%": 3000, "b/%": 2000, "r/%": 1000} {
|
|
if _, err := db.Exec("UPDATE audio_files SET mtime_unix = ? WHERE rel_path LIKE ?", mtime, prefix); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if _, err := db.Exec("UPDATE audio_files SET mtime_unix = 9000 WHERE track_id = ?", s.track["Ghost"]); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := s.repo.ListAlbums(ctx, catalog.Filter{Sort: "recent", Limit: 50})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if want := []string{"Kind of Blue", "Various Hits", "Post", "OK Computer"}; !equal(albumTitles(got), want) || got.Total != 4 {
|
|
t.Errorf("newest first = %v (total %d), want %v", albumTitles(got), got.Total, want)
|
|
}
|
|
// A page of it is a page of that order.
|
|
page2, _ := s.repo.ListAlbums(ctx, catalog.Filter{Sort: "recent", Limit: 2, Offset: 1})
|
|
if want := []string{"Various Hits", "Post"}; !equal(albumTitles(page2), want) {
|
|
t.Errorf("second page = %v, want %v", albumTitles(page2), want)
|
|
}
|
|
// Without a sort it is still by title.
|
|
byTitle, _ := s.repo.ListAlbums(ctx, catalog.Filter{Limit: 50})
|
|
if want := []string{"Kind of Blue", "OK Computer", "Post", "Various Hits"}; !equal(albumTitles(byTitle), want) {
|
|
t.Errorf("by title = %v", albumTitles(byTitle))
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestAListCanBeLimitedToTheIdsOfItsItems(t *testing.T) {
|
|
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
|
|
s := seedCatalog(t, db)
|
|
ctx := context.Background()
|
|
got, err := s.repo.ListTracks(ctx, catalog.Filter{IDs: []int64{s.track["Airbag"], s.track["Karma Police"], s.track["Ghost"]}, Limit: 50})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Ghost has no file to play, so it is not there whatever the ids say.
|
|
if titles := trackTitles(got); len(titles) != 2 || got.Total != 2 {
|
|
t.Fatalf("tracks of ids = %v (%d)", titles, got.Total)
|
|
}
|
|
albums, err := s.repo.ListAlbums(ctx, catalog.Filter{Query: "", Limit: 50})
|
|
if err != nil || len(albums.Items) < 2 {
|
|
t.Fatalf("albums %v, %v", albums, err)
|
|
}
|
|
one, err := s.repo.ListAlbums(ctx, catalog.Filter{IDs: []int64{albums.Items[1].ID}, Limit: 50})
|
|
if err != nil || len(one.Items) != 1 || one.Items[0].ID != albums.Items[1].ID {
|
|
t.Fatalf("albums of an id = %+v, %v", one.Items, err)
|
|
}
|
|
none, err := s.repo.ListTracks(ctx, catalog.Filter{IDs: []int64{}, Limit: 50})
|
|
if err != nil || len(none.Items) != 0 {
|
|
t.Fatalf("an empty list of ids is no item, got %v, %v", trackTitles(none), err)
|
|
}
|
|
})
|
|
}
|