sonda/internal/api/http/api_test.go
tgiachi 46463846b3 feat(library): named media libraries managed through the API
- feat(storage): libraries table (name, path); audio_files points at a library
  by id instead of repeating the root path; migration 0005 for both drivers
  turns every existing root into a library and keeps file ids, tracks and the
  missing flag
- feat(library): Libraries service validates names and paths: absolute, an
  existing directory, never the filesystem root, never inside or around
  another library (checked on real paths, so symlinks cannot hide an overlap)
- feat(api): admin-only GET/POST /libraries, PATCH/DELETE /libraries/{id} and
  POST /libraries/{id}/scan; deleting a library drops its index entries and
  keeps tracks and listening history
- feat(library): the scanner and the scan manager work on libraries; scanning
  with no libraries answers 409 no_libraries
- feat(streaming): the library directory comes from the database instead of
  a configured list of roots
- breaking(config): library.roots is removed; an old config fails with a hint
  to use POST /api/v1/libraries
- test: CRUD and duplicates on both databases, path change keeps files,
  upgrade of a database written before libraries existed
2026-11-11 13:30:25 +01:00

238 lines
7.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"
"go.uber.org/zap"
"codeberg.org/squidd/sonda/internal/auth"
"codeberg.org/squidd/sonda/internal/library"
"codeberg.org/squidd/sonda/internal/listening"
"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()
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)
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)),
Scan: &fakeScan{},
Libraries: library.NewLibraries(storage.NewLibraryRepo(db)),
Streams: streaming.NewService(noFiles{}),
}
mutate(&deps)
return NewRouter(deps)
}
// 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)
}
}