A retry now carries the operator's worktree choice (refresh onto the base branch or continue the work already pushed on the task branch) from the dashboard through the task action to the daemon dispatch, and persists it on the task row so it survives a reload. The daemon resolves the mode from the task, never from the workflow; BeginRemediation records continue explicitly so a remediation still resumes its pull request branch.
945 lines
35 KiB
Go
945 lines
35 KiB
Go
package webui
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
"github.com/samcharles93/archie-core/internal/domain/storecontract"
|
|
"github.com/samcharles93/archie-core/internal/domain/taskactions"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow"
|
|
workflowtask "github.com/samcharles93/archie-core/internal/domain/workflow/task"
|
|
"github.com/samcharles93/archie-core/internal/events"
|
|
"github.com/samcharles93/archie-core/internal/gateway"
|
|
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.
|
|
type recordingCloser struct {
|
|
calls []closeCall
|
|
err error
|
|
}
|
|
|
|
type closeCall struct {
|
|
owner, repo string
|
|
number int
|
|
comment string
|
|
}
|
|
|
|
func (r *recordingCloser) CloseIssue(_ context.Context, owner, repo string, number int, comment string) error {
|
|
r.calls = append(r.calls, closeCall{owner, repo, number, comment})
|
|
return r.err
|
|
}
|
|
|
|
// daemonActions stands in for the daemon behind the Gateway contract. The
|
|
// dashboard no longer composes a task-action service of its own: it asks
|
|
// whoever owns task execution, reaching the same taskactions.Service over
|
|
// gRPC and NATS in production (internal/infrastructure/taskactions). Running
|
|
// that service directly here keeps these tests on real behaviour -- retry
|
|
// limits, forge closure, timeline events, archiving -- rather than on a stub
|
|
// that would agree with any handler.
|
|
//
|
|
// The service is rebuilt per call because tests attach collaborators after
|
|
// the server exists, exactly as the daemon rebuilds it per request.
|
|
type daemonActions struct {
|
|
srv *Server
|
|
// cfg is the daemon's configuration, held by the stand-in daemon
|
|
// rather than by the dashboard: retry caps are the task owner's
|
|
// policy and the dashboard does not hold configuration.
|
|
cfg *config.Holder
|
|
// logs is the daemon's own task-log registry. Archiving removes a
|
|
// task's log files, and that is the daemon's cleanup over the state
|
|
// directory it owns -- the dashboard reads logs through a contract and
|
|
// has no directory to remove anything from.
|
|
logs *logging.TaskRegistry
|
|
issues *recordingCloser
|
|
stopper *recordingTaskStopper
|
|
// scopes records the identity each action arrived with, one per call.
|
|
scopes []*string
|
|
}
|
|
|
|
func (d *daemonActions) ApplyChatTaskAction(
|
|
ctx context.Context, identity *string, actor taskactions.Actor, id int64, action taskstate.Action, res taskactions.ActionPayload,
|
|
) (gateway.TaskActionResult, error) {
|
|
d.scopes = append(d.scopes, identity)
|
|
service := taskactionstore.NewService(
|
|
taskactionstore.Store{TaskStore: d.srv.Store},
|
|
taskactionstore.MaxRetries(d.cfg),
|
|
d.cancelTask(),
|
|
d.closeIssue(),
|
|
d.removeLogs(),
|
|
nil,
|
|
d.publish(),
|
|
d.srv.logf,
|
|
)
|
|
if err := service.Apply(ctx, identity, actor, id, action, res); err != nil {
|
|
return gateway.TaskActionResult{}, err
|
|
}
|
|
return gateway.TaskActionResult{TaskID: id, Action: string(action)}, nil
|
|
}
|
|
|
|
func (d *daemonActions) cancelTask() func(int64) bool {
|
|
if d.stopper == nil {
|
|
return nil
|
|
}
|
|
return d.stopper.CancelTask
|
|
}
|
|
|
|
func (d *daemonActions) closeIssue() func(context.Context, string, string, int, string) error {
|
|
if d.issues == nil {
|
|
return nil
|
|
}
|
|
return d.issues.CloseIssue
|
|
}
|
|
|
|
func (d *daemonActions) removeLogs() func(int64) error {
|
|
if d.logs == nil {
|
|
return nil
|
|
}
|
|
return d.logs.Remove
|
|
}
|
|
|
|
func (d *daemonActions) publish() func(events.Event) {
|
|
if d.srv.Events == nil {
|
|
return nil
|
|
}
|
|
return d.srv.Events.Publish
|
|
}
|
|
|
|
// wireOperatorActions gives srv a task-action owner, the way composition
|
|
// gives the dashboard a Gateway contract.
|
|
func wireOperatorActions(srv *Server) *daemonActions {
|
|
actions := &daemonActions{srv: srv, cfg: config.NewHolder(config.Config{})}
|
|
srv.Chat = &ChatService{Contract: &gateway.LocalChatAdapter{TaskActor: actions}}
|
|
return actions
|
|
}
|
|
|
|
// operatorActions returns the stand-in daemon behind srv's contract.
|
|
func operatorActions(t *testing.T, srv *Server) *daemonActions {
|
|
t.Helper()
|
|
local, ok := srv.Chat.Contract.(*gateway.LocalChatAdapter)
|
|
if !ok {
|
|
t.Fatalf("chat contract is %T, want the local adapter these tests wire", srv.Chat.Contract)
|
|
}
|
|
actions, ok := local.TaskActor.(*daemonActions)
|
|
if !ok {
|
|
t.Fatalf("task actor is %T, want the stand-in daemon", local.TaskActor)
|
|
}
|
|
return actions
|
|
}
|
|
|
|
// actionServer builds a dashboard server with a task in the given state, plus
|
|
// the collaborators the action path needs.
|
|
func actionServer(t *testing.T, status, parkReason string) (*Server, *workflow.Task, *recordingCloser, *events.Bus, *events.Sub) {
|
|
t.Helper()
|
|
srv := newTestServer(t)
|
|
ctx := t.Context()
|
|
|
|
if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 11, "a task", "", "", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, err := srv.Store.ClaimNext(ctx)
|
|
if err != nil || task == nil {
|
|
t.Fatalf("ClaimNext = (%+v, %v)", task, err)
|
|
}
|
|
taskstatetest.Seed(ctx, t, srv.Store, task.ID, workflow.StatusRunning, status, parkReason)
|
|
|
|
closer := &recordingCloser{}
|
|
bus := events.NewBus()
|
|
t.Cleanup(bus.Close)
|
|
sub := bus.Subscribe(16)
|
|
|
|
operatorActions(t, srv).issues = closer
|
|
srv.Events = bus
|
|
operatorActions(t, srv).cfg = config.NewHolder(config.Config{MaxRetries: 3})
|
|
return srv, task, closer, bus, sub
|
|
}
|
|
|
|
func postAction(t *testing.T, srv *Server, id int64, action string) *httptest.ResponseRecorder {
|
|
t.Helper()
|
|
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost,
|
|
"/api/tasks/"+strconv.FormatInt(id, 10)+"/action",
|
|
bytes.NewBufferString(fmt.Sprintf(`{"action":%q}`, action)))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Archie-CSRF", "1")
|
|
w := httptest.NewRecorder()
|
|
srv.Handler().ServeHTTP(w, req)
|
|
return w
|
|
}
|
|
|
|
type recordingTaskStopper struct {
|
|
calls []int64
|
|
result bool
|
|
}
|
|
|
|
type archiveFailingStore struct {
|
|
storecontract.TaskStore
|
|
err error
|
|
}
|
|
|
|
func (s *archiveFailingStore) ArchiveTask(
|
|
context.Context,
|
|
int64,
|
|
string,
|
|
events.Event,
|
|
) (int64, error) {
|
|
return 0, s.err
|
|
}
|
|
|
|
func (s *recordingTaskStopper) CancelTask(id int64) bool {
|
|
s.calls = append(s.calls, id)
|
|
return s.result
|
|
}
|
|
|
|
func setTaskStopper(t *testing.T, srv *Server, stopper *recordingTaskStopper) {
|
|
t.Helper()
|
|
operatorActions(t, srv).stopper = stopper
|
|
}
|
|
|
|
// max_retries is configured, defaulted and shown in /api/config, but nothing
|
|
// enforced it: the Web UI retry incremented retry_count with no cap, so a
|
|
// task that fails every time could be retried forever. At the cap the task
|
|
// belongs in dead, which is what the setting exists to express.
|
|
func TestRetryEnforcesMaxRetries(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
priorCount int
|
|
maxRetries int
|
|
wantStatus int
|
|
wantTask string
|
|
}{
|
|
{name: "under the cap", priorCount: 0, maxRetries: 3, wantStatus: http.StatusOK, wantTask: workflow.StatusQueued},
|
|
{name: "one below the cap", priorCount: 2, maxRetries: 3, wantStatus: http.StatusOK, wantTask: workflow.StatusQueued},
|
|
{name: "at the cap", priorCount: 3, maxRetries: 3, wantStatus: http.StatusConflict, wantTask: workflow.StatusDead},
|
|
{name: "past the cap", priorCount: 5, maxRetries: 3, wantStatus: http.StatusConflict, wantTask: workflow.StatusDead},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
srv, task, _, _, _ := actionServer(t, workflow.StatusParked, "it broke")
|
|
operatorActions(t, srv).cfg = config.NewHolder(config.Config{MaxRetries: tc.maxRetries})
|
|
ctx := t.Context()
|
|
// Drive retry_count up through the real atomic retry path
|
|
// (RetryTask) rather than a raw counter bump, re-parking
|
|
// between retries so each call sees the fromStatus it needs.
|
|
for range tc.priorCount {
|
|
if err := srv.Store.RetryTask(ctx, task.ID, workflow.StatusParked, "", ""); 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")
|
|
if w.Code != tc.wantStatus {
|
|
t.Fatalf("status = %d, want %d (body %s)", w.Code, tc.wantStatus, w.Body)
|
|
}
|
|
|
|
got, err := srv.Store.TaskByID(ctx, task.ID)
|
|
if err != nil || got == nil {
|
|
t.Fatalf("TaskByID = (%+v, %v)", got, err)
|
|
}
|
|
if got.Status != tc.wantTask {
|
|
t.Errorf("status = %q, want %q", got.Status, tc.wantTask)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Rejecting a task must stop the forge issue coming back. It stays open,
|
|
// labelled and assigned otherwise, so the next poll re-enqueues it -- and if
|
|
// the operator has used the dashboard's Clear, which deletes the row, that is
|
|
// a second implementation and a second PR for work already declined.
|
|
func TestRejectClosesTheForgeIssue(t *testing.T) {
|
|
srv, task, closer, _, _ := actionServer(t, workflow.StatusWaitingHuman, "review")
|
|
|
|
if w := postAction(t, srv, task.ID, "reject"); w.Code != http.StatusOK {
|
|
t.Fatalf("reject status = %d, body %s", w.Code, w.Body)
|
|
}
|
|
|
|
if len(closer.calls) != 1 {
|
|
t.Fatalf("CloseIssue calls = %d, want 1: the issue stays open and is "+
|
|
"re-polled, so the work is done twice", len(closer.calls))
|
|
}
|
|
call := closer.calls[0]
|
|
if call.owner != "acme" || call.repo != "widget" || call.number != 11 {
|
|
t.Errorf("closed %s/%s#%d, want acme/widget#11", call.owner, call.repo, call.number)
|
|
}
|
|
if call.comment == "" {
|
|
t.Error("closed with no comment: an issue that closes itself with no " +
|
|
"explanation reads as archie losing the work")
|
|
}
|
|
}
|
|
|
|
// Approve and retry put the task back to work, so the issue must stay open.
|
|
func TestApproveAndRetryDoNotCloseTheIssue(t *testing.T) {
|
|
for _, tc := range []struct{ action, status, reason string }{
|
|
{"approve", workflow.StatusWaitingHuman, "review"},
|
|
{"retry", workflow.StatusParked, "it broke"},
|
|
} {
|
|
t.Run(tc.action, func(t *testing.T) {
|
|
srv, task, closer, _, _ := actionServer(t, tc.status, tc.reason)
|
|
if w := postAction(t, srv, task.ID, tc.action); w.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body %s", w.Code, w.Body)
|
|
}
|
|
if len(closer.calls) != 0 {
|
|
t.Errorf("CloseIssue called %d times for %s; the task is going "+
|
|
"back to work", len(closer.calls), tc.action)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// A chat-sourced task has a synthetic issue number that matches no forge
|
|
// issue, so closing it would either error or close an unrelated issue.
|
|
func TestRejectDoesNotCloseAChatTaskIssue(t *testing.T) {
|
|
srv := newTestServer(t)
|
|
ctx := t.Context()
|
|
closer := &recordingCloser{}
|
|
operatorActions(t, srv).issues = closer
|
|
operatorActions(t, srv).cfg = config.NewHolder(config.Config{MaxRetries: 3})
|
|
|
|
task, err := srv.Store.EnqueueChatTask(ctx, "acme", "widget", "chat task", "", "", "", nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := srv.Store.ClaimNext(ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusRunning, workflow.StatusWaitingHuman, "review"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if w := postAction(t, srv, task.ID, "reject"); w.Code != http.StatusOK {
|
|
t.Fatalf("reject status = %d, body %s", w.Code, w.Body)
|
|
}
|
|
if len(closer.calls) != 0 {
|
|
t.Errorf("CloseIssue called for a chat task: issue number %d is synthetic",
|
|
task.IssueNumber)
|
|
}
|
|
}
|
|
|
|
// A forge that cannot close the issue must not fail the action: the operator's
|
|
// decision is already recorded in the store, and reporting failure would
|
|
// invite them to click again.
|
|
func TestRejectSurvivesAForgeFailure(t *testing.T) {
|
|
srv, task, closer, _, _ := actionServer(t, workflow.StatusWaitingHuman, "review")
|
|
closer.err = errors.New("forge unreachable")
|
|
|
|
if w := postAction(t, srv, task.ID, "reject"); w.Code != http.StatusOK {
|
|
t.Fatalf("reject status = %d, want 200: the store transition succeeded", w.Code)
|
|
}
|
|
got, err := srv.Store.TaskByID(t.Context(), task.ID)
|
|
if err != nil || got == nil {
|
|
t.Fatalf("TaskByID = (%+v, %v)", got, err)
|
|
}
|
|
if got.Status != workflow.StatusClosedWontDo {
|
|
t.Errorf("status = %q, want %q", got.Status, workflow.StatusClosedWontDo)
|
|
}
|
|
}
|
|
|
|
// Actions wrote store rows and nothing else, so the activity stream and the
|
|
// task timeline never showed that a human had intervened -- the one kind of
|
|
// event most worth seeing.
|
|
func TestActionsEmitEvents(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
action string
|
|
status string
|
|
reason string
|
|
wantMsg string
|
|
}{
|
|
{name: "approve", action: "approve", status: workflow.StatusWaitingHuman, reason: "review", wantMsg: "approve"},
|
|
{name: "retry", action: "retry", status: workflow.StatusParked, reason: "it broke", wantMsg: "retry"},
|
|
{name: "reject", action: "reject", status: workflow.StatusWaitingHuman, reason: "review", wantMsg: "reject"},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
srv, task, _, _, sub := actionServer(t, tc.status, tc.reason)
|
|
|
|
if w := postAction(t, srv, task.ID, tc.action); w.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body %s", w.Code, w.Body)
|
|
}
|
|
|
|
select {
|
|
case ev := <-sub.C:
|
|
if ev.TaskID != task.ID {
|
|
t.Errorf("event TaskID = %d, want %d", ev.TaskID, task.ID)
|
|
}
|
|
if ev.Kind == "" {
|
|
t.Error("event Kind is empty")
|
|
}
|
|
if tc.action == "retry" {
|
|
if ev.Data["retry_count"] != 1 || ev.Data["previous_reason"] != tc.reason {
|
|
t.Errorf("retry event Data = %#v, want retry count and previous failure", ev.Data)
|
|
}
|
|
}
|
|
default:
|
|
t.Fatalf("%s emitted no event: the activity stream and timeline "+
|
|
"never show that a human intervened", tc.action)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Error mapping. A store failure is not the client's fault, and returning 409
|
|
// tells the UI to say "conflict" for what is actually a broken database.
|
|
func TestTaskActionErrorMapping(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
body string
|
|
setup func(t *testing.T, srv *Server, id int64)
|
|
id func(id int64) string
|
|
wantStatus int
|
|
wantHidden string
|
|
}{
|
|
{
|
|
name: "unknown action",
|
|
body: `{"action":"detonate"}`,
|
|
wantStatus: http.StatusBadRequest,
|
|
},
|
|
{
|
|
name: "malformed body",
|
|
body: `not json`,
|
|
wantStatus: http.StatusBadRequest,
|
|
},
|
|
{
|
|
name: "non-numeric id",
|
|
body: `{"action":"approve"}`,
|
|
id: func(int64) string { return "banana" },
|
|
wantStatus: http.StatusBadRequest,
|
|
},
|
|
{
|
|
name: "unknown task",
|
|
body: `{"action":"approve"}`,
|
|
id: func(int64) string { return "424242" },
|
|
wantStatus: http.StatusNotFound,
|
|
},
|
|
{
|
|
name: "store lookup failure is redacted",
|
|
body: `{"action":"approve"}`,
|
|
setup: func(_ *testing.T, srv *Server, _ int64) {
|
|
srv.Store = &stubStore{TaskStore: srv.Store, taskByIDErr: errors.New("database password leaked")}
|
|
},
|
|
wantStatus: http.StatusInternalServerError,
|
|
wantHidden: "password",
|
|
},
|
|
{
|
|
name: "wrong state",
|
|
body: `{"action":"retry"}`,
|
|
// The task is waiting_human, not parked.
|
|
wantStatus: http.StatusConflict,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
srv, task, _, _, _ := actionServer(t, workflow.StatusWaitingHuman, "review")
|
|
if tc.setup != nil {
|
|
tc.setup(t, srv, task.ID)
|
|
}
|
|
path := strconv.FormatInt(task.ID, 10)
|
|
if tc.id != nil {
|
|
path = tc.id(task.ID)
|
|
}
|
|
|
|
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost,
|
|
"/api/tasks/"+path+"/action", bytes.NewBufferString(tc.body))
|
|
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 != tc.wantStatus {
|
|
t.Fatalf("status = %d, want %d (body %s)", w.Code, tc.wantStatus, w.Body)
|
|
}
|
|
if tc.wantHidden != "" && strings.Contains(w.Body.String(), tc.wantHidden) {
|
|
t.Fatalf("response exposed internal error: %s", w.Body)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// postActionBody posts one raw action body through the dashboard handler.
|
|
func postActionBody(t *testing.T, srv *Server, id int64, body string) *httptest.ResponseRecorder {
|
|
t.Helper()
|
|
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost,
|
|
"/api/tasks/"+strconv.FormatInt(id, 10)+"/action", bytes.NewBufferString(body))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Archie-CSRF", "1")
|
|
w := httptest.NewRecorder()
|
|
srv.Handler().ServeHTTP(w, req)
|
|
return w
|
|
}
|
|
|
|
// TestTaskActionRecordsTheReviewGateAnswer is the dashboard half of Decision
|
|
// 1: the action body carries instructions (required by rereview) and the
|
|
// finding keys approve posts, and the answer lands on the task's review_gate
|
|
// document through the same path chat uses.
|
|
func TestTaskActionRecordsTheReviewGateAnswer(t *testing.T) {
|
|
keep := workflowtask.ReviewGateFinding{Key: "main.go:1:keep", Finding: json.RawMessage(`{"file":"main.go","line_start":1,"title":"keep","body":"keep me"}`)}
|
|
drop := workflowtask.ReviewGateFinding{Key: "main.go:9:drop", Finding: json.RawMessage(`{"file":"main.go","line_start":9,"title":"drop","body":"drop me"}`)}
|
|
offer := workflowtask.EncodeReviewGate(workflowtask.ReviewGate{
|
|
Findings: []workflowtask.ReviewGateFinding{keep, drop}, HeadSHA: "abc", Owner: "acme", Repo: "widget",
|
|
PRNumber: 42, Workflow: "pr-review",
|
|
})
|
|
|
|
t.Run("approve records the selection", func(t *testing.T) {
|
|
srv, task, _, _, _ := actionServer(t, workflow.StatusWaitingHuman, "review")
|
|
if err := srv.Store.Update(t.Context(), &workflow.Task{ID: task.ID, Workflow: "pr-review", ReviewGate: offer}); err != nil {
|
|
t.Fatalf("seed the offer: %v", err)
|
|
}
|
|
w := postActionBody(t, srv, task.ID, fmt.Sprintf(`{"action":"approve","findings":[%q]}`, keep.Key))
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body %s", w.Code, w.Body)
|
|
}
|
|
updated, err := srv.Store.TaskByID(t.Context(), task.ID)
|
|
if err != nil || updated == nil {
|
|
t.Fatalf("TaskByID = (%+v, %v)", updated, err)
|
|
}
|
|
gate, ok := workflowtask.DecodeReviewGate(updated.ReviewGate)
|
|
if !ok || !gate.Approved() {
|
|
t.Fatalf("recorded gate = %q, want an approve", updated.ReviewGate)
|
|
}
|
|
if len(gate.Selection) != 1 || gate.Selection[0] != keep.Key {
|
|
t.Fatalf("recorded selection = %v, want only the posted key", gate.Selection)
|
|
}
|
|
if updated.Status != workflow.StatusQueued {
|
|
t.Fatalf("status = %q, want %q", updated.Status, workflow.StatusQueued)
|
|
}
|
|
})
|
|
|
|
t.Run("rereview records the instructions and clears the offer", func(t *testing.T) {
|
|
srv, task, _, _, _ := actionServer(t, workflow.StatusWaitingHuman, "review")
|
|
if err := srv.Store.Update(t.Context(), &workflow.Task{ID: task.ID, Workflow: "pr-review", ReviewGate: offer}); err != nil {
|
|
t.Fatalf("seed the offer: %v", err)
|
|
}
|
|
w := postActionBody(t, srv, task.ID, `{"action":"rereview","instructions":"the migration ordering"}`)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body %s", w.Code, w.Body)
|
|
}
|
|
updated, err := srv.Store.TaskByID(t.Context(), task.ID)
|
|
if err != nil || updated == nil {
|
|
t.Fatalf("TaskByID = (%+v, %v)", updated, err)
|
|
}
|
|
gate, _ := workflowtask.DecodeReviewGate(updated.ReviewGate)
|
|
if gate.Outcome != workflowtask.GateRereview || gate.Instructions != "the migration ordering" {
|
|
t.Fatalf("recorded gate = %+v, want the re-review outcome and instructions", gate)
|
|
}
|
|
if len(gate.Findings) != 0 {
|
|
t.Fatalf("re-review kept the offer: %+v", gate.Findings)
|
|
}
|
|
if updated.RereviewRounds != 1 {
|
|
t.Fatalf("rereview rounds = %d, want 1 (the guarded write counts it)", updated.RereviewRounds)
|
|
}
|
|
})
|
|
|
|
t.Run("rereview without instructions is refused before any write", func(t *testing.T) {
|
|
srv, task, _, _, _ := actionServer(t, workflow.StatusWaitingHuman, "review")
|
|
if err := srv.Store.Update(t.Context(), &workflow.Task{ID: task.ID, Workflow: "pr-review", ReviewGate: offer}); err != nil {
|
|
t.Fatalf("seed the offer: %v", err)
|
|
}
|
|
w := postActionBody(t, srv, task.ID, `{"action":"rereview"}`)
|
|
if w.Code != http.StatusBadRequest {
|
|
t.Fatalf("status = %d, want 400 (body %s)", w.Code, w.Body)
|
|
}
|
|
updated, err := srv.Store.TaskByID(t.Context(), task.ID)
|
|
if err != nil || updated == nil {
|
|
t.Fatalf("TaskByID = (%+v, %v)", updated, err)
|
|
}
|
|
if updated.Status != workflow.StatusWaitingHuman || updated.RereviewRounds != 0 {
|
|
t.Fatalf("refused re-review changed the row: %+v", updated)
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestTaskActionIsUnscopedAndRemote covers what routing through the Gateway
|
|
// contract has to preserve: the dashboard operator is authenticated and acts
|
|
// across identities, so the action must arrive unscoped rather than claiming
|
|
// some identity of the UI process's own invention.
|
|
func TestTaskActionIsUnscopedAndRemote(t *testing.T) {
|
|
srv, task, _, _, _ := actionServer(t, workflow.StatusWaitingHuman, "review")
|
|
|
|
if w := postAction(t, srv, task.ID, "approve"); w.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body %s", w.Code, w.Body)
|
|
}
|
|
|
|
actions := operatorActions(t, srv)
|
|
if len(actions.scopes) != 1 {
|
|
t.Fatalf("task-action owner saw %d calls, want the handler to have made exactly 1", len(actions.scopes))
|
|
}
|
|
if actions.scopes[0] != nil {
|
|
t.Fatalf("dashboard action arrived scoped to %q, want an unscoped operator", *actions.scopes[0])
|
|
}
|
|
}
|
|
|
|
// TestTaskActionWithoutAContractIsUnavailable: the dashboard has no local
|
|
// task-action implementation to fall back on, and must say so rather than
|
|
// half-applying an action over the task store it can reach.
|
|
func TestTaskActionWithoutAContractIsUnavailable(t *testing.T) {
|
|
srv, task, _, _, _ := actionServer(t, workflow.StatusWaitingHuman, "review")
|
|
srv.Chat = nil
|
|
|
|
w := postAction(t, srv, task.ID, "approve")
|
|
if w.Code != http.StatusServiceUnavailable {
|
|
t.Fatalf("status = %d, want 503 with no gateway contract wired", w.Code)
|
|
}
|
|
got, err := srv.Store.TaskByID(t.Context(), task.ID)
|
|
if err != nil || got == nil {
|
|
t.Fatalf("TaskByID = (%+v, %v)", got, err)
|
|
}
|
|
if got.Status != workflow.StatusWaitingHuman {
|
|
t.Fatalf("task status = %q, want it untouched at %q", got.Status, workflow.StatusWaitingHuman)
|
|
}
|
|
}
|
|
|
|
// A store write failure is a 500, not a 409.
|
|
func TestTaskActionStoreFailureIs500(t *testing.T) {
|
|
base := newTestServer(t)
|
|
ctx := t.Context()
|
|
if _, err := base.Store.EnqueueIssue(ctx, "acme", "widget", 11, "a task", "", "", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, err := base.Store.ClaimNext(ctx)
|
|
if err != nil || task == nil {
|
|
t.Fatalf("ClaimNext = (%+v, %v)", task, err)
|
|
}
|
|
if err := base.Store.Transition(ctx, task.ID, workflow.StatusRunning, workflow.StatusWaitingHuman, "review"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
srv := &Server{
|
|
Store: &stubStore{TaskStore: base.Store, requeueErr: errors.New("db locked")},
|
|
Log: base.Log,
|
|
}
|
|
wireOperatorActions(srv).cfg = config.NewHolder(config.Config{MaxRetries: 3})
|
|
w := postAction(t, srv, task.ID, "approve")
|
|
if w.Code != http.StatusInternalServerError {
|
|
t.Fatalf("status = %d, want 500: a store failure is not a conflict", w.Code)
|
|
}
|
|
}
|
|
|
|
func TestTaskListExposesLifecycleActions(t *testing.T) {
|
|
srv := newTestServer(t)
|
|
ctx := t.Context()
|
|
want := map[string][]string{
|
|
workflow.StatusQueued: {"cancel", "reject"},
|
|
workflow.StatusRunning: {"stop", "reject"},
|
|
workflow.StatusWaitingHuman: {"approve", "reject", "rereview"},
|
|
workflow.StatusParked: {"retry", "abandon", "reject"},
|
|
workflow.StatusPROpen: {"open_pr", "open_issue", "reject"},
|
|
workflow.StatusMerged: {"archive"},
|
|
workflow.StatusRejected: {"archive"},
|
|
workflow.StatusDead: {"archive"},
|
|
workflow.StatusClosedWontDo: {"archive"},
|
|
workflow.StatusCompleted: {"archive"},
|
|
}
|
|
|
|
number := 1
|
|
for status := range want {
|
|
if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", number, status, "", "", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, err := srv.Store.TaskByIssue(ctx, "acme", "widget", number)
|
|
if err != nil || task == nil {
|
|
t.Fatalf("TaskByIssue(%s) = (%+v, %v)", status, task, err)
|
|
}
|
|
taskstatetest.Seed(ctx, t, srv.Store, task.ID, workflow.StatusQueued, status, "test")
|
|
number++
|
|
}
|
|
|
|
req := httptest.NewRequestWithContext(ctx, http.MethodGet, "/api/tasks", nil)
|
|
w := httptest.NewRecorder()
|
|
srv.Handler().ServeHTTP(w, req)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body %s", w.Code, w.Body)
|
|
}
|
|
var got []struct {
|
|
Status string `json:"status"`
|
|
Actions []string `json:"actions"`
|
|
}
|
|
if err := json.Unmarshal(w.Body.Bytes(), &got); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, task := range got {
|
|
if !slices.Equal(task.Actions, want[task.Status]) {
|
|
t.Errorf("actions for %s = %v, want %v", task.Status, task.Actions, want[task.Status])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestLifecycleSpecificTaskActions(t *testing.T) {
|
|
tests := []struct {
|
|
name, from, action, want string
|
|
stopperResult bool
|
|
closesIssue bool
|
|
}{
|
|
{name: "cancel queued", from: workflow.StatusQueued, action: "cancel", want: workflow.StatusClosedWontDo, closesIssue: true},
|
|
{name: "stop running", from: workflow.StatusRunning, action: "stop", want: workflow.StatusParked, stopperResult: true},
|
|
{name: "park stale running row", from: workflow.StatusRunning, action: "stop", want: workflow.StatusParked},
|
|
{name: "abandon parked", from: workflow.StatusParked, action: "abandon", want: workflow.StatusClosedWontDo, closesIssue: false},
|
|
// Reject is available from every non-terminal state and always lands in
|
|
// the terminal Declined state, closing the forge issue.
|
|
{name: "reject queued", from: workflow.StatusQueued, action: "reject", want: workflow.StatusClosedWontDo, closesIssue: true},
|
|
{name: "reject running stops execution", from: workflow.StatusRunning, action: "reject", want: workflow.StatusClosedWontDo, closesIssue: true, stopperResult: true},
|
|
{name: "reject waiting_human", from: workflow.StatusWaitingHuman, action: "reject", want: workflow.StatusClosedWontDo, closesIssue: true},
|
|
{name: "reject parked", from: workflow.StatusParked, action: "reject", want: workflow.StatusClosedWontDo, closesIssue: true},
|
|
{name: "reject pr_open", from: workflow.StatusPROpen, action: "reject", want: workflow.StatusClosedWontDo, closesIssue: true},
|
|
}
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
srv := newTestServer(t)
|
|
ctx := t.Context()
|
|
if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 11, "a task", "", "", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, err := srv.Store.TaskByIssue(ctx, "acme", "widget", 11)
|
|
if err != nil || task == nil {
|
|
t.Fatalf("TaskByIssue = (%+v, %v)", task, err)
|
|
}
|
|
taskstatetest.Seed(ctx, t, srv.Store, task.ID, workflow.StatusQueued, tc.from, "test")
|
|
closer := &recordingCloser{}
|
|
operatorActions(t, srv).issues = closer
|
|
bus := events.NewBus()
|
|
t.Cleanup(bus.Close)
|
|
srv.Events = bus
|
|
sub := bus.Subscribe(1)
|
|
if tc.action == "stop" || (tc.action == "reject" && tc.from == workflow.StatusRunning) {
|
|
setTaskStopper(t, srv, &recordingTaskStopper{result: tc.stopperResult})
|
|
}
|
|
if w := postAction(t, srv, task.ID, tc.action); w.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body %s", w.Code, w.Body)
|
|
}
|
|
got, err := srv.Store.TaskByID(ctx, task.ID)
|
|
if err != nil || got == nil || got.Status != tc.want {
|
|
t.Fatalf("task = (%+v, %v), want status %s", got, err, tc.want)
|
|
}
|
|
if got := len(closer.calls) > 0; got != tc.closesIssue {
|
|
t.Errorf("forge issue closed = %v, want %v", got, tc.closesIssue)
|
|
}
|
|
select {
|
|
case event := <-sub.C:
|
|
if event.TaskID != task.ID || event.Kind == "" {
|
|
t.Errorf("event = %+v", event)
|
|
}
|
|
default:
|
|
t.Error("operator action emitted no activity event")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestArchiveRemovesOnlyOneTerminalTask(t *testing.T) {
|
|
srv := newTestServer(t)
|
|
ctx := t.Context()
|
|
for number := 1; number <= 2; number++ {
|
|
if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", number, "done", "", "", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, err := srv.Store.TaskByIssue(ctx, "acme", "widget", number)
|
|
if err != nil || task == nil {
|
|
t.Fatalf("TaskByIssue = (%+v, %v)", task, 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()
|
|
t.Cleanup(bus.Close)
|
|
srv.Events = bus
|
|
sub := bus.Subscribe(1)
|
|
if w := postAction(t, srv, task.ID, "archive"); w.Code != http.StatusOK {
|
|
t.Fatalf("archive status = %d, body %s", w.Code, w.Body)
|
|
}
|
|
if got, err := srv.Store.TaskByID(ctx, task.ID); err != nil || got != nil {
|
|
t.Fatalf("archived task = (%+v, %v), want nil", got, err)
|
|
}
|
|
if other, err := srv.Store.TaskByIssue(ctx, "acme", "widget", 2); err != nil || other == nil {
|
|
t.Fatalf("archive removed another task: (%+v, %v)", other, err)
|
|
}
|
|
history, err := srv.Store.EventsSince(ctx, "", 10)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(history) != 1 || history[0].Kind != events.KindTaskArchiveRequested || history[0].ID == 0 {
|
|
t.Fatalf("durable archive audit = %+v", history)
|
|
}
|
|
select {
|
|
case event := <-sub.C:
|
|
if event.Kind != events.KindTaskArchiveRequested || event.TaskID != task.ID {
|
|
t.Errorf("archive event = %+v", event)
|
|
}
|
|
default:
|
|
t.Error("archive emitted no activity event")
|
|
}
|
|
}
|
|
|
|
// TestArchiveRemovesTheTaskLogDirectory guards the cleanup half of task
|
|
// logging: without this, an archived task's log files (and every rotated
|
|
// generation under it) would accumulate on disk forever, since nothing else
|
|
// in the system ever visits a task again once it leaves the active board.
|
|
//
|
|
// The removal is the task owner's, not the dashboard's: the log files live in
|
|
// the state directory, which the daemon owns, so the stand-in daemon holds the
|
|
// registry the way the real one does. The dashboard reads logs through a
|
|
// contract and has no directory to remove anything from.
|
|
func TestArchiveRemovesTheTaskLogDirectory(t *testing.T) {
|
|
srv := newTestServer(t)
|
|
ctx := t.Context()
|
|
baseDir := t.TempDir()
|
|
logs := logging.NewTaskRegistry(baseDir, logging.NewFeed(10), logging.TaskSinkOptions{})
|
|
operatorActions(t, srv).logs = logs
|
|
|
|
if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 1, "done", "", "", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, _ := srv.Store.TaskByIssue(ctx, "acme", "widget", 1)
|
|
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)
|
|
}
|
|
logs.Write(ctx, task.ID, logging.Entry{Message: "line"})
|
|
if err := logs.Close(task.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
dir := logging.TaskLogDir(baseDir, task.ID)
|
|
if _, err := os.Stat(dir); err != nil {
|
|
t.Fatalf("task log dir missing before archive: %v", err)
|
|
}
|
|
|
|
if w := postAction(t, srv, task.ID, "archive"); w.Code != http.StatusOK {
|
|
t.Fatalf("archive status = %d, body %s", w.Code, w.Body)
|
|
}
|
|
if _, err := os.Stat(dir); !os.IsNotExist(err) {
|
|
t.Errorf("task log dir still present after archive: err=%v", err)
|
|
}
|
|
}
|
|
|
|
func TestArchiveAuditFailurePreservesTaskAndFailsRequest(t *testing.T) {
|
|
srv := newTestServer(t)
|
|
ctx := t.Context()
|
|
if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 1, "done", "", "", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, _ := srv.Store.TaskByIssue(ctx, "acme", "widget", 1)
|
|
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")}
|
|
|
|
if w := postAction(t, srv, task.ID, "archive"); w.Code != http.StatusInternalServerError {
|
|
t.Fatalf("archive status = %d, want 500", w.Code)
|
|
}
|
|
if got, err := base.TaskByID(ctx, task.ID); err != nil || got == nil {
|
|
t.Fatalf("failed archive removed task: (%+v, %v)", got, err)
|
|
}
|
|
}
|
|
|
|
func TestTaskActionRejectsUnsafeRequests(t *testing.T) {
|
|
srv := newTestServer(t)
|
|
ctx := t.Context()
|
|
if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 1, "queued", "", "", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, _ := srv.Store.TaskByIssue(ctx, "acme", "widget", 1)
|
|
path := "/api/tasks/" + strconv.FormatInt(task.ID, 10) + "/action"
|
|
tests := []struct {
|
|
name, body, contentType, csrf, origin string
|
|
want int
|
|
}{
|
|
{name: "cross origin", body: `{"action":"cancel"}`, contentType: "application/json", csrf: "1", origin: "https://evil.example", want: http.StatusForbidden},
|
|
{name: "non JSON", body: `{"action":"cancel"}`, contentType: "text/plain", csrf: "1", want: http.StatusUnsupportedMediaType},
|
|
{name: "oversized", body: strings.Repeat(" ", 5000) + `{"action":"cancel"}`, contentType: "application/json", csrf: "1", want: http.StatusRequestEntityTooLarge},
|
|
{name: "unknown field", body: `{"action":"cancel","status":"queued"}`, contentType: "application/json", csrf: "1", want: http.StatusBadRequest},
|
|
}
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
req := httptest.NewRequestWithContext(ctx, http.MethodPost, path, strings.NewReader(tc.body))
|
|
req.Header.Set("Content-Type", tc.contentType)
|
|
req.Header.Set("X-Archie-CSRF", tc.csrf)
|
|
if tc.origin != "" {
|
|
req.Header.Set("Origin", tc.origin)
|
|
}
|
|
w := httptest.NewRecorder()
|
|
srv.Handler().ServeHTTP(w, req)
|
|
if w.Code != tc.want {
|
|
t.Fatalf("status = %d, want %d (body %s)", w.Code, tc.want, w.Body)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTaskActionRequiresCSRFHeader(t *testing.T) {
|
|
srv := newTestServer(t)
|
|
ctx := t.Context()
|
|
if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 1, "queued", "", "", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, _ := srv.Store.TaskByIssue(ctx, "acme", "widget", 1)
|
|
req := httptest.NewRequestWithContext(ctx, http.MethodPost,
|
|
"/api/tasks/"+strconv.FormatInt(task.ID, 10)+"/action",
|
|
bytes.NewBufferString(`{"action":"cancel"}`))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
srv.Handler().ServeHTTP(w, req)
|
|
if w.Code != http.StatusForbidden {
|
|
t.Fatalf("status = %d, want 403 without CSRF header (body %s)", w.Code, w.Body)
|
|
}
|
|
}
|
|
|
|
// TestRetryCarriesTheWorktreeModeToTheStore is the dashboard half of the
|
|
// operator retry choice: the mode in the action body reaches the store write,
|
|
// so the daemon reads the operator's choice rather than inferring one. The
|
|
// refusal case pins that continuing with nothing pushed is a conflict, not a
|
|
// queued resume.
|
|
func TestRetryCarriesTheWorktreeModeToTheStore(t *testing.T) {
|
|
t.Run("continue pushed work persists the choice", func(t *testing.T) {
|
|
srv, task, _, _, _ := actionServer(t, workflow.StatusParked, "it broke")
|
|
if err := srv.Store.Update(t.Context(), &workflow.Task{ID: task.ID, Branch: "fix/11-thing"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
w := postActionBody(t, srv, task.ID, `{"action":"retry","retry_mode":"continue_pushed_work"}`)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200 (body %s)", w.Code, w.Body)
|
|
}
|
|
|
|
got, err := srv.Store.TaskByID(t.Context(), task.ID)
|
|
if err != nil || got == nil {
|
|
t.Fatalf("TaskByID = (%+v, %v)", got, err)
|
|
}
|
|
if got.RetryMode != string(taskstate.RetryContinuePushedWork) {
|
|
t.Errorf("retry_mode = %q, want %q", got.RetryMode, taskstate.RetryContinuePushedWork)
|
|
}
|
|
})
|
|
|
|
t.Run("continue with no branch is refused", func(t *testing.T) {
|
|
srv, task, _, _, _ := actionServer(t, workflow.StatusParked, "it broke")
|
|
|
|
w := postActionBody(t, srv, task.ID, `{"action":"retry","retry_mode":"continue_pushed_work"}`)
|
|
if w.Code != http.StatusConflict {
|
|
t.Fatalf("status = %d, want 409 (body %s)", w.Code, w.Body)
|
|
}
|
|
|
|
got, err := srv.Store.TaskByID(t.Context(), task.ID)
|
|
if err != nil || got == nil {
|
|
t.Fatalf("TaskByID = (%+v, %v)", got, err)
|
|
}
|
|
if got.Status != workflow.StatusParked {
|
|
t.Errorf("status = %q, want the task left parked", got.Status)
|
|
}
|
|
})
|
|
}
|