test(taskstate): seed fixture task states along the transition table

The execution transition table refuses most of the pairs shipped fixtures
wrote to build a finished task -- running -> merged, queued -> parked,
queued -> waiting_human, queued -> merged -- so those fixtures fail the
moment the store enforces it.

internal/taskstate/taskstatetest seeds a status by walking the table's
legal edges (shortest route, computed from taskstate.CanTransition), so a
fixture cannot write an illegal pair and fails loudly when no route
exists. The fixtures in internal/daemon, internal/app/archied,
internal/webui and internal/infrastructure/postgres go through it, and
the table's own test names running -> merged as refused.
This commit is contained in:
sam committed 2026-09-26 04:01:08 +10:00
1 parent 9a3f02a17a
commit 1024feda21
10 files changed
+291 -65

No files matched your search

+3 -6
View File
@@ -30,6 +30,7 @@ import (
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/pgstore"
"github.com/samcharles93/archie-core/internal/logging"
"github.com/samcharles93/archie-core/internal/secret"
"github.com/samcharles93/archie-core/internal/taskstate/taskstatetest"
"github.com/samcharles93/archie-core/internal/tools"
"github.com/samcharles93/archie-core/internal/worktree"
"github.com/samcharles93/archie-core/internal/worktreerpc"
@@ -536,9 +537,7 @@ func TestManualRequeueTaskUsesPersistedStatus(t *testing.T) {
if err != nil || task == nil {
t.Fatalf("TaskByIssue = (%+v, %v)", task, err)
}
if err := st.Transition(t.Context(), task.ID, workflow.StatusQueued, status, ""); err != nil {
t.Fatal(err)
}
taskstatetest.Seed(t.Context(), t, st, task.ID, workflow.StatusQueued, status, "")
if err := manualRequeueTask(t.Context(), st, task.ID); err != nil {
t.Fatal(err)
}
@@ -862,9 +861,7 @@ func TestChatTaskCommandsEndToEnd(t *testing.T) {
t.Fatalf("spawned task = %+v", task)
}
if err := st.Transition(ctx, taskID, workflow.StatusQueued, workflow.StatusWaitingHuman, "await approval"); err != nil {
t.Fatal(err)
}
taskstatetest.Seed(t.Context(), t, st, taskID, workflow.StatusQueued, workflow.StatusWaitingHuman, "await approval")
task, err = st.TaskByID(ctx, taskID)
if err != nil || task == nil || task.Status != workflow.StatusWaitingHuman {
t.Fatalf("waiting task = (%+v, %v)", task, err)
@@ -14,6 +14,7 @@ import (
"github.com/samcharles93/archie-core/internal/gateway"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/pgstore"
"github.com/samcharles93/archie-core/internal/taskstate"
"github.com/samcharles93/archie-core/internal/taskstate/taskstatetest"
)
// testTaskActor formats taskactions.Service's result the same way the real
@@ -55,9 +56,7 @@ func TestChatTaskActorAdapterCrossIdentityRefused(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if err := st.Transition(ctx, task.ID, workflow.StatusQueued, workflow.StatusParked, "needs help"); err != nil {
t.Fatal(err)
}
taskstatetest.Seed(ctx, t, st, task.ID, workflow.StatusQueued, workflow.StatusParked, "needs help")
adapter := newChatTaskActorForTest(t, st, config.Config{})
@@ -151,11 +150,7 @@ func TestChatTaskActorAdapterRefusesDisallowedStateAction(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if tc.initialStatus != workflow.StatusQueued {
if err := st.Transition(ctx, task.ID, workflow.StatusQueued, tc.initialStatus, "setup"); err != nil {
t.Fatal(err)
}
}
taskstatetest.Seed(ctx, t, st, task.ID, workflow.StatusQueued, tc.initialStatus, "setup")
_, err = adapter.ApplyChatTaskAction(ctx, new("archie"), taskactions.Actor{}, task.ID, tc.attemptAction)
if err == nil {
@@ -260,11 +255,7 @@ func TestChatTaskActorAdapterAppliesActionsToStore(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if tc.initialStatus != workflow.StatusQueued {
if err := st.Transition(ctx, task.ID, workflow.StatusQueued, tc.initialStatus, "setup"); err != nil {
t.Fatal(err)
}
}
taskstatetest.Seed(ctx, t, st, task.ID, workflow.StatusQueued, tc.initialStatus, "setup")
result, err := adapter.ApplyChatTaskAction(ctx, new("archie"), taskactions.Actor{}, task.ID, tc.action)
if err != nil {
+2 -3
View File
@@ -14,6 +14,7 @@ import (
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/gateway"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/pgstore"
"github.com/samcharles93/archie-core/internal/taskstate/taskstatetest"
"github.com/samcharles93/archie-core/internal/webui"
)
@@ -51,9 +52,7 @@ func TestDashboardAndChatAgreeOnTerminalStates(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if err := st.Transition(ctx, task.ID, workflow.StatusQueued, workflow.StatusWaitingHuman, "await"); err != nil {
t.Fatal(err)
}
taskstatetest.Seed(ctx, t, st, task.ID, workflow.StatusQueued, workflow.StatusWaitingHuman, "await")
if tc.viaChat {
runChatAction(t, ctx, st, tc.action, task.ID)
+5 -6
View File
@@ -26,6 +26,7 @@ import (
"github.com/samcharles93/archie-core/internal/storage"
"github.com/samcharles93/archie-core/internal/taskrun"
"github.com/samcharles93/archie-core/internal/taskstate"
"github.com/samcharles93/archie-core/internal/taskstate/taskstatetest"
"github.com/samcharles93/archie-core/internal/worktree"
)
@@ -261,9 +262,9 @@ func TestCleanupTerminalTaskWorktreeWithCancelledContext(t *testing.T) {
t.Fatalf("ClaimNext: (%v, %v)", task, err)
}
if err := st.Transition(context.Background(), task.ID, workflow.StatusRunning, tt.taskStatus, "setup"); err != nil {
t.Fatalf("Transition: %v", err)
}
// Seeded along the table's legal edges: a merge and a rejection
// are both observed on an open pull request.
taskstatetest.Seed(t.Context(), t, st, task.ID, task.Status, tt.taskStatus, "setup")
if tt.prNumber > 0 {
task.PRNumber = tt.prNumber
if err := st.Update(context.Background(), task); err != nil {
@@ -435,9 +436,7 @@ func TestParkRunningTaskGuardedAndLogging(t *testing.T) {
}
if tt.workerStatus != "" {
if err := s.Transition(ctx, task.ID, workflow.StatusRunning, tt.workerStatus, "worker completion"); err != nil {
t.Fatalf("Transition to workerStatus: %v", err)
}
taskstatetest.Seed(ctx, t, s, task.ID, task.Status, tt.workerStatus, "worker completion")
}
callCtx := ctx
+17 -6
View File
@@ -27,6 +27,7 @@ import (
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/pgstore"
"github.com/samcharles93/archie-core/internal/storage"
"github.com/samcharles93/archie-core/internal/taskrun"
"github.com/samcharles93/archie-core/internal/taskstate/taskstatetest"
"github.com/samcharles93/archie-core/internal/worktree"
)
@@ -230,11 +231,9 @@ func TestCleanupTerminalTaskWorktreeLifecycle(t *testing.T) {
t.Fatalf("ClaimNext: (%v, %v)", claimed, err)
}
if tt.setupStatus != workflow.StatusRunning {
if err := st.Transition(ctx, claimed.ID, workflow.StatusRunning, tt.setupStatus, "status update"); err != nil {
t.Fatalf("Transition to %s: %v", tt.setupStatus, err)
}
}
// Seeded along the table's legal edges: a merged task reached
// `merged` through an open pull request, never from running.
taskstatetest.Seed(ctx, t, st, claimed.ID, claimed.Status, tt.setupStatus, "status update")
if tt.prNumber > 0 {
claimed.PRNumber = tt.prNumber
@@ -374,9 +373,21 @@ func TestProcessCleansWorktreeOnTerminalNoChange(t *testing.T) {
targetTrees := d.treesFor(task)
workDir := targetTrees.Dir(task.Owner, task.Repo, task.IssueNumber)
// The route the worker's completion report takes to its status,
// computed here because t.Fatalf is not callable from the
// subscription goroutine below.
route, err := taskstatetest.Path(workflow.StatusRunning, tt.workerStatus)
if err != nil {
t.Fatalf("no legal route to %s: %v", tt.workerStatus, err)
}
sub, err := mustCoreConn(t, busClient).Subscribe(agentnats.SubjectForTask(task.ID), func(msg *natsio.Msg) {
// Transition task in store as archie-agent would do over the gRPC State Store
_ = s.Transition(ctx, task.ID, workflow.StatusRunning, tt.workerStatus, "worker completion")
at := workflow.StatusRunning
for _, to := range route {
_ = s.Transition(ctx, task.ID, at, to, "worker completion")
at = to
}
resp, _ := json.Marshal(taskrun.Response{
Status: tt.workerStatus,
})
@@ -4,6 +4,7 @@ import (
"testing"
"github.com/samcharles93/archie-core/internal/taskstate"
"github.com/samcharles93/archie-core/internal/taskstate/taskstatetest"
)
// TestWorkflowStatsCountsCompletedRuns pins the per-workflow count the
@@ -21,12 +22,9 @@ func TestWorkflowStatsCountsCompletedRuns(t *testing.T) {
merged := insertChatTask(t, q)
finish := func(id int64, to string) {
t.Helper()
if err := store.Transition(t.Context(), id, taskstate.Queued, taskstate.Running, ""); err != nil {
t.Fatalf("queued -> running: %v", err)
}
if err := store.Transition(t.Context(), id, taskstate.Running, to, ""); err != nil {
t.Fatalf("running -> %s: %v", to, err)
}
// Seeded along the table's edges: a merged task is merged on an open
// pull request, and the fixture used to write running -> merged.
taskstatetest.Seed(t.Context(), t, store, id, taskstate.Queued, to, "")
}
finish(finished.ID, taskstate.Completed)
finish(merged.ID, taskstate.Merged)
@@ -0,0 +1,105 @@
// Package taskstatetest seeds task lifecycle states for tests.
//
// A fixture that needs a task in a finished state used to write the pair it
// wanted -- queued -> merged, queued -> parked -- because the store accepted
// it. The transition tables (internal/taskstate) refuse most of those pairs,
// so a fixture that keeps writing one fails the moment the store enforces
// them. Seeding through this package moves the task along the table's legal
// edges instead, and fails loudly when no legal route exists.
package taskstatetest
import (
"context"
"fmt"
"slices"
"testing"
"github.com/samcharles93/archie-core/internal/taskstate"
)
// Transitioner is the guarded status write the seeder needs: the store's own
// Transition, which refuses a from that is not the task's current status.
type Transitioner interface {
Transition(ctx context.Context, taskID int64, from, to, detail string) error
}
// Seed moves taskID from the status it holds to want, one legal edge at a
// time, recording detail on every edge. It fails the test on the edge that the
// store refuses, or before any edge when the table has no route at all.
//
// ctx is the caller's, so a fixture that seeds with a context of its own
// chooses it rather than inheriting one the helper invented.
func Seed(ctx context.Context, t testing.TB, st Transitioner, taskID int64, from, want, detail string) {
t.Helper()
route, err := Path(from, want)
if err != nil {
t.Fatalf("seed task %d: %v", taskID, err)
}
at := from
for _, to := range route {
if err := st.Transition(ctx, taskID, at, to, detail); err != nil {
t.Fatalf("seed task %d to %s: %s -> %s: %v", taskID, want, at, to, err)
}
at = to
}
}
// Path returns the statuses a task moves through to get from one status to
// another, as the shortest route through the execution transition table. A nil
// route means from is already want.
//
// It is exported for the fixtures that seed from a goroutine, where t.Fatalf is
// not callable: those compute the route on the test goroutine and apply it in
// the callback.
func Path(from, want string) ([]string, error) {
statuses := statusIDs()
if !slices.Contains(statuses, from) {
return nil, fmt.Errorf("%q is not a task status", from)
}
if !slices.Contains(statuses, want) {
return nil, fmt.Errorf("%q is not a task status", want)
}
if from == want {
return nil, nil
}
// Breadth-first, walking each row's edges in catalog order, so the route a
// fixture takes is the shortest one and the same on every run.
arrivedFrom := map[string]string{from: from}
queue := []string{from}
for len(queue) > 0 {
at := queue[0]
queue = queue[1:]
for _, next := range statuses {
if _, seen := arrivedFrom[next]; seen || !taskstate.CanTransition(at, next) {
continue
}
arrivedFrom[next] = at
if next == want {
return route(arrivedFrom, from, want), nil
}
queue = append(queue, next)
}
}
return nil, fmt.Errorf("no legal route from %s to %s", from, want)
}
// route reconstructs the way to want, ending with it and leaving out the
// status the task was already in.
func route(arrivedFrom map[string]string, from, want string) []string {
var reverse []string
for at := want; at != from; at = arrivedFrom[at] {
reverse = append(reverse, at)
}
slices.Reverse(reverse)
return reverse
}
func statusIDs() []string {
catalog := taskstate.Statuses()
ids := make([]string, 0, len(catalog))
for _, meta := range catalog {
ids = append(ids, meta.ID)
}
return ids
}
@@ -0,0 +1,133 @@
package taskstatetest
import (
"context"
"slices"
"testing"
"github.com/samcharles93/archie-core/internal/taskstate"
)
// The routes the fixtures ask for, written out rather than derived from the
// table: a route that changed shape -- a longer way round, or through a status
// whose transition writes something else -- would otherwise be invisible.
func TestPathIsTheShortLegalRoute(t *testing.T) {
tests := []struct {
name, from, target string
want []string
}{
{name: "already there", from: taskstate.Queued, target: taskstate.Queued},
{name: "claim", from: taskstate.Queued, target: taskstate.Running, want: []string{taskstate.Running}},
{name: "await approval", from: taskstate.Queued, target: taskstate.WaitingHuman, want: []string{taskstate.Running, taskstate.WaitingHuman}},
{name: "park", from: taskstate.Queued, target: taskstate.Parked, want: []string{taskstate.Running, taskstate.Parked}},
{name: "spend the retries", from: taskstate.Queued, target: taskstate.Dead, want: []string{taskstate.Running, taskstate.Parked, taskstate.Dead}},
{name: "merge", from: taskstate.Queued, target: taskstate.Merged, want: []string{taskstate.Running, taskstate.PROpen, taskstate.Merged}},
{name: "rejected pull request", from: taskstate.Queued, target: taskstate.Rejected, want: []string{taskstate.Running, taskstate.PROpen, taskstate.Rejected}},
{name: "finish with no pull request", from: taskstate.Queued, target: taskstate.Completed, want: []string{taskstate.Running, taskstate.Completed}},
{name: "refuse the work", from: taskstate.Queued, target: taskstate.Declined, want: []string{taskstate.Declined}},
{name: "merge a running task", from: taskstate.Running, target: taskstate.Merged, want: []string{taskstate.PROpen, taskstate.Merged}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := Path(tt.from, tt.target)
if err != nil {
t.Fatalf("Path(%s, %s) error = %v", tt.from, tt.target, err)
}
if !slices.Equal(got, tt.want) {
t.Errorf("Path(%s, %s) = %v, want %v", tt.from, tt.target, got, tt.want)
}
})
}
}
// Every route is walkable. A route through a pair the table refuses is exactly
// what this package exists to prevent, so it is checked here rather than
// discovered later at the store.
func TestRoutesOnlyTakeLegalEdges(t *testing.T) {
for _, from := range statusIDs() {
for _, want := range statusIDs() {
got, err := Path(from, want)
if err != nil {
continue
}
at := from
for _, to := range got {
if !taskstate.CanTransition(at, to) {
t.Errorf("route %s -> %s takes %s -> %s, which the table refuses", from, want, at, to)
}
at = to
}
if at != want {
t.Errorf("route %s -> %s ends at %s", from, want, at)
}
}
}
}
// Nothing follows a terminal status, so no fixture can seed out of one: it
// would have to have been written there illegitimately in the first place.
func TestTerminalStatusIsNotAStartingPoint(t *testing.T) {
for _, from := range statusIDs() {
if !taskstate.Terminal(from) {
continue
}
for _, want := range statusIDs() {
if want == from {
continue
}
got, err := Path(from, want)
if err == nil {
t.Errorf("Path(%s, %s) = %v, want an error", from, want, got)
}
}
}
}
func TestUnknownStatusIsNeverARoute(t *testing.T) {
const unknown = "half_written"
if got, err := Path(unknown, taskstate.Running); err == nil {
t.Errorf("Path(%s, running) = %v, want an error", unknown, got)
}
if got, err := Path(taskstate.Queued, unknown); err == nil {
t.Errorf("Path(queued, %s) = %v, want an error", unknown, got)
}
if got, err := Path(unknown, unknown); err == nil {
t.Errorf("Path(%s, %s) = %v, want an error", unknown, unknown, got)
}
}
// Seed applies the route edge by edge, in order, carrying the fixture's own
// reason: a park seeded this way keeps the reason the fixture passed, which is
// what the retry path reads back as the previous failure.
func TestSeedWalksTheRouteThroughTheStore(t *testing.T) {
st := &recorder{}
Seed(t.Context(), t, st, 7, taskstate.Queued, taskstate.Merged, "fixture reason")
want := []edge{
{from: taskstate.Queued, to: taskstate.Running, detail: "fixture reason"},
{from: taskstate.Running, to: taskstate.PROpen, detail: "fixture reason"},
{from: taskstate.PROpen, to: taskstate.Merged, detail: "fixture reason"},
}
if !slices.Equal(st.edges, want) {
t.Errorf("Seed wrote %v, want %v", st.edges, want)
}
}
// A task already in the wanted status is left untouched rather than written to
// itself: a guarded transition from running to running matches no row.
func TestSeedOfTheSameStatusWritesNothing(t *testing.T) {
st := &recorder{}
Seed(t.Context(), t, st, 7, taskstate.Completed, taskstate.Completed, "")
if len(st.edges) != 0 {
t.Errorf("Seed wrote %v, want no writes", st.edges)
}
}
type edge struct{ from, to, detail string }
type recorder struct{ edges []edge }
func (r *recorder) Transition(_ context.Context, _ int64, from, to, detail string) error {
r.edges = append(r.edges, edge{from: from, to: to, detail: detail})
return nil
}
+10
View File
@@ -82,6 +82,16 @@ func TestQueuedCannotReachMerged(t *testing.T) {
}
}
// The other pair written before the table existed, by every fixture that
// needed a finished task: a merge is observed on an open pull request, never
// straight from running. Named here so the next fixture that reaches for it is
// a failure in the table's own test rather than a surprise at the store.
func TestRunningCannotReachMerged(t *testing.T) {
if CanTransition(Running, Merged) {
t.Error("CanTransition(running, merged) = true; a merge is only observed on an open pull request")
}
}
// An unknown status must be illegal in both positions. A status written by a
// newer version, or a typo, must not be able to start or end a transition.
func TestUnknownStatusIsNeverATransition(t *testing.T) {
+8 -25
View File
@@ -23,6 +23,7 @@ import (
taskactionstore "github.com/samcharles93/archie-core/internal/infrastructure/taskactions"
"github.com/samcharles93/archie-core/internal/logging"
"github.com/samcharles93/archie-core/internal/taskstate"
"github.com/samcharles93/archie-core/internal/taskstate/taskstatetest"
)
// recordingCloser captures the forge issue-closure calls an action makes.
@@ -152,9 +153,7 @@ func actionServer(t *testing.T, status, parkReason string) (*Server, *workflow.T
if err != nil || task == nil {
t.Fatalf("ClaimNext = (%+v, %v)", task, err)
}
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusRunning, status, parkReason); err != nil {
t.Fatal(err)
}
taskstatetest.Seed(ctx, t, srv.Store, task.ID, workflow.StatusRunning, status, parkReason)
closer := &recordingCloser{}
bus := events.NewBus()
@@ -238,9 +237,7 @@ func TestRetryEnforcesMaxRetries(t *testing.T) {
if err := srv.Store.RetryTask(ctx, task.ID, workflow.StatusParked, ""); err != nil {
t.Fatal(err)
}
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusQueued, workflow.StatusParked, "re-parked for test fixture"); err != nil {
t.Fatal(err)
}
taskstatetest.Seed(ctx, t, srv.Store, task.ID, workflow.StatusQueued, workflow.StatusParked, "re-parked for test fixture")
}
w := postAction(t, srv, task.ID, "retry")
@@ -564,11 +561,7 @@ func TestTaskListExposesLifecycleActions(t *testing.T) {
if err != nil || task == nil {
t.Fatalf("TaskByIssue(%s) = (%+v, %v)", status, task, err)
}
if status != workflow.StatusQueued {
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusQueued, status, "test"); err != nil {
t.Fatal(err)
}
}
taskstatetest.Seed(ctx, t, srv.Store, task.ID, workflow.StatusQueued, status, "test")
number++
}
@@ -621,11 +614,7 @@ func TestLifecycleSpecificTaskActions(t *testing.T) {
if err != nil || task == nil {
t.Fatalf("TaskByIssue = (%+v, %v)", task, err)
}
if tc.from != workflow.StatusQueued {
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusQueued, tc.from, "test"); err != nil {
t.Fatal(err)
}
}
taskstatetest.Seed(ctx, t, srv.Store, task.ID, workflow.StatusQueued, tc.from, "test")
closer := &recordingCloser{}
operatorActions(t, srv).issues = closer
bus := events.NewBus()
@@ -668,9 +657,7 @@ func TestArchiveRemovesOnlyOneTerminalTask(t *testing.T) {
if err != nil || task == nil {
t.Fatalf("TaskByIssue = (%+v, %v)", task, err)
}
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusQueued, workflow.StatusMerged, "done"); err != nil {
t.Fatal(err)
}
taskstatetest.Seed(ctx, t, srv.Store, task.ID, workflow.StatusQueued, workflow.StatusMerged, "done")
}
task, _ := srv.Store.TaskByIssue(ctx, "acme", "widget", 1)
bus := events.NewBus()
@@ -723,9 +710,7 @@ func TestArchiveRemovesTheTaskLogDirectory(t *testing.T) {
t.Fatal(err)
}
task, _ := srv.Store.TaskByIssue(ctx, "acme", "widget", 1)
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusQueued, workflow.StatusMerged, "done"); err != nil {
t.Fatal(err)
}
taskstatetest.Seed(ctx, t, srv.Store, task.ID, workflow.StatusQueued, workflow.StatusMerged, "done")
if err := logs.Open(task.ID, task.Attempt); err != nil {
t.Fatal(err)
@@ -754,9 +739,7 @@ func TestArchiveAuditFailurePreservesTaskAndFailsRequest(t *testing.T) {
t.Fatal(err)
}
task, _ := srv.Store.TaskByIssue(ctx, "acme", "widget", 1)
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusQueued, workflow.StatusMerged, "done"); err != nil {
t.Fatal(err)
}
taskstatetest.Seed(ctx, t, srv.Store, task.ID, workflow.StatusQueued, workflow.StatusMerged, "done")
base := srv.Store
srv.Store = &archiveFailingStore{TaskStore: base, err: errors.New("audit unavailable")}