package httpapi import ( "math" "net/http" "strconv" "testing" "time" "github.com/uptrace/bun" "go.uber.org/zap" "codeberg.org/squidd/sonda/internal/discover" "codeberg.org/squidd/sonda/internal/discovery" "codeberg.org/squidd/sonda/internal/feedback" "codeberg.org/squidd/sonda/internal/providers" "codeberg.org/squidd/sonda/internal/storage" "codeberg.org/squidd/sonda/internal/taste" "codeberg.org/squidd/sonda/internal/usersettings" ) type discoverEnv struct { *similarEnv lf *fakeTags // what Last.fm says about tags, for any artist mb *fakeTags // MusicBrainz, which Discover must never ask } // newDiscoverEnv wires the real Discover on the similar-artists environment: Last.fm // is off until a test turns it on. The fake answers say Beta (match 1, in the // library) and Gamma (match 0.5, not in it) are similar to anyone. func newDiscoverEnv(t *testing.T) *discoverEnv { t.Helper() e := &discoverEnv{ lf: &fakeTags{tags: []discovery.Tag{{Name: "rock", Weight: 100}, {Name: "grunge", Weight: 40}}}, mb: &fakeTags{tags: []discovery.Tag{{Name: "alternative rock", Weight: 43, Genre: true}}}, } e.similarEnv = newSimilarEnvWith(t, func(d *Deps, db *bun.DB, prov *providers.Service) { tasteSvc := taste.NewService(storage.NewTasteRepo(db), taste.Options{MinListen: 20 * time.Second, HalfLife: 90 * 24 * time.Hour}) settings := usersettings.NewService(storage.NewUserSettingsRepo(db)) tags := discovery.NewTagService(storage.NewDiscoveryRepo(db), map[string]discovery.TagSource{providers.LastFM: e.lf, providers.MusicBrainz: e.mb}, prov, zap.NewNop()) d.Taste, d.Settings = tasteSvc, settings fb := feedback.NewService(storage.NewFeedbackRepo(db)) d.Feedback = fb d.Discover = discover.NewService(tasteSvc, d.Discovery.(discover.Similar), tags, storage.NewTasteRepo(db), settings, fb, discover.DefaultWeights()) }) return e } func (e *discoverEnv) get(t *testing.T, query string) resp { t.Helper() return do(t, e.h, "GET", "/api/v1/discover"+query, e.admin, nil) } func (e *discoverEnv) allowListening(t *testing.T) { t.Helper() if r := do(t, e.h, "PATCH", "/api/v1/me/settings", e.admin, map[string]any{"discover_from_listening": true}); r.Code != http.StatusOK { t.Fatalf("turn the setting on: %d %v", r.Code, r.Body) } } func (e *discoverEnv) seed(id int64) string { return "seed=" + strconv.FormatInt(id, 10) } func itemFor(t *testing.T, r resp, name string) map[string]any { t.Helper() items, _ := r.Body["items"].([]any) for _, it := range items { m := it.(map[string]any) if m["artist"].(map[string]any)["name"] == name { return m } } t.Fatalf("%s is not in %v", name, r.Body["items"]) return nil } func TestDiscoverNeedsASignedInUser(t *testing.T) { e := newDiscoverEnv(t) if r := do(t, e.h, "GET", "/api/v1/discover", "", nil); r.Code != http.StatusUnauthorized { t.Errorf("no token: %d", r.Code) } } func TestDiscoverWithoutASeedAndTheSettingOffAsksNobody(t *testing.T) { e := newDiscoverEnv(t) e.enableLastfm(t) r := e.get(t, "") if r.Code != http.StatusBadRequest || errCode(r) != "seed_required" { t.Errorf("%d %v, want 400 seed_required", r.Code, r.Body) } if e.source.count() != 0 || e.lf.calls != 0 { t.Errorf("Last.fm was asked (%d similar, %d tags) without the listener's permission", e.source.count(), e.lf.calls) } } func TestDiscoverFromANamedSeed(t *testing.T) { e := newDiscoverEnv(t) e.enableLastfm(t) r := e.get(t, "?"+e.seed(e.alpha)) if r.Code != http.StatusOK { t.Fatalf("%d %v", r.Code, r.Body) } sameKeys(t, "discover", r.Body, "provider_status", "attribution", "from_listening", "seeds", "items") if r.Body["provider_status"] != "ok" || r.Body["from_listening"] != false || r.Body["attribution"] == "" { t.Errorf("answer = %v", r.Body) } seeds := r.Body["seeds"].([]any) if len(seeds) != 1 { t.Fatalf("seeds = %v", seeds) } sameKeys(t, "seed", seeds[0].(map[string]any), "id", "name", "weight") if s := seeds[0].(map[string]any); s["name"] != "Alpha" || s["weight"] != float64(1) { t.Errorf("seed = %v", s) } beta, gamma := itemFor(t, r, "Beta"), itemFor(t, r, "Gamma") sameKeys(t, "item", beta, "artist", "in_library", "wishlisted", "score", "components", "because") sameKeys(t, "components", beta["components"].(map[string]any), "a", "g", "p", "d") if beta["in_library"] != true || gamma["in_library"] != false { t.Errorf("in_library: Beta %v, Gamma %v", beta["in_library"], gamma["in_library"]) } // Nothing was ever listened to: no profile, so no genre, a neutral preference, full discovery. c := beta["components"].(map[string]any) if v, present := c["g"]; !present || v != nil { t.Errorf("g = %#v, want an explicit null", v) } if c["p"] != 0.5 || c["d"] != float64(1) || c["a"] != float64(1) { t.Errorf("components = %v, want a=1 p=0.5 d=1", c) } because := beta["because"].([]any) if len(because) != 1 { t.Fatalf("because = %v", because) } sameKeys(t, "because", because[0].(map[string]any), "artist", "match") if because[0].(map[string]any)["artist"].(map[string]any)["name"] != "Alpha" { t.Errorf("because = %v", because) } if e.lf.calls != 0 { t.Error("tags were read although there is no taste to compare them with") } } func TestDiscoverFromMyListeningNeedsAndUsesTheSetting(t *testing.T) { e := newDiscoverEnv(t) e.enableLastfm(t) alpha := e.trackOf(t, "Alpha") e.listen(t, e.admin, alpha, "complete", 1000, "a1") e.listen(t, e.admin, alpha, "complete", 1000, "a2") if _, err := e.db.Exec("INSERT INTO track_genres (track_id, genre) VALUES (?, 'rock')", alpha); err != nil { t.Fatal(err) } if r := e.get(t, ""); r.Code != http.StatusBadRequest || errCode(r) != "seed_required" { t.Fatalf("setting off: %d %v", r.Code, r.Body) } if e.source.count() != 0 { t.Fatal("Last.fm was asked about the listening although the setting is off") } e.allowListening(t) r := e.get(t, "") if r.Code != http.StatusOK || r.Body["from_listening"] != true { t.Fatalf("%d %v", r.Code, r.Body) } seeds := r.Body["seeds"].([]any) if len(seeds) != 1 || seeds[0].(map[string]any)["name"] != "Alpha" { t.Fatalf("seeds = %v, want Alpha", seeds) } if w := seeds[0].(map[string]any)["weight"].(float64); math.Abs(w-math.Tanh(2.0/3)) > 0.001 { t.Errorf("seed weight = %v, want the preference %v", w, math.Tanh(2.0/3)) } gamma := itemFor(t, r, "Gamma") comp := gamma["components"].(map[string]any) // The profile is {rock: 1}; Gamma's Last.fm tags are rock 1 and grunge 0.4. if g, _ := comp["g"].(float64); math.Abs(g-1/math.Sqrt(1.16)) > 0.001 { t.Errorf("g = %v, want %v", comp["g"], 1/math.Sqrt(1.16)) } if e.lf.calls == 0 { t.Error("the tags of the candidates were never read") } if e.mb.calls != 0 { t.Errorf("MusicBrainz was asked %d times: Discover reads tags from Last.fm only", e.mb.calls) } } func TestTheSettingBelongsToEachUser(t *testing.T) { e := newDiscoverEnv(t) e.enableLastfm(t) e.listen(t, e.admin, e.trackOf(t, "Alpha"), "complete", 1000, "a1") e.allowListening(t) // alice allows it body := map[string]any{"email": "bob@example.org", "password": "longenough"} if r := do(t, e.h, "POST", "/api/v1/users", e.admin, body); r.Code != http.StatusCreated { t.Fatalf("create bob: %d %v", r.Code, r.Body) } bob, _ := do(t, e.h, "POST", "/api/v1/auth/login", "", body).Body["access_token"].(string) r := do(t, e.h, "GET", "/api/v1/discover", bob, nil) if r.Code != http.StatusBadRequest || errCode(r) != "seed_required" { t.Errorf("bob did not allow it: %d %v, want 400 seed_required", r.Code, r.Body) } if e.source.count() != 0 { t.Error("Last.fm was asked on behalf of bob, who never allowed it") } if r := e.get(t, ""); r.Code != http.StatusOK { t.Errorf("alice did: %d %v", r.Code, r.Body) } } func TestDiscoverFilterAndLimit(t *testing.T) { e := newDiscoverEnv(t) e.enableLastfm(t) base := "?" + e.seed(e.alpha) r := e.get(t, base+"&in_library=false") if r.Code != http.StatusOK || len(r.Body["items"].([]any)) != 1 { t.Fatalf("outside: %d %v", r.Code, r.Body) } itemFor(t, r, "Gamma") r = e.get(t, base+"&in_library=true") if r.Code != http.StatusOK || len(r.Body["items"].([]any)) != 1 { t.Fatalf("inside: %d %v", r.Code, r.Body) } itemFor(t, r, "Beta") if r = e.get(t, base+"&limit=1"); len(r.Body["items"].([]any)) != 1 { t.Errorf("limit 1: %v", r.Body["items"]) } if r = e.get(t, base+"&limit=1000"); r.Code != http.StatusOK { t.Errorf("a large limit is lowered, not refused: %d", r.Code) } } func TestDiscoverRefusesWhatItCannotUnderstand(t *testing.T) { e := newDiscoverEnv(t) e.enableLastfm(t) for name, q := range map[string]string{ "seed not a number": "?seed=abc", "unknown seed": "?seed=99999", "zero seed": "?seed=0", "too many seeds": "?seed=1&seed=2&seed=3&seed=4&seed=5&seed=6", "limit not number": "?" + e.seed(e.alpha) + "&limit=lots", "negative limit": "?" + e.seed(e.alpha) + "&limit=-1", "bad in_library": "?" + e.seed(e.alpha) + "&in_library=maybe", "in_library twice": "?" + e.seed(e.alpha) + "&in_library=true&in_library=false", } { r := e.get(t, q) if r.Code != http.StatusBadRequest || errCode(r) != "invalid_input" { t.Errorf("%s: %d %v, want 400 invalid_input", name, r.Code, r.Body) } } if e.source.count() != 0 { t.Error("Last.fm was asked about a request that was refused") } } func TestDiscoverWithLastfmOffSaysSoAndAsksNobody(t *testing.T) { e := newDiscoverEnv(t) // Last.fm is off r := e.get(t, "?"+e.seed(e.alpha)) if r.Code != http.StatusOK || r.Body["provider_status"] != "disabled" { t.Fatalf("%d %v, want 200 and status disabled", r.Code, r.Body) } if len(r.Body["items"].([]any)) != 0 || e.source.count() != 0 || e.lf.calls != 0 { t.Errorf("items %v, similar calls %d, tag calls %d", r.Body["items"], e.source.count(), e.lf.calls) } }