sonda/internal/api/http/api_test.go
tgiachi 07ea997cd0 feat(discovery): artist tags from Last.fm and MusicBrainz, and ids from my files
- feat: GET /api/v1/artists/{id}/tags lists, for each provider that is on, the
  tags it gives to an artist with its own weights, kept as they came: Last.fm's
  are relative to the artist, MusicBrainz's are counts of votes, and they are
  never mixed. MusicBrainz also marks the tags it lists as genres. The same
  rules as similar artists apply: asked only on demand, kept 7 days (1 for an
  unknown artist), old data served when a provider fails, and one call for
  simultaneous requests. A provider that is off, failing or lacking an id does
  not hide the other
- feat: a thin MusicBrainz client that reads an artist's tags and genres by its
  id. It never searches by name, because a search returns look-alikes and
  picking one would be a guess. The id is checked before it reaches the path,
  and errors never repeat the provider's text
- feat: the User-Agent can change while the server runs, so the contact an
  admin sets for MusicBrainz applies to the next request; if the settings
  cannot be read it falls back to the project address
- feat: Last.fm top tags, by id when known and by name otherwise, never
  autocorrected
- feat: the scan reads MusicBrainz artist ids from the file tags, offline, and
  keeps them on the artists. An id is only used when it can be paired with its
  artist for certain: the same number of ids as artists, all valid. The same id
  is the same artist whatever the spelling, an artist without an id takes the
  one its file gives, and another id under the same name is another artist. A
  file that confirms the id a provider gave to a discovered artist keeps it
- feat: POST /providers/musicbrainz/test checks that the service answers
- test: what leaves the server for MusicBrainz is checked from the other end:
  the id of the artist and the admin's contact, nothing from the library;
  removing the safeguards on ids and pairing makes tests fail
- docs: README, OpenAPI and the provider text updated
2026-11-11 17:01:43 +01:00

260 lines
8.1 KiB
Go

