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.

30.0 KB
Raw Blame
package httpapi

import (
	"agentflow/internal/domain"
	"agentflow/internal/repo"
	"encoding/json"
	"errors"
	"net/http"
	"strings"
	"testing"
)

func TestCatalogRepositoryAgentAndAssetBranches(t *testing.T) {
	f := cvBNewHTTPFixture(t)
	for _, p := range []domain.Project{
		{ID: "cvb-cat", Key: "CVBC", Name: "CVB Catalog", OwnerID: f.user.ID},
		{ID: "cvb-other", Key: "CVBO", Name: "CVB Other", OwnerID: f.user.ID},
	} {
		if err := f.s.PutProject(p); err != nil {
			t.Fatal(err)
		}
	}
	requests := []struct {
		method, path string
		body         any
		want         int
	}{
		{http.MethodDelete, "/api/repositories", nil, 400},
		{http.MethodPost, "/api/repositories", map[string]any{"projectId": "cvb-cat", "repoUrl": "https://bitbucket.org/nope/x"}, 200},
		{http.MethodPost, "/api/repositories", map[string]any{"projectId": "cvb-cat", "repoUrl": "https://git.example.com/a/one", "url": "https://git.example.com/a/two"}, 400},
		{http.MethodPost, "/api/repositories", map[string]any{"projectId": "missing", "name": "x", "gongfengProjectId": "a/x"}, 400},
		{http.MethodPost, "/api/repositories", map[string]any{"projectId": "cvb-cat", "name": "x", "gongfengProjectId": "a/x", "provider": "gitlab"}, 400},
		{http.MethodPost, "/api/repositories", map[string]any{"id": "cvb-repo", "projectId": "cvb-cat", "repoUrl": "https://git.example.com/a/x"}, 200},
		{http.MethodGet, "/api/repositories/cvb-repo", nil, 200},

		{http.MethodPut, "/api/agents", map[string]any{"id": "cvb-agent"}, 400},
		{http.MethodPut, "/api/agents", map[string]any{"id": "cvb-agent", "projectId": "missing"}, 404},
		{http.MethodPut, "/api/agents", map[string]any{"id": "cvb-agent", "projectId": "cvb-cat", "executorId": "bad"}, 400},
		{http.MethodPut, "/api/agents", map[string]any{"id": "cvb-agent", "name": "Agent", "projectId": "cvb-cat"}, 200},
		{http.MethodPut, "/api/agents", map[string]any{"id": "cvb-agent", "name": "Agent", "projectId": "cvb-other"}, 409},
		{http.MethodGet, "/api/agents?projectId=cvb-cat", nil, 200},
		{http.MethodGet, "/api/agents/cvb-agent/revisions", nil, 200},
		{http.MethodGet, "/api/agents/cvb-agent/revisions/missing", nil, 404},
		{http.MethodPost, "/api/agents/cvb-agent/clone", map[string]any{}, 400},
		{http.MethodPost, "/api/agents/cvb-agent/clone", map[string]any{"id": "clone", "name": "Clone", "projectId": "missing"}, 404},
		{http.MethodPost, "/api/agents/cvb-agent/clone", map[string]any{"id": "cvb-agent-clone", "name": "Clone", "projectId": "cvb-other"}, 201},
		{http.MethodDelete, "/api/agents/cvb-agent-clone", nil, 204},

		{http.MethodPut, "/api/rules", map[string]any{"id": "cvb-rule", "name": "Rule", "projectId": "missing"}, 404},
		{http.MethodPut, "/api/rules", map[string]any{"id": "cvb-rule", "name": "Rule", "projectId": "cvb-cat", "global": true, "workflowIds": []string{"missing"}}, 400},
		{http.MethodPut, "/api/rules", map[string]any{"id": "cvb-rule", "name": "Rule", "projectId": "cvb-cat"}, 200},
		{http.MethodGet, "/api/rules?projectId=cvb-cat", nil, 200},
		{http.MethodPut, "/api/skills", map[string]any{"id": "cvb-skill", "name": "Skill", "projectId": "missing"}, 404},
		{http.MethodPut, "/api/skills", map[string]any{"id": "cvb-skill", "name": "Skill", "projectId": "cvb-cat"}, 200},
		{http.MethodGet, "/api/skills?projectId=cvb-cat", nil, 200},

		{http.MethodPut, "/api/dockerfiles", map[string]any{"id": "cvb-df", "name": "DF", "projectId": "cvb-cat", "content": "FROM scratch"}, 200},
		{http.MethodPut, "/api/environments", map[string]any{"id": "cvb-env", "name": "Env", "projectId": "cvb-cat", "installScript": "true"}, 200},
		{http.MethodPut, "/api/sandboxes", map[string]any{"id": "cvb-box-bad", "name": "Box", "projectId": "cvb-cat", "dockerfileId": "missing"}, 400},
		{http.MethodPut, "/api/sandboxes", map[string]any{"id": "cvb-box", "name": "Box", "projectId": "cvb-cat", "driver": "docker", "dockerfileId": "cvb-df", "environmentId": "cvb-env"}, 200},
		{http.MethodGet, "/api/dockerfiles?projectId=cvb-cat", nil, 200},
		{http.MethodGet, "/api/environments?projectId=cvb-cat", nil, 200},
		{http.MethodGet, "/api/sandboxes?projectId=cvb-cat", nil, 200},
		{http.MethodDelete, "/api/dockerfiles?id=cvb-df", nil, 409},
		{http.MethodDelete, "/api/environments?id=cvb-env", nil, 204},
	}
	for i, tc := range requests {
		rec := cvBRequest(t, f, tc.method, tc.path, tc.body, true)
		if rec.Code != tc.want {
			t.Errorf("%d %s %s = %d want %d: %s", i, tc.method, tc.path, rec.Code, tc.want, rec.Body.String())
		}
	}

	// Referenced/shared assets exercise delete guards and shared-reference checks.
	agent, _ := f.s.Agent("cvb-agent")
	agent.Rules = []string{"cvb-rule"}
	agent.Skills = []string{"cvb-skill"}
	agent.Shared = true
	if err := f.s.PutAgent(agent); err != nil {
		t.Fatal(err)
	}
	for _, path := range []string{"/api/rules?id=cvb-rule", "/api/skills?id=cvb-skill"} {
		if rec := cvBRequest(t, f, http.MethodDelete, path, nil, true); rec.Code != 409 {
			t.Errorf("guarded delete %s = %d: %s", path, rec.Code, rec.Body.String())
		}
	}
	if rec := cvBRequest(t, f, http.MethodPut, "/api/rules", map[string]any{"id": "cvb-rule", "name": "Rule", "projectId": "cvb-cat", "shared": true}, true); rec.Code != 200 {
		t.Fatal(rec.Body.String())
	}
	if rec := cvBRequest(t, f, http.MethodPut, "/api/rules", map[string]any{"id": "cvb-rule", "name": "Rule", "projectId": "cvb-cat", "shared": false}, true); rec.Code != 409 {
		t.Errorf("unshare referenced rule = %d: %s", rec.Code, rec.Body.String())
	}
}

