Skip to content

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.

17.3 KB
Raw Blame
package engine

import (
	"net/url"
	"os"
	"path/filepath"
	"testing"
	"time"

	"agentflow/internal/domain"
	"agentflow/internal/preview"
	"agentflow/internal/repo"
	"agentflow/internal/runtime"
)

func enablePreview(t *testing.T, engine *Engine, store *repo.Store) *preview.Service {
	t.Helper()
	svc := preview.NewService(store, preview.NewDBStore(store), preview.Config{
		PublicScheme:        "http",
		FrameAncestors:      "'self'",
		MaxFiles:            50,
		MaxCompressed:       1 << 20,
		MaxExpanded:         4 << 20,
		DefaultRetention:    24 * time.Hour,
		FinalizationTimeout: time.Minute,
		SessionTTL:          time.Minute,
	})
	engine.SetPreview(svc)
	return svc
}

func TestPendingPreviewHoldsWorkspaceCleanup(t *testing.T) {
	t.Parallel()
	store, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(store.Close)
	engine := New(store, runtime.NewManager(t.TempDir()))
	enablePreview(t, engine, store)
	run := domain.Run{
		ID: "preview-hold", Status: "succeeded",
		WorkflowSnapshot: domain.WorkflowDefinition{Preview: &domain.PreviewContract{Enabled: true, Kind: "static", SourcePath: "dist"}},
		Nodes:            map[string]*domain.NodeRun{},
	}
	if err := store.PutRun(run); err != nil {
		t.Fatal(err)
	}
	if err := store.PutPreview(domain.RunPreview{
		ID: "preview-preview-hold", RunID: run.ID, Kind: "static", Status: domain.PreviewPending, SourcePath: "dist", EntryFile: "index.html",
	}); err != nil {
		t.Fatal(err)
	}
	if err := store.SetRunWorkspaceCleanupHold(run.ID, time.Now().UTC().Add(15*time.Minute)); err != nil {
		t.Fatal(err)
	}

	engine.reconcileTerminalWorkspaceCleanup()

	kept, _ := store.Run(run.ID)
	if !kept.WorkspaceCleanedAt.IsZero() {
		t.Fatal("pending preview must hold workspace cleanup")
	}
}

func TestReadyPreviewReleasesWorkspaceCleanup(t *testing.T) {
	t.Parallel()
	root := t.TempDir()
	store, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(store.Close)
	engine := New(store, runtime.NewManager(root))
	svc := enablePreview(t, engine, store)
	run := domain.Run{
		ID: "preview-ready", Status: "succeeded",
		WorkflowSnapshot: domain.WorkflowDefinition{Preview: &domain.PreviewContract{Enabled: true, Kind: "static", SourcePath: "dist", IndexFile: "index.html"}},
		Nodes:            map[string]*domain.NodeRun{},
	}
	if err := store.PutRun(run); err != nil {
		t.Fatal(err)
	}
	workspace := engine.sandboxes.RunWorkspace(run.ID)
	if err := os.MkdirAll(filepath.Join(workspace, "dist"), 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(workspace, "dist", "index.html"), []byte("<html>ok</html>"), 0o644); err != nil {
		t.Fatal(err)
	}
	if !svc.BeginFinalization(run) {
		t.Fatal("expected preview finalization to hold cleanup")
	}
	deadline := time.Now().Add(5 * time.Second)
	for time.Now().Before(deadline) {
		p, ok := store.PreviewByRun(run.ID)
		if ok && p.Status == domain.PreviewReady {
			break
		}
		time.Sleep(20 * time.Millisecond)
	}
	p, ok := store.PreviewByRun(run.ID)
	if !ok || p.Status != domain.PreviewReady {
		t.Fatalf("preview not ready: %+v", p)
	}
	// Marking the preview ready and releasing the workspace overlap. A single
	// reconcile can land in the middle of that release, so wait until the
	// cleanup is actually recorded.
	deadline = time.Now().Add(30 * time.Second)
	var cleaned domain.Run
	for time.Now().Before(deadline) {
		engine.reconcileTerminalWorkspaceCleanup()
		cleaned, _ = store.Run(run.ID)
		if !cleaned.WorkspaceCleanedAt.IsZero() {
			break
		}
		time.Sleep(20 * time.Millisecond)
	}
	if cleaned.WorkspaceCleanedAt.IsZero() {
		t.Fatal("ready preview should release workspace cleanup")
	}
}

