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.
505 lines
22 KiB
Go
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)
|
|
}
|
|
}
|