func TestCatalogWorkflowBranches(t *testing.T) {
	f := cvBNewHTTPFixture(t)
	for _, p := range []domain.Project{{ID: "cvb-wfp", Key: "WFP", Name: "Workflow", OwnerID: f.user.ID}, {ID: "cvb-wfo", Key: "WFO", Name: "Other", OwnerID: f.user.ID}} {
		if err := f.s.PutProject(p); err != nil {
			t.Fatal(err)
		}
	}
	if err := f.s.PutSandbox(domain.SandboxProfile{ID: "cvb-private-box", Name: "Private", ProjectID: "cvb-wfo", Driver: "bwrap"}); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutSandbox(domain.SandboxProfile{ID: "cvb-box", Name: "Box", ProjectID: "cvb-wfp", Driver: "bwrap"}); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutAgent(domain.AgentDefinition{ID: "cvb-private-agent", Name: "Private", ProjectID: "cvb-wfo", Version: 1}); err != nil {
		t.Fatal(err)
	}
	base := map[string]any{"id": "cvb-flow", "name": "Flow", "projectId": "cvb-wfp", "sandboxProfileId": "cvb-box"}
	cases := []struct {
		method, path string
		body         any
		want         int
	}{
		{http.MethodPut, "/api/workflows", map[string]any{"id": "wf-no-box", "name": "No box", "projectId": "cvb-wfp"}, 400},
		{http.MethodPut, "/api/workflows", map[string]any{"id": "wf-missing-box", "name": "Missing", "projectId": "cvb-wfp", "sandboxProfileId": "missing"}, 400},
		{http.MethodPut, "/api/workflows", map[string]any{"id": "wf-foreign-box", "name": "Foreign", "projectId": "cvb-wfp", "sandboxProfileId": "cvb-private-box"}, 400},
		{http.MethodPut, "/api/workflows", map[string]any{"id": "wf-agent", "name": "Agent", "projectId": "cvb-wfp", "sandboxProfileId": "cvb-box", "nodes": []any{map[string]any{"id": "n", "type": "agent", "agentId": "missing"}}}, 400},
		{http.MethodPut, "/api/workflows", map[string]any{"id": "wf-agent2", "name": "Agent", "projectId": "cvb-wfp", "sandboxProfileId": "cvb-box", "nodes": []any{map[string]any{"id": "n", "type": "agent", "agentId": "cvb-private-agent"}}}, 400},
		{http.MethodPut, "/api/workflows", base, 200},
		{http.MethodGet, "/api/workflows?q=flow&projectId=cvb-wfp", nil, 200},
		{http.MethodGet, "/api/workflows/cvb-flow", nil, 200},
		{http.MethodGet, "/api/workflows/cvb-flow/revisions", nil, 200},
		{http.MethodGet, "/api/workflows/cvb-flow/revisions/missing", nil, 404},
		{http.MethodPost, "/api/workflows/cvb-flow/clone", map[string]any{}, 400},
		{http.MethodPost, "/api/workflows/cvb-flow/clone", map[string]any{"id": "cvb-flow-clone", "name": "Clone", "projectId": "cvb-wfp"}, 201},
		{http.MethodPost, "/api/workflows/cvb-flow-clone/publish", nil, 200},
		{http.MethodDelete, "/api/workflows/cvb-flow-clone", nil, 204},
		{http.MethodPut, "/api/workflows", map[string]any{"id": "deleted-stale", "name": "Stale", "projectId": "cvb-wfp", "sandboxProfileId": "cvb-box", "revision": 2}, 409},
	}
	for i, tc := range cases {
		rec := cvBRequest(t, f, tc.method, tc.path, tc.body, true)
		if rec.Code != tc.want {
			t.Errorf("%d %s %s = %d want %d: %s", i, tc.method, tc.path, rec.Code, tc.want, rec.Body.String())
		}
	}

	// Deletion conflicts: active run, then bound issue.
	if err := f.s.PutRun(domain.Run{ID: "cvb-active", WorkflowID: "cvb-flow", Status: "running", Nodes: map[string]*domain.NodeRun{}}); err != nil {
		t.Fatal(err)
	}
	if rec := cvBRequest(t, f, http.MethodDelete, "/api/workflows/cvb-flow", nil, true); rec.Code != 409 {
		t.Errorf("active workflow delete = %d: %s", rec.Code, rec.Body.String())
	}
	run, _ := f.s.Run("cvb-active")
	run.Status = "succeeded"
	if err := f.s.PutRun(run); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutIssue(domain.Issue{ID: "cvb-bound", ProjectID: "cvb-wfp", Title: "Bound", WorkflowID: "cvb-flow", Status: "todo"}); err != nil {
		t.Fatal(err)
	}
	if rec := cvBRequest(t, f, http.MethodDelete, "/api/workflows/cvb-flow", nil, true); rec.Code != 409 || !strings.Contains(rec.Body.String(), "Issue") {
		t.Errorf("bound workflow delete = %d: %s", rec.Code, rec.Body.String())
	}
}

