Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.
JavaScript agent-orchestrationagentic-workflowai-agentsai-codingclaude-codecode-reviewcodebuddycodexcoding-agentscursordeveloper-toolshuman-on-the-loopllmmcpmulti-agentsdlcself-hostedsopworkflow-automationworkflow-engine
package engine
import (
"context"
"encoding/json"
"strings"
"testing"
"time"
"agentflow/internal/domain"
"agentflow/internal/runtime"
)
func cvEFinishQueuedTask(t *testing.T, e *Engine, status, result, errText string, exitCode *int) {
t.Helper()
tasks := e.repo.RunnerTasks()
if len(tasks) == 0 {
t.Fatal("runner dispatch did not create a task")
}
task := tasks[0]
task.Status = status
task.Result = result
task.Error = errText
task.ExitCode = exitCode
task.Attempt = 1
task.UpdatedAt = time.Now().UTC()
payload, err := json.Marshal(task)
if err != nil {
t.Fatal(err)
}
if err := e.repo.DB.Table("runner_tasks").Where("id = ?", task.ID).Updates(map[string]any{
"status": status, "payload": payload, "updated_at": task.UpdatedAt,
}).Error; err != nil {
t.Fatal(err)
}
}
func cvETerminalEngine(t *testing.T, status, result, errText string, exitCode *int) (*Engine, domain.Runner) {
t.Helper()
e, _ := cvEEngine(t)
runner := cvERunner(t, e, "runner-terminal", domain.RunnerStatusOnline, "terminal", "codex")
e.SetRunnerDispatchNotify(func(string) {
cvEFinishQueuedTask(t, e, status, result, errText, exitCode)
})
return e, runner
}
func TestRunnerTerminalDispatchResults(t *testing.T) {
for _, tc := range []struct {
name, status, errText string
exit *int
wantErr string
}{
{name: "success", status: domain.RunnerTaskSuccess},
{name: "failed-default", status: domain.RunnerTaskFailed, wantErr: "runner task failed"},
{name: "failed-exit", status: domain.RunnerTaskFailed, errText: "bad command", exit: func() *int { v := 17; return &v }(), wantErr: "exit 17"},
{name: "canceled", status: domain.RunnerTaskCanceled, wantErr: "canceled"},
} {
t.Run(tc.name, func(t *testing.T) {
e, _ := cvETerminalEngine(t, tc.status, "finished", tc.errText, tc.exit)
sb := &runEnvironment{sandbox: &cvESandbox{id: "sb", workspace: t.TempDir()}}
run := cvERunnerRun("dispatch-"+tc.name, "runner-terminal")
node := domain.WorkflowNode{ID: "node", Type: "agent"}
ex := domain.ExecutorDefinition{Kind: "codex"}
got, err := e.dispatchRunnerTask(context.Background(), "runner-terminal", run, node, sb, sb.Workspace(), ex, domain.AgentDefinition{}, domain.AgentAssetBundle{}, "prompt", "inv", runtime.InvocationOptions{}, func(domain.TelemetryEvent) {})
if tc.wantErr == "" {
if err != nil || got != "finished" {
t.Fatalf("result=%q err=%v", got, err)
}
} else if err == nil || !strings.Contains(err.Error(), tc.wantErr) {
t.Fatalf("err=%v, want %q", err, tc.wantErr)
}
})
}
}
func TestRunnerScriptAndCommandTerminalResults(t *testing.T) {
for _, status := range []string{domain.RunnerTaskSuccess, domain.RunnerTaskFailed, domain.RunnerTaskCanceled} {
t.Run("script-"+status, func(t *testing.T) {
e, _ := cvETerminalEngine(t, status, "script-output", "", nil)
sb := &runEnvironment{sandbox: &cvESandbox{id: "sb", workspace: t.TempDir()}}
run := cvERunnerRun("script-"+status, "runner-terminal")
got, err := e.dispatchRunnerScript(context.Background(), "runner-terminal", run, "node", sb.Workspace(), "python", "print(1)", "", nil, sb, "", "", "", domain.AgentAssetBundle{}, func(domain.TelemetryEvent) {})
if status == domain.RunnerTaskSuccess {
if err != nil || got != "script-output" {
t.Fatalf("result=%q err=%v", got, err)
}
} else if err == nil {
t.Fatalf("status %q unexpectedly succeeded", status)
}
})
t.Run("command-"+status, func(t *testing.T) {
e, _ := cvETerminalEngine(t, status, "command-output", "", nil)
got, err := e.dispatchRunnerCommand(context.Background(), "runner-terminal", "run-command", "gate", "/workspace", "true", func(domain.TelemetryEvent) {})
if status == domain.RunnerTaskSuccess {
if err != nil || got != "command-output" {
t.Fatalf("result=%q err=%v", got, err)
}
} else if err == nil {
t.Fatalf("status %q unexpectedly succeeded", status)
}
})
}
}
func TestRunnerIntegrateAndConversationTerminalResults(t *testing.T) {
rc := domain.RepositoryContext{RepositoryID: "repo", Name: "Repo", CloneURL: "https://example.invalid/repo.git", WorkspaceDir: "repo", BaseBranch: "main", WorkBranch: "work", IntegrateBranch: "integration"}
run := cvERunnerRun("terminal-integrate", "runner-terminal")
run.Repositories = []domain.RepositoryContext{rc}
run.ExecutionContext.RunnerWorkspaceLayout = domain.RunnerWorkspaceLayoutShared
integrationJSON := `[{"repositoryId":"repo","name":"Repo","workBranch":"work","integrateBranch":"integration","head":"abc","conflicts":["one.go"],"pushedIntegrate":true}]`
e, runner := cvETerminalEngine(t, domain.RunnerTaskSuccess, integrationJSON, "", nil)
conflicts, err := e.integrateOnRunner(context.Background(), runner, run, rc, true)
if err != nil || len(conflicts) != 1 || conflicts[0] != "one.go" {
t.Fatalf("conflicts=%v err=%v", conflicts, err)
}
e, runner = cvETerminalEngine(t, domain.RunnerTaskSuccess, "{", "", nil)
if _, err := e.integrateOnRunner(context.Background(), runner, run, rc, false); err == nil || !strings.Contains(err.Error(), "decode") {
t.Fatalf("invalid integrate result err=%v", err)
}
for _, tc := range []struct{ status, errText, want string }{
{domain.RunnerTaskCanceled, "", "canceled"},
{domain.RunnerTaskFailed, "", "failed on runner"},
{domain.RunnerTaskFailed, "integration broke", "integration broke"},
} {
e, runner = cvETerminalEngine(t, tc.status, "", tc.errText, nil)
if _, err := e.integrateOnRunner(context.Background(), runner, run, rc, false); err == nil || !strings.Contains(err.Error(), tc.want) {
t.Fatalf("integrate status=%s err=%v", tc.status, err)
}
}
headsJSON := `[{"repositoryId":"repo","name":"Repo","workBranch":"work","head":"def"}]`
e, _ = cvETerminalEngine(t, domain.RunnerTaskSuccess, headsJSON, "", nil)
heads, err := e.pushConversationOnRunner(context.Background(), "runner-terminal", run, []domain.RepositoryContext{rc}, 0, "User", "[email protected]", "message", "")
if err != nil || len(heads) != 1 {
t.Fatalf("heads=%v err=%v", heads, err)
}
e, _ = cvETerminalEngine(t, domain.RunnerTaskSuccess, "{", "", nil)
if _, err := e.pushConversationOnRunner(context.Background(), "runner-terminal", run, []domain.RepositoryContext{rc}, 0, "", "", "message", ""); err == nil || !strings.Contains(err.Error(), "decode") {
t.Fatalf("invalid push result err=%v", err)
}
e, _ = cvETerminalEngine(t, domain.RunnerTaskFailed, "", "", nil)
if _, err := e.pushConversationOnRunner(context.Background(), "runner-terminal", run, []domain.RepositoryContext{rc}, 0, "", "", "message", ""); err == nil {
t.Fatal("failed push succeeded")
}
}
func TestRunnerAlignTerminalResults(t *testing.T) {
repository := domain.RepositoryContext{
RepositoryID: "align-repo", Name: "Align Repo", CloneURL: "https://example.invalid/align.git",
DefaultBranch: "main", IntegrateBranch: "integration",
}
for _, tc := range []struct {
name, status, result, errText, want string
}{
{name: "success", status: domain.RunnerTaskSuccess, result: `{}`},
{name: "invalid-json", status: domain.RunnerTaskSuccess, result: `{`, want: "decode align result"},
{name: "conflicts", status: domain.RunnerTaskSuccess, result: `{"conflicts":["a.go"],"blocks":[{"file":"a.go"}]}`, want: "冲突"},
{name: "failed-default", status: domain.RunnerTaskFailed, want: "align_baseline failed on runner"},
{name: "failed-message", status: domain.RunnerTaskFailed, errText: "runner alignment broke", want: "runner alignment broke"},
} {
t.Run(tc.name, func(t *testing.T) {
e, _ := cvETerminalEngine(t, tc.status, tc.result, tc.errText, nil)
runner, ok := e.repo.Runner("runner-terminal")
if !ok {
t.Fatal("runner missing")
}
runner.Labels = []string{"align-pool"}
runner.RunnerVersion = domain.RunnerVersionWorkspaceOwnerPreparation
if err := e.repo.PutRunner(runner); err != nil {
t.Fatal(err)
}
e.ConfigureCloudRunnerPool(CloudRunnerPool{Label: "align-pool", Projects: []string{"*"}})
err := e.AlignBaselineForUser(repository, 0)
if tc.want == "" {
if err != nil {
t.Fatal(err)
}
} else if err == nil || !strings.Contains(strings.ToLower(err.Error()), strings.ToLower(tc.want)) {
t.Fatalf("err=%v, want %q", err, tc.want)
}
})
}
}