Files
archie/internal/webui/api_tasks_test.go
T
sam 21710f1147 test(ui): smoke the archie-ui process against live dependencies
The in-process suite proved the composition; nothing proved the process.
This builds the real binary, points it at a State Store and a Gateway on
loopback gRPC through an operator-shaped config.toml, and drives it over
HTTP: the token exchange and its 401s, the embedded SPA, a chat stream
relayed frame by frame, an operator task action crossing to the Gateway
and refused without the CSRF header, unauthenticated capture intake, the
ratified degradations, readiness dropping when a dependency dies while
liveness holds, and a clean SIGTERM.

It found one regression, fixed here at the producer. Task rows lost their
forge links in the extracted process: taskURLs read config.Holder, which
is nil once the dashboard stops sharing the daemon's process, so every
click-through to the issue and the PR silently disappeared. The forge is
now resolved once per request from whichever source that process owns,
the daemon's configuration or the daemon's published projection.

A multi-identity deployment keeps no links rather than gaining wrong ones:
the projection carries the default identity alone, so it now says so and
the renderer withholds.
2026-09-11 20:10:59 +10:00

250 lines
8.5 KiB
Go

package webui
// Tests for the task-timeline route. The dashboard's "Click a row for its
// timeline" interaction depends on GET /api/tasks/{id} returning exactly that
// task's events, ordered, and on the literal /api/tasks/clear route beating
// the {id} wildcard.
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
"net/http/httptest"
"strconv"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/events"
)
func TestTaskURLsUseOwningForgeRoutes(t *testing.T) {
srv := &Server{Cfg: config.NewHolder(config.Config{
Forge: config.Forge{Type: "github", Host: "https://github.example"},
Identities: []config.IdentityConfig{{
Name: "gitea", Forge: config.Forge{Type: "gitea", Host: "https://gitea.example"},
Repos: []config.Repo{{Owner: "acme", Name: "widget"}},
}},
})}
task := workflow.Task{Owner: "acme", Repo: "widget", IssueNumber: 12, PRNumber: 34, Identity: "gitea"}
forge := srv.resolveForge(t.Context())
repoURL, issueURL, prURL := taskURLs(task, forge(task))
if repoURL != "https://gitea.example/acme/widget" || issueURL != repoURL+"/issues/12" || prURL != repoURL+"/pulls/34" {
t.Fatalf("URLs = %q, %q, %q; want canonical Gitea routes", repoURL, issueURL, prURL)
}
task.Identity = ""
task.Owner, task.Repo = "other", "repo"
_, _, prURL = taskURLs(task, forge(task))
if prURL != "https://github.example/other/repo/pull/34" {
t.Fatalf("GitHub PR URL = %q", prURL)
}
}
// A process with no configuration of its own still has to render the links,
// or the extracted dashboard loses every click-through to the issue and the
// pull request it opened. The daemon's published projection is where they
// come from once the holder is gone.
func TestTaskURLsFallBackToThePublishedProjection(t *testing.T) {
tests := []struct {
name string
view ConfigView
ok bool
err error
wantPR string
wantURL string
}{
{
name: "published projection",
view: ConfigView{Identity: IdentityView{ForgeType: "github", ForgeHost: "https://github.example"}},
ok: true,
wantURL: "https://github.example/acme/widget",
wantPR: "https://github.example/acme/widget/pull/34",
},
{
name: "multi-identity publishes only the default forge, so links are withheld",
view: ConfigView{
Identity: IdentityView{ForgeType: "github", ForgeHost: "https://github.example"},
MultiIdentity: true,
},
ok: true,
},
{
name: "no snapshot published yet",
},
{
name: "snapshot read failed",
err: errors.New("state store down"),
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
srv := &Server{ConfigSource: func(context.Context) (ConfigView, bool, error) {
return tc.view, tc.ok, tc.err
}}
task := workflow.Task{Owner: "acme", Repo: "widget", IssueNumber: 12, PRNumber: 34}
forge := srv.resolveForge(t.Context())
repoURL, _, prURL := taskURLs(task, forge(task))
if repoURL != tc.wantURL || prURL != tc.wantPR {
t.Fatalf("repo/PR URLs = %q, %q; want %q, %q", repoURL, prURL, tc.wantURL, tc.wantPR)
}
})
}
}
// Approve requeues from the task's own recorded state rather than anything
// the caller supplies, so a stale dashboard cannot approve a task twice.
func TestHandleTaskActionApproveUsesRecordedState(t *testing.T) {
srv := newTestServer(t)
ctx := t.Context()
if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 1, "approve me", "", "", ""); err != nil {
t.Fatal(err)
}
task, err := srv.Store.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("claim = (%+v, %v)", task, err)
}
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusRunning, workflow.StatusWaitingHuman, "review"); err != nil {
t.Fatal(err)
}
req := httptest.NewRequestWithContext(ctx, http.MethodPost, "/api/tasks/"+strconv.FormatInt(task.ID, 10)+"/action", bytes.NewBufferString(`{"action":"approve"}`))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-Archie-CSRF", "1")
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Fatalf("approve status = %d, body = %s", w.Code, 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 != workflow.StatusQueued || got.Workflow != "implement" {
t.Fatalf("approved task = %+v, want queued/implement", got)
}
}
func TestHandleTaskActionRetriesParkedTask(t *testing.T) {
srv := newTestServer(t)
ctx := t.Context()
if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 1, "retry me", "", "", ""); err != nil {
t.Fatal(err)
}
task, err := srv.Store.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("claim = (%+v, %v)", task, err)
}
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusRunning, workflow.StatusParked, "failed"); err != nil {
t.Fatal(err)
}
req := httptest.NewRequestWithContext(ctx, http.MethodPost, "/api/tasks/"+strconv.FormatInt(task.ID, 10)+"/action", bytes.NewBufferString(`{"action":"retry"}`))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-Archie-CSRF", "1")
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Fatalf("retry status = %d, body = %s", w.Code, 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 != workflow.StatusQueued || got.RetryCount != 1 {
t.Fatalf("retried task = %+v, want queued/retry_count=1", got)
}
}
// TestHandleTaskIsolatesTasks returns the timeline for one task, and only
// that task: another task's events must not leak into the response.
func TestHandleTaskIsolatesTasks(t *testing.T) {
srv := newTestServer(t)
ctx := t.Context()
for _, ev := range []events.Event{
{TaskID: 7, Kind: "stage_start", Stage: "plan", Detail: "bootstrap"},
{TaskID: 7, Kind: "stage_end", Stage: "plan"},
{TaskID: 8, Kind: "stage_start", Stage: "implement"},
} {
if _, err := srv.Store.InsertEvent(ctx, ev); err != nil {
t.Fatal(err)
}
}
req := httptest.NewRequestWithContext(ctx, http.MethodGet, "/api/tasks/7", 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 []events.Event
if err := json.Unmarshal(w.Body.Bytes(), &got); err != nil {
t.Fatal(err)
}
if len(got) != 2 {
t.Fatalf("timeline has %d events, want 2 (task 8 must not leak in)", len(got))
}
if got[0].Kind != "stage_start" || got[0].Stage != "plan" {
t.Errorf("first event = %+v, want stage_start/plan", got[0])
}
}
// TestHandleTaskUnknownID returns an empty list, not an error, for a task id
// that has no events yet -- the UI renders "No events yet" from that.
func TestHandleTaskUnknownID(t *testing.T) {
srv := newTestServer(t)
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/tasks/999", nil)
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, want 200", w.Code)
}
if body := strings.TrimSpace(w.Body.String()); body != "null" && body != "[]" {
t.Fatalf("body = %s, want an empty timeline", body)
}
}
// TestHandleTaskBadID is covered in webui_test.go (400 on a non-numeric id).
// TestHandleTaskStoreError proves a store failure surfaces as 500 -- the UI
// shows its "Could not load timeline" state and offers a retry.
func TestHandleTaskStoreError(t *testing.T) {
base := newTestServer(t)
srv := &Server{
Store: &stubStore{TaskStore: base.Store, taskEventsErr: fmt.Errorf("db locked")},
Log: base.Log,
}
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/tasks/7", nil)
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusInternalServerError {
t.Fatalf("status = %d, want 500", w.Code)
}
}
func TestBulkClearRouteCannotMutateTasks(t *testing.T) {
srv := newTestServer(t)
if _, err := srv.Store.EnqueueIssue(t.Context(), "acme", "widget", 1, "task", "", "", ""); err != nil {
t.Fatal(err)
}
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/tasks/clear", nil)
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code == http.StatusOK {
t.Fatal("GET /api/tasks/clear still exposes a destructive mutation")
}
tasks, err := srv.Store.Tasks(t.Context(), 10)
if err != nil || len(tasks) != 1 {
t.Fatalf("tasks after legacy clear request = (%d, %v), want one preserved", len(tasks), err)
}
}