func TestCatalogDirectSharingAndCloneHelpers(t *testing.T) {
	f := cvBNewHTTPFixture(t)
	for _, project := range []domain.Project{
		{ID: "cvb-direct-a", Key: "CDA", Name: "Direct A"},
		{ID: "cvb-direct-b", Key: "CDB", Name: "Direct B"},
	} {
		if err := f.s.PutProject(project); err != nil {
			t.Fatal(err)
		}
	}
	h := &catalogHandlers{deps: &deps{repo: f.s}}

	for _, rule := range []domain.RuleDefinition{
		{ID: "cvb-share-rule", Name: "Share", ProjectID: "cvb-direct-a"},
		{ID: "cvb-foreign-rule", Name: "Foreign", ProjectID: "cvb-direct-b"},
		{ID: "cvb-already-rule", Name: "Already", ProjectID: "cvb-direct-a", Shared: true},
	} {
		if err := f.s.PutRule(rule); err != nil {
			t.Fatal(err)
		}
	}
	for _, skill := range []domain.SkillDefinition{
		{ID: "cvb-share-skill", Name: "Share", ProjectID: "cvb-direct-a"},
		{ID: "cvb-foreign-skill", Name: "Foreign", ProjectID: "cvb-direct-b"},
		{ID: "cvb-already-skill", Name: "Already", ProjectID: "cvb-direct-a", Shared: true},
	} {
		if err := f.s.PutSkill(skill); err != nil {
			t.Fatal(err)
		}
	}
	agent := domain.AgentDefinition{
		ID: "cvb-share-agent", Name: "Share agent", ProjectID: "cvb-direct-a",
		Rules:  []string{"missing", "cvb-foreign-rule", "cvb-already-rule", "cvb-share-rule"},
		Skills: []string{"missing", "cvb-foreign-skill", "cvb-already-skill", "cvb-share-skill"},
	}
	if err := h.shareAgentAssets(agent); err != nil {
		t.Fatal(err)
	}
	if item, _ := f.s.Rule("cvb-share-rule"); !item.Shared {
		t.Fatal("same-project rule was not shared")
	}
	if item, _ := f.s.Skill("cvb-share-skill"); !item.Shared {
		t.Fatal("same-project skill was not shared")
	}
	if item, _ := f.s.Rule("cvb-foreign-rule"); item.Shared {
		t.Fatal("foreign rule was shared")
	}

	servers := []domain.MCPServerDefinition{
		{ID: "cvb-empty", Name: "Legacy", Command: "true"},
		{ID: "cvb-project-same", Name: "Same", Command: "true", Scope: "project", ProjectID: "cvb-direct-b"},
		{ID: "cvb-project-market", Name: "Market source", Command: "true", Scope: "project", ProjectID: "cvb-direct-a", MarketID: "market-x"},
		{ID: "cvb-project-installed", Name: "Installed", Command: "true", Scope: "project", ProjectID: "cvb-direct-b", MarketID: "market-x"},
		{ID: "cvb-project-copy", Name: "Copy", Command: "true", Scope: "project", ProjectID: "cvb-direct-a"},
		{ID: "cvb-personal-own", Name: "Own", Command: "true", Scope: "personal", OwnerUserID: f.user.ID},
		{ID: "cvb-personal-other", Name: "Other", Command: "true", Scope: "personal", OwnerUserID: f.user.ID + 100},
	}
	for _, server := range servers {
		if err := f.s.PutMCPServer(server); err != nil {
			t.Fatal(err)
		}
	}
	if _, err := h.cloneAgentMCPServers([]string{"cvb-personal-other"}, "cvb-direct-b", 0); !errors.Is(err, errPersonalMCPCloneRequiresLogin) {
		t.Fatalf("personal clone without login error = %v", err)
	}
	got, err := h.cloneAgentMCPServers([]string{
		"missing", "cvb-empty", "cvb-project-same", "cvb-project-market",
		"cvb-project-copy", "cvb-personal-own", "cvb-personal-other",
	}, "cvb-direct-b", f.user.ID)
	if err != nil {
		t.Fatal(err)
	}
	if len(got) != 5 {
		t.Fatalf("cloned MCP ids = %#v", got)
	}
	if got[0] != "cvb-project-same" || got[1] != "cvb-project-installed" || got[3] != "cvb-personal-own" {
		t.Fatalf("unexpected reused MCP ids: %#v", got)
	}
	for _, id := range []string{got[2], got[4]} {
		if _, ok := f.s.MCPServer(id); !ok {
			t.Fatalf("cloned MCP %q was not stored", id)
		}
	}
	again, err := h.cloneAgentMCPServers([]string{"cvb-project-copy"}, "cvb-direct-b", f.user.ID)
	if err != nil || len(again) != 1 || again[0] != got[2] {
		t.Fatalf("idempotent clone = %#v, %v", again, err)
	}
}

