sonda/internal/api/http/api_test.go
tgiachi aa4883b955 feat(import): an Import page, with the numbers of every import kept
The report of an import used to be shown once in Settings and lost. Each
import is now stored (migration 0030, spotify_imports) as the report in
JSON, and GET /me/import/spotify lists the past ones, newest first.
POST /me/import/spotify answers with the same shape plus id and created_at.

The web app gets an Import page (menu, More tab) with the form and one card
for each past import: plays read, added, already there, not in the library,
the playlists it made and the artists that are missing. Settings only links
to it. An import that finds nothing is not kept, and a report that cannot be
stored is still returned to the person who asked.
2026-11-15 10:34:12 +01:00

353 lines
13 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/about"
"codeberg.org/squidd/sonda/internal/auth"
"codeberg.org/squidd/sonda/internal/catalog"
"codeberg.org/squidd/sonda/internal/discover"
"codeberg.org/squidd/sonda/internal/discovery"
"codeberg.org/squidd/sonda/internal/duplicates"
"codeberg.org/squidd/sonda/internal/federation"
"codeberg.org/squidd/sonda/internal/feedback"
"codeberg.org/squidd/sonda/internal/images"
"codeberg.org/squidd/sonda/internal/jobs"
"codeberg.org/squidd/sonda/internal/library"
"codeberg.org/squidd/sonda/internal/listening"
"codeberg.org/squidd/sonda/internal/mastodon"
"codeberg.org/squidd/sonda/internal/mixes"
"codeberg.org/squidd/sonda/internal/naming"
"codeberg.org/squidd/sonda/internal/playlists"
"codeberg.org/squidd/sonda/internal/providers"
"codeberg.org/squidd/sonda/internal/providers/anthropic"
"codeberg.org/squidd/sonda/internal/smart"
"codeberg.org/squidd/sonda/internal/spotifyimport"
"codeberg.org/squidd/sonda/internal/storage"
"codeberg.org/squidd/sonda/internal/streaming"
"codeberg.org/squidd/sonda/internal/taste"
"codeberg.org/squidd/sonda/internal/usersettings"
"codeberg.org/squidd/sonda/internal/waveform"
"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 := newProviders(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)),
Catalog: catalog.NewService(storage.NewCatalogRepo(db)),
Providers: prov,
Lidarr: &fakeLidarr{},
LidarrArtists: &fakeSender{},
Discovery: discovery.NewService(storage.NewDiscoveryRepo(db), &fakeLastfm{}, prov, zap.NewNop()),
Tags: discovery.NewTagService(storage.NewDiscoveryRepo(db), map[string]discovery.TagSource{}, prov, zap.NewNop()),
Taste: taste.NewService(storage.NewTasteRepo(db), taste.Options{MinListen: 20 * time.Second, HalfLife: 90 * 24 * time.Hour}),
Settings: usersettings.NewService(storage.NewUserSettingsRepo(db)),
Streams: streaming.NewService(noFiles{}),
Federation: federation.NewService(storage.NewFederationRepo(db), federation.NewClient()),
Mastodon: mastodon.NewService(storage.NewMastodonRepo(db), &fakeMastodon{handle: "@test@mastodon.social"}, zap.NewNop()),
}
libRepo := storage.NewLibraryRepo(db)
deps.PeerCatalog = catalog.NewService(storage.NewSharedCatalogRepo(db))
deps.PeerStreams = streaming.NewService(libRepo.Shared())
deps.PeerWaveform = waveform.NewService(storage.NewWaveformRepo(db), streaming.NewService(libRepo.Shared()))
deps.Waveform = waveform.NewService(storage.NewWaveformRepo(db), streaming.NewService(libRepo))
feedbackSvc := feedback.NewService(storage.NewFeedbackRepo(db))
deps.Feedback = feedbackSvc
deps.Playlists = playlists.NewService(storage.NewPlaylistRepo(db))
deps.SpotifyImport = spotifyimport.NewService(storage.NewCatalogRepo(db), storage.NewListeningRepo(db), deps.Playlists, storage.NewSpotifyImportRepo(db), storage.SearchKey, 20*time.Second)
deps.Mixes = mixes.NewService(storage.NewMixRepo(db), deps.Taste.(mixes.Taster), 20*time.Second)
deps.Smart = smart.NewService(storage.NewSmartRepo(db), deps.Taste.(smart.Taster), 20*time.Second)
namingSvc := naming.NewService(prov, noClaude{}, storage.NewNamingRepo(db), nil)
namingSvc.SetLedger(storage.NewNamingRepo(db))
deps.Naming = namingSvc
imageRepo := storage.NewImageRepo(db)
imageSvc := images.NewService(filepath.Join(t.TempDir(), "data"), imageRepo, imageRepo)
deps.Images, deps.ArtistImages = imageSvc, imageSvc
deps.PeerCovers = images.StoredOnly{Service: imageSvc}
deps.CoversJob = jobs.Runner{Ctx: context.Background(), Job: images.NewCoversJob(imageSvc, imageRepo)}
deps.ArtistImagesJob = jobs.Runner{Ctx: context.Background(), Job: images.NewArtistImagesJob(imageSvc, imageRepo)}
mutate(&deps, db)
if deps.About == nil {
deps.About = about.NewService(storage.NewDiscoveryRepo(db), noWikipedia{}, prov, []string{"en"}, zap.NewNop())
}
if deps.DescriptionsJob == nil {
deps.DescriptionsJob = jobs.Runner{Ctx: context.Background(), Job: about.NewJob(about.NewService(storage.NewDiscoveryRepo(db), noWikipedia{}, prov, []string{"en"}, zap.NewNop()), storage.NewDiscoveryRepo(db))}
}
// Deleting is off unless a test turns it on.
if deps.Duplicates == nil {
svc := duplicates.NewService(storage.NewDuplicatesRepo(db), duplicates.Options{Logger: zap.NewNop()})
deps.Duplicates = svc
if deps.DuplicatesJob == nil {
deps.DuplicatesJob = jobs.Runner{Ctx: context.Background(), Job: duplicates.NewHashJob(svc)}
}
}
// Built from the final services, so a test that swaps one gets a Discover that uses it.
if deps.Discover == nil {
deps.Discover = discover.NewService(deps.Taste.(discover.Taster), deps.Discovery.(discover.Similar),
discovery.NewTagService(storage.NewDiscoveryRepo(db), map[string]discovery.TagSource{}, prov, zap.NewNop()),
storage.NewTasteRepo(db), usersettings.NewService(storage.NewUserSettingsRepo(db)), feedbackSvc, discover.DefaultWeights())
}
return NewRouter(deps), db
}
// noWikipedia is a Wikipedia that knows nothing, for tests that do not care about it.
type noWikipedia struct{}
func (noWikipedia) WikidataID(context.Context, string) (string, error) { return "", nil }
func (noWikipedia) Pages(context.Context, string, []string) (string, map[string]string, error) {
return "", nil, about.ErrSourceNotFound
}
func (noWikipedia) Summary(context.Context, string, string) (about.Summary, error) {
return about.Summary{}, about.ErrSourceNotFound
}
// newProviders builds the provider service the way main does, with the real way
// of removing provider data.
func newProviders(db *bun.DB) *providers.Service {
svc := providers.NewService(storage.NewProviderRepo(db))
svc.SetPurger(func(ctx context.Context, name string) (providers.Purged, error) {
return storage.NewDiscoveryRepo(db).Purge(ctx, name)
})
return svc
}
// noClaude is a Claude that is never there: with the provider off it is never asked.
type noClaude struct{}
func (noClaude) Name(context.Context, string, anthropic.Request) (anthropic.Result, error) {
return anthropic.Result{}, anthropic.ErrNoName
}
// 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{"email": "alice@example.org", "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{"email": "bob@example.org", "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{"email": "alice@example.org", "password": "x"},
"bad email": map[string]string{"email": "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{"email": "alice@example.org", "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, Email: "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 := `{"email":"` + 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)
}
}