sonda/internal/api/http/catalog_test.go
tgiachi e14c523828 feat(catalog): add the read API for artists, albums and tracks
- feat(api): GET /api/v1/artists, /albums and /tracks with q (case and accent
  insensitive substring), limit and offset (default 50, at most 200) and a
  total; filters library_id, artist_id and album_id; GET /artists/{id},
  /albums/{id} and /tracks/{id}; any signed-in user can read
- feat(catalog): only tracks with a file that is not flagged missing are
  visible, so everything shown can be played; a track with several files is
  listed once; album artists without credited tracks (compilations) are listed
- feat(storage): results are ordered the same way on SQLite and PostgreSQL
  (plain byte order), LIKE wildcards in the search text are escaped, and a
  page costs a fixed number of queries: related items and counts are loaded in
  batches
- feat(storage): tracks get a title_key computed in Go (migration 0006, with
  a startup refresh), like artists and albums
- test: ordering, paging, search with accents and wildcards, library filter,
  duplicate encodings, missing files, details, and a query-count guard on
  both databases
2026-11-11 13:43:38 +01:00

257 lines
9.3 KiB
Go

package httpapi
import (
"context"
"net/http"
"sort"
"testing"
"codeberg.org/squidd/sonda/internal/catalog"
)
// fakeCatalog returns canned data and records the last filter it received.
type fakeCatalog struct {
last catalog.Filter
err error
artists []catalog.Artist
albums []catalog.Album
tracks []catalog.Track
}
func (f *fakeCatalog) Artists(_ context.Context, fl catalog.Filter) (catalog.Page[catalog.Artist], error) {
f.last = fl
return catalog.Page[catalog.Artist]{Items: f.artists, Total: 123, Limit: fl.Limit, Offset: fl.Offset}, f.err
}
func (f *fakeCatalog) Albums(_ context.Context, fl catalog.Filter) (catalog.Page[catalog.Album], error) {
f.last = fl
return catalog.Page[catalog.Album]{Items: f.albums, Total: 7, Limit: fl.Limit, Offset: fl.Offset}, f.err
}
func (f *fakeCatalog) Tracks(_ context.Context, fl catalog.Filter) (catalog.Page[catalog.Track], error) {
f.last = fl
return catalog.Page[catalog.Track]{Items: f.tracks, Total: 9, Limit: fl.Limit, Offset: fl.Offset}, f.err
}
func (f *fakeCatalog) Artist(_ context.Context, id int64) (catalog.Artist, error) {
if f.err != nil {
return catalog.Artist{}, f.err
}
return catalog.Artist{ID: id, Name: "Radiohead", AlbumCount: 2, TrackCount: 20}, nil
}
func (f *fakeCatalog) Album(_ context.Context, id int64) (catalog.Album, error) {
if f.err != nil {
return catalog.Album{}, f.err
}
return catalog.Album{ID: id, Title: "OK Computer", TrackCount: 12, DurationMs: 3200000,
Artist: &catalog.ArtistRef{ID: 1, Name: "Radiohead"}}, nil
}
func (f *fakeCatalog) Track(_ context.Context, id int64) (catalog.Track, error) {
if f.err != nil {
return catalog.Track{}, f.err
}
return catalog.Track{ID: id, Title: "Airbag", DurationMs: 284000, TrackNo: 1, DiscNo: 1, Format: "flac",
Album: &catalog.AlbumRef{ID: 3, Title: "OK Computer"},
Artists: []catalog.ArtistRef{{ID: 1, Name: "Radiohead"}}}, nil
}
var catalogRoutes = []string{
"/api/v1/artists", "/api/v1/albums", "/api/v1/tracks",
"/api/v1/artists/1", "/api/v1/albums/1", "/api/v1/tracks/1",
}
func catalogAPI(t *testing.T, fc *fakeCatalog) (http.Handler, string) {
t.Helper()
h := newTestAPIWith(t, func(d *Deps) { d.Catalog = fc })
return h, registerAndLogin(t, h)
}
func keys(m map[string]any) []string {
var out []string
for k := range m {
out = append(out, k)
}
sort.Strings(out)
return out
}
func sameKeys(t *testing.T, what string, got map[string]any, want ...string) {
t.Helper()
sort.Strings(want)
g := keys(got)
if len(g) != len(want) {
t.Errorf("%s keys = %v, want %v", what, g, want)
return
}
for i := range g {
if g[i] != want[i] {
t.Errorf("%s keys = %v, want %v", what, g, want)
return
}
}
}
func TestCatalogRoutesRequireAuth(t *testing.T) {
h, _ := catalogAPI(t, &fakeCatalog{})
for _, path := range catalogRoutes {
if r := do(t, h, "GET", path, "", nil); r.Code != http.StatusUnauthorized {
t.Errorf("GET %s without a token: %d", path, r.Code)
}
if r := do(t, h, "GET", path+"?access_token=x", "", nil); r.Code != http.StatusUnauthorized {
t.Errorf("GET %s: a token in the URL must not work here: %d", path, r.Code)
}
}
}
func TestAnySignedInUserCanBrowse(t *testing.T) {
fc := &fakeCatalog{}
h, admin := catalogAPI(t, fc)
_, bob := addUser(t, h, admin, "bob", false)
for _, path := range catalogRoutes {
if r := do(t, h, "GET", path, bob, nil); r.Code != http.StatusOK {
t.Errorf("GET %s as a normal user: %d %v", path, r.Code, r.Body)
}
}
}
func TestCatalogListShapeAndPaging(t *testing.T) {
fc := &fakeCatalog{
artists: []catalog.Artist{{ID: 1, Name: "Björk", AlbumCount: 3, TrackCount: 30}},
albums: []catalog.Album{{ID: 2, Title: "Post", TrackCount: 11, DurationMs: 2400000, Artist: &catalog.ArtistRef{ID: 1, Name: "Björk"}}},
tracks: []catalog.Track{{ID: 3, Title: "Army of Me", DurationMs: 235000, TrackNo: 1, DiscNo: 1, Format: "flac",
Album: &catalog.AlbumRef{ID: 2, Title: "Post"}, Artists: []catalog.ArtistRef{{ID: 1, Name: "Björk"}}}},
}
h, tok := catalogAPI(t, fc)
r := do(t, h, "GET", "/api/v1/artists?limit=20&offset=40", tok, nil)
if r.Code != http.StatusOK || r.Body["total"] != float64(123) || r.Body["limit"] != float64(20) || r.Body["offset"] != float64(40) {
t.Fatalf("artists page: %d %v", r.Code, r.Body)
}
sameKeys(t, "artists response", r.Body, "items", "total", "limit", "offset")
a := r.Body["items"].([]any)[0].(map[string]any)
sameKeys(t, "artist", a, "id", "name", "album_count", "track_count")
if a["name"] != "Björk" || a["album_count"] != float64(3) || a["track_count"] != float64(30) {
t.Errorf("artist = %v", a)
}
r = do(t, h, "GET", "/api/v1/albums", tok, nil)
al := r.Body["items"].([]any)[0].(map[string]any)
sameKeys(t, "album", al, "id", "title", "artist", "track_count", "duration_ms")
sameKeys(t, "album artist", al["artist"].(map[string]any), "id", "name")
r = do(t, h, "GET", "/api/v1/tracks", tok, nil)
tr := r.Body["items"].([]any)[0].(map[string]any)
// No file path, root or library path may ever appear.
sameKeys(t, "track", tr, "id", "title", "duration_ms", "track_no", "disc_no", "album", "artists", "format")
sameKeys(t, "track album", tr["album"].(map[string]any), "id", "title")
if tr["format"] != "flac" || len(tr["artists"].([]any)) != 1 {
t.Errorf("track = %v", tr)
}
}
func TestCatalogEmptyListIsAnArrayNotNull(t *testing.T) {
h, tok := catalogAPI(t, &fakeCatalog{})
for _, path := range []string{"/api/v1/artists", "/api/v1/albums", "/api/v1/tracks"} {
r := do(t, h, "GET", path, tok, nil)
items, ok := r.Body["items"].([]any)
if !ok || len(items) != 0 {
t.Errorf("%s: items = %#v, want an empty array", path, r.Body["items"])
}
}
}
func TestTrackWithoutAlbumHasNullAlbum(t *testing.T) {
fc := &fakeCatalog{tracks: []catalog.Track{{ID: 1, Title: "Loose", Artists: nil}}}
h, tok := catalogAPI(t, fc)
r := do(t, h, "GET", "/api/v1/tracks", tok, nil)
tr := r.Body["items"].([]any)[0].(map[string]any)
if v, present := tr["album"]; !present || v != nil {
t.Errorf("album = %#v, want an explicit null", v)
}
if arts, ok := tr["artists"].([]any); !ok || len(arts) != 0 {
t.Errorf("artists = %#v, want an empty array", tr["artists"])
}
}
func TestCatalogQueryParametersReachTheService(t *testing.T) {
fc := &fakeCatalog{}
h, tok := catalogAPI(t, fc)
do(t, h, "GET", "/api/v1/tracks?q=black+sabbath&limit=25&offset=50&library_id=2&artist_id=3&album_id=4", tok, nil)
want := catalog.Filter{Query: "black sabbath", Limit: 25, Offset: 50, LibraryID: 2, ArtistID: 3, AlbumID: 4}
if fc.last != want {
t.Errorf("filter = %+v, want %+v", fc.last, want)
}
do(t, h, "GET", "/api/v1/albums?artist_id=9", tok, nil)
if fc.last.ArtistID != 9 || fc.last.Limit != 0 {
t.Errorf("album filter = %+v (unset paging must stay 0 for the service to default)", fc.last)
}
// Special characters survive URL decoding.
do(t, h, "GET", "/api/v1/artists?q=100%25+%26+more", tok, nil)
if fc.last.Query != "100% & more" {
t.Errorf("q = %q", fc.last.Query)
}
}
func TestCatalogRejectsBadParameters(t *testing.T) {
fc := &fakeCatalog{}
h, tok := catalogAPI(t, fc)
for _, qs := range []string{"limit=abc", "offset=x", "library_id=1.5", "artist_id=-", "album_id=%20", "limit=99999999999999999999"} {
r := do(t, h, "GET", "/api/v1/tracks?"+qs, tok, nil)
if r.Code != http.StatusBadRequest || errCode(r) != "invalid_input" {
t.Errorf("?%s: %d %v", qs, r.Code, r.Body)
}
}
// The service's own validation is a 400 too.
fc.err = catalog.ErrInvalidQuery
r := do(t, h, "GET", "/api/v1/tracks?limit=-1", tok, nil)
if r.Code != http.StatusBadRequest || errCode(r) != "invalid_input" {
t.Errorf("service rejection: %d %v", r.Code, r.Body)
}
}
func TestCatalogDetails(t *testing.T) {
h, tok := catalogAPI(t, &fakeCatalog{})
r := do(t, h, "GET", "/api/v1/artists/5", tok, nil)
sameKeys(t, "artist", r.Body, "id", "name", "album_count", "track_count")
if r.Code != http.StatusOK || r.Body["id"] != float64(5) {
t.Errorf("artist: %d %v", r.Code, r.Body)
}
r = do(t, h, "GET", "/api/v1/albums/6", tok, nil)
sameKeys(t, "album", r.Body, "id", "title", "artist", "track_count", "duration_ms")
r = do(t, h, "GET", "/api/v1/tracks/7", tok, nil)
sameKeys(t, "track", r.Body, "id", "title", "duration_ms", "track_no", "disc_no", "album", "artists", "format")
if r.Code != http.StatusOK || r.Body["id"] != float64(7) {
t.Errorf("track: %d %v", r.Code, r.Body)
}
}
func TestCatalogDetailErrors(t *testing.T) {
fc := &fakeCatalog{err: catalog.ErrNotFound}
h, tok := catalogAPI(t, fc)
for path, code := range map[string]string{
"/api/v1/artists/1": "artist_not_found",
"/api/v1/albums/1": "album_not_found",
"/api/v1/tracks/1": "track_not_found",
} {
r := do(t, h, "GET", path, tok, nil)
if r.Code != http.StatusNotFound || errCode(r) != code {
t.Errorf("%s: %d %v, want 404 %s", path, r.Code, r.Body, code)
}
}
for _, path := range []string{"/api/v1/artists/abc", "/api/v1/albums/0", "/api/v1/tracks/-1"} {
if r := do(t, h, "GET", path, tok, nil); r.Code != http.StatusBadRequest {
t.Errorf("%s: %d, want 400", path, r.Code)
}
}
}
// The stream route lives under /tracks/{id}: the detail route must not shadow it.
func TestTrackDetailDoesNotShadowTheStreamRoute(t *testing.T) {
h, tok := catalogAPI(t, &fakeCatalog{})
r := do(t, h, "GET", "/api/v1/tracks/1/stream", tok, nil)
if r.Code == http.StatusOK && r.Body["title"] != nil {
t.Fatal("the stream URL answered with track details")
}
}