func TestCatalogDirectEnvironmentBranches(t *testing.T) {
	f := cvBNewHTTPFixture(t)
	for _, project := range []domain.Project{
		{ID: "cvb-env-a", Key: "CEA", Name: "Environment A"},
		{ID: "cvb-env-b", Key: "CEB", Name: "Environment B"},
	} {
		if err := f.s.PutProject(project); err != nil {
			t.Fatal(err)
		}
	}
	h := &catalogHandlers{deps: &deps{repo: f.s}}
	if err := h.validateEnvironmentAsset("", "name", "cvb-env-a", "asset"); err == nil {
		t.Fatal("missing id accepted")
	}
	if err := h.validateEnvironmentAsset("id", "name", "missing", "asset"); err == nil {
		t.Fatal("missing project accepted")
	}
	if err := h.validateEnvironmentAsset("id", "name", "cvb-env-a", "asset"); err != nil {
		t.Fatal(err)
	}

	if err := h.shareSandboxDependencies(domain.SandboxProfile{ProjectID: "cvb-env-a", DockerfileID: "missing"}); err == nil {
		t.Fatal("missing Dockerfile accepted")
	}
	if err := h.shareSandboxDependencies(domain.SandboxProfile{ProjectID: "cvb-env-a", EnvironmentID: "missing"}); err == nil {
		t.Fatal("missing environment accepted")
	}
	if err := f.s.PutDockerfile(domain.DockerfileDefinition{ID: "cvb-foreign-df", Name: "Foreign DF", ProjectID: "cvb-env-b", Content: "FROM scratch"}); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutEnvironment(domain.EnvironmentDefinition{ID: "cvb-foreign-env", Name: "Foreign env", ProjectID: "cvb-env-b"}); err != nil {
		t.Fatal(err)
	}
	if err := h.shareSandboxDependencies(domain.SandboxProfile{ProjectID: "cvb-env-a", DockerfileID: "cvb-foreign-df"}); err == nil {
		t.Fatal("private foreign Dockerfile accepted")
	}
	if err := h.shareSandboxDependencies(domain.SandboxProfile{ProjectID: "cvb-env-a", EnvironmentID: "cvb-foreign-env"}); err == nil {
		t.Fatal("private foreign environment accepted")
	}
	if err := f.s.PutDockerfile(domain.DockerfileDefinition{ID: "cvb-own-df", Name: "Own DF", ProjectID: "cvb-env-a", Content: "FROM scratch"}); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutEnvironment(domain.EnvironmentDefinition{ID: "cvb-own-env", Name: "Own env", ProjectID: "cvb-env-a"}); err != nil {
		t.Fatal(err)
	}
	box := domain.SandboxProfile{
		ID: "cvb-shared-box", Name: "Shared box", ProjectID: "cvb-env-a", Shared: true,
		Driver: "docker", DockerfileID: "cvb-own-df", EnvironmentID: "cvb-own-env",
	}
	if err := h.shareSandboxDependencies(box); err != nil {
		t.Fatal(err)
	}
	df, _ := f.s.Dockerfile("cvb-own-df")
	env, _ := f.s.Environment("cvb-own-env")
	if !df.Shared || !env.Shared {
		t.Fatalf("dependencies not shared: df=%v env=%v", df.Shared, env.Shared)
	}

	if err := f.s.PutSandbox(box); err != nil {
		t.Fatal(err)
	}
	envBox := domain.SandboxProfile{
		ID: "cvb-shared-env-box", Name: "Shared env box", ProjectID: "cvb-env-a",
		Shared: true, Driver: "bwrap", EnvironmentID: "cvb-own-env",
	}
	if err := f.s.PutSandbox(envBox); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutWorkflow(domain.WorkflowDefinition{ID: "cvb-shared-wf", Name: "Shared workflow", Shared: true, SandboxProfileID: box.ID}); err != nil {
		t.Fatal(err)
	}
	if !h.sharedEnvironmentReference("sandbox", box.ID) || h.sharedEnvironmentReference("sandbox", "missing") {
		t.Fatal("shared workflow sandbox reference lookup is wrong")
	}
	if !h.sharedEnvironmentReference("dockerfile", df.ID) || !h.sharedEnvironmentReference("environment", env.ID) {
		t.Fatal("shared sandbox dependency reference lookup is wrong")
	}
	if h.sharedEnvironmentReference("other", df.ID) {
		t.Fatal("unknown dependency kind matched")
	}
}

