From 1024feda2123d92e5e4dc5d075f6a38a34f72040 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Sat, 26 Sep 2026 03:43:12 +1000 Subject: [PATCH] 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. --- internal/app/archied/main_test.go | 9 +- .../app/archied/task_action_adapter_test.go | 17 +-- internal/app/archied/task_actions_test.go | 5 +- internal/daemon/task_cancellation_test.go | 11 +- internal/daemon/terminal_cleanup_test.go | 23 ++- .../postgres/workflow_stats_test.go | 10 +- .../taskstate/taskstatetest/taskstatetest.go | 105 ++++++++++++++ .../taskstatetest/taskstatetest_test.go | 133 ++++++++++++++++++ internal/taskstate/transitions_test.go | 10 ++ internal/webui/api_tasks_actions_test.go | 33 ++--- 10 files changed, 291 insertions(+), 65 deletions(-) create mode 100644 internal/taskstate/taskstatetest/taskstatetest.go create mode 100644 internal/taskstate/taskstatetest/taskstatetest_test.go diff --git a/internal/app/archied/main_test.go b/internal/app/archied/main_test.go index accc1ab7e..612fc8adf 100644 --- a/internal/app/archied/main_test.go +++ b/internal/app/archied/main_test.go @@ -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) diff --git a/internal/app/archied/task_action_adapter_test.go b/internal/app/archied/task_action_adapter_test.go index 2daa8428c..aa9514eac 100644 --- a/internal/app/archied/task_action_adapter_test.go +++ b/internal/app/archied/task_action_adapter_test.go @@ -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 { diff --git a/internal/app/archied/task_actions_test.go b/internal/app/archied/task_actions_test.go index 4754d72fd..3dd62f000 100644 --- a/internal/app/archied/task_actions_test.go +++ b/internal/app/archied/task_actions_test.go @@ -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) diff --git a/internal/daemon/task_cancellation_test.go b/internal/daemon/task_cancellation_test.go index 965952b00..8537536d0 100644 --- a/internal/daemon/task_cancellation_test.go +++ b/internal/daemon/task_cancellation_test.go @@ -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 diff --git a/internal/daemon/terminal_cleanup_test.go b/internal/daemon/terminal_cleanup_test.go index dc456f54c..30ff8e6f3 100644 --- a/internal/daemon/terminal_cleanup_test.go +++ b/internal/daemon/terminal_cleanup_test.go @@ -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, }) diff --git a/internal/infrastructure/postgres/workflow_stats_test.go b/internal/infrastructure/postgres/workflow_stats_test.go index a2d8ad14d..24a0c6346 100644 --- a/internal/infrastructure/postgres/workflow_stats_test.go +++ b/internal/infrastructure/postgres/workflow_stats_test.go @@ -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) diff --git a/internal/taskstate/taskstatetest/taskstatetest.go b/internal/taskstate/taskstatetest/taskstatetest.go new file mode 100644 index 000000000..68943bb5e --- /dev/null +++ b/internal/taskstate/taskstatetest/taskstatetest.go @@ -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 +} diff --git a/internal/taskstate/taskstatetest/taskstatetest_test.go b/internal/taskstate/taskstatetest/taskstatetest_test.go new file mode 100644 index 000000000..44cb46eee --- /dev/null +++ b/internal/taskstate/taskstatetest/taskstatetest_test.go @@ -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 +} diff --git a/internal/taskstate/transitions_test.go b/internal/taskstate/transitions_test.go index 3030dd568..ac6a1e92d 100644 --- a/internal/taskstate/transitions_test.go +++ b/internal/taskstate/transitions_test.go @@ -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) { diff --git a/internal/webui/api_tasks_actions_test.go b/internal/webui/api_tasks_actions_test.go index 2a52bcf43..fb311e3a3 100644 --- a/internal/webui/api_tasks_actions_test.go +++ b/internal/webui/api_tasks_actions_test.go @@ -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")}