Files
archie/internal/webui/api_tasks_attempts_test.go
T
sam e7b21b9e5d feat(state-store): ListSteps, dashboard run detail reads it; drop tasks.stage
docs/prds/execution-tree-state-machine.md: step_executions (0017) is now the
durable per-step record; the dashboard's run detail (GET /api/tasks/{id}/
attempts) still folded stage_start/stage_finish events into a rail by hand,
and tasks.stage duplicated what StartStep/FinishStep already record properly.

Added the missing read:
- ListSteps(execution_id, attempt) -- attempt 0 lists every attempt of the
  execution, oldest first, so the rail renders every attempt from one call.
  New storecontract.StepReader (separate from StepRecorder: this is a
  dashboard/API/dispatch action per the PRD's wire contract, never
  task-scoped-grant callable), postgresdb.ListStepExecutions, staterpc
  client/server/values.go plumbing, wired through state_store.go's Deps and
  archieui/compose.go's Server.Steps the same optional-capability pattern
  every other dashboard read uses.
- internal/webui/api_tasks_attempts.go: stageViewsFromSteps replaces
  foldStages/finishStage/stageOutcome. Attempt bounds, event_count and which
  attempt numbers exist stay sourced from events (an attempt can carry
  events -- agent calls -- with no step), only the stage list itself moves.
  The wire JSON contract is unchanged, so no frontend change was needed;
  `task ui` confirms ui/dist still matches a fresh build.