func TestCatalogMoreHTTPBranches(t *testing.T) {
	f := cvBNewHTTPFixture(t)
	for _, project := range []domain.Project{
		{ID: "cvb-http-a", Key: "CHA", Name: "HTTP A", DefaultRepositoryID: "cvb-delete-repo"},
		{ID: "cvb-http-b", Key: "CHB", Name: "HTTP B"},
	} {
		if err := f.s.PutProject(project); err != nil {
			t.Fatal(err)
		}
	}
	if err := f.s.PutRepository(domain.Repository{ID: "cvb-delete-repo", ProjectID: "cvb-http-a", Name: "Delete", Provider: "gongfeng", GongfengProjectID: "a/delete"}); err != nil {
		t.Fatal(err)
	}
	if rec := cvBRequest(t, f, http.MethodDelete, "/api/repositories?id=cvb-delete-repo", nil, true); rec.Code != http.StatusOK {
		t.Fatalf("delete repository = %d: %s", rec.Code, rec.Body.String())
	}
	if project, _ := f.s.Project("cvb-http-a"); project.DefaultRepositoryID != "" {
		t.Fatalf("default repository was not cleared: %+v", project)
	}
	if rec := cvBRequest(t, f, http.MethodGet, "/api/repositories/cvb-delete-repo", nil, true); rec.Code != http.StatusNotFound {
		t.Fatalf("deleted repository lookup = %d", rec.Code)
	}

	if err := f.s.PutRule(domain.RuleDefinition{ID: "cvb-http-rule", Name: "Rule", ProjectID: "cvb-http-a"}); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutSkill(domain.SkillDefinition{ID: "cvb-http-skill", Name: "Skill", ProjectID: "cvb-http-a"}); err != nil {
		t.Fatal(err)
	}
	agent := domain.AgentDefinition{
		ID: "cvb-http-agent", Name: "Agent", ProjectID: "cvb-http-a", Shared: true,
		Rules: []string{"cvb-http-rule"}, Skills: []string{"cvb-http-skill"}, Version: 1,
	}
	if err := f.s.PutAgent(agent); err != nil {
		t.Fatal(err)
	}
	for _, path := range []string{"/api/agents/cvb-http-agent", "/api/rules?id=cvb-http-rule", "/api/skills?id=cvb-http-skill"} {
		rec := cvBRequest(t, f, http.MethodDelete, path, nil, true)
		if rec.Code != http.StatusConflict {
			t.Errorf("shared delete %s = %d: %s", path, rec.Code, rec.Body.String())
		}
	}
	agent.Shared = false
	if err := f.s.PutAgent(agent); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutSandbox(domain.SandboxProfile{ID: "cvb-http-box", Name: "Box", ProjectID: "cvb-http-a", Driver: "bwrap"}); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutWorkflow(domain.WorkflowDefinition{
		ID: "cvb-agent-ref-flow", Name: "Agent ref", ProjectID: "cvb-http-a", SandboxProfileID: "cvb-http-box",
		Nodes: []domain.WorkflowNode{{ID: "work", Name: "Work", Type: "agent", AgentID: agent.ID}},
	}); err != nil {
		t.Fatal(err)
	}
	if rec := cvBRequest(t, f, http.MethodDelete, "/api/agents/cvb-http-agent", nil, true); rec.Code != http.StatusConflict {
		t.Fatalf("referenced agent delete = %d: %s", rec.Code, rec.Body.String())
	}

	cases := []struct {
		method string
		path   string
		body   any
		want   int
	}{
		{http.MethodPut, "/api/rules", map[string]any{"id": "x"}, http.StatusBadRequest},
		{http.MethodPut, "/api/skills", map[string]any{"id": "x"}, http.StatusBadRequest},
		{http.MethodDelete, "/api/rules?id=missing", nil, http.StatusNotFound},
		{http.MethodDelete, "/api/skills", nil, http.StatusBadRequest},
		{http.MethodPut, "/api/rules", map[string]any{"id": "cvb-http-rule", "name": "Moved", "projectId": "cvb-http-b"}, http.StatusConflict},
		{http.MethodPut, "/api/skills", map[string]any{"id": "cvb-http-skill", "name": "Moved", "projectId": "cvb-http-b"}, http.StatusConflict},
		{http.MethodPut, "/api/dockerfiles", map[string]any{"id": "", "name": "Bad", "projectId": "cvb-http-a"}, http.StatusBadRequest},
		{http.MethodPut, "/api/environments", map[string]any{"id": "bad", "name": "Bad", "projectId": "missing"}, http.StatusBadRequest},
		{http.MethodPut, "/api/sandboxes", map[string]any{"id": "bad", "name": "Bad", "projectId": "missing"}, http.StatusBadRequest},
		{http.MethodDelete, "/api/dockerfiles?id=" + repo.GenericBackendDockerfileID, nil, http.StatusConflict},
		{http.MethodDelete, "/api/sandboxes?id=local", nil, http.StatusConflict},
		{http.MethodGet, "/api/executors", nil, http.StatusOK},
	}
	for _, tc := range cases {
		rec := cvBRequest(t, f, tc.method, tc.path, tc.body, true)
		if rec.Code != tc.want {
			t.Errorf("%s %s = %d want %d: %s", tc.method, tc.path, rec.Code, tc.want, rec.Body.String())
		}
	}
}

