Files
archie/internal/domain/workflow/workflow_call_test.go
T

330 lines
13 KiB
Go

package workflow
import (
"context"
"errors"
"log/slog"
"strings"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/agentexec"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
"github.com/samcharles93/archie-core/internal/events"
)
func callRegistry() StepRegistry {
registry := BuiltinStepRegistry()
registry[AgentRunStepName] = newAgentRunStage
registry[WorkflowCallStepName] = newWorkflowCallStage
return registry
}
// fakeCaller records StartCall/CallStatus and answers the poll with a
// scripted sequence of statuses.
type fakeCaller struct {
starts []startCall
statuses map[int64][]statusAt
statusErr error
startErr error
}
type startCall struct {
callerID int64
workflow string
inputs map[string]any
}
type statusAt struct {
status string
detail string
}
func (f *fakeCaller) StartCall(_ context.Context, callerID int64, workflow string, inputs map[string]any) (*task.Task, error) {
if f.startErr != nil {
return nil, f.startErr
}
f.starts = append(f.starts, startCall{callerID: callerID, workflow: workflow, inputs: inputs})
callee := &task.Task{ID: int64(len(f.starts) + 100), Workflow: workflow, CallParentTaskID: callerID, CallDepth: 1, Status: StatusQueued}
return callee, nil
}
func (f *fakeCaller) CallStatus(_ context.Context, callerID, callID int64) (string, string, error) {
if f.statusErr != nil {
return "", "", f.statusErr
}
seq := f.statuses[callID]
if len(seq) == 0 {
return "", "", nil
}
at := seq[0]
if len(seq) > 1 {
f.statuses[callID] = seq[1:]
}
return at.status, at.detail, nil
}
func callerYAML(callee string, extra ...string) string {
body := "id: caller\nsteps:\n - type: workflow.call\n settings:\n workflow: " + callee + "\n"
for _, line := range extra {
body += line + "\n"
}
return body
}
// ---- Save-time: collection validation ----
func TestValidateCollectionWorkflowCalls(t *testing.T) {
for _, test := range []struct {
name string
collection WorkflowDefinitionCollection
want string
}{
{
name: "callee is not defined",
collection: collectionOf(
callerYAML("missing"),
),
want: `calls "missing", which is not defined`,
},
{
name: "direct self-call",
collection: collectionOf(
"id: w\nsteps:\n - type: workflow.call\n settings:\n workflow: w\n",
),
want: `calls itself through w -> w`,
},
{
name: "indirect cycle",
collection: collectionOf(
"id: a\nsteps:\n - type: workflow.call\n settings:\n workflow: b\n",
"id: b\nsteps:\n - type: workflow.call\n settings:\n workflow: a\n",
),
want: "calls itself through a -> b -> a",
},
{
name: "reference to an undeclared caller input",
collection: collectionOf(
callerYAML("callee", " inputs: {src_ip: \"inputs.missing\"}"),
"id: callee\ninputs:\n src_ip: {type: string}\nsteps:\n - type: agent.run\n settings:\n mission: m\n",
),
want: `input "src_ip" references "inputs.missing", which the calling workflow does not declare`,
},
{
name: "callee input type mismatch",
collection: collectionOf(
"id: caller\ninputs:\n src_ip: {type: string}\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n inputs: {src_ip: \"inputs.src_ip\"}\n",
"id: callee\ninputs:\n src_ip: {type: number}\nsteps:\n - type: agent.run\n settings:\n mission: m\n",
),
want: `input "src_ip" is string, want number`,
},
{
name: "required callee input is not assigned",
collection: collectionOf(
"id: caller\ninputs:\n src_ip: {type: string}\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n inputs: {severity: \"inputs.src_ip\"}\n",
"id: callee\ninputs:\n src_ip: {type: string, required: true}\n severity: {type: string}\nsteps:\n - type: agent.run\n settings:\n mission: m\n",
),
want: `input "src_ip" is required by "callee"`,
},
{
name: "undeclared callee input",
collection: collectionOf(
"id: caller\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n inputs: {extra: 7}\n",
"id: callee\nsteps:\n - type: agent.run\n settings:\n mission: m\n",
),
want: `input "extra" is not declared by "callee"`,
},
} {
t.Run(test.name, func(t *testing.T) {
err := ValidateDefinitionCollection(test.collection, callRegistry())
if err == nil || !strings.Contains(err.Error(), test.want) {
t.Fatalf("ValidateDefinitionCollection() error = %v, want containing %q", err, test.want)
}
})
}
valid := collectionOf(
"id: caller\nrepository: none\ninputs:\n src_ip: {type: string, required: true}\n n: {type: number}\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n inputs: {src_ip: \"inputs.src_ip\", n: 3}\n",
"id: callee\ninputs:\n src_ip: {type: string, required: true}\n n: {type: number}\nsteps:\n - type: agent.run\n settings:\n mission: m\n",
)
if err := ValidateDefinitionCollection(valid, callRegistry()); err != nil {
t.Fatalf("ValidateDefinitionCollection(valid) = %v, want nil", err)
}
// A chain of distinct workflows is not a cycle.
chain := collectionOf(
"id: a\nsteps:\n - type: workflow.call\n settings:\n workflow: b\n",
"id: b\nsteps:\n - type: workflow.call\n settings:\n workflow: c\n",
"id: c\nsteps:\n - type: agent.run\n settings:\n mission: m\n",
)
if err := ValidateDefinitionCollection(chain, callRegistry()); err != nil {
t.Fatalf("ValidateDefinitionCollection(chain) = %v, want nil", err)
}
}
func collectionOf(yamls ...string) WorkflowDefinitionCollection {
c := WorkflowDefinitionCollection{}
for _, y := range yamls {
c.Definitions = append(c.Definitions, WorkflowDefinitionEntry{ID: yamlID(y), YAML: y})
}
return c
}
func yamlID(y string) string {
for line := range strings.SplitSeq(y, "\n") {
if after, ok := strings.CutPrefix(line, "id: "); ok {
return after
}
}
return ""
}
// ---- Runtime: the stage ----
func compileCaller(t *testing.T, yaml string) Workflow {
t.Helper()
wf, err := ParseAndCompile(yaml, callRegistry())
if err != nil {
t.Fatalf("ParseAndCompile: %v", err)
}
return wf
}
func TestWorkflowCallStageRefusesWithoutCapability(t *testing.T) {
wf := compileCaller(t, "id: caller\nrepository: none\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n")
store := &recordingStore{}
tc := &TaskContext{Task: &Task{ID: 3, Attempt: 1}, Store: store, Trees: &fakeTrees{}, Log: slog.New(slog.DiscardHandler)}
Run(context.Background(), wf, tc)
if !strings.Contains(tc.Task.ParkReason, "callee capability") {
t.Fatalf("park reason %q; want a park naming the missing capability", tc.Task.ParkReason)
}
if len(store.ofKind(events.KindWorkflowCallStarted)) != 0 {
t.Error("a refused call must not record a started event")
}
}
func TestWorkflowCallStageDepthLimit(t *testing.T) {
wf := compileCaller(t, "id: caller\nrepository: none\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n")
caller := &fakeCaller{}
store := &recordingStore{}
deep := &Task{ID: 3, Attempt: 1, CallDepth: MaxCallDepth}
tc := &TaskContext{Task: deep, Calls: caller, Store: store, Trees: &fakeTrees{}, Log: slog.New(slog.DiscardHandler)}
Run(context.Background(), wf, tc)
if len(caller.starts) != 0 {
t.Fatalf("StartCall ran %d times at the depth limit, want none", len(caller.starts))
}
if !strings.Contains(deep.ParkReason, "depth") {
t.Fatalf("park reason %q; want a park naming the depth limit", deep.ParkReason)
}
}
func TestWorkflowCallWaitFalseStartsAndContinues(t *testing.T) {
wf := compileCaller(t, "id: caller\nrepository: none\ninputs:\n src_ip: {type: string}\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n inputs: {src_ip: \"inputs.src_ip\"}\n wait: false\n - type: agent.run\n settings:\n mission: report\n")
caller := &fakeCaller{}
store := &recordingStore{}
tc := &TaskContext{
Task: &Task{ID: 3, Attempt: 1, Inputs: map[string]any{"src_ip": "10.0.0.9"}},
Calls: caller, Store: store, Trees: &fakeTrees{dir: "/scratch/3"}, Log: slog.New(slog.DiscardHandler),
Agent: &fakeAgentRunner{result: agentexec.Result{Status: agentexec.StatusPassed, Summary: "reported"}},
Cfg: config.Config{Models: map[string]string{"builder": "p/m"}},
}
Run(context.Background(), wf, tc)
if len(caller.starts) != 1 {
t.Fatalf("StartCall ran %d times, want exactly one", len(caller.starts))
}
start := caller.starts[0]
if start.callerID != 3 || start.workflow != "callee" {
t.Errorf("start = %+v, want caller 3 calling callee", start)
}
if got := start.inputs["src_ip"]; got != "10.0.0.9" {
t.Errorf("input src_ip = %v, want the caller's resolved input", got)
}
if tc.Outcome.Status != StatusCompleted {
t.Errorf("outcome = %+v, want the caller to continue and complete", tc.Outcome)
}
started := store.ofKind(events.KindWorkflowCallStarted)
if len(started) != 1 || started[0].Data["callee_task_id"] != int64(101) {
t.Errorf("started events = %+v, want one carrying callee task 101", started)
}
}
func TestWorkflowCallWaitTrueWaitsForTerminalCallee(t *testing.T) {
wf := compileCaller(t, "id: caller\nrepository: none\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n wait: true\n - type: agent.run\n settings:\n mission: report\n")
caller := &fakeCaller{statuses: map[int64][]statusAt{
101: {{StatusQueued, ""}, {StatusRunning, ""}, {StatusCompleted, "contained 10.0.0.9"}},
}}
store := &recordingStore{}
tc := &TaskContext{
Task: &Task{ID: 3, Attempt: 1}, Calls: caller, Store: store,
Trees: &fakeTrees{dir: "/scratch/3"}, Log: slog.New(slog.DiscardHandler),
Agent: &fakeAgentRunner{result: agentexec.Result{Status: agentexec.StatusPassed, Summary: "reported"}},
Cfg: config.Config{Models: map[string]string{"builder": "p/m"}},
}
callPollInterval = time.Millisecond
defer func() { callPollInterval = 2 * time.Second }()
Run(context.Background(), wf, tc)
if tc.Outcome.Status != StatusCompleted {
t.Errorf("outcome = %+v, want completed after the callee succeeded", tc.Outcome)
}
finished := store.ofKind(events.KindWorkflowCallFinished)
if len(finished) != 1 || finished[0].Data["status"] != StatusCompleted || finished[0].Data["detail"] != "contained 10.0.0.9" {
t.Errorf("finished events = %+v, want the callee's terminal status and detail", finished)
}
}
func TestWorkflowCallWaitTrueFailsWhenCalleeFails(t *testing.T) {
wf := compileCaller(t, "id: caller\nrepository: none\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n wait: true\n")
caller := &fakeCaller{statuses: map[int64][]statusAt{
101: {{StatusParked, "needs an operator"}},
}}
store := &recordingStore{}
tc := &TaskContext{
Task: &Task{ID: 3, Attempt: 1}, Calls: caller, Store: store,
Trees: &fakeTrees{}, Log: slog.New(slog.DiscardHandler),
}
callPollInterval = time.Millisecond
defer func() { callPollInterval = 2 * time.Second }()
Run(context.Background(), wf, tc)
if !strings.Contains(tc.Task.ParkReason, "needs an operator") {
t.Fatalf("reason %q; want a park carrying the callee's detail", tc.Task.ParkReason)
}
if len(store.ofKind(events.KindWorkflowCallFinished)) != 0 {
t.Error("a failed call must not record a finished event")
}
}
func TestWorkflowCallWaitTrueStartFailure(t *testing.T) {
wf := compileCaller(t, "id: caller\nrepository: none\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n wait: true\n")
caller := &fakeCaller{startErr: errors.New("callee is not enabled for this org")}
store := &recordingStore{}
tc := &TaskContext{
Task: &Task{ID: 3, Attempt: 1}, Calls: caller, Store: store,
Trees: &fakeTrees{}, Log: slog.New(slog.DiscardHandler),
}
Run(context.Background(), wf, tc)
if !strings.Contains(tc.Task.ParkReason, "callee is not enabled") {
t.Fatalf("reason %q; want the start failure parked", tc.Task.ParkReason)
}
}
func TestWorkflowCallSettingsValidation(t *testing.T) {
for _, test := range []struct{ name, yaml, want string }{
{"no workflow named", "id: w\nrepository: none\nsteps:\n - type: workflow.call\n", "settings.workflow is required"},
{"works in a repository-free workflow", "id: w\nrepository: none\nsteps:\n - type: workflow.call\n settings:\n workflow: other\n", ""},
} {
t.Run(test.name, func(t *testing.T) {
_, err := ParseDefinition(test.yaml, callRegistry())
if test.want == "" {
if err != nil {
t.Fatalf("ParseDefinition() = %v, want nil", err)
}
return
}
if err == nil || !strings.Contains(err.Error(), test.want) {
t.Fatalf("ParseDefinition() error = %v, want containing %q", err, test.want)
}
})
}
}