sonda/internal/api/http/smart_test.go
tgiachi d3695d00d6 feat(smart): smart playlists by the year a song came out
I can now ask for songs from a year to a year, for example the eighties.

- The year is read from the tags of each file (the original date first, then the date) and kept on the track: migration 0028 adds tracks.year (SQLite and PostgreSQL).
- Two new rules, min_year and max_year, both included and checked (1000 to 2999, the first not after the second). The index answers them. A song with no year never matches.
- Files indexed before have no year until a full rescan reads their tags again; the editor and the API description say so.
- The smart playlist editor gets From year and Up to year, and the rules are described in words.
- English and Italian.
2026-11-14 10:19:39 +01:00

505 lines
22 KiB
Go

package httpapi
import (
"fmt"
"net/http"
"slices"
"strings"
"testing"
)
const sp = "/api/v1/smart-playlists"
// smartMade makes a smart playlist of alice's and returns its id.
func smartMade(t *testing.T, m *mixAPI, body map[string]any) int {
t.Helper()
r := do(t, m.h, "POST", sp, m.alice, body)
if r.Code != http.StatusCreated {
t.Fatalf("create: %d %v", r.Code, r.Body)
}
return int(r.Body["id"].(float64))
}
func smartTracks(t *testing.T, m *mixAPI, id int, query string) []float64 {
t.Helper()
r := do(t, m.h, "GET", fmt.Sprintf("%s/%d/tracks%s", sp, id, query), m.alice, nil)
if r.Code != http.StatusOK {
t.Fatalf("tracks: %d %v", r.Code, r.Body)
}
return trackIDs(t, r)
}
func TestSmartPlaylistRoutesNeedASignedInUser(t *testing.T) {
m := newMixAPI(t)
for _, rt := range []struct{ method, path string }{
{"GET", "/api/v1/genres"}, {"GET", sp + "/suggested"}, {"GET", sp + "/suggested/never-played/tracks"}, {"GET", sp + "/suggested/never-played/covers"}, {"GET", sp + "/1/covers"}, {"POST", sp + "/suggested/never-played/playlist"}, {"GET", sp}, {"POST", sp}, {"POST", sp + "/preview"}, {"GET", sp + "/1"}, {"PATCH", sp + "/1"}, {"DELETE", sp + "/1"},
{"GET", sp + "/1/tracks"}, {"POST", sp + "/1/playlist"},
} {
if r := do(t, m.h, rt.method, rt.path, "", nil); r.Code != http.StatusUnauthorized {
t.Errorf("%s %s without a token: %d", rt.method, rt.path, r.Code)
}
}
}
func TestASmartPlaylistIsMadeReadChangedAndDeleted(t *testing.T) {
m := newMixAPI(t)
r := do(t, m.h, "POST", sp, m.alice, map[string]any{
"name": " Rock, new ", "rules": map[string]any{"genres": []string{"Rock"}, "never_played": true, "formats": []string{"FLAC"}},
})
if r.Code != http.StatusCreated {
t.Fatalf("create: %d %v", r.Code, r.Body)
}
id := int(r.Body["id"].(float64))
rules := r.Body["rules"].(map[string]any)
if r.Body["name"] != "Rock, new" || r.Body["sort"] != "random" || r.Body["limit"] != float64(50) || r.Body["description"] != "" ||
r.Body["created_at"] == nil || r.Body["updated_at"] == nil ||
rules["never_played"] != true || fmt.Sprint(rules["genres"]) != "[rock]" || fmt.Sprint(rules["formats"]) != "[flac]" {
t.Errorf("created = %v", r.Body)
}
got := do(t, m.h, "GET", fmt.Sprintf("%s/%d", sp, id), m.alice, nil)
if got.Code != http.StatusOK || got.Body["name"] != "Rock, new" {
t.Errorf("get: %d %v", got.Code, got.Body)
}
list := do(t, m.h, "GET", sp, m.alice, nil)
if list.Body["total"] != float64(1) || list.Body["limit"] != float64(50) || list.Body["offset"] != float64(0) || len(list.Body["items"].([]any)) != 1 {
t.Errorf("list = %v", list.Body)
}
upd := do(t, m.h, "PATCH", fmt.Sprintf("%s/%d", sp, id), m.alice, map[string]any{
"name": "Rock, again", "sort": "title", "limit": 20, "rules": map[string]any{"min_plays": 3},
})
rules = upd.Body["rules"].(map[string]any)
if upd.Code != http.StatusOK || upd.Body["name"] != "Rock, again" || upd.Body["sort"] != "title" || upd.Body["limit"] != float64(20) ||
rules["min_plays"] != float64(3) || rules["never_played"] != nil || rules["genres"] != nil {
t.Errorf("update: %d %v: the rules are replaced whole", upd.Code, upd.Body)
}
// Only what is sent changes.
again := do(t, m.h, "PATCH", fmt.Sprintf("%s/%d", sp, id), m.alice, map[string]any{"description": "d"})
if again.Body["name"] != "Rock, again" || again.Body["description"] != "d" || again.Body["sort"] != "title" {
t.Errorf("a patch with one field: %v", again.Body)
}
if del := do(t, m.h, "DELETE", fmt.Sprintf("%s/%d", sp, id), m.alice, nil); del.Code != http.StatusNoContent {
t.Errorf("delete: %d", del.Code)
}
if r := do(t, m.h, "GET", fmt.Sprintf("%s/%d", sp, id), m.alice, nil); r.Code != http.StatusNotFound || errCode(r) != "smart_playlist_not_found" {
t.Errorf("get after delete: %d %v", r.Code, r.Body)
}
}
func TestWhatIsNotAcceptedIsSaidSo(t *testing.T) {
m := newMixAPI(t)
for name, body := range map[string]map[string]any{
"no name": {"rules": map[string]any{}},
"an unknown order": {"name": "a", "sort": "loudest"},
"a limit too big": {"name": "a", "limit": 501},
"days below zero": {"name": "a", "rules": map[string]any{"played_within_days": -1}},
"a genre that isn't": {"name": "a", "rules": map[string]any{"genres": []string{"unknown"}}},
"a bad format": {"name": "a", "rules": map[string]any{"formats": []string{"fl/ac"}}},
"a year too early": {"name": "a", "rules": map[string]any{"min_year": 99}},
"years the wrong way": {"name": "a", "rules": map[string]any{"min_year": 1990, "max_year": 1980}},
} {
if r := do(t, m.h, "POST", sp, m.alice, body); r.Code != http.StatusBadRequest || errCode(r) != "invalid_input" {
t.Errorf("%s: %d %v", name, r.Code, r.Body)
}
}
for _, path := range []string{sp + "/0", sp + "/x", sp + "/1/tracks?variant=-1", sp + "/1/tracks?variant=x", sp + "?limit=-1"} {
if r := do(t, m.h, "GET", path, m.alice, nil); r.Code != http.StatusBadRequest {
t.Errorf("GET %s: %d %v", path, r.Code, r.Body)
}
}
if r := do(t, m.h, "POST", sp, m.alice, nil); r.Code != http.StatusBadRequest {
t.Errorf("no body: %d", r.Code)
}
}
func TestTheYearRulesAreKeptAndShown(t *testing.T) {
m := newMixAPI(t)
id := smartMade(t, m, map[string]any{"name": "Eighties", "rules": map[string]any{"min_year": 1980, "max_year": 1989}})
r := do(t, m.h, "GET", fmt.Sprintf("%s/%d", sp, id), m.alice, nil)
rules, _ := r.Body["rules"].(map[string]any)
if r.Code != http.StatusOK || rules["min_year"] != float64(1980) || rules["max_year"] != float64(1989) {
t.Errorf("get: %d %v", r.Code, r.Body)
}
// None of the songs of this library has a year, so the rule leaves none.
tr := do(t, m.h, "GET", fmt.Sprintf("%s/%d/tracks", sp, id), m.alice, nil)
if tr.Code != http.StatusOK || len(trackIDs(t, tr)) != 0 {
t.Errorf("tracks: %d %v", tr.Code, tr.Body)
}
}
func TestTheSongsAreWorkedOutFromTheRules(t *testing.T) {
m := newMixAPI(t)
id := smartMade(t, m, map[string]any{"name": "Hard", "sort": "title", "limit": 5, "rules": map[string]any{"genres": []string{"hard rock"}}})
r := do(t, m.h, "GET", fmt.Sprintf("%s/%d/tracks", sp, id), m.alice, nil)
ids := trackIDs(t, r)
if r.Code != http.StatusOK || r.Body["variant"] != float64(0) || len(ids) != 5 {
t.Fatalf("tracks: %d %v", r.Code, r.Body)
}
for _, x := range r.Body["tracks"].([]any) {
track := x.(map[string]any)
if !strings.HasPrefix(track["title"].(string), "hard song") || track["album"] == nil || len(track["artists"].([]any)) != 1 {
t.Errorf("a song = %v", track)
}
}
if again := smartTracks(t, m, id, ""); !slices.Equal(ids, again) {
t.Error("the same order twice is not the same")
}
// A rule that no song meets gives an empty list, which is no error.
none := smartMade(t, m, map[string]any{"name": "Polka", "rules": map[string]any{"genres": []string{"polka"}}})
if got := smartTracks(t, m, none, ""); len(got) != 0 {
t.Errorf("polka: %v", got)
}
}
func TestARandomOrderStaysTheSameForADayAndAVariantGivesAnother(t *testing.T) {
m := newMixAPI(t)
id := smartMade(t, m, map[string]any{"name": "Any", "limit": 10, "rules": map[string]any{"genres": []string{"rock"}}})
first := smartTracks(t, m, id, "")
if len(first) != 10 || !slices.Equal(first, smartTracks(t, m, id, "")) {
t.Fatalf("the random order of a day changed: %v", first)
}
if v := smartTracks(t, m, id, "?variant=1"); slices.Equal(first, v) {
t.Error("another variant gave the same songs")
}
}
func TestListeningRulesUseTheHistoryOfTheOwner(t *testing.T) {
m := newMixAPI(t)
var played []int64
rows, err := m.db.Query("SELECT id FROM tracks WHERE title LIKE 'hard song%' ORDER BY id LIMIT 4")
if err != nil {
t.Fatal(err)
}
for rows.Next() {
var id int64
if err := rows.Scan(&id); err != nil {
t.Fatal(err)
}
played = append(played, id)
}
rows.Close()
for i, id := range played {
if _, err := m.db.Exec(`INSERT INTO listening_events (user_id, track_id, event_type, occurred_at, duration_played_ms, idempotency_key)
VALUES (1, ?, 'complete', strftime('%s','now'), 60000, ?)`, id, fmt.Sprintf("k%d", i)); err != nil {
t.Skipf("cannot add listening events by hand here: %v", err)
}
}
never := smartMade(t, m, map[string]any{"name": "New hard", "limit": 500, "rules": map[string]any{"genres": []string{"hard rock"}, "never_played": true}})
if got := smartTracks(t, m, never, ""); len(got) != 36-4 {
t.Errorf("never played: %d songs, want 32", len(got))
}
heard := smartMade(t, m, map[string]any{"name": "Heard", "limit": 500, "rules": map[string]any{"played_within_days": 7}})
if got := smartTracks(t, m, heard, ""); len(got) != 4 {
t.Errorf("played this week: %d songs, want 4", len(got))
}
}
func TestPreviewTriesRulesWithoutKeepingAnything(t *testing.T) {
m := newMixAPI(t)
r := do(t, m.h, "POST", sp+"/preview", m.alice, map[string]any{"rules": map[string]any{"genres": []string{"hard rock"}}, "sort": "title", "limit": 3})
if r.Code != http.StatusOK || r.Body["variant"] != float64(0) || len(trackIDs(t, r)) != 3 {
t.Fatalf("preview: %d %v", r.Code, r.Body)
}
if list := do(t, m.h, "GET", sp, m.alice, nil); list.Body["total"] != float64(0) {
t.Errorf("a preview kept something: %v", list.Body)
}
r = do(t, m.h, "POST", sp+"/preview", m.alice, map[string]any{"rules": map[string]any{"genres": []string{"rock"}}, "limit": 10, "variant": 2})
if r.Code != http.StatusOK || r.Body["variant"] != float64(2) {
t.Errorf("preview with a variant: %d %v", r.Code, r.Body)
}
if r := do(t, m.h, "POST", sp+"/preview", m.alice, map[string]any{"sort": "loudest"}); r.Code != http.StatusBadRequest {
t.Errorf("preview of a bad order: %d", r.Code)
}
if r := do(t, m.h, "POST", sp+"/preview", m.alice, map[string]any{"variant": -1}); r.Code != http.StatusBadRequest {
t.Errorf("preview of a bad variant: %d", r.Code)
}
}
func TestASmartPlaylistIsKeptAsAPlaylistWithTheSongsShown(t *testing.T) {
m := newMixAPI(t)
id := smartMade(t, m, map[string]any{"name": "Hard, kept", "limit": 6, "rules": map[string]any{"genres": []string{"hard rock"}}})
shown := smartTracks(t, m, id, "?variant=3")
r := do(t, m.h, "POST", fmt.Sprintf("%s/%d/playlist", sp, id), m.alice, map[string]any{"variant": 3})
if r.Code != http.StatusCreated || r.Body["name"] != "Hard, kept" || r.Body["track_count"] != float64(6) {
t.Fatalf("save: %d %v", r.Code, r.Body)
}
items := do(t, m.h, "GET", fmt.Sprintf("/api/v1/playlists/%d/tracks", int(r.Body["id"].(float64))), m.alice, nil)
var kept []float64
for _, x := range items.Body["items"].([]any) {
kept = append(kept, x.(map[string]any)["track"].(map[string]any)["id"].(float64))
}
if !slices.Equal(kept, shown) {
t.Errorf("the playlist has %v, the smart playlist showed %v", kept, shown)
}
// It is a copy: the smart playlist is still there, and a name can be given.
named := do(t, m.h, "POST", fmt.Sprintf("%s/%d/playlist", sp, id), m.alice, map[string]any{"name": "Mine"})
if named.Code != http.StatusCreated || named.Body["name"] != "Mine" {
t.Errorf("named save: %d %v", named.Code, named.Body)
}
if r := do(t, m.h, "POST", fmt.Sprintf("%s/%d/playlist", sp, id), m.alice, nil); r.Code != http.StatusCreated {
t.Errorf("a save with no body: %d", r.Code)
}
}
func TestASmartPlaylistWithNoSongsIsNotKept(t *testing.T) {
m := newMixAPI(t)
id := smartMade(t, m, map[string]any{"name": "Polka", "rules": map[string]any{"genres": []string{"polka"}}})
r := do(t, m.h, "POST", fmt.Sprintf("%s/%d/playlist", sp, id), m.alice, nil)
if r.Code != http.StatusUnprocessableEntity || errCode(r) != "smart_playlist_empty" {
t.Errorf("save: %d %v", r.Code, r.Body)
}
if list := do(t, m.h, "GET", "/api/v1/playlists", m.alice, nil); list.Body["total"] != float64(0) {
t.Errorf("a playlist was made: %v", list.Body)
}
}
func TestASmartPlaylistIsItsOwnersAlone(t *testing.T) {
m := newMixAPI(t)
_, bob := addUser(t, m.h, m.alice, "bob", false)
id := smartMade(t, m, map[string]any{"name": "Mine", "rules": map[string]any{}})
path := fmt.Sprintf("%s/%d", sp, id)
for _, rt := range []struct {
method, path string
body any
}{
{"GET", path, nil}, {"PATCH", path, map[string]any{"name": "x"}}, {"DELETE", path, nil},
{"GET", path + "/tracks", nil}, {"POST", path + "/playlist", nil},
} {
if r := do(t, m.h, rt.method, rt.path, bob, rt.body); r.Code != http.StatusNotFound || errCode(r) != "smart_playlist_not_found" {
t.Errorf("bob %s %s: %d %v, want 404 smart_playlist_not_found", rt.method, rt.path, r.Code, r.Body)
}
}
if list := do(t, m.h, "GET", sp, bob, nil); list.Body["total"] != float64(0) {
t.Errorf("bob's list: %v", list.Body)
}
if r := do(t, m.h, "GET", path, m.alice, nil); r.Code != http.StatusOK || r.Body["name"] != "Mine" {
t.Errorf("alice's own changed: %d %v", r.Code, r.Body)
}
}
func TestTheGenresOfTheLibraryAreListedBiggestFirst(t *testing.T) {
m := newMixAPI(t)
r := do(t, m.h, "GET", "/api/v1/genres", m.alice, nil)
if r.Code != http.StatusOK {
t.Fatalf("genres: %d %v", r.Code, r.Body)
}
items := r.Body["items"].([]any)
if len(items) != 2 {
t.Fatalf("genres = %v", items)
}
first, second := items[0].(map[string]any), items[1].(map[string]any)
if first["name"] != "rock" || first["tracks"] != float64(40) || second["name"] != "hard rock" || second["tracks"] != float64(36) {
t.Errorf("genres = %v", items)
}
}
func TestSuggestedSmartPlaylistsAreThereForEveryoneWithTheirRules(t *testing.T) {
m := newMixAPI(t)
r := do(t, m.h, "GET", sp+"/suggested", m.alice, nil)
if r.Code != http.StatusOK {
t.Fatalf("suggested: %d %v", r.Code, r.Body)
}
byKey := map[string]map[string]any{}
for _, x := range r.Body["items"].([]any) {
s := x.(map[string]any)
byKey[s["key"].(string)] = s
}
for _, key := range []string{"recently-added", "on-rotation", "top-year", "most-played", "never-played", "forgotten", "high-quality", "long-tracks"} {
if byKey[key] == nil {
t.Errorf("%s is missing from %v", key, byKey)
}
}
never := byKey["never-played"]
if never["sort"] != "random" || never["limit"] != float64(50) || never["rules"].(map[string]any)["never_played"] != true {
t.Errorf("never-played = %v", never)
}
// The list of mine does not have them: they are not stored.
if list := do(t, m.h, "GET", sp, m.alice, nil); list.Body["total"] != float64(0) {
t.Errorf("my smart playlists = %v", list.Body)
}
}
func TestTheSongsOfASuggestedSmartPlaylistAreWorkedOutForTheListener(t *testing.T) {
m := newMixAPI(t)
r := do(t, m.h, "GET", sp+"/suggested/never-played/tracks", m.alice, nil)
if r.Code != http.StatusOK || r.Body["variant"] != float64(0) || len(trackIDs(t, r)) != 50 {
t.Fatalf("never-played: %d, %d songs", r.Code, len(trackIDs(t, r)))
}
first := trackIDs(t, r)
if again := trackIDs(t, do(t, m.h, "GET", sp+"/suggested/never-played/tracks", m.alice, nil)); !slices.Equal(first, again) {
t.Error("the same day gave other songs")
}
if v := trackIDs(t, do(t, m.h, "GET", sp+"/suggested/never-played/tracks?variant=1", m.alice, nil)); slices.Equal(first, v) {
t.Error("another variant gave the same songs")
}
// Nothing was played, so there is no most played, and the library has no 900 kbps file.
if got := trackIDs(t, do(t, m.h, "GET", sp+"/suggested/most-played/tracks", m.alice, nil)); len(got) != 0 {
t.Errorf("most-played with no history = %v", got)
}
if r := do(t, m.h, "GET", sp+"/suggested/nonsense/tracks", m.alice, nil); r.Code != http.StatusNotFound || errCode(r) != "suggested_not_found" {
t.Errorf("unknown key: %d %v", r.Code, r.Body)
}
if r := do(t, m.h, "GET", sp+"/suggested/never-played/tracks?variant=-1", m.alice, nil); r.Code != http.StatusBadRequest {
t.Errorf("negative variant: %d", r.Code)
}
}
func TestASuggestedSmartPlaylistIsKeptAsAPlaylist(t *testing.T) {
m := newMixAPI(t)
shown := trackIDs(t, do(t, m.h, "GET", sp+"/suggested/never-played/tracks?variant=2", m.alice, nil))
r := do(t, m.h, "POST", sp+"/suggested/never-played/playlist", m.alice, map[string]any{"name": "Fresh ears", "variant": 2})
if r.Code != http.StatusCreated || r.Body["name"] != "Fresh ears" || r.Body["track_count"] != float64(len(shown)) {
t.Fatalf("save: %d %v", r.Code, r.Body)
}
if r := do(t, m.h, "POST", sp+"/suggested/never-played/playlist", m.alice, nil); r.Code != http.StatusCreated || r.Body["name"] != "never-played" {
t.Errorf("save with no body: %d %v", r.Code, r.Body)
}
if r := do(t, m.h, "POST", sp+"/suggested/most-played/playlist", m.alice, nil); r.Code != http.StatusUnprocessableEntity || errCode(r) != "smart_playlist_empty" {
t.Errorf("save of an empty one: %d %v", r.Code, r.Body)
}
if r := do(t, m.h, "POST", sp+"/suggested/nonsense/playlist", m.alice, nil); r.Code != http.StatusNotFound || errCode(r) != "suggested_not_found" {
t.Errorf("unknown key: %d %v", r.Code, r.Body)
}
}
func TestPlaysInTheLastDaysAreCountedForTheListenerOnly(t *testing.T) {
m := newMixAPI(t)
var ids []int64
rows, err := m.db.Query("SELECT id FROM tracks WHERE title LIKE 'hard song%' ORDER BY id LIMIT 3")
if err != nil {
t.Fatal(err)
}
for rows.Next() {
var id int64
if err := rows.Scan(&id); err != nil {
t.Fatal(err)
}
ids = append(ids, id)
}
rows.Close()
// Song 0: three listens long ago. Song 1: two listens this week. Song 2: one this week.
events := []struct {
track int64
days int
}{{ids[0], 200}, {ids[0], 201}, {ids[0], 202}, {ids[1], 1}, {ids[1], 2}, {ids[2], 3}}
for i, e := range events {
if _, err := m.db.Exec(`INSERT INTO listening_events (user_id, track_id, event_type, occurred_at, duration_played_ms, idempotency_key)
VALUES (1, ?, 'complete', strftime('%s','now') - ?, 60000, ?)`, e.track, e.days*86400, fmt.Sprintf("r%d", i)); err != nil {
t.Fatal(err)
}
}
rot := trackIDs(t, do(t, m.h, "GET", sp+"/suggested/on-rotation/tracks", m.alice, nil))
if len(rot) != 1 || rot[0] != float64(ids[1]) {
t.Errorf("on rotation = %v, want only the song played twice this week (%d)", rot, ids[1])
}
year := trackIDs(t, do(t, m.h, "GET", sp+"/suggested/top-year/tracks", m.alice, nil))
if len(year) != 2 || year[0] != float64(ids[0]) && year[0] != float64(ids[1]) {
t.Errorf("top of the year = %v", year)
}
all := trackIDs(t, do(t, m.h, "GET", sp+"/suggested/most-played/tracks", m.alice, nil))
if len(all) != 3 || all[0] != float64(ids[0]) {
t.Errorf("most played ever = %v, want song %d first (three listens)", all, ids[0])
}
// The rule is in the API for a smart playlist of one's own too.
id := smartMade(t, m, map[string]any{"name": "Lately", "sort": "most_played", "rules": map[string]any{"plays_within_days": 7, "min_plays": 1}})
got := smartTracks(t, m, id, "")
if len(got) != 2 || got[0] != float64(ids[1]) {
t.Errorf("a smart playlist with the window = %v, want %d then %d", got, ids[1], ids[2])
}
if r := do(t, m.h, "POST", sp, m.alice, map[string]any{"name": "x", "rules": map[string]any{"plays_within_days": -1}}); r.Code != http.StatusBadRequest {
t.Errorf("a negative window: %d", r.Code)
}
}
func TestTheCoversOfASmartPlaylistAreThoseOfTheSongsItGivesNow(t *testing.T) {
m := newMixAPI(t)
// Songs of "rock song N" come in six albums; give covers to some of them.
rows, err := m.db.Query("SELECT DISTINCT t.album_id FROM tracks t WHERE t.title LIKE 'hard song%' ORDER BY t.album_id")
if err != nil {
t.Fatal(err)
}
var albums []int64
for rows.Next() {
var a int64
if err := rows.Scan(&a); err != nil {
t.Fatal(err)
}
albums = append(albums, a)
}
rows.Close()
if len(albums) < 5 {
t.Fatalf("albums = %v", albums)
}
for _, a := range albums[:5] {
_, _ = m.db.Exec("DELETE FROM images WHERE kind = 'album' AND owner_id = ?", a)
if _, err := m.db.Exec("INSERT INTO images (kind, owner_id, status, checked_at) VALUES ('album', ?, 'ok', 1)", a); err != nil {
t.Fatal(err)
}
}
id := smartMade(t, m, map[string]any{"name": "Hard", "sort": "title", "limit": 20, "rules": map[string]any{"genres": []string{"hard rock"}}})
r := do(t, m.h, "GET", fmt.Sprintf("%s/%d/covers", sp, id), m.alice, nil)
ids, _ := r.Body["album_ids"].([]any)
if r.Code != http.StatusOK || len(ids) != 4 {
t.Fatalf("covers: %d %v", r.Code, r.Body)
}
// They are albums of the songs on screen for the same variant.
shown := map[float64]bool{}
tracks := do(t, m.h, "GET", fmt.Sprintf("%s/%d/tracks", sp, id), m.alice, nil)
for _, x := range tracks.Body["tracks"].([]any) {
shown[x.(map[string]any)["album"].(map[string]any)["id"].(float64)] = true
}
for _, a := range ids {
if !shown[a.(float64)] {
t.Errorf("album %v is not one of the songs of the playlist", a)
}
}
// Rules that give nothing have an empty list, and an unknown playlist is not found.
none := smartMade(t, m, map[string]any{"name": "Polka", "rules": map[string]any{"genres": []string{"polka"}}})
if r := do(t, m.h, "GET", fmt.Sprintf("%s/%d/covers", sp, none), m.alice, nil); r.Code != http.StatusOK || len(r.Body["album_ids"].([]any)) != 0 {
t.Errorf("no songs: %d %v", r.Code, r.Body)
}
if r := do(t, m.h, "GET", sp+"/999999/covers", m.alice, nil); r.Code != http.StatusNotFound || errCode(r) != "smart_playlist_not_found" {
t.Errorf("unknown: %d %v", r.Code, r.Body)
}
if r := do(t, m.h, "GET", fmt.Sprintf("%s/%d/covers?variant=-1", sp, id), m.alice, nil); r.Code != http.StatusBadRequest {
t.Errorf("a negative variant: %d", r.Code)
}
// Somebody else's is not found either.
_, bob := addUser(t, m.h, m.alice, "bob", false)
if r := do(t, m.h, "GET", fmt.Sprintf("%s/%d/covers", sp, id), bob, nil); r.Code != http.StatusNotFound {
t.Errorf("another user's: %d", r.Code)
}
}
func TestTheCoversOfASuggestedOneAreAskedAsOnesOwn(t *testing.T) {
m := newMixAPI(t)
rows, err := m.db.Query("SELECT DISTINCT album_id FROM tracks WHERE album_id IS NOT NULL ORDER BY album_id LIMIT 3")
if err != nil {
t.Fatal(err)
}
for rows.Next() {
var a int64
if err := rows.Scan(&a); err != nil {
t.Fatal(err)
}
_, _ = m.db.Exec("DELETE FROM images WHERE kind = 'album' AND owner_id = ?", a)
if _, err := m.db.Exec("INSERT INTO images (kind, owner_id, status, checked_at) VALUES ('album', ?, 'ok', 1)", a); err != nil {
t.Fatal(err)
}
}
rows.Close()
r := do(t, m.h, "GET", sp+"/suggested/never-played/covers", m.alice, nil)
if r.Code != http.StatusOK || len(r.Body["album_ids"].([]any)) == 0 || len(r.Body["album_ids"].([]any)) > 4 {
t.Errorf("covers: %d %v", r.Code, r.Body)
}
if r := do(t, m.h, "GET", sp+"/suggested/nonsense/covers", m.alice, nil); r.Code != http.StatusNotFound || errCode(r) != "suggested_not_found" {
t.Errorf("unknown key: %d %v", r.Code, r.Body)
}
if r := do(t, m.h, "GET", sp+"/suggested/never-played/covers?variant=x", m.alice, nil); r.Code != http.StatusBadRequest {
t.Errorf("bad variant: %d", r.Code)
}
}