Registration, login and the admin's create-user call take `email` instead of `username`, and the user object returns `email`. The address is checked for its shape (a plain address, no display name, at most 254 bytes), trimmed, lowercased and unique. Sonda sends no mail and does not verify it. - Migration 0018 renames the users column (and the PostgreSQL index); values are kept, so an account made before keeps its plain name and still logs in with it (login does not check the shape). - Error code username_taken becomes email_taken; the JWT claim is now `email`, so access tokens issued before the upgrade are refused once and clients refresh. - OpenAPI spec, README, the web login form (type email), strings (en, it) and the generated API types follow. Closes #65
144 lines
4.8 KiB
Go
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{"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)
|
|
}
|
|
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)
|
|
}
|
|
}
|
|
}
|