package httpapi
import (
"bytes"
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"path/filepath"
"strings"
"testing"
"time"
"github.com/gin-gonic/gin"
"github.com/uptrace/bun"
"go.uber.org/zap"
"codeberg.org/squidd/sonda/internal/auth"
"codeberg.org/squidd/sonda/internal/discovery"
"codeberg.org/squidd/sonda/internal/library"
"codeberg.org/squidd/sonda/internal/listening"
"codeberg.org/squidd/sonda/internal/providers"
"codeberg.org/squidd/sonda/internal/storage"
"codeberg.org/squidd/sonda/internal/streaming"
"codeberg.org/squidd/sonda/migrations"
)
const secret = "0123456789abcdef0123456789abcdef"
func init() { gin.SetMode(gin.TestMode) }
// newTestAPI wires real services on a temporary SQLite database.
func newTestAPI(t *testing.T) http.Handler {
t.Helper()
return newTestAPIWithScan(t, &fakeScan{})
}
func newTestAPIWithScan(t *testing.T, scan scanService) http.Handler {
t.Helper()
return newTestAPIWith(t, func(d *Deps) { d.Scan = scan })
}
// newTestAPIWith wires real services and lets a test replace parts of Deps.
func newTestAPIWith(t *testing.T, mutate func(*Deps)) http.Handler {
t.Helper()
h, _ := newTestEnv(t, mutate)
return h
}
// newTestEnv is newTestAPIWith that also returns the database, for tests that
// need to look at or seed it.
func newTestEnv(t *testing.T, mutate func(*Deps)) (http.Handler, *bun.DB) {
t.Helper()
return newTestEnvDB(t, func(d *Deps, _ *bun.DB) { mutate(d) })
}
// newTestEnvDB lets the mutate function see the database as well, for tests
// that build services on top of it.
func newTestEnvDB(t *testing.T, mutate func(*Deps, *bun.DB)) (http.Handler, *bun.DB) {
t.Helper()
db, err := storage.Open(storage.DriverSQLite, filepath.Join(t.TempDir(), "api.db"))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = db.Close() })
fsys, err := migrations.For(storage.DriverSQLite)
if err != nil {
t.Fatal(err)
}
if err := storage.Migrate(context.Background(), db, fsys); err != nil {
t.Fatal(err)
}
if _, err := db.DB.Exec("INSERT INTO tracks (title) VALUES ('song')"); err != nil {
t.Fatal(err)
}
tokens := auth.NewTokenIssuer(secret, time.Hour)
prov := providers.NewService(storage.NewProviderRepo(db))
deps := Deps{
Logger: zap.NewNop(),
Auth: auth.NewService(storage.NewUserRepo(db), storage.NewRefreshRepo(db), tokens, 24*time.Hour),
Tokens: tokens,
Listening: listening.NewService(storage.NewListeningRepo(db), 20*time.Second),
Scan: &fakeScan{},
Libraries: library.NewLibraries(storage.NewLibraryRepo(db)),
Providers: prov,
Discovery: discovery.NewService(storage.NewDiscoveryRepo(db), &fakeLastfm{}, prov, zap.NewNop()),
Tags: discovery.NewTagService(storage.NewDiscoveryRepo(db), map[string]discovery.TagSource{}, prov, zap.NewNop()),
Streams: streaming.NewService(noFiles{}),
}
mutate(&deps, db)
return NewRouter(deps), db
}
// noFiles is a streaming source with nothing to play.
type noFiles struct{}
func (noFiles) PlayableFile(context.Context, int64) (streaming.File, error) {
return streaming.File{}, streaming.ErrNotFound
}
type resp struct {
Code int
Body map[string]any
}
func do(t *testing.T, h http.Handler, method, path, token string, body any) resp {
t.Helper()
var buf bytes.Buffer
if body != nil {
if s, ok := body.(string); ok {
buf.WriteString(s)
} else if err := json.NewEncoder(&buf).Encode(body); err != nil {
t.Fatal(err)
}
}
req := httptest.NewRequest(method, path, &buf)
req.Header.Set("Content-Type", "application/json")
if token != "" {
req.Header.Set("Authorization", "Bearer "+token)
}
rec := httptest.NewRecorder()
h.ServeHTTP(rec, req)
out := resp{Code: rec.Code, Body: map[string]any{}}
_ = json.Unmarshal(rec.Body.Bytes(), &out.Body)
return out
}
func errCode(r resp) string {
e, _ := r.Body["error"].(map[string]any)
c, _ := e["code"].(string)
return c
}
// registerAndLogin creates the first user and returns a valid token.
func registerAndLogin(t *testing.T, h http.Handler) string {
t.Helper()
creds := map[string]string{"username": "alice", "password": "longenough"}
if r := do(t, h, "POST", "/api/v1/auth/register", "", creds); r.Code != http.StatusCreated {
t.Fatalf("register: %d %v", r.Code, r.Body)
}
r := do(t, h, "POST", "/api/v1/auth/login", "", creds)
if r.Code != http.StatusOK {
t.Fatalf("login: %d %v", r.Code, r.Body)
}
tok, _ := r.Body["access_token"].(string)
if tok == "" {
t.Fatal("no access_token in login response")
}
return tok
}
func TestHealth(t *testing.T) {
r := do(t, newTestAPI(t), "GET", "/api/v1/health", "", nil)
if r.Code != http.StatusOK || r.Body["status"] != "ok" {
t.Fatalf("health: %d %v", r.Code, r.Body)
}
}
func TestRegisterThenClosed(t *testing.T) {
h := newTestAPI(t)
registerAndLogin(t, h)
r := do(t, h, "POST", "/api/v1/auth/register", "", map[string]string{"username": "bob", "password": "longenough"})
if r.Code != http.StatusForbidden || errCode(r) != "registration_closed" {
t.Fatalf("second register: %d %v", r.Code, r.Body)
}
}
func TestRegisterInvalid(t *testing.T) {
h := newTestAPI(t)
for name, body := range map[string]any{
"short password": map[string]string{"username": "alice", "password": "x"},
"bad username": map[string]string{"username": "a", "password": "longenough"},
"malformed json": "{not json",
} {
r := do(t, h, "POST", "/api/v1/auth/register", "", body)
if r.Code != http.StatusBadRequest || errCode(r) != "invalid_input" {
t.Errorf("%s: %d %v", name, r.Code, r.Body)
}
}
}
func TestLoginWrongPassword(t *testing.T) {
h := newTestAPI(t)
registerAndLogin(t, h)
r := do(t, h, "POST", "/api/v1/auth/login", "", map[string]string{"username": "alice", "password": "nopenopenope"})
if r.Code != http.StatusUnauthorized || errCode(r) != "invalid_credentials" {
t.Fatalf("login: %d %v", r.Code, r.Body)
}
}
func TestListenRequiresAuth(t *testing.T) {
h := newTestAPI(t)
body := map[string]any{"track_id": 1, "event_type": "play", "idempotency_key": "k"}
if r := do(t, h, "POST", "/api/v1/listens", "", body); r.Code != http.StatusUnauthorized {
t.Errorf("no token: %d", r.Code)
}
if r := do(t, h, "POST", "/api/v1/listens", "garbage", body); r.Code != http.StatusUnauthorized {
t.Errorf("bad token: %d", r.Code)
}
// A token signed with another secret is rejected.
other, _, _ := auth.NewTokenIssuer("ffffffffffffffffffffffffffffffff", time.Hour).Issue(auth.User{ID: 1, Username: "alice"})
if r := do(t, h, "POST", "/api/v1/listens", other, body); r.Code != http.StatusUnauthorized {
t.Errorf("foreign token: %d", r.Code)
}
}
func TestListenFlow(t *testing.T) {
h := newTestAPI(t)
tok := registerAndLogin(t, h)
body := map[string]any{
"track_id": 1, "event_type": "complete", "duration_played_ms": 1000,
"idempotency_key": "abc", "occurred_at": "2026-01-02T03:04:05Z",
}
r := do(t, h, "POST", "/api/v1/listens", tok, body)
if r.Code != http.StatusCreated || r.Body["status"] != "recorded" {
t.Fatalf("first: %d %v", r.Code, r.Body)
}
// Same idempotency key: accepted, not duplicated.
r = do(t, h, "POST", "/api/v1/listens", tok, body)
if r.Code != http.StatusOK || r.Body["status"] != "duplicate" {
t.Fatalf("retry: %d %v", r.Code, r.Body)
}
body["idempotency_key"] = "def"
body["track_id"] = 999
r = do(t, h, "POST", "/api/v1/listens", tok, body)
if r.Code != http.StatusNotFound || errCode(r) != "track_not_found" {
t.Fatalf("unknown track: %d %v", r.Code, r.Body)
}
body["track_id"] = 1
body["event_type"] = "dance"
r = do(t, h, "POST", "/api/v1/listens", tok, body)
if r.Code != http.StatusBadRequest || errCode(r) != "invalid_input" {
t.Fatalf("bad type: %d %v", r.Code, r.Body)
}
body["event_type"] = "play"
body["occurred_at"] = "yesterday"
r = do(t, h, "POST", "/api/v1/listens", tok, body)
if r.Code != http.StatusBadRequest || errCode(r) != "invalid_input" {
t.Fatalf("bad time: %d %v", r.Code, r.Body)
}
}
func TestBodyTooLarge(t *testing.T) {
h := newTestAPI(t)
huge := `{"username":"` + strings.Repeat("a", 200_000) + `","password":"longenough"}`
r := do(t, h, "POST", "/api/v1/auth/register", "", huge)
if r.Code != http.StatusBadRequest && r.Code != http.StatusRequestEntityTooLarge {
t.Fatalf("huge body: %d", r.Code)
}
}