- A running step past the task's own current attempt reads interrupted, not
  running: RecoverStale (archie-core, still open per #1214) is what corrects
  a crashed run's stale "running" row, and until it does this is the honest
  read rather than trusting a row that may be stale.

Dropped tasks.stage and every reader, no fallback:
- Migration 0018 drops the column; tasks.sql's INSERT/UPDATE/RETURNING lists
  and the sqlc-generated code no longer carry it.
- workflow.Task.Stage is gone; workflow.Run's in-flight "which stage is this"
  bookkeeping moves to TaskContext.Stage (execution-time only, never
  persisted -- park/finish's event tagging is its only reader).
- pb.Task.stage (wire field 10) is `[deprecated = true]`, not deleted (never
  reuse a field number); staterpc's taskProto/taskValue no longer map it.
- taskactions.Task.Stage and the retry event's "previous_stage" data field
  are gone: the operator-action package had no reader for the column beyond
  echoing it.
- The chat /tasks command's per-task "workflow/stage" display drops to
  workflow-only (ChatTaskSummary.Stage removed, workflowStage() deleted):
  it was a genuine reader with no replacement in scope for this change.

Read the archie-web-ui skill and the state-store/daemon docs/development
pages first, per instruction. Stayed out of cancel/stop code throughout
(Pi's concurrent CancelExecution work); the only shared files touched
(workflow.go, daemon-adjacent SQL) got the smallest possible diff.
2026-09-27 06:57:47 +10:00

584 lines
23 KiB
Go

package webui
import (
"context"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"strconv"
"strings"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/taskstate"
)
// stepWriter is StepRecorder, asserted against srv.Store here rather than
// widened onto storecontract.TaskStore: the dashboard never writes a step
// itself, only reads them (Server.Steps, storecontract.StepReader), and this
// test needs real rows to exercise the read against.
type stepWriter interface {
StartStep(ctx context.Context, s task.StepStart) (int64, events.Event, error)
FinishStep(ctx context.Context, s task.StepFinish) (events.Event, error)
}
// railBase is the fixed clock the rail fixtures hang off, so every timestamp
// and duration asserted below is a literal rather than a tolerance.
var railBase = time.Date(2026, 9, 18, 7, 0, 0, 0, time.UTC)
// attemptEvent stands in for the events that still drive attempt bounds and
// counts (attemptsFromEvents), independent of the stage rail those events
// used to also back.
func attemptEvent(taskID int64, attempt int, at time.Time) events.Event {
return events.Event{Kind: events.KindAgentFinish, TaskID: taskID, Attempt: attempt, At: at}
}
func insertTaskEvent(t *testing.T, srv *Server, ev events.Event) {
t.Helper()
if _, err := srv.Store.InsertEvent(t.Context(), ev); err != nil {
t.Fatalf("insert %s event: %v", ev.Kind, err)
}
}
// stageStep is a fixture StepExecution the pure-function test builds by
// hand -- no store round trip, since stageViewsFromSteps operates on
// task.StepExecution values directly.
func stageStep(name string, attempt int, status taskstate.StepStatus, startedAt, finishedAt time.Time, detail string) task.StepExecution {
return task.StepExecution{
Attempt: attempt, Kind: task.StepKindStage, Name: name, Status: status,
StartedAt: startedAt, FinishedAt: finishedAt, Detail: detail,
}
}
// getTaskAPI issues one task-detail request through the real mux. A route that
// is not registered falls through to the SPA asset handler and answers 200 with
// an HTML page, so using the mux makes a missing registration fail the shape
// assertions below rather than passing quietly.
func getTaskAPI(t *testing.T, srv *Server, url string) *httptest.ResponseRecorder {
t.Helper()
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, url, nil)
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
return w
}
func taskRoute(id int64, suffix string) string {
return "/api/tasks/" + strconv.FormatInt(id, 10) + suffix
}
// twoAttemptTask drives one task through the lifecycle the rail has to read:
// claim (attempt 1), park, retry, claim (attempt 2), leaving the task running
// on its second attempt. No test writes an attempt number directly, so the
// attempt under test is the one the real lifecycle produced.
func twoAttemptTask(t *testing.T, srv *Server) *workflow.Task {
t.Helper()
ctx := t.Context()
if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 1, "task", "", "", ""); err != nil {
t.Fatal(err)
}
first, err := srv.Store.ClaimNext(ctx)
if err != nil {
t.Fatal(err)
}
if first == nil {
t.Fatal("ClaimNext returned no task")
}
if first.Attempt != 1 {
t.Fatalf("first claim attempt = %d, want 1", first.Attempt)
}
if err := srv.Store.Transition(ctx, first.ID, workflow.StatusRunning, workflow.StatusParked, "stage implement: builder exited 1"); err != nil {
t.Fatal(err)
}
if err := srv.Store.RetryTask(ctx, first.ID, workflow.StatusParked, ""); err != nil {
t.Fatal(err)
}
second, err := srv.Store.ClaimNext(ctx)
if err != nil {
t.Fatal(err)
}
if second == nil {
t.Fatal("second claim returned no task")
}
if second.Attempt != 2 || second.Status != workflow.StatusRunning {
t.Fatalf("second claim = attempt %d status %q, want attempt 2 running", second.Attempt, second.Status)
}
return second
}
// summarizeAttemptRail renders a folded rail as one line per attempt so a table
// case states the derivation it expects without a struct literal per stage:
// "attempt:status[name:status:duration[#error][@nostart],...] duration".
func durationToken(ms *int64) string {
if ms == nil {
return "?"
}
return strconv.FormatInt(*ms, 10)
}
// summarizeStages renders a stage list the same way summarizeAttemptRail's
// inner loop does, for a test that exercises stageViewsFromSteps alone.
func summarizeStages(stages []taskStageView) string {
tokens := make([]string, 0, len(stages))
for _, s := range stages {
token := s.Name + ":" + s.Status + ":" + durationToken(s.DurationMS)
if s.StartedAt == nil {
token += "@nostart"
}
if s.Error != "" {
token += "#" + s.Error
}
tokens = append(tokens, token)
}
return strings.Join(tokens, ",")
}
// TestStageViewsFromStepsDerivesEveryRailRule is the table behind R1: every
// status rule the rail depends on, sourced from StepExecutions -- the
// authoritative record (docs/prds/execution-tree-state-machine.md) -- rather
// than a fold over stage_start/stage_finish events.
func TestStageViewsFromStepsDerivesEveryRailRule(t *testing.T) {
at := railBase.Add
tests := []struct {
name string
steps []task.StepExecution
inFlight bool
want string
}{
{
name: "a succeeded step is ok and reports its measured span",
steps: []task.StepExecution{stageStep("prepare", 1, taskstate.StepSucceeded, at(0), at(time.Second), "")},
want: "prepare:ok:1000",
},
{
name: "a failed step fails and carries its detail as the error",
steps: []task.StepExecution{stageStep("implement", 1, taskstate.StepFailed, at(0), at(2*time.Second), "builder exited 1")},
want: "implement:failed:2000#builder exited 1",
},
{
name: "a cancelled step reads interrupted",
steps: []task.StepExecution{stageStep("implement", 1, taskstate.StepCancelled, at(0), at(time.Second), "stopped by operator")},
want: "implement:interrupted:1000",
},
{
name: "an interrupted step reads interrupted",
steps: []task.StepExecution{stageStep("implement", 1, taskstate.StepInterrupted, at(0), at(time.Second), "")},
want: "implement:interrupted:1000",
},
{
name: "a running step on the task's current in-flight attempt is running",
steps: []task.StepExecution{stageStep("implement", 2, taskstate.StepRunning, at(0), time.Time{}, "")},
inFlight: true,
want: "implement:running:?",
},
{
name: "a running step past the task's live attempt is stale, read as interrupted",
steps: []task.StepExecution{stageStep("implement", 1, taskstate.StepRunning, at(0), time.Time{}, "")},
inFlight: false,
want: "implement:interrupted:?",
},
{
name: "a pending step (never observed in practice) reads unknown rather than a false verdict",
steps: []task.StepExecution{stageStep("implement", 1, taskstate.StepPending, time.Time{}, time.Time{}, "")},
want: "implement:unknown:?@nostart",
},
{
name: "a repeated stage name yields one rail entry per occurrence",
steps: []task.StepExecution{
stageStep("implement", 1, taskstate.StepSucceeded, at(0), at(time.Second), ""),
{Attempt: 1, Kind: task.StepKindStage, Name: "implement", Status: taskstate.StepRunning, StartedAt: at(2 * time.Second)},
},
inFlight: true,
want: "implement:ok:1000,implement:running:?",
},
{
name: "an agent or call step is not part of the stage rail",
steps: []task.StepExecution{
stageStep("implement", 1, taskstate.StepSucceeded, at(0), at(time.Second), ""),
{Attempt: 1, Kind: task.StepKindAgent, Name: "implement", Status: taskstate.StepSucceeded, StartedAt: at(0), FinishedAt: at(time.Second)},
{Attempt: 1, Kind: task.StepKindCall, Name: "callee", Status: taskstate.StepSucceeded, StartedAt: at(0), FinishedAt: at(time.Second)},
},
want: "implement:ok:1000",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := summarizeStages(stageViewsFromSteps(tt.steps, tt.inFlight)); got != tt.want {
t.Errorf("stages = %q, want %q", got, tt.want)
}
})
}
}
// TestAttemptsFromEventsIndexesAttemptsFromEventsAndUnattributedCount pins
// what attemptsFromEvents still owns now that stage derivation moved to
// steps: which attempt numbers exist, and the unattributed-event count --
// both read from the task's events, since an attempt can carry events (agent
// calls, say) with no recorded step at all.
func TestAttemptsFromEventsIndexesAttemptsFromEventsAndUnattributedCount(t *testing.T) {
at := railBase.Add
tests := []struct {
name string
taskStatus string
currentAttempt int
evs []events.Event
steps []task.StepExecution
wantAttempts []int
wantUnattributed int
}{
{
name: "a later attempt does not absorb the earlier attempt's steps",
taskStatus: workflow.StatusRunning, currentAttempt: 2,
evs: []events.Event{attemptEvent(1, 1, at(0)), attemptEvent(1, 2, at(time.Second))},
steps: []task.StepExecution{stageStep("prepare", 1, taskstate.StepSucceeded, at(0), at(time.Second), "")},
wantAttempts: []int{1, 2},
},
{
name: "events carrying no attempt are counted, never grouped",
taskStatus: workflow.StatusQueued, currentAttempt: 0,
evs: []events.Event{{Kind: events.KindAgentFinish, TaskID: 1, At: at(0)}, {Kind: events.KindAgentFinish, TaskID: 1, At: at(time.Second)}},
wantUnattributed: 2,
},
{
name: "a task with no events has no attempts and nothing unattributed",
taskStatus: workflow.StatusQueued, currentAttempt: 0,
},
{
name: "an attempt with events but no recorded step still appears, with no stages",
taskStatus: workflow.StatusParked, currentAttempt: 1,
evs: []events.Event{attemptEvent(1, 1, at(0))},
wantAttempts: []int{1},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
attempts, unattributed := attemptsFromEvents(tt.evs, tt.steps, tt.taskStatus, tt.currentAttempt)
var got []int
for _, a := range attempts {
got = append(got, a.Attempt)
}
if len(got) != len(tt.wantAttempts) {
t.Fatalf("attempts = %v, want %v", got, tt.wantAttempts)
}
for i, want := range tt.wantAttempts {
if got[i] != want {
t.Errorf("attempts = %v, want %v", got, tt.wantAttempts)
}
}
if unattributed != tt.wantUnattributed {
t.Errorf("unattributed = %d, want %d", unattributed, tt.wantUnattributed)
}
})
}
}
// TestHandleTaskAttemptsRendersBothAttemptsOfARetry pins the wire shape: an
// attempt's ordered stages with name, start time, duration, terminal status and
// error text, the task's current attempt, and attempt 1's rail excluding
// attempt 2's stages.
func TestHandleTaskAttemptsRendersBothAttemptsOfARetry(t *testing.T) {
srv := newTestServer(t)
ctx := t.Context()
steps, ok := srv.Store.(stepWriter)
if !ok {
t.Fatal("test store does not implement stepWriter")
}
// Not twoAttemptTask: StartStep guards on the execution's own current
// attempt (a step named for a superseded attempt is a stale transition
// by design -- steps.go, "a caller naming one the execution no longer
// runs is describing a run that is over"), so attempt 1's steps have to
// be recorded while the task is actually on attempt 1, before the retry
// that moves it to attempt 2.
if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 1, "task", "", "", ""); err != nil {
t.Fatal(err)
}
claimed1, err := srv.Store.ClaimNext(ctx)
if err != nil || claimed1 == nil || claimed1.Attempt != 1 {
t.Fatalf("ClaimNext = (%+v, %v), want attempt 1", claimed1, err)
}
prepareID, _, err := steps.StartStep(ctx, task.StepStart{ExecutionID: claimed1.ID, Attempt: 1, Kind: task.StepKindStage, Name: "prepare"})
if err != nil {
t.Fatalf("StartStep prepare: %v", err)
}
if _, err := steps.FinishStep(ctx, task.StepFinish{
StepID: prepareID, ExecutionID: claimed1.ID, From: taskstate.StepRunning, To: taskstate.StepSucceeded,
}); err != nil {
t.Fatalf("FinishStep prepare: %v", err)
}
implementID, _, err := steps.StartStep(ctx, task.StepStart{ExecutionID: claimed1.ID, Attempt: 1, Kind: task.StepKindStage, Name: "implement"})
if err != nil {
t.Fatalf("StartStep implement: %v", err)
}
if _, err := steps.FinishStep(ctx, task.StepFinish{
StepID: implementID, ExecutionID: claimed1.ID, From: taskstate.StepRunning, To: taskstate.StepFailed,
Detail: "stage implement: builder exited 1",
}); err != nil {
t.Fatalf("FinishStep implement: %v", err)
}
if err := srv.Store.Transition(ctx, claimed1.ID, workflow.StatusRunning, workflow.StatusParked, "stage implement: builder exited 1"); err != nil {
t.Fatal(err)
}
if err := srv.Store.RetryTask(ctx, claimed1.ID, workflow.StatusParked, ""); err != nil {
t.Fatal(err)
}
current, err := srv.Store.ClaimNext(ctx)
if err != nil || current == nil || current.Attempt != 2 {
t.Fatalf("second ClaimNext = (%+v, %v), want attempt 2", current, err)
}
if _, _, err := steps.StartStep(ctx, task.StepStart{ExecutionID: current.ID, Attempt: 2, Kind: task.StepKindStage, Name: "implement"}); err != nil {
t.Fatalf("StartStep attempt 2 implement: %v", err)
}
// No hand-inserted events: StartStep/FinishStep already write
// stage_start/stage_finish events in the same transaction as the step
// row (steps.go), which is what attemptBounds and event_count read --
// attempt 1 gets exactly the 4 those two StartStep+FinishStep pairs
// produce, attempt 2 the 1 its lone StartStep produces. Their
// timestamps are the store's own clock, so bounds are checked for
// presence and order below rather than against a literal railBase time.
w := getTaskAPI(t, srv, taskRoute(current.ID, "/attempts"))
if w.Code != http.StatusOK {
t.Fatalf("status = %d, body %s", w.Code, w.Body)
}
if raw := w.Body.String(); !strings.Contains(raw, `"error":""`) {
t.Errorf("body = %s, want the ok stage's error field present and empty rather than omitted", raw)
}
var body struct {
TaskID int64 `json:"task_id"`
CurrentAttempt int `json:"current_attempt"`
UnattributedEvents int `json:"unattributed_events"`
Attempts []struct {
Attempt int `json:"attempt"`
Status string `json:"status"`
StartedAt *time.Time `json:"started_at"`
FinishedAt *time.Time `json:"finished_at"`
DurationMS *int64 `json:"duration_ms"`
EventCount int `json:"event_count"`
Stages []struct {
Name string `json:"name"`
Seq int `json:"seq"`
Status string `json:"status"`
StartedAt *time.Time `json:"started_at"`
DurationMS *int64 `json:"duration_ms"`
Error string `json:"error"`
} `json:"stages"`
} `json:"attempts"`
}
if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil {
t.Fatalf("decode response: %v (%s)", err, w.Body)
}
if body.TaskID != current.ID || body.CurrentAttempt != 2 || body.UnattributedEvents != 0 {
t.Fatalf("envelope = task %d, current attempt %d, unattributed %d; want %d, 2, 0",
body.TaskID, body.CurrentAttempt, body.UnattributedEvents, current.ID)
}
if len(body.Attempts) != 2 {
t.Fatalf("attempts = %d, want 2 (%s)", len(body.Attempts), w.Body)
}
first := body.Attempts[0]
if first.Attempt != 1 || first.Status != "failed" {
t.Errorf("attempt 1 = %d/%q, want 1/failed", first.Attempt, first.Status)
}
if first.EventCount != 4 {
t.Errorf("attempt 1 event_count = %d, want 4", first.EventCount)
}
// StartStep/FinishStep stamp their events with the store's own clock, so
// only presence, order and non-negativity are checked here.
if first.StartedAt == nil || first.FinishedAt == nil || first.FinishedAt.Before(*first.StartedAt) {
t.Errorf("attempt 1 bounds = started %v finished %v, want finished not before started", first.StartedAt, first.FinishedAt)
}
if first.DurationMS == nil || *first.DurationMS < 0 {
t.Errorf("attempt 1 duration_ms = %v, want a non-negative measured span", first.DurationMS)
}
if len(first.Stages) != 2 {
t.Fatalf("attempt 1 stages = %d, want 2 (%s)", len(first.Stages), w.Body)
}
prepare := first.Stages[0]
if prepare.Name != "prepare" || prepare.Seq != 0 || prepare.Status != "ok" || prepare.Error != "" {
t.Errorf("stage 0 = %+v, want prepare/0/ok with no error", prepare)
}
// StartStep/FinishStep stamp started_at/finished_at with the store's own
// clock (now()), not a caller-supplied time, so only their presence and
// non-negativity are checked here -- railBase no longer applies to a step
// row the way it did to a hand-inserted event.
if prepare.StartedAt == nil || prepare.DurationMS == nil || *prepare.DurationMS < 0 {
t.Errorf("stage 0 = %+v, want a recorded start and a non-negative duration", prepare)
}
implement := first.Stages[1]
if implement.Name != "implement" || implement.Seq != 1 || implement.Status != "failed" {
t.Errorf("stage 1 = %+v, want implement/1/failed", implement)
}
if implement.Error != "stage implement: builder exited 1" {
t.Errorf("stage 1 error = %q, want the recorded error text", implement.Error)
}
if implement.DurationMS == nil || *implement.DurationMS < 0 {
t.Errorf("stage 1 duration_ms = %v, want a non-negative measured duration", implement.DurationMS)
}
second := body.Attempts[1]
if second.Attempt != 2 || second.Status != "running" || second.EventCount != 1 {
t.Errorf("attempt 2 = %d/%q with %d events, want 2/running with 1", second.Attempt, second.Status, second.EventCount)
}
if second.FinishedAt != nil || second.DurationMS != nil {
t.Errorf("attempt 2 finished_at = %v, duration_ms = %v; both must be omitted for a running attempt",
second.FinishedAt, second.DurationMS)
}
if len(second.Stages) != 1 || second.Stages[0].Name != "implement" || second.Stages[0].Status != "running" {
t.Fatalf("attempt 2 stages = %+v, want one running implement", second.Stages)
}
if second.Stages[0].Error != "" {
t.Errorf("attempt 2 stage error = %q, want empty", second.Stages[0].Error)
}
}
// TestHandleTaskAttemptsSeparatesUnattributedEventsFromAFirstRun pins the
// honesty requirement: events that carry no attempt cannot be presented as
// attempt 1, and a task with nothing recorded at all is a different answer from
// a task whose events predate attribution.
func TestHandleTaskAttemptsSeparatesUnattributedEventsFromAFirstRun(t *testing.T) {
t.Run("a task with no events at all", func(t *testing.T) {
srv := newTestServer(t)
if _, err := srv.Store.EnqueueIssue(t.Context(), "acme", "widget", 1, "task", "", "", ""); err != nil {
t.Fatal(err)
}
task, err := srv.Store.TaskByIssue(t.Context(), "acme", "widget", 1)
if err != nil {
t.Fatal(err)
}
w := getTaskAPI(t, srv, taskRoute(task.ID, "/attempts"))
if w.Code != http.StatusOK {
t.Fatalf("status = %d, body %s", w.Code, w.Body)
}
raw := w.Body.String()
if !strings.Contains(raw, `"attempts":[]`) {
t.Errorf("body = %s, want an empty attempts array rather than null", raw)
}
if !strings.Contains(raw, `"unattributed_events":0`) {
t.Errorf("body = %s, want unattributed_events 0 for a task with nothing recorded", raw)
}
})
t.Run("events that carry no attempt", func(t *testing.T) {
srv := newTestServer(t)
if _, err := srv.Store.EnqueueIssue(t.Context(), "acme", "widget", 1, "task", "", "", ""); err != nil {
t.Fatal(err)
}
task, err := srv.Store.TaskByIssue(t.Context(), "acme", "widget", 1)
if err != nil {
t.Fatal(err)
}
insertTaskEvent(t, srv, attemptEvent(task.ID, 0, railBase))
insertTaskEvent(t, srv, attemptEvent(task.ID, 0, railBase.Add(time.Second)))
w := getTaskAPI(t, srv, taskRoute(task.ID, "/attempts"))
if w.Code != http.StatusOK {
t.Fatalf("status = %d, body %s", w.Code, w.Body)
}
var body struct {
UnattributedEvents int `json:"unattributed_events"`
Attempts []struct {
Attempt int `json:"attempt"`
} `json:"attempts"`
}
if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil {
t.Fatalf("decode response: %v (%s)", err, w.Body)
}
if body.UnattributedEvents != 2 {
t.Errorf("unattributed_events = %d, want 2", body.UnattributedEvents)
}
if len(body.Attempts) != 0 {
t.Errorf("attempts = %+v, want none: events carrying no attempt must never be presented as a run", body.Attempts)
}
})
}
// TestTaskDetailRoutesRejectUnknownTasksAndStoreFailures keeps the three new
// reads on the existing task-route conventions: an unknown task is 404 plain
// text (never 200 with an empty body), a store failure is 500, and a
// non-numeric id is 400.
func TestTaskDetailRoutesRejectUnknownTasksAndStoreFailures(t *testing.T) {
base := newTestServer(t)
if _, err := base.Store.EnqueueIssue(t.Context(), "acme", "widget", 1, "task", "", "", ""); err != nil {
t.Fatal(err)
}
existing, err := base.Store.TaskByIssue(t.Context(), "acme", "widget", 1)
if err != nil {
t.Fatal(err)
}
eventsBroken := &Server{
Store: &stubStore{TaskStore: base.Store, taskEventsErr: fmt.Errorf("db locked")},
Log: base.Log,
}
lookupBroken := &Server{
Store: &stubStore{TaskStore: base.Store, taskByIDErr: fmt.Errorf("db locked")},
Log: base.Log,
}
tests := []struct {
name string
srv *Server
id int64
suffix string
wantStatus int
}{
{"attempts unknown task", base, 999, "/attempts", http.StatusNotFound},
{"changes unknown task", base, 999, "/changes", http.StatusNotFound},
{"debug unknown task", base, 999, "/debug", http.StatusNotFound},
{"attempts events failure", eventsBroken, existing.ID, "/attempts", http.StatusInternalServerError},
{"changes events failure", eventsBroken, existing.ID, "/changes", http.StatusInternalServerError},
{"debug events failure", eventsBroken, existing.ID, "/debug", http.StatusInternalServerError},
{"attempts lookup failure", lookupBroken, existing.ID, "/attempts", http.StatusInternalServerError},
{"changes lookup failure", lookupBroken, existing.ID, "/changes", http.StatusInternalServerError},
{"debug lookup failure", lookupBroken, existing.ID, "/debug", http.StatusInternalServerError},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
w := getTaskAPI(t, tt.srv, taskRoute(tt.id, tt.suffix))
if w.Code != tt.wantStatus {
t.Errorf("GET %s = %d (%s), want %d", tt.suffix, w.Code, w.Body, tt.wantStatus)
}
})
}
for _, suffix := range []string{"/attempts", "/changes", "/debug"} {
t.Run("non-numeric id "+suffix, func(t *testing.T) {
w := getTaskAPI(t, base, "/api/tasks/not-a-number"+suffix)
if w.Code != http.StatusBadRequest {
t.Errorf("GET %s = %d (%s), want 400", suffix, w.Code, w.Body)
}
})
}
// The attempt parameter belongs to the per-attempt reads: /attempts returns
// every attempt of the task, so it does not consume the parameter at all,
// while /changes and /debug resolve it and must refuse a value that is not
// an attempt number rather than silently read the current one.
t.Run("non-numeric attempt on /attempts is not a parameter of that read", func(t *testing.T) {
w := getTaskAPI(t, base, taskRoute(existing.ID, "/attempts?attempt=later"))
if w.Code != http.StatusOK {
t.Errorf("GET /attempts?attempt=later = %d (%s), want 200", w.Code, w.Body)
}
})
for _, suffix := range []string{"/changes", "/debug"} {
t.Run("non-numeric attempt "+suffix, func(t *testing.T) {
w := getTaskAPI(t, base, taskRoute(existing.ID, suffix+"?attempt=later"))
if w.Code != http.StatusBadRequest {
t.Errorf("GET %s?attempt=later = %d (%s), want 400", suffix, w.Code, w.Body)
}
})
}
}