Files
archie/internal/infrastructure/postgres/steps_test.go
T
sam 5de07fac0e feat(pr-review): operator/chat trigger queues a pr-review task
review_pr self-omitted since 625ead95 deleted the synchronous reviewer it
called. It is rebuilt on the task enqueue path everything else uses: the
tool resolves the identity's configured repo, then queues a pr-review task
naming the pull request through the workflow's declared pr_number input,
which is the same generic input mechanism a watched-repos binding uses.

That input has to reach the store with the task, so
EnqueueChatTaskRequest gains inputs_json and the tasks insert writes the
inputs column directly. StampTaskBinding no longer writes it: the insert is
now the column's only writer, and a chat task must not acquire binding
provenance just to carry an input.

ChatPRReviewer, its result shape and the reviewer wiring are deleted with
the path they served.
2026-09-28 18:24:36 +10:00

315 lines
11 KiB
Go

package postgres
import (
"errors"
"testing"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/domain/workflow"
task "github.com/samcharles93/archie-core/internal/domain/workflow/task"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/taskstate"
)
// The step-execution writes (docs/prds/execution-tree-state-machine.md): each
// of StartStep and FinishStep is one transaction -- guarded row write plus the
// domain event row -- under the step transition table, with the execution's
// own status gating whether a step may run at all.
// runningExecution enqueues and claims one task, the state a step runs in.
func runningExecution(t *testing.T, s *Store) *workflow.Task {
t.Helper()
seed, err := s.EnqueueChatTask(t.Context(), "acme", "widgets", "t", "b", "implement", "", nil)
if err != nil || seed == nil {
t.Fatalf("EnqueueChatTask: %+v %v", seed, err)
}
claimed, err := s.ClaimNext(t.Context())
if err != nil || claimed == nil {
t.Fatalf("ClaimNext: %+v %v", claimed, err)
}
return claimed
}
func TestStartStepRecordsAStageEnteringRunning(t *testing.T) {
s := storeFor(t)
execution := runningExecution(t, s)
stepID, startEvent, err := s.StartStep(t.Context(), task.StepStart{
ExecutionID: execution.ID, Attempt: execution.Attempt, Kind: task.StepKindStage, Name: "implement",
})
if err != nil {
t.Fatalf("StartStep: %v", err)
}
if startEvent.Kind != events.KindStageStart || startEvent.Stage != "implement" ||
startEvent.TaskID != execution.ID || startEvent.Attempt != execution.Attempt ||
startEvent.Repo != "acme/widgets" || startEvent.ID == 0 {
t.Fatalf("stage_start event = %+v, want the transition's row", startEvent)
}
eventsForTask, err := s.TaskEvents(t.Context(), execution.ID)
if err != nil {
t.Fatalf("TaskEvents: %v", err)
}
if n := len(eventsForTask); n != 1 {
t.Fatalf("events after StartStep = %d, want exactly the one the transition wrote", n)
}
step, err := s.FinishStep(t.Context(), task.StepFinish{
StepID: stepID, ExecutionID: execution.ID,
From: taskstate.StepRunning, To: taskstate.StepSucceeded, Detail: "implemented",
})
if err != nil {
t.Fatalf("FinishStep: %v", err)
}
if step.Kind != events.KindStageFinish || step.Stage != "implement" || step.ID == 0 {
t.Fatalf("stage_finish event = %+v, want the transition's row", step)
}
if _, ok := step.Data["duration_ms"]; !ok {
t.Errorf("stage_finish data = %v, want duration_ms: the stage statistics read it", step.Data)
}
if _, has := step.Data["error"]; has {
t.Errorf("stage_finish data = %v, want no error key for a succeeded step", step.Data)
}
}
func TestFinishStepFailedCarriesTheErrorTheDashboardRenders(t *testing.T) {
s := storeFor(t)
execution := runningExecution(t, s)
stepID, _, err := s.StartStep(t.Context(), task.StepStart{
ExecutionID: execution.ID, Attempt: execution.Attempt, Kind: task.StepKindStage, Name: "review",
})
if err != nil {
t.Fatalf("StartStep: %v", err)
}
step, err := s.FinishStep(t.Context(), task.StepFinish{
StepID: stepID, ExecutionID: execution.ID,
From: taskstate.StepRunning, To: taskstate.StepFailed, Detail: "review found 3 findings",
})
if err != nil {
t.Fatalf("FinishStep: %v", err)
}
if step.Data["error"] != "review found 3 findings" {
t.Errorf("stage_finish data = %v, want the error text stageOutcome renders", step.Data)
}
}
func TestStartStepRefusesWhatTheStateMachineForbids(t *testing.T) {
tests := []struct {
name string
seed func(s *Store, taskID int64) error
start task.StepStart
want error
}{
{
name: "an execution that is not running",
start: task.StepStart{Kind: task.StepKindStage, Name: "plan", Attempt: 1},
want: storecontract.ErrIllegalTransition,
},
{
name: "an execution that does not exist",
start: task.StepStart{Kind: task.StepKindStage, Name: "plan", Attempt: 1},
want: storecontract.ErrStaleTransition,
},
{
name: "an attempt the execution no longer runs",
start: task.StepStart{Kind: task.StepKindStage, Name: "plan", Attempt: 99},
want: storecontract.ErrStaleTransition,
},
{
name: "an unknown step kind",
start: task.StepStart{Kind: "quantum", Name: "plan", Attempt: 1},
want: storecontract.ErrInvalidStep,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := storeFor(t)
execution := runningExecution(t, s)
if tt.name == "an execution that is not running" {
// Back on the queue: nothing may run under it. The seed rides
// the legal running->queued edge, not a hand-written pair.
if err := s.Transition(t.Context(), execution.ID, taskstate.Running, taskstate.Queued, "requeue"); err != nil {
t.Fatalf("seed queued: %v", err)
}
}
start := tt.start
start.ExecutionID = execution.ID
if tt.name == "an execution that does not exist" {
start.ExecutionID = execution.ID + 999999
}
if _, _, err := s.StartStep(t.Context(), start); !errors.Is(err, tt.want) {
t.Fatalf("StartStep = %v, want %v", err, tt.want)
}
})
}
}
func TestStartStepUnderATerminalParentIsIllegal(t *testing.T) {
s := storeFor(t)
execution := runningExecution(t, s)
parentID, _, err := s.StartStep(t.Context(), task.StepStart{
ExecutionID: execution.ID, Attempt: execution.Attempt, Kind: task.StepKindStage, Name: "review",
})
if err != nil {
t.Fatalf("StartStep parent: %v", err)
}
if _, err := s.FinishStep(t.Context(), task.StepFinish{
StepID: parentID, ExecutionID: execution.ID,
From: taskstate.StepRunning, To: taskstate.StepSucceeded, Detail: "done",
}); err != nil {
t.Fatalf("FinishStep parent: %v", err)
}
_, _, err = s.StartStep(t.Context(), task.StepStart{
ExecutionID: execution.ID, Attempt: execution.Attempt,
ParentID: parentID, Kind: task.StepKindAgent, Name: "review:2",
})
if !errors.Is(err, storecontract.ErrIllegalTransition) {
t.Fatalf("StartStep under a terminal parent = %v, want ErrIllegalTransition", err)
}
}
func TestStepDepthIsDerivedFromTheParent(t *testing.T) {
s := storeFor(t)
execution := runningExecution(t, s)
parentID, _, err := s.StartStep(t.Context(), task.StepStart{
ExecutionID: execution.ID, Attempt: execution.Attempt, Kind: task.StepKindStage, Name: "implement",
})
if err != nil {
t.Fatalf("StartStep stage: %v", err)
}
childID, _, err := s.StartStep(t.Context(), task.StepStart{
ExecutionID: execution.ID, Attempt: execution.Attempt,
ParentID: parentID, Kind: task.StepKindAgent, Name: "implement",
})
if err != nil {
t.Fatalf("StartStep agent child: %v", err)
}
var depths map[int64]int
if err := s.pool.QueryRow(t.Context(),
`SELECT jsonb_object_agg(id, depth) FROM step_executions WHERE execution_id = $1`,
execution.ID).Scan(&depths); err != nil {
t.Fatalf("read depths: %v", err)
}
if depths[parentID] != 0 || depths[childID] != 1 {
t.Fatalf("depths = %v, want the stage at 0 and its child at 1", depths)
}
}
func TestFinishStepRefusesStaleAndForeign(t *testing.T) {
s := storeFor(t)
execution := runningExecution(t, s)
other := runningExecution(t, s)
stepID, _, err := s.StartStep(t.Context(), task.StepStart{
ExecutionID: execution.ID, Attempt: execution.Attempt, Kind: task.StepKindStage, Name: "plan",
})
if err != nil {
t.Fatalf("StartStep: %v", err)
}
if _, err := s.FinishStep(t.Context(), task.StepFinish{
StepID: stepID, ExecutionID: other.ID,
From: taskstate.StepRunning, To: taskstate.StepSucceeded,
}); !errors.Is(err, storecontract.ErrStaleTransition) {
t.Fatalf("FinishStep naming another execution = %v, want ErrStaleTransition", err)
}
if _, err := s.FinishStep(t.Context(), task.StepFinish{
StepID: stepID, ExecutionID: execution.ID,
From: taskstate.StepSucceeded, To: taskstate.StepFailed,
}); !errors.Is(err, storecontract.ErrStaleTransition) {
t.Fatalf("FinishStep with an untruthful from = %v, want ErrStaleTransition", err)
}
if _, err := s.FinishStep(t.Context(), task.StepFinish{
StepID: stepID, ExecutionID: execution.ID,
From: taskstate.StepRunning, To: taskstate.StepPending,
}); !errors.Is(err, storecontract.ErrIllegalTransition) {
t.Fatalf("FinishStep off-table pair = %v, want ErrIllegalTransition", err)
}
if _, err := s.FinishStep(t.Context(), task.StepFinish{
StepID: stepID + 999999, ExecutionID: execution.ID,
From: taskstate.StepRunning, To: taskstate.StepSucceeded,
}); !errors.Is(err, storecontract.ErrStaleTransition) {
t.Fatalf("FinishStep on a missing step = %v, want ErrStaleTransition", err)
}
}
// TestListStepsOrdersByAttemptThenID is the dashboard run detail's
// authoritative read (docs/prds/execution-tree-state-machine.md): every
// attempt in one call when attempt is 0, one attempt's steps when it names
// one, both ordered oldest first.
func TestListStepsOrdersByAttemptThenID(t *testing.T) {
s := storeFor(t)
execution := runningExecution(t, s)
firstStepID, _, err := s.StartStep(t.Context(), task.StepStart{
ExecutionID: execution.ID, Attempt: execution.Attempt, Kind: task.StepKindStage, Name: "plan",
})
if err != nil {
t.Fatalf("StartStep: %v", err)
}
if _, err := s.FinishStep(t.Context(), task.StepFinish{
StepID: firstStepID, ExecutionID: execution.ID,
From: taskstate.StepRunning, To: taskstate.StepSucceeded, Detail: "planned", TokensUsed: 42,
}); err != nil {
t.Fatalf("FinishStep: %v", err)
}
secondStepID, _, err := s.StartStep(t.Context(), task.StepStart{
ExecutionID: execution.ID, Attempt: execution.Attempt, Kind: task.StepKindStage, Name: "implement",
})
if err != nil {
t.Fatalf("StartStep: %v", err)
}
steps, err := s.ListSteps(t.Context(), execution.ID, execution.Attempt)
if err != nil {
t.Fatalf("ListSteps: %v", err)
}
if len(steps) != 2 {
t.Fatalf("ListSteps len = %d, want 2", len(steps))
}
if steps[0].ID != firstStepID || steps[0].Name != "plan" || steps[0].Status != taskstate.StepSucceeded ||
steps[0].Detail != "planned" || steps[0].TokensUsed != 42 || steps[0].StartedAt.IsZero() || steps[0].FinishedAt.IsZero() {
t.Fatalf("steps[0] = %+v, want the finished plan step", steps[0])
}
if steps[1].ID != secondStepID || steps[1].Name != "implement" || steps[1].Status != taskstate.StepRunning ||
steps[1].StartedAt.IsZero() || !steps[1].FinishedAt.IsZero() {
t.Fatalf("steps[1] = %+v, want the still-running implement step", steps[1])
}
// attempt 0 lists every attempt; there is only one here, so the result is
// the same, proving the "list everything" branch is reachable and correct
// rather than coincidentally equal to a hardcoded attempt.
all, err := s.ListSteps(t.Context(), execution.ID, 0)
if err != nil {
t.Fatalf("ListSteps(attempt=0): %v", err)
}
if len(all) != 2 {
t.Fatalf("ListSteps(attempt=0) len = %d, want 2", len(all))
}
// A different execution's steps never appear, however queried.
other := runningExecution(t, s)
otherSteps, err := s.ListSteps(t.Context(), other.ID, 0)
if err != nil {
t.Fatalf("ListSteps other execution: %v", err)
}
if len(otherSteps) != 0 {
t.Fatalf("ListSteps other execution = %+v, want none", otherSteps)
}
}
// A late FinishStep for a step another path already finished is stale, the
// PRD's named wire behaviour: errors.Is matches on the client too.
func TestFinishStepOffTablePairIsIllegalOverTheTable(t *testing.T) {
if !taskstate.CanStepTransition(taskstate.StepPending, taskstate.StepRunning) {
t.Fatal("pending -> running must be in the step transition table")
}
if taskstate.CanStepTransition(taskstate.StepSucceeded, taskstate.StepRunning) {
t.Fatal("succeeded -> running must not be in the step transition table: terminal is terminal")
}
}