- 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
260 lines
8.1 KiB
Go
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)
|
|
}
|
|
}
|