func TestCatalogWorkflowMoreBranches(t *testing.T) {
	f := cvBNewHTTPFixture(t)
	if err := f.s.PutProject(domain.Project{ID: "cvb-wf-more", Key: "CWM", Name: "Workflow More"}); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutSandbox(domain.SandboxProfile{ID: "cvb-wf-more-box", Name: "Box", ProjectID: "cvb-wf-more", Driver: "bwrap"}); err != nil {
		t.Fatal(err)
	}
	for _, workflow := range []domain.WorkflowDefinition{
		{ID: "cvb-search-hit", Name: "Needle Alpha", Description: "plain", ProjectID: "cvb-wf-more", SandboxProfileID: "cvb-wf-more-box"},
		{ID: "cvb-search-miss", Name: "Other", Description: "plain", ProjectID: "cvb-wf-more", SandboxProfileID: "cvb-wf-more-box"},
		{ID: "cvb-other-project", Name: "Needle Other", ProjectID: "elsewhere", SandboxProfileID: "cvb-wf-more-box"},
	} {
		if err := f.s.PutWorkflow(workflow); err != nil {
			t.Fatal(err)
		}
	}
	rec := cvBRequest(t, f, http.MethodGet, "/api/workflows?projectId=cvb-wf-more&q=needle", nil, true)
	if rec.Code != http.StatusOK || !strings.Contains(rec.Body.String(), "cvb-search-hit") ||
		strings.Contains(rec.Body.String(), "cvb-search-miss") || strings.Contains(rec.Body.String(), "cvb-other-project") {
		t.Fatalf("filtered workflows = %d: %s", rec.Code, rec.Body.String())
	}
	if rec := cvBRequest(t, f, http.MethodPut, "/api/workflows", map[string]any{
		"id": "cvb-bad-stage", "name": "Bad stage", "projectId": "cvb-wf-more", "sandboxProfileId": "cvb-wf-more-box",
		"nodes": []any{map[string]any{"id": "n", "name": "N", "type": "script", "metricStage": "typo"}},
	}, true); rec.Code != http.StatusBadRequest {
		t.Fatalf("bad metric stage = %d: %s", rec.Code, rec.Body.String())
	}
	if rec := cvBRequest(t, f, http.MethodGet, "/api/workflows/missing", nil, true); rec.Code != http.StatusNotFound {
		t.Fatalf("missing workflow = %d", rec.Code)
	}
	if rec := cvBRequest(t, f, http.MethodGet, "/api/workflows/cvb-search-hit/agents", nil, true); rec.Code != http.StatusNotFound {
		t.Fatalf("nongeneric agents = %d: %s", rec.Code, rec.Body.String())
	}
	if rec := cvBRequest(t, f, http.MethodPost, "/api/workflows/cvb-search-hit/clone", map[string]any{
		"id": "cvb-search-clone", "name": "Clone", "owner": "owner",
	}, true); rec.Code != http.StatusCreated {
		t.Fatalf("workflow clone default project = %d: %s", rec.Code, rec.Body.String())
	}
	cloned, ok := f.s.Workflow("cvb-search-clone")
	if !ok || cloned.ProjectID != "cvb-wf-more" || cloned.Status != "draft" || cloned.Version != 1 {
		t.Fatalf("cloned workflow = %+v, %v", cloned, ok)
	}
}

