sonda/internal/api/http/jobs_test.go
tgiachi 96ad8b1f62 feat(auth): accounts are identified by an email address
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
2026-11-12 14:40:33 +01:00

205 lines
7.7 KiB
Go

package httpapi
import (
"net/http"
"testing"
"time"
"github.com/uptrace/bun"
"codeberg.org/squidd/sonda/internal/images"
"codeberg.org/squidd/sonda/internal/jobs"
"codeberg.org/squidd/sonda/internal/storage"
)
type fakeJob struct {
started []bool
err error
running bool
stopped int
status jobs.Status
}
func (f *fakeJob) Start(refresh bool) error {
if f.err != nil {
return f.err
}
f.started = append(f.started, refresh)
return nil
}
func (f *fakeJob) Stop() bool { f.stopped++; return f.running }
func (f *fakeJob) Status() jobs.Status { return f.status }
// jobCase is one of the jobs that go through the library: they all behave the same.
type jobCase struct {
name string
path string
running string // the error code when it is already running
keys []string // the counters of a summary
count string // the key of the outcomes the test fills in
outcome string // the outcome that this key counts
set func(*Deps, jobService)
}
var jobCases = []jobCase{
{"covers", "/api/v1/library/covers", "covers_job_running",
[]string{"checked", "from_files", "from_archive", "none", "skipped", "failed", "stopped"},
"from_files", images.OutcomeFromFiles, func(d *Deps, j jobService) { d.CoversJob = j }},
{"artist images", "/api/v1/library/artist-images", "artist_images_job_running",
[]string{"checked", "found", "none", "skipped", "failed", "stopped"},
"found", images.OutcomeFound, func(d *Deps, j jobService) { d.ArtistImagesJob = j }},
{"descriptions", "/api/v1/library/descriptions", "descriptions_job_running",
[]string{"checked", "found", "none", "skipped", "failed", "stopped"},
"found", images.OutcomeFound, func(d *Deps, j jobService) { d.DescriptionsJob = j }},
}
func newJobAPI(t *testing.T, jc jobCase) (http.Handler, *fakeJob, string, string) {
t.Helper()
fake := &fakeJob{}
h, _ := newTestEnvDB(t, func(d *Deps, _ *bun.DB) { jc.set(d, fake) })
admin := registerAndLogin(t, h)
// A second user who is not an admin.
cred := map[string]any{"email": "bob@example.org", "password": "longenough"}
if r := do(t, h, "POST", "/api/v1/users", admin, cred); r.Code != http.StatusCreated {
t.Fatalf("create bob: %d %v", r.Code, r.Body)
}
bob, _ := do(t, h, "POST", "/api/v1/auth/login", "", cred).Body["access_token"].(string)
return h, fake, admin, bob
}
func eachJob(t *testing.T, f func(t *testing.T, jc jobCase)) {
for _, jc := range jobCases {
t.Run(jc.name, func(t *testing.T) { f(t, jc) })
}
}
func TestOnlyAnAdminStartsOrStopsAJob(t *testing.T) {
eachJob(t, func(t *testing.T, jc jobCase) {
h, fake, admin, bob := newJobAPI(t, jc)
for _, m := range []string{"POST", "DELETE"} {
if r := do(t, h, m, jc.path, "", nil); r.Code != http.StatusUnauthorized {
t.Errorf("%s without a token: %d", m, r.Code)
}
if r := do(t, h, m, jc.path, bob, nil); r.Code != http.StatusForbidden || errCode(r) != "admin_required" {
t.Errorf("%s as a user: %d %v", m, r.Code, r.Body)
}
}
if len(fake.started) != 0 || fake.stopped != 0 {
t.Error("something was started or stopped by someone who is not an admin")
}
if r := do(t, h, "GET", jc.path, "", nil); r.Code != http.StatusUnauthorized {
t.Errorf("status without a token: %d", r.Code)
}
if r := do(t, h, "GET", jc.path, bob, nil); r.Code != http.StatusOK {
t.Errorf("status for a user (like the scan status): %d", r.Code)
}
if r := do(t, h, "POST", jc.path, admin, nil); r.Code != http.StatusAccepted || r.Body["status"] != "started" {
t.Errorf("start: %d %v", r.Code, r.Body)
}
})
}
func TestAJobTakesAStrictRefreshParameter(t *testing.T) {
eachJob(t, func(t *testing.T, jc jobCase) {
h, fake, admin, _ := newJobAPI(t, jc)
for q, want := range map[string]bool{"": false, "?refresh=false": false, "?refresh=true": true} {
if r := do(t, h, "POST", jc.path+q, admin, nil); r.Code != http.StatusAccepted {
t.Fatalf("%q: %d %v", q, r.Code, r.Body)
}
if got := fake.started[len(fake.started)-1]; got != want {
t.Errorf("%q: refresh = %v, want %v", q, got, want)
}
}
n := len(fake.started)
for _, q := range []string{"?refresh=yes", "?refresh=1", "?refresh=true&refresh=false", "?refresh="} {
if r := do(t, h, "POST", jc.path+q, admin, nil); r.Code != http.StatusBadRequest || errCode(r) != "invalid_input" {
t.Errorf("%q: %d %v, want 400", q, r.Code, r.Body)
}
}
if len(fake.started) != n {
t.Error("a request that was refused started a job")
}
})
}
func TestAJobIsOneAtATime(t *testing.T) {
eachJob(t, func(t *testing.T, jc jobCase) {
h, fake, admin, _ := newJobAPI(t, jc)
fake.err = jobs.ErrRunning
if r := do(t, h, "POST", jc.path, admin, nil); r.Code != http.StatusConflict || errCode(r) != jc.running {
t.Errorf("%d %v, want 409 %s", r.Code, r.Body, jc.running)
}
})
}
func TestStoppingAJobIsAlwaysFine(t *testing.T) {
eachJob(t, func(t *testing.T, jc jobCase) {
h, fake, admin, _ := newJobAPI(t, jc)
for _, running := range []bool{true, false} {
fake.running = running
if r := do(t, h, "DELETE", jc.path, admin, nil); r.Code != http.StatusNoContent {
t.Errorf("running=%v: %d %v", running, r.Code, r.Body)
}
}
if fake.stopped != 2 {
t.Errorf("stopped %d times", fake.stopped)
}
})
}
func TestTheStatusOfAJobSaysWhatItIsDoingAndHowTheLastOneEnded(t *testing.T) {
eachJob(t, func(t *testing.T, jc jobCase) {
h, fake, admin, _ := newJobAPI(t, jc)
r := do(t, h, "GET", jc.path, admin, nil)
if r.Code != http.StatusOK || r.Body["running"] != false {
t.Fatalf("idle: %d %v", r.Code, r.Body)
}
sameKeys(t, "idle status", r.Body, "running")
started := time.Date(2026, 11, 12, 10, 0, 0, 0, time.UTC)
fake.status = jobs.Status{Running: true, StartedAt: started, Progress: &jobs.Progress{Done: 3, Total: 10}}
r = do(t, h, "GET", jc.path, admin, nil)
sameKeys(t, "running status", r.Body, "running", "started_at", "progress")
p, _ := r.Body["progress"].(map[string]any)
if r.Body["running"] != true || r.Body["started_at"] != "2026-11-12T10:00:00Z" || p["done"] != float64(3) || p["total"] != float64(10) {
t.Errorf("running = %v", r.Body)
}
fake.status = jobs.Status{StartedAt: started, LastFinishedAt: started.Add(time.Minute), LastError: "gave up after 5 in a row failed",
Last: &jobs.Summary{Checked: 7, Failed: 5, Skipped: 1, Outcomes: map[string]int{jc.outcome: 1}}}
r = do(t, h, "GET", jc.path, admin, nil)
sameKeys(t, "finished status", r.Body, "running", "started_at", "last_finished_at", "last", "last_error")
last, _ := r.Body["last"].(map[string]any)
sameKeys(t, "last", last, jc.keys...)
if last["checked"] != float64(7) || last["failed"] != float64(5) || last["skipped"] != float64(1) || last["stopped"] != false ||
last[jc.count] != float64(1) || r.Body["last_error"] == "" {
t.Errorf("last = %v", r.Body)
}
})
}
// With the real job on the real stack: the albums of a library get their covers.
func TestTheCoversJobBuildsTheCoversOfTheLibrary(t *testing.T) {
e := newCoversEnv(t) // "With Art" has a cover.jpg in its folder, "Without" has nothing
repo := storage.NewImageRepo(e.db)
job := images.NewCoversJob(e.svc, repo)
if err := job.Start(t.Context(), jobs.Options{}); err != nil {
t.Fatal(err)
}
deadline := time.Now().Add(20 * time.Second)
for job.Status().Running {
if time.Now().After(deadline) {
t.Fatal("the job did not finish")
}
time.Sleep(10 * time.Millisecond)
}
st := job.Status()
if st.Last == nil || st.Last.Checked != 2 || st.Last.Outcomes[images.OutcomeFromFiles] != 1 || st.Last.Outcomes[images.OutcomeNone] != 1 {
t.Errorf("last = %+v, want two albums: one cover from the files, one with none", st.Last)
}
// The cover is there without anybody having asked for it.
if rec, ok, _ := repo.Get(t.Context(), "album", e.withArt); !ok || rec.Status != images.StatusOK {
t.Errorf("record of the album with a picture: %+v ok=%v", rec, ok)
}
}