The transport could carry an actor and nothing filled it. It does now, so a dashboard approval is recorded as the person whose credential verified, and an agent's token is recorded as the agent's action -- for an agent, agent_approved; for a person, human_approved; and for a caller whose identity archie could not verify, task_approved, which claims nothing about who did it. The actor travels the path the action takes: webui reads it from the request context the middleware resolved, carries it in the gateway request, the daemon passes it through the in-process adapter, and the NATS request body carries it to the service that records it. Scope stays separate from actor at every hop, because scope is which task a caller may touch and the actor is who touched it. A chat channel's bound identity is an actor too: a bot acting on its own channel's task is recorded as an agent's action rather than a person's, via ActorFromScope, whose empty kind is what keeps it out of human_approved. The agent-facing task_action tool passes that identity and never input["identity"]. The UI process's credential check is now filled by endpoint references rather than by configuration: -oidc-issuer and -oidc-audience on archie-ui, two URLs the process already understands the shape of, with the verifier built in Run because cmd/ parses flags and nothing else. The UI package still never reads config, and a configured provider that cannot be reached fails boot rather than falling back to the gate that names nobody. Evidence for this change, stated as measured: go build ./... and go vet ./... are clean, and every package this touches passes -- webui, domain/taskactions, infrastructure/taskactions, infrastructure/gatewayrpc, gateway, app/archieui, app/archied, domain/messaging, channels/telegram, cmd/archie-ui. task check could not be run to completion: it fails in cmd/archie-messaging on an untracked internal/buildinfo package another lane has in flight, which is not this change and was left untouched. The end-to-end flip is covered in internal/webui/api_tasks_actor_test.go: a person's credential produces a record naming that person with human_approved, an agent's produces agent_approved, an unverified request produces task_approved with no actor, and a request carrying forged actor fields cannot name one.
822 lines
29 KiB
Go
822 lines
29 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/taskactions"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow"
|
|
"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/store"
|
|
"github.com/samcharles93/archie-core/internal/taskstate"
|
|
)
|
|
|
|
// 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,
|
|
) (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(),
|
|
d.publish(),
|
|
d.srv.logf,
|
|
)
|
|
if err := service.Apply(ctx, identity, actor, id, action); 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)
|
|
}
|
|
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusRunning, status, parkReason); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
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 {
|
|
store.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)
|
|
}
|
|
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusQueued, workflow.StatusParked, "re-parked for test fixture"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
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", "", "", "")
|
|
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)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// 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"},
|
|
workflow.StatusParked: {"retry", "abandon", "reject"},
|
|
workflow.StatusPROpen: {"open_pr", "open_issue", "reject"},
|
|
workflow.StatusMerged: {"archive"},
|
|
workflow.StatusRejected: {"archive"},
|
|
workflow.StatusDead: {"archive"},
|
|
workflow.StatusClosedWontDo: {"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)
|
|
}
|
|
if status != workflow.StatusQueued {
|
|
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusQueued, status, "test"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
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: true},
|
|
// 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)
|
|
}
|
|
if tc.from != workflow.StatusQueued {
|
|
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusQueued, tc.from, "test"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
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)
|
|
}
|
|
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusQueued, workflow.StatusMerged, "done"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
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, 0, 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)
|
|
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusQueued, workflow.StatusMerged, "done"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
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)
|
|
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusQueued, workflow.StatusMerged, "done"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
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)
|
|
}
|
|
}
|