func TestBeginFinalizationSkipsNonFrontendWorkspace(t *testing.T) {
	t.Parallel()
	root := t.TempDir()
	store, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(store.Close)
	engine := New(store, runtime.NewManager(root))
	svc := enablePreview(t, engine, store)
	run := domain.Run{
		ID: "preview-skip-go", Status: "succeeded",
		WorkflowSnapshot: domain.WorkflowDefinition{Preview: &domain.PreviewContract{Enabled: true, Kind: "static", SourcePath: "dist", IndexFile: "index.html"}},
		Nodes:            map[string]*domain.NodeRun{},
	}
	if err := store.PutRun(run); err != nil {
		t.Fatal(err)
	}
	workspace := engine.sandboxes.RunWorkspace(run.ID)
	if err := os.MkdirAll(workspace, 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(workspace, "go.mod"), []byte("module inventory-api\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(workspace, "main.go"), []byte("package main\nfunc main() {}\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	if svc.BeginFinalization(run) {
		t.Fatal("non-frontend workspace must not hold cleanup for archive")
	}
	p, ok := store.PreviewByRun(run.ID)
	if !ok || p.Status != domain.PreviewSkipped {
		t.Fatalf("preview status = %+v ok=%v", p, ok)
	}
	if svc.BeginFinalization(run) {
		t.Fatal("skipped preview must not hold cleanup on a second pass")
	}
	again, _ := store.PreviewByRun(run.ID)
	if again.Status != domain.PreviewSkipped {
		t.Fatalf("second finalization revived skip: %+v", again)
	}
	engine.reconcileTerminalWorkspaceCleanup()
	cleaned, _ := store.Run(run.ID)
	if cleaned.WorkspaceCleanedAt.IsZero() {
		t.Fatal("skipped preview should still clean the workspace")
	}
}

func TestStartInjectsPreviewBuildNode(t *testing.T) {
	t.Parallel()
	store, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(store.Close)
	wf := domain.WorkflowDefinition{
		ID: "preview-auto-build", Name: "preview", SandboxProfileID: "local",
		Preview: &domain.PreviewContract{Enabled: true, Model: "gpt-5.6-terra"},
		Nodes: []domain.WorkflowNode{
			{ID: "impl", Name: "实现", Type: "script", ScriptLanguage: "shell", Script: "printf ok\n", MaxAttempts: 1},
		},
	}
	if err := store.PutWorkflow(wf); err != nil {
		t.Fatal(err)
	}
	engine := New(store, runtime.NewManager(t.TempDir()))
	engine.ConfigureExecution("test-instance", "localhost", time.Minute, false)
	run, err := engine.Start(wf.ID, "")
	if err != nil {
		t.Fatal(err)
	}
	if len(run.WorkflowSnapshot.Nodes) != 2 {
		t.Fatalf("snapshot nodes = %d, want injected preview-build", len(run.WorkflowSnapshot.Nodes))
	}
	last := run.WorkflowSnapshot.Nodes[1]
	if last.ID != domain.PreviewBuildNodeID || last.AgentID != domain.PreviewBuildAgentID {
		t.Fatalf("injected node = %+v", last)
	}
	if run.Nodes[domain.PreviewBuildNodeID] == nil || run.Nodes[domain.PreviewBuildNodeID].Status != "pending" {
		t.Fatalf("preview-build node run = %+v", run.Nodes[domain.PreviewBuildNodeID])
	}
	stored, _ := store.Workflow(wf.ID)
	if len(stored.Nodes) != 1 {
		t.Fatalf("catalog SOP must stay without the injected node: %+v", stored.Nodes)
	}
	agent, ok := workflowAgent(store, run.WorkflowSnapshot, domain.PreviewBuildAgentID)
	if !ok || agent.ExecutorID != domain.PreviewBuildExecutor || agent.Model != "gpt-5.6-terra" {
		t.Fatalf("synthetic agent = %+v ok=%v", agent, ok)
	}
}

func TestCancelledRunDoesNotCreatePreview(t *testing.T) {
	t.Parallel()
	store, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(store.Close)
	engine := New(store, runtime.NewManager(t.TempDir()))
	enablePreview(t, engine, store)
	run := domain.Run{
		ID: "preview-cancel", Status: "cancelled",
		WorkflowSnapshot: domain.WorkflowDefinition{Preview: &domain.PreviewContract{Enabled: true, Kind: "static", SourcePath: "dist"}},
		Nodes:            map[string]*domain.NodeRun{},
	}
	if err := store.PutRun(run); err != nil {
		t.Fatal(err)
	}
	engine.reconcileTerminalWorkspaceCleanup()
	if _, ok := store.PreviewByRun(run.ID); ok {
		t.Fatal("cancelled run must not create a preview")
	}
	cleaned, _ := store.Run(run.ID)
	if cleaned.WorkspaceCleanedAt.IsZero() {
		t.Fatal("cancelled run should still clean immediately")
	}
}

func TestRecoverMissingPreviewFinalizerHoldsWorkspace(t *testing.T) {
	t.Parallel()
	root := t.TempDir()
	store, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(store.Close)
	engine := New(store, runtime.NewManager(root))
	enablePreview(t, engine, store)
	run := domain.Run{
		ID: "preview-crash-gap", Status: "succeeded",
		WorkflowSnapshot: domain.WorkflowDefinition{Preview: &domain.PreviewContract{Enabled: true, Kind: "static", SourcePath: "dist", IndexFile: "index.html"}},
		Nodes:            map[string]*domain.NodeRun{},
	}
	if err := store.PutRun(run); err != nil {
		t.Fatal(err)
	}
	workspace := engine.sandboxes.RunWorkspace(run.ID)
	if err := os.MkdirAll(filepath.Join(workspace, "dist"), 0o755); err != nil {
		t.Fatal(err)
	}
	index := filepath.Join(workspace, "dist", "index.html")
	if err := os.WriteFile(index, []byte("<html>ok</html>"), 0o644); err != nil {
		t.Fatal(err)
	}

	engine.recoverMissingPreviewFinalizers()
	if _, ok := store.PreviewByRun(run.ID); !ok {
		t.Fatal("crash recovery must create the missing preview row")
	}
	engine.reconcileTerminalWorkspaceCleanup()
	p, _ := store.PreviewByRun(run.ID)
	if p.Status == domain.PreviewPending || p.Status == domain.PreviewArchiving {
		if _, err := os.Stat(index); err != nil {
			t.Fatal("workspace must survive cleanup until archive finishes")
		}
		kept, _ := store.Run(run.ID)
		if !kept.WorkspaceCleanedAt.IsZero() {
			t.Fatal("recovered pending preview must hold workspace cleanup")
		}
	}

	deadline := time.Now().Add(5 * time.Second)
	for time.Now().Before(deadline) {
		p, ok := store.PreviewByRun(run.ID)
		if ok && p.Status == domain.PreviewReady {
			return
		}
		time.Sleep(20 * time.Millisecond)
	}
	p, _ = store.PreviewByRun(run.ID)
	t.Fatalf("recovered preview never became ready: %+v", p)
}

func TestSucceededPreviewWithoutRecordLosesWorkspaceWithoutRecover(t *testing.T) {
	t.Parallel()
	root := t.TempDir()
	store, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(store.Close)
	engine := New(store, runtime.NewManager(root))
	enablePreview(t, engine, store)
	run := domain.Run{
		ID: "preview-lost-without-recover", Status: "succeeded",
		WorkflowSnapshot: domain.WorkflowDefinition{Preview: &domain.PreviewContract{Enabled: true, Kind: "static", SourcePath: "dist"}},
		Nodes:            map[string]*domain.NodeRun{},
	}
	if err := store.PutRun(run); err != nil {
		t.Fatal(err)
	}
	workspace := engine.sandboxes.RunWorkspace(run.ID)
	if err := os.MkdirAll(filepath.Join(workspace, "dist"), 0o755); err != nil {
		t.Fatal(err)
	}
	index := filepath.Join(workspace, "dist", "index.html")
	if err := os.WriteFile(index, []byte("<html>ok</html>"), 0o644); err != nil {
		t.Fatal(err)
	}

	engine.reconcileTerminalWorkspaceCleanup()
	if _, err := os.Stat(index); !os.IsNotExist(err) {
		t.Fatal("without recovery, terminal cleanup deletes the workspace")
	}
	if _, ok := store.PreviewByRun(run.ID); ok {
		t.Fatal("cleanup-only path must not invent a preview")
	}
}

func TestDeleteRunRevokesPreviewSession(t *testing.T) {
	t.Parallel()
	root := t.TempDir()
	store, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(store.Close)
	engine := New(store, runtime.NewManager(root))
	svc := enablePreview(t, engine, store)
	run := domain.Run{
		ID: "preview-delete-run", Status: "succeeded",
		WorkflowSnapshot: domain.WorkflowDefinition{Preview: &domain.PreviewContract{Enabled: true, Kind: "static", SourcePath: "dist", IndexFile: "index.html"}},
		Nodes:            map[string]*domain.NodeRun{},
	}
	if err := store.PutRun(run); err != nil {
		t.Fatal(err)
	}
	workspace := engine.sandboxes.RunWorkspace(run.ID)
	if err := os.MkdirAll(filepath.Join(workspace, "dist"), 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(workspace, "dist", "index.html"), []byte("<html>ok</html>"), 0o644); err != nil {
		t.Fatal(err)
	}
	if !svc.BeginFinalization(run) {
		t.Fatal("expected preview finalization")
	}
	deadline := time.Now().Add(5 * time.Second)
	var ready domain.RunPreview
	for time.Now().Before(deadline) {
		p, ok := store.PreviewByRun(run.ID)
		if ok && p.Status == domain.PreviewReady {
			ready = p
			break
		}
		time.Sleep(20 * time.Millisecond)
	}
	if ready.Status != domain.PreviewReady {
		t.Fatalf("preview not ready: %+v", ready)
	}
	session, urlStr, err := svc.CreateSession(ready, nil, "")
	if err != nil || urlStr == "" || session.ID == "" {
		t.Fatalf("session %v %s", err, urlStr)
	}
	u, err := url.Parse(urlStr)
	if err != nil {
		t.Fatal(err)
	}
	plain, _, ok := preview.ParsePreviewPath(u.Path)
	if !ok {
		t.Fatalf("token from %s", urlStr)
	}
	if _, _, ok := svc.LookupSession(plain); !ok {
		t.Fatalf("session should be live before delete: %s", urlStr)
	}
	if err := engine.DeleteRun(run.ID); err != nil {
		t.Fatal(err)
	}
	if _, ok := store.PreviewByRun(run.ID); ok {
		t.Fatal("preview metadata survived run delete")
	}
	if _, _, ok := svc.LookupSession(plain); ok {
		t.Fatal("preview URL must stop working after run delete")
	}
}

func TestWaitingRunArchivesPreviewAfterBuild(t *testing.T) {
	t.Parallel()
	root := t.TempDir()
	store, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(store.Close)
	engine := New(store, runtime.NewManager(root))
	svc := enablePreview(t, engine, store)
	run := domain.Run{
		ID: "preview-waiting-build", Status: "waiting",
		WorkflowSnapshot: domain.WorkflowDefinition{Preview: &domain.PreviewContract{Enabled: true, Kind: "static", SourcePath: "dist", IndexFile: "index.html"}},
		Nodes: map[string]*domain.NodeRun{
			domain.PreviewBuildNodeID: {NodeID: domain.PreviewBuildNodeID, Status: "succeeded"},
			"confirm-demo":            {NodeID: "confirm-demo", Status: "waiting_approval"},
		},
	}
	if err := store.PutRun(run); err != nil {
		t.Fatal(err)
	}
	workspace := engine.sandboxes.RunWorkspace(run.ID)
	if err := os.MkdirAll(filepath.Join(workspace, "dist"), 0o755); err != nil {
		t.Fatal(err)
	}
	index := filepath.Join(workspace, "dist", "index.html")
	if err := os.WriteFile(index, []byte("<html>demo</html>"), 0o644); err != nil {
		t.Fatal(err)
	}

	engine.recoverBuiltPreviewArchives()
	deadline := time.Now().Add(5 * time.Second)
	var ready domain.RunPreview
	for time.Now().Before(deadline) {
		p, ok := store.PreviewByRun(run.ID)
		if ok && p.Status == domain.PreviewReady {
			ready = p
			break
		}
		time.Sleep(20 * time.Millisecond)
	}
	if ready.Status != domain.PreviewReady {
		t.Fatalf("preview not ready while the run is still waiting: %+v", ready)
	}
	if svc.BeginFinalization(run) {
		t.Fatal("a ready preview must not be archived again when the run later succeeds")
	}
	engine.reconcileTerminalWorkspaceCleanup()
	if _, err := os.Stat(index); err != nil {
		t.Fatal("workspace must stay until the run itself finishes")
	}
	kept, _ := store.Run(run.ID)
	if kept.Status != "waiting" || !kept.WorkspaceCleanedAt.IsZero() {
		t.Fatalf("waiting run was cleaned: status=%s cleaned=%v", kept.Status, kept.WorkspaceCleanedAt)
	}
}

func TestWaitingRunnerPreviewDoesNotSkipEmptyControlPlane(t *testing.T) {
	t.Parallel()
	root := t.TempDir()
	store, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(store.Close)
	engine := New(store, runtime.NewManager(root))
	enablePreview(t, engine, store)
	if err := store.PutRunner(domain.Runner{ID: "runner-preview", Status: domain.RunnerStatusOnline}); err != nil {
		t.Fatal(err)
	}
	run := domain.Run{
		ID: "preview-waiting-runner", Status: "waiting",
		ExecutionContext: domain.TelemetryContext{ExecutionMode: domain.ExecutionModeRunner, ExecutionRunnerID: "runner-preview"},
		WorkflowSnapshot: domain.WorkflowDefinition{Preview: &domain.PreviewContract{Enabled: true, Kind: "static", SourcePath: "dist", IndexFile: "index.html"}},
		Nodes: map[string]*domain.NodeRun{
			domain.PreviewBuildNodeID: {NodeID: domain.PreviewBuildNodeID, Status: "succeeded"},
		},
	}
	if err := store.PutRun(run); err != nil {
		t.Fatal(err)
	}
	workspace := engine.sandboxes.RunWorkspace(run.ID)
	if err := os.MkdirAll(workspace, 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(workspace, "go.mod"), []byte("module demo\n"), 0o644); err != nil {
		t.Fatal(err)
	}

	engine.recoverBuiltPreviewArchives()
	p, ok := store.PreviewByRun(run.ID)
	if !ok || p.Status != domain.PreviewArchiving {
		t.Fatalf("runner preview = %+v ok=%v", p, ok)
	}
	task, ok := store.RunnerTask("rt-preview-archive-" + run.ID)
	if !ok || task.Status != domain.RunnerTaskQueued || task.Action != domain.RunnerTaskActionArchivePreview {
		t.Fatalf("archive task = %+v ok=%v", task, ok)
	}
	kept, _ := store.Run(run.ID)
	if !kept.WorkspaceCleanedAt.IsZero() {
		t.Fatal("queueing the runner archive cleaned a waiting run")
	}
}

func TestSkippedPreviewIsNotRevivedWhileWaiting(t *testing.T) {
	t.Parallel()
	store, err := repo.OpenTest()
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(store.Close)
	engine := New(store, runtime.NewManager(t.TempDir()))
	enablePreview(t, engine, store)
	run := domain.Run{
		ID: "preview-waiting-skip", Status: "waiting",
		WorkflowSnapshot: domain.WorkflowDefinition{Preview: &domain.PreviewContract{Enabled: true, Kind: "static", SourcePath: "dist", IndexFile: "index.html"}},
		Nodes: map[string]*domain.NodeRun{
			domain.PreviewBuildNodeID: {NodeID: domain.PreviewBuildNodeID, Status: "succeeded"},
		},
	}
	if err := store.PutRun(run); err != nil {
		t.Fatal(err)
	}
	if err := store.PutPreview(domain.RunPreview{
		ID: "preview-preview-waiting-skip", RunID: run.ID, Kind: "static", Status: domain.PreviewSkipped, SourcePath: "dist", EntryFile: "index.html",
	}); err != nil {
		t.Fatal(err)
	}
	engine.recoverBuiltPreviewArchives()
	p, _ := store.PreviewByRun(run.ID)
	if p.Status != domain.PreviewSkipped {
		t.Fatalf("recovery revived a skipped preview: %+v", p)
	}
}