Files
archie/internal/webui/api_tasks_actions_test.go
T
sam a7d6f71d5a feat(identity): verify provider tokens and attribute task actions to their actor
Two halves of one boundary: a credential resolves to an identity, and an action
records which identity acted and whose authority it used.

resource server. internal/infrastructure/oidc verifies a provider-issued bearer
token against the provider's published keys, using an OSS OIDC library: archie
compares no signature, validates no claim and rotates no key itself, holds no
client secret and issues no session, so a compromised archie cannot mint an
identity. Audience is required rather than optional -- a token minted for another
service must not authenticate here -- and discovery happens at construction, so an
unreachable provider is a startup failure rather than a request-time surprise.

identity.Authenticate is the single place a credential becomes an identity, and it
refuses in four distinguishable ways: no credential presented, a credential that
did not verify (wrong key, expired, wrong issuer, wrong audience, malformed), a
verified subject with no identity bound to it, and an identity that may not act.
The order is deliberate: verification happens before any field of the token is
used, so nothing an unverified token carries can select an identity. A suspended
identity is refused even though its credential verified, because suspension is
archie's decision and must not depend on the provider withdrawing a token.

The binding is the second bridge beside the legacy-name alias: identity_subjects
keys (issuer, subject) so the same subject string from another issuer is a
different caller, and rebinding moves a subject so two identities can never claim
one provider subject. The contract Authenticate needs is SubjectResolver, narrower
than Repository, so a consumer that only authenticates does not take the whole
identity CRUD surface -- and staterpc.Client, which asserts Repository, does not
need a new RPC to satisfy it.

attribution. taskactions now records two identities per action: the acting
identity and the authorising principal, both on the event row as new columns added
through the existing migration table. The rule that the bug turned on is enforced
by the event kind describing the actor: a person's approval is human_approved, an
agent's is agent_approved, and an action with no verified actor is task_approved,
a task-level event that credits nobody. An agent acting under a person's standing
approval records itself as the actor and that person as the principal, so
"approved by came from me" is answerable from the record rather than asserted.
Scope and actor are separated: scope decides which task a caller may touch and is
never promoted into an actor, because the dashboard's credential is a shared token
and possession of it is not evidence that a person was at the keyboard.

That last point is a deliberate fidelity trade, and the reason the transport is
not wired: the dashboard action path passes no actor yet, so dashboard approvals
are now recorded as task_approved rather than claimed as a human's. Recording
nothing false is the requirement; naming the human verifiably needs the dashboard
to authenticate a token and resolve it, which needs two new state-store RPCs
(ResolveIdentitySubject, BindIdentitySubject) -- the next piece, not a rewrite:
the verifier is a one-method interface, so introspection would be a second
implementation of it.

Verified: task check exit 0; focused runs recorded in the handoff. Opaque
authelia_at_ tokens were inspected rather than assumed and cannot be verified
against public keys; infra is configuring access_token_signed_response_alg RS256
on the archie client, with audience https://archie.catlow.cloud and issuer
https://auth.catlow.cloud.
2026-09-22 14:34:16 +10:00

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, 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, taskactions.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)
}
}