sonda/internal/api/http/taste_test.go
tgiachi 544ec67dd1 feat(taste): learn what I like from what I listen to
- taste package: each listening event has a value (complete +1, a play that
  counts +0.5, a skip that does not count -1, a short play 0), older events
  weigh less (half-life 90 days, taste.half_life_days), and the values of an
  artist become a preference in (-1, 1) with tanh.
- Tag profile built from the artists I like: genres of my files plus the tags
  already stored from providers, each source scaled to its own best tag.
- GET /me/taste shows the liked artists and the tags. It reads local data only
  and never asks a provider.
- TasteRepo reads events, names and tags; tests on SQLite and PostgreSQL.
- OpenAPI spec, contract test, README and example config updated.

Closes #27
2026-11-11 18:46:58 +01:00

144 lines
4.8 KiB
Go

package httpapi
import (
"math"
"net/http"
"strconv"
"testing"
"time"
"github.com/uptrace/bun"
"codeberg.org/squidd/sonda/internal/providers"
"codeberg.org/squidd/sonda/internal/storage"
"codeberg.org/squidd/sonda/internal/taste"
)
func newTasteEnv(t *testing.T) *similarEnv {
t.Helper()
return newSimilarEnvWith(t, func(d *Deps, db *bun.DB, _ *providers.Service) {
d.Taste = taste.NewService(storage.NewTasteRepo(db), taste.Options{MinListen: 20 * time.Second, HalfLife: 90 * 24 * time.Hour})
})
}
func (e *similarEnv) trackOf(t *testing.T, artist string) int64 {
t.Helper()
var id int64
if err := e.db.QueryRow(`SELECT t.id FROM tracks t JOIN track_artists ta ON ta.track_id = t.id
JOIN artists a ON a.id = ta.artist_id WHERE a.name = ?`, artist).Scan(&id); err != nil {
t.Fatalf("track of %q: %v", artist, err)
}
return id
}
func (e *similarEnv) listen(t *testing.T, token string, track int64, typ string, ms int64, key string) {
t.Helper()
body := map[string]any{"track_id": track, "event_type": typ, "duration_played_ms": ms, "idempotency_key": key}
if r := do(t, e.h, "POST", "/api/v1/listens", token, body); r.Code != http.StatusCreated {
t.Fatalf("listen %s: %d %v", key, r.Code, r.Body)
}
}
func TestTasteNeedsASignedInUser(t *testing.T) {
e := newTasteEnv(t)
if r := do(t, e.h, "GET", "/api/v1/me/taste", "", nil); r.Code != http.StatusUnauthorized {
t.Errorf("no token: %d", r.Code)
}
}
func TestTasteOfANewListenerIsEmptyLists(t *testing.T) {
e := newTasteEnv(t)
r := do(t, e.h, "GET", "/api/v1/me/taste", e.admin, nil)
if r.Code != http.StatusOK {
t.Fatalf("%d %v", r.Code, r.Body)
}
sameKeys(t, "taste", r.Body, "artists", "tags")
artists, ok1 := r.Body["artists"].([]any)
tags, ok2 := r.Body["tags"].([]any)
if !ok1 || !ok2 || len(artists) != 0 || len(tags) != 0 {
t.Errorf("taste = %v, want two empty lists", r.Body)
}
}
func TestTasteFollowsWhatIListenTo(t *testing.T) {
e := newTasteEnv(t)
alpha, beta := e.trackOf(t, "Alpha"), e.trackOf(t, "Beta")
for i := 0; i < 3; i++ {
e.listen(t, e.admin, alpha, "complete", 1000, "a"+strconv.Itoa(i))
}
e.listen(t, e.admin, beta, "skip", 1000, "b1") // too soon: against Beta
if _, err := e.db.Exec("INSERT INTO track_genres (track_id, genre) VALUES (?, 'shoegaze')", alpha); err != nil {
t.Fatal(err)
}
r := do(t, e.h, "GET", "/api/v1/me/taste", e.admin, nil)
if r.Code != http.StatusOK {
t.Fatalf("%d %v", r.Code, r.Body)
}
artists := r.Body["artists"].([]any)
if len(artists) != 1 {
t.Fatalf("artists = %v, want only the one I like", artists)
}
a := artists[0].(map[string]any)
sameKeys(t, "artist", a, "id", "name", "preference", "listens", "last_listened_at")
if a["name"] != "Alpha" || a["id"] != float64(e.alpha) || a["listens"] != float64(3) {
t.Errorf("artist = %v", a)
}
if p, _ := a["preference"].(float64); math.Abs(p-math.Tanh(1)) > 0.001 { // three listens, just now
t.Errorf("preference = %v, want about %v", p, math.Tanh(1))
}
if _, err := time.Parse(time.RFC3339, a["last_listened_at"].(string)); err != nil {
t.Errorf("last_listened_at = %v", a["last_listened_at"])
}
tags := r.Body["tags"].([]any)
if len(tags) != 1 {
t.Fatalf("tags = %v", tags)
}
tg := tags[0].(map[string]any)
sameKeys(t, "tag", tg, "tag", "weight")
if tg["tag"] != "shoegaze" || tg["weight"] != float64(1) {
t.Errorf("tag = %v", tg)
}
}
func TestTasteIsPrivate(t *testing.T) {
e := newTasteEnv(t)
e.listen(t, e.admin, e.trackOf(t, "Alpha"), "complete", 1000, "a1")
body := map[string]any{"username": "bob", "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)
}
login := do(t, e.h, "POST", "/api/v1/auth/login", "", body)
bob, _ := login.Body["access_token"].(string)
r := do(t, e.h, "GET", "/api/v1/me/taste", bob, nil)
if r.Code != http.StatusOK || len(r.Body["artists"].([]any)) != 0 {
t.Errorf("bob sees %d %v, want nothing of alice's listening", r.Code, r.Body)
}
}
func TestTasteLimit(t *testing.T) {
e := newTasteEnv(t)
e.listen(t, e.admin, e.trackOf(t, "Alpha"), "complete", 1000, "a1")
e.listen(t, e.admin, e.trackOf(t, "Beta"), "complete", 1000, "b1")
for _, tt := range []struct {
query string
code int
n int
}{
{"", 200, 2}, {"?limit=1", 200, 1}, {"?limit=0", 200, 2}, {"?limit=1000", 200, 2},
{"?limit=abc", 400, 0}, {"?limit=-1", 400, 0},
} {
r := do(t, e.h, "GET", "/api/v1/me/taste"+tt.query, e.admin, nil)
if r.Code != tt.code {
t.Errorf("%q: %d %v, want %d", tt.query, r.Code, r.Body, tt.code)
continue
}
if tt.code == 200 && len(r.Body["artists"].([]any)) != tt.n {
t.Errorf("%q: %d artists, want %d", tt.query, len(r.Body["artists"].([]any)), tt.n)
}
if tt.code == 400 && errCode(r) != "invalid_input" {
t.Errorf("%q: error %v", tt.query, r.Body)
}
}
}