Migrating hosting from Codeberg to git.kmalloc.org. Renames the module path in go.mod, every internal import, and the OCI image source label in the Dockerfile. Build and full test suite verified green after the rename.
262 lines
9.6 KiB
Go
262 lines
9.6 KiB
Go
package httpapi
|
|
|
|
import (
|
|
"math"
|
|
"net/http"
|
|
"strconv"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/uptrace/bun"
|
|
"go.uber.org/zap"
|
|
|
|
"git.kmalloc.org/squid/sonda/internal/discover"
|
|
"git.kmalloc.org/squid/sonda/internal/discovery"
|
|
"git.kmalloc.org/squid/sonda/internal/feedback"
|
|
"git.kmalloc.org/squid/sonda/internal/providers"
|
|
"git.kmalloc.org/squid/sonda/internal/storage"
|
|
"git.kmalloc.org/squid/sonda/internal/taste"
|
|
"git.kmalloc.org/squid/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)
|
|
}
|
|
}
|