func TestCatalogSmallDirectHelpers(t *testing.T) {
	f := cvBNewHTTPFixture(t)
	if err := f.s.PutProject(domain.Project{ID: "cvb-helper", Key: "CVH", Name: "Helpers"}); err != nil {
		t.Fatal(err)
	}
	h := &catalogHandlers{deps: &deps{repo: f.s}}
	if err := normalizeGlobalRule(f.s, nil); err != nil {
		t.Fatal(err)
	}
	rule := domain.RuleDefinition{Global: false, WorkflowIDs: []string{"discard"}}
	if err := normalizeGlobalRule(f.s, &rule); err != nil || rule.WorkflowIDs != nil {
		t.Fatalf("disabled global rule = %+v, %v", rule, err)
	}
	if err := h.validateWorkflowAgentScopes(domain.WorkflowDefinition{}); err != nil {
		t.Fatal(err)
	}
	if err := h.validateWorkflowAgentScopes(domain.WorkflowDefinition{
		ProjectID: "cvb-helper",
		Nodes: []domain.WorkflowNode{
			{ID: "script", Type: "script"},
			{ID: "empty", Type: "agent"},
			{ID: "preview", Type: "agent", AgentID: domain.PreviewBuildAgentID},
		},
	}); err != nil {
		t.Fatal(err)
	}
	if workflowHasNotifications(domain.WorkflowDefinition{}) {
		t.Fatal("empty workflow reported notifications")
	}
	if !workflowHasNotifications(domain.WorkflowDefinition{Notifications: []domain.NotificationBinding{{}}}) {
		t.Fatal("workflow notification was missed")
	}
	if !workflowHasNotifications(domain.WorkflowDefinition{Nodes: []domain.WorkflowNode{{Notifications: []domain.NodeNotification{{}}}}}) {
		t.Fatal("node notification was missed")
	}

	if err := f.s.PutAgent(domain.AgentDefinition{
		ID: "cvb-helper-agent", Name: "Helper agent", ProjectID: "cvb-helper",
		Rules: []string{"r", "r"}, Skills: []string{"s"},
	}); err != nil {
		t.Fatal(err)
	}
	if names := h.agentNamesReferencing("rule", "r"); len(names) != 1 || names[0] != "Helper agent" {
		t.Fatalf("rule references = %#v", names)
	}
	if names := h.agentNamesReferencing("skill", "s"); len(names) != 1 {
		t.Fatalf("skill references = %#v", names)
	}
	if err := f.s.PutDockerfile(domain.DockerfileDefinition{ID: "cvb-helper-df", Name: "DF", ProjectID: "cvb-helper", Content: "FROM scratch"}); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutEnvironment(domain.EnvironmentDefinition{ID: "cvb-helper-env", Name: "Env", ProjectID: "cvb-helper"}); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutSandbox(domain.SandboxProfile{
		ID: "cvb-helper-docker", Name: "Docker", ProjectID: "cvb-helper",
		Driver: "docker", DockerfileID: "cvb-helper-df",
	}); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutSandbox(domain.SandboxProfile{
		ID: "cvb-helper-bwrap", Name: "Bwrap", ProjectID: "cvb-helper",
		Driver: "bwrap", EnvironmentID: "cvb-helper-env",
	}); err != nil {
		t.Fatal(err)
	}
	if len(h.sandboxNamesReferencing("dockerfile", "cvb-helper-df")) != 1 ||
		len(h.sandboxNamesReferencing("environment", "cvb-helper-env")) != 1 {
		t.Fatal("sandbox dependency names were not found")
	}
	if len(h.workflowNamesReferencingSandbox("missing")) != 0 {
		t.Fatal("missing sandbox unexpectedly referenced")
	}
}

