Files
archie/internal/app/archied/task_actions_test.go
T
sam 30211478c2 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.
2026-09-26 04:01:08 +10:00

125 lines
4.4 KiB
Go

package archied
import (
"bytes"
"context"
"log/slog"
"net/http"
"net/http/httptest"
"strconv"
"testing"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"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"
)
// The dashboard and chat both let an operator approve or decline a task, and
// they had drifted: declining from the dashboard left the task
// closed_wont_do, cancelling the same task from chat left it rejected. Two
// operators looking at one queue saw different states for the same decision,
// and "rejected" -- which reconcilePRs uses for a pull request closed without
// merging -- no longer meant one thing.
//
// This drives both real surfaces against one store and asserts they agree.
// It lives in cmd/archied because that is the only place both are wired.
func TestDashboardAndChatAgreeOnTerminalStates(t *testing.T) {
tests := []struct {
name string
// viaChat runs the action through the chat router; otherwise it
// goes through the dashboard's HTTP handler.
viaChat bool
action string
want string
}{
{name: "dashboard reject", action: "reject", want: workflow.StatusClosedWontDo},
{name: "chat cancel", viaChat: true, action: "cancel", want: workflow.StatusClosedWontDo},
{name: "dashboard approve", action: "approve", want: workflow.StatusQueued},
{name: "chat approve", viaChat: true, action: "approve", want: workflow.StatusQueued},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
ctx := context.Background()
st := pgstore.Open(t)
t.Cleanup(func() { _ = st.Close() })
task, err := st.EnqueueChatTask(ctx, "acme", "widget", "decide on me", "", "", "reviewer")
if 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)
} else {
runDashboardAction(t, ctx, st, tc.action, task.ID)
}
got, err := st.TaskByID(ctx, task.ID)
if err != nil || got == nil {
t.Fatalf("TaskByID = (%+v, %v)", got, err)
}
if got.Status != tc.want {
t.Errorf("status = %q, want %q: the two surfaces disagree about "+
"what this action means", got.Status, tc.want)
}
})
}
}
// runChatAction performs the approve/cancel action through the chat
// controller path and fails the test on error.
func runChatAction(t *testing.T, ctx context.Context, st storecontract.TaskStore, action string, taskID int64) {
t.Helper()
controller := gateway.NewStoreTaskController(chatTaskControllerAdapter{
taskByID: st.TaskByID,
requeue: st.Requeue,
transition: st.Transition,
})
var err error
if action == "approve" {
err = controller.Approve(ctx, taskID, "reviewer")
} else {
err = controller.Cancel(ctx, taskID, "reviewer")
}
if err != nil {
t.Fatalf("chat %s: %v", action, err)
}
}
// runDashboardAction performs the approve/cancel action through the
// dashboard's HTTP handler and fails the test when the request is
// rejected.
func runDashboardAction(t *testing.T, ctx context.Context, st storecontract.TaskStore, action string, taskID int64) {
t.Helper()
// The dashboard reaches task actions through the Gateway contract, which
// in production carries them back to this daemon's own service. Wiring
// that service behind a local adapter keeps both surfaces in this test
// driving the one implementation, which is the whole point of it.
actor := testTaskActor{&boot{
st: st, stateStore: st,
cfg: config.Config{MaxRetries: 3},
cfgHolder: config.NewHolder(config.Config{MaxRetries: 3}),
log: slog.New(slog.DiscardHandler),
}}
srv := &webui.Server{
Store: st,
Chat: &webui.ChatService{Contract: &gateway.LocalChatAdapter{TaskActor: actor}},
}
req := httptest.NewRequestWithContext(ctx, http.MethodPost,
"/api/tasks/"+strconv.FormatInt(taskID, 10)+"/action",
bytes.NewBufferString(`{"action":"`+action+`"}`))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-Archie-CSRF", "1")
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Fatalf("dashboard %s: status %d, body %s", action, w.Code, w.Body)
}
}