Files
archie/internal/webui/api_workflows_test.go
T
sam 5891d581cb fix(webui): the workflow handlers act in the caller's org
The definitions query was built by hand, so it carried no org and the server
resolved the default one, while the enablement document read beside it and the
enablement write went to the default org outright. A caller in a non-default
org therefore read one org's definitions beside another org's enablement, and
toggled that other org's workflows.

workflowCollection now builds its query with controlplanerpc.QueryRequest, and
the three enablement reads and the write use org.OrgFromContext, so every one of
them names the org the principal put on the request context.
2026-09-30 07:33:16 +10:00

316 lines
13 KiB
Go

package webui
import (
"bytes"
"context"
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"strings"
"testing"
controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/gateway"
)
func workflowControlPlane(t *testing.T, definitions workflow.WorkflowDefinitionCollection) *controlPlaneClientStub {
t.Helper()
value, err := json.Marshal(definitions)
if err != nil {
t.Fatal(err)
}
return &controlPlaneClientStub{query: &controlpb.Resource{Kind: "workflow-definitions", Version: 1, ValueJson: value}}
}
// workflowOrgControlPlane is the control-plane stub holding the two resources
// the workflows handlers read together -- the definition collection and the
// enablement document -- so a test can read back the org each was asked for.
func workflowOrgControlPlane(t *testing.T, definitions workflow.WorkflowDefinitionCollection, enablement string) *controlPlaneClientStub {
t.Helper()
value, err := json.Marshal(definitions)
if err != nil {
t.Fatal(err)
}
return &controlPlaneClientStub{resources: map[string]*controlpb.Resource{
workflowDefinitionsKind: {Kind: workflowDefinitionsKind, Version: 1, ValueJson: value},
workflowEnablementKind: {Kind: workflowEnablementKind, Version: 1, ValueJson: []byte(enablement)},
}}
}
// doJSONInOrg issues a request acting in orgID, or in no org at all when orgID
// is empty. The org travels on the request context (org.WithOrg) exactly as
// authorize attaches the verified principal's, so a test reads back the org a
// handler acts in the way production puts it there.
func doJSONInOrg(t *testing.T, srv *Server, orgID org.OrgID, method, path string, body any) *httptest.ResponseRecorder {
t.Helper()
var reader io.Reader
if body != nil {
encoded, err := json.Marshal(body)
if err != nil {
t.Fatalf("marshal request body: %v", err)
}
reader = bytes.NewReader(encoded)
}
ctx := t.Context()
if orgID != "" {
ctx = org.WithOrg(ctx, orgID)
}
r := httptest.NewRequestWithContext(ctx, method, path, reader)
r.Header.Set("Content-Type", "application/json")
r.Header.Set("X-Archie-CSRF", "1")
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, r)
return w
}
type recordingWorkRequestCreator struct{ request gateway.SpawnRequest }
func (c *recordingWorkRequestCreator) CreateTask(_ context.Context, request gateway.SpawnRequest) (int64, error) {
c.request = request
return 42, nil
}
func TestWorkflowsIncludeInstalledZeroRunDefinitions(t *testing.T) {
srv := newTestServer(t)
srv.ControlPlane = workflowControlPlane(t, workflow.WorkflowDefinitionCollection{Definitions: []workflow.WorkflowDefinitionEntry{{ID: "custom", YAML: "id: custom\nsteps:\n - type: implement.prepare\n - type: implement.plan\n"}}})
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/workflows", nil))
if w.Code != http.StatusOK {
t.Fatalf("status = %d, body = %s", w.Code, w.Body)
}
var response struct {
Definitions []workflow.Definition `json:"definitions"`
}
if err := json.Unmarshal(w.Body.Bytes(), &response); err != nil {
t.Fatal(err)
}
if len(response.Definitions) != 1 || response.Definitions[0].ID != "custom" || response.Definitions[0].Origin != "database" {
t.Fatalf("definitions = %#v", response.Definitions)
}
}
// TestWorkflowDefinitionsPathActsInTheCallersOrg: the definitions listing and
// the enablement read beside it both act in the caller's org. A handler that
// reads the definitions in the caller's org while reading the enablement in the
// default org reports another org's enablement as the caller's own.
func TestWorkflowDefinitionsPathActsInTheCallersOrg(t *testing.T) {
// acme has disabled custom; the default org has not.
const enablement = `{"orgs":{"acme":{"disabled":["custom"]}}}`
tests := []struct {
name string
orgID org.OrgID
want org.OrgID
wantEnabled bool
}{
{name: "a caller resolved into acme", orgID: "acme", want: "acme"},
{name: "no org on the context is the default org", want: org.DefaultOrgID, wantEnabled: true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
srv := newTestServer(t)
stub := workflowOrgControlPlane(t, workflow.WorkflowDefinitionCollection{Definitions: []workflow.WorkflowDefinitionEntry{{ID: "custom", YAML: "id: custom\nsteps:\n - type: implement.prepare\n"}}}, enablement)
srv.ControlPlane = stub
w := doJSONInOrg(t, srv, tt.orgID, http.MethodGet, "/api/workflows", nil)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, body = %s", w.Code, w.Body)
}
queried := map[string]bool{}
for _, request := range stub.queries {
queried[request.GetKind()] = true
if got := request.GetOrgId(); got != string(tt.want) {
t.Errorf("%s query carried org %q, want %q", request.GetKind(), got, tt.want)
}
}
if !queried[workflowDefinitionsKind] || !queried[workflowEnablementKind] {
t.Fatalf("definitions path queried %v, want both %s and %s", queried, workflowDefinitionsKind, workflowEnablementKind)
}
var response struct {
Definitions []workflow.Definition `json:"definitions"`
}
if err := json.Unmarshal(w.Body.Bytes(), &response); err != nil {
t.Fatal(err)
}
if len(response.Definitions) != 1 || response.Definitions[0].Enabled != tt.wantEnabled {
t.Fatalf("definitions = %#v, want custom enabled=%v", response.Definitions, tt.wantEnabled)
}
})
}
}
// TestWorkRequestEnablementReadsTheCallersOrg: whether a workflow may run is
// the caller's org's answer, so the org that disabled pr-review cannot run it
// while an org that did not can.
func TestWorkRequestEnablementReadsTheCallersOrg(t *testing.T) {
const enablement = `{"orgs":{"acme":{"disabled":["pr-review"]}}}`
request := map[string]any{
"identity": "archie", "repository": "acme/widget", "workflow": "pr-review",
"title": "Review 77", "instructions": "Review it.", "inputs": map[string]any{"pr_number": 77},
}
tests := []struct {
name string
orgID org.OrgID
want org.OrgID
wantCode int
}{
{name: "a caller in the org that disabled it", orgID: "acme", want: "acme", wantCode: http.StatusConflict},
{name: "a caller in the org that kept it enabled", want: org.DefaultOrgID, wantCode: http.StatusCreated},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
srv := newTestServer(t)
creator := &recordingWorkRequestCreator{}
srv.WorkRequests = creator
stub := workflowOrgControlPlane(t, workflow.WorkflowDefinitionCollection{Definitions: []workflow.WorkflowDefinitionEntry{{ID: "pr-review", YAML: declaredInputsDefinition}}}, enablement)
srv.ControlPlane = stub
w := doJSONInOrg(t, srv, tt.orgID, http.MethodPost, "/api/work-requests", request)
if w.Code != tt.wantCode {
t.Fatalf("status = %d, body = %s, want %d", w.Code, w.Body, tt.wantCode)
}
for _, query := range stub.queries {
if got := query.GetOrgId(); got != string(tt.want) {
t.Errorf("%s query carried org %q, want %q", query.GetKind(), got, tt.want)
}
}
if admitted := creator.request.Title != ""; admitted != (tt.wantCode == http.StatusCreated) {
t.Errorf("task admitted = %v, want %v", admitted, tt.wantCode == http.StatusCreated)
}
})
}
}
// declaredInputsDefinition is a pr-review-shaped definition: it declares the
// inputs the handler checks a work request against, one of them required, so a
// request that does not name a pull request number cannot be admitted.
const declaredInputsDefinition = `id: pr-review
inputs:
pr_number:
type: number
required: true
depth:
type: string
steps:
- type: implement.prepare
`
func postWorkRequest(t *testing.T, srv *Server, body string) *httptest.ResponseRecorder {
t.Helper()
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/api/work-requests", strings.NewReader(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
}
// TestWorkRequestCarriesDeclaredInputs: a dashboard request names the workflow's
// declared inputs and the admitted task carries them, so a pr-review request
// reaches its workflow with the pull request number stagePRIntake reads
// (archie-core-06nq).
func TestWorkRequestCarriesDeclaredInputs(t *testing.T) {
srv := newTestServer(t)
creator := &recordingWorkRequestCreator{}
srv.WorkRequests = creator
srv.ControlPlane = workflowControlPlane(t, workflow.WorkflowDefinitionCollection{Definitions: []workflow.WorkflowDefinitionEntry{{ID: "pr-review", YAML: declaredInputsDefinition}}})
w := postWorkRequest(t, srv, `{"identity":"archie","repository":"acme/widget","workflow":"pr-review","title":"Review 77","instructions":"Review it.","inputs":{"pr_number":77,"depth":"deep"}}`)
if w.Code != http.StatusCreated {
t.Fatalf("status = %d, body = %s", w.Code, w.Body)
}
if got := creator.request.Inputs["pr_number"]; got != float64(77) {
t.Errorf("pr_number input = %#v, want the number the request sent", got)
}
if got := creator.request.Inputs["depth"]; got != "deep" {
t.Errorf("depth input = %#v, want \"deep\"", got)
}
// EffectivePRNumber is how the daemon and stagePRIntake read the input, so
// the assignment is proven against the consumer rather than against the
// map's shape alone.
if got := (workflow.Task{Inputs: creator.request.Inputs}).EffectivePRNumber(); got != 77 {
t.Errorf("EffectivePRNumber() = %d, want 77", got)
}
}
// TestWorkRequestRejectsUnmetDeclaredInputs: the request is refused at the
// producer, naming the input, instead of being admitted and then parked or
// failed at the workflow's first stage.
func TestWorkRequestRejectsUnmetDeclaredInputs(t *testing.T) {
tests := []struct {
name string
body string
want string
}{
{
name: "missing a required input",
body: `{"identity":"archie","repository":"acme/widget","workflow":"pr-review","title":"Review","instructions":"Review it."}`,
want: `input "pr_number" is required`,
},
{
name: "naming an input the workflow does not declare",
body: `{"identity":"archie","repository":"acme/widget","workflow":"pr-review","title":"Review","instructions":"Review it.","inputs":{"pr_number":77,"pull_request":77}}`,
want: `input "pull_request" is not declared by the workflow`,
},
{
name: "a value of the wrong type",
body: `{"identity":"archie","repository":"acme/widget","workflow":"pr-review","title":"Review","instructions":"Review it.","inputs":{"pr_number":"seventy-seven"}}`,
want: `input "pr_number" is string, want number`,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
srv := newTestServer(t)
creator := &recordingWorkRequestCreator{}
srv.WorkRequests = creator
srv.ControlPlane = workflowControlPlane(t, workflow.WorkflowDefinitionCollection{Definitions: []workflow.WorkflowDefinitionEntry{{ID: "pr-review", YAML: declaredInputsDefinition}}})
w := postWorkRequest(t, srv, tt.body)
if w.Code != http.StatusBadRequest {
t.Fatalf("status = %d, body = %s", w.Code, w.Body)
}
if !strings.Contains(w.Body.String(), tt.want) {
t.Errorf("body = %q, want it to name the failure %q", w.Body, tt.want)
}
if got := creator.request; got.Title != "" || got.Body != "" || len(got.Inputs) != 0 {
t.Errorf("creator called with %#v", got)
}
})
}
}
func TestWorkRequestUsesNormalTaskAdmission(t *testing.T) {
srv := newTestServer(t)
creator := &recordingWorkRequestCreator{}
srv.WorkRequests = creator
srv.ControlPlane = workflowControlPlane(t, workflow.WorkflowDefinitionCollection{Definitions: []workflow.WorkflowDefinitionEntry{{ID: "implement", YAML: "id: implement\nsteps:\n - type: implement.prepare\n"}}})
// An inputless workflow keeps taking an inputless request.
body := `{"identity":"archie","repository":"acme/widget","workflow":"implement","title":"Fix login","instructions":"Reproduce and fix it."}`
w := postWorkRequest(t, srv, body)
if w.Code != http.StatusCreated {
t.Fatalf("status = %d, body = %s", w.Code, w.Body)
}
if got := creator.request; got.Identity != "archie" || got.Repo != "acme/widget" || got.Workflow != "implement" || got.Title != "Fix login" || got.Body != "Reproduce and fix it." {
t.Fatalf("request = %#v", got)
}
}
func TestWorkRequestRejectsDisabledWorkflow(t *testing.T) {
srv := newTestServer(t)
creator := &recordingWorkRequestCreator{}
srv.WorkRequests = creator
srv.ControlPlane = workflowControlPlane(t, workflow.WorkflowDefinitionCollection{Definitions: []workflow.WorkflowDefinitionEntry{{ID: "custom", YAML: "id: custom\nsteps:\n - type: implement.prepare\n"}}})
w := postWorkRequest(t, srv, `{"identity":"archie","repository":"acme/widget","workflow":"implement","title":"Fix","instructions":"Do it"}`)
if w.Code != http.StatusConflict {
t.Fatalf("status = %d, body = %s", w.Code, w.Body)
}
if got := creator.request; got.Title != "" || got.Body != "" || got.Repo != "" || got.Workflow != "" || got.Identity != "" || len(got.Inputs) != 0 {
t.Fatalf("creator called with %#v", got)
}
}