func TestCatalogRevisionRestoreAndValidation(t *testing.T) {
	f := cvBNewHTTPFixture(t)
	project := domain.Project{ID: "cvb-r2-catalog", Key: "R2C", Name: "Catalog", OwnerID: f.user.ID}
	other := domain.Project{ID: "cvb-r2-catalog-other", Key: "R2O", Name: "Other", OwnerID: f.user.ID}
	if err := f.s.PutProject(project); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutProject(other); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutSandbox(domain.SandboxProfile{ID: "cvb-r2-box", Name: "Box", ProjectID: project.ID, Driver: "bwrap"}); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutSandbox(domain.SandboxProfile{ID: "cvb-r2-private-box", Name: "Private", ProjectID: other.ID, Driver: "bwrap"}); err != nil {
		t.Fatal(err)
	}
	agent := domain.AgentDefinition{ID: "cvb-r2-agent", Name: "Agent", ProjectID: project.ID, ExecutorID: "codebuddy", Version: 1}
	if err := f.s.PutAgent(agent); err != nil {
		t.Fatal(err)
	}
	agent.Name = "Agent v2"
	if err := f.s.PutAgent(agent); err != nil {
		t.Fatal(err)
	}
	workflow := domain.WorkflowDefinition{ID: "cvb-r2-workflow", Name: "Workflow", ProjectID: project.ID,
		SandboxProfileID: "cvb-r2-box", Version: 1, Nodes: []domain.WorkflowNode{{ID: "n", Type: "agent", AgentID: agent.ID}}}
	if err := f.s.PutWorkflow(workflow); err != nil {
		t.Fatal(err)
	}
	workflow, _ = f.s.Workflow(workflow.ID)
	workflow.Name = "Workflow v2"
	if err := f.s.PutWorkflow(workflow); err != nil {
		t.Fatal(err)
	}
	for _, tc := range []struct {
		method, path string
		body         any
		want         int
	}{
		{http.MethodPut, "/api/workflows", map[string]any{"id": "cvb-r2-bad-stage", "name": "Bad", "projectId": project.ID, "sandboxProfileId": "cvb-r2-box",
			"nodes": []any{map[string]any{"id": "n", "type": "script", "metricStage": "invalid"}}}, 400},
		{http.MethodPut, "/api/workflows", map[string]any{"id": "cvb-r2-shared-private", "name": "Bad", "projectId": other.ID,
			"sandboxProfileId": "cvb-r2-private-box", "shared": true}, 400},
		{http.MethodPut, "/api/workflows", map[string]any{"id": "cvb-r2-foreign-box", "name": "Bad", "projectId": project.ID,
			"sandboxProfileId": "cvb-r2-private-box"}, 400},
		{http.MethodGet, "/api/workflows?q=workflow&projectId=" + project.ID, nil, 200},
		{http.MethodGet, "/api/workflows/" + workflow.ID + "/revisions", nil, 200},
		{http.MethodGet, "/api/agents/" + agent.ID + "/revisions", nil, 200},
		{http.MethodPost, "/api/workflows/" + workflow.ID + "/revisions/missing/restore", nil, 404},
		{http.MethodPost, "/api/agents/" + agent.ID + "/revisions/missing/restore", nil, 400},
	} {
		rec := cvBRequest(t, f, tc.method, tc.path, tc.body, true)
		if rec.Code != tc.want {
			t.Errorf("%s %s = %d want %d: %s", tc.method, tc.path, rec.Code, tc.want, rec.Body.String())
		}
	}

	restoreFirstRevision := func(kind, id string) {
		rec := cvBRequest(t, f, http.MethodGet, "/api/"+kind+"/"+id+"/revisions", nil, true)
		var revisions []domain.DefinitionRevision
		if err := json.Unmarshal(rec.Body.Bytes(), &revisions); err != nil || len(revisions) == 0 {
			t.Fatalf("%s revisions: %v %s", kind, err, rec.Body.String())
		}
		path := "/api/" + kind + "/" + id + "/revisions/" + revisions[0].ID + "/restore"
		if restored := cvBRequest(t, f, http.MethodPost, path, nil, true); restored.Code != http.StatusOK {
			t.Errorf("restore %s = %d: %s", kind, restored.Code, restored.Body.String())
		}
	}
	restoreFirstRevision("workflows", workflow.ID)
	restoreFirstRevision("agents", agent.ID)
}

func TestCatalogCrossProjectAssetConflicts(t *testing.T) {
	f := cvBNewHTTPFixture(t)
	for _, project := range []domain.Project{
		{ID: "cvb-r2-assets-a", Key: "R2A", Name: "A", OwnerID: f.user.ID},
		{ID: "cvb-r2-assets-b", Key: "R2B", Name: "B", OwnerID: f.user.ID},
	} {
		if err := f.s.PutProject(project); err != nil {
			t.Fatal(err)
		}
	}
	if err := f.s.PutRule(domain.RuleDefinition{ID: "cvb-r2-cross-rule", Name: "Rule", ProjectID: "cvb-r2-assets-a"}); err != nil {
		t.Fatal(err)
	}
	if err := f.s.PutSkill(domain.SkillDefinition{ID: "cvb-r2-cross-skill", Name: "Skill", ProjectID: "cvb-r2-assets-a"}); err != nil {
		t.Fatal(err)
	}
	for _, tc := range []struct {
		path string
		body any
	}{
		{"/api/rules", map[string]any{"id": "cvb-r2-cross-rule", "name": "Rule", "projectId": "cvb-r2-assets-b"}},
		{"/api/skills", map[string]any{"id": "cvb-r2-cross-skill", "name": "Skill", "projectId": "cvb-r2-assets-b"}},
	} {
		rec := cvBRequest(t, f, http.MethodPut, tc.path, tc.body, true)
		if rec.Code != http.StatusConflict {
			t.Errorf("%s conflict = %d: %s", tc.path, rec.Code, rec.Body.String())
		}
	}
}