* fix(formula): resolve worktree-aware search paths (beads-oto) intent(formula): worktree users should resolve formulas from the active shared .beads registry instead of cwd-only paths decision(formula-search): route CLI help, formula lookup, and distill output hints through formula.DefaultSearchPaths so search path display matches runtime behavior constraint(worktree): keep cwd/.beads fallback when no beads project is resolved so local formula registries still work before init * fix(formula): align mol seed help with resolved search paths intent(formula-help): worktree users should see the active beads workspace path instead of stale cwd-based guidance constraint(formula-runtime): seed already resolves formulas through the shared default search helper so this change only updates the displayed contract * test(formula): isolate worktree parser repo hooks intent(formula-tests): keep worktree search path coverage focused on formula resolution instead of developer git hook state constraint(git-test-repos): global core.hooksPath can inject failing pre-commit hooks into temp repos and break the setup commit decision(formula-tests): reuse ForceRepoLocalHooksPath so the new worktree test follows the repo's existing git test isolation rule * test(formula): simplify search-path test setup (beads-6kum) intent(formula-tests): keep the new search-path coverage easy to extend without re-reading repetitive test scaffolding constraint(formula-tests): helper extraction must preserve the hook-isolation and cache-reset behavior added for worktree coverage decision(formula-tests): centralize repo init, fixture writing, and canonical path handling into local test helpers so each case stays focused on its assertions
1935 lines
47 KiB
Go
1935 lines
47 KiB
Go
package formula
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/steveyegge/beads/internal/beads"
|
|
"github.com/steveyegge/beads/internal/git"
|
|
"github.com/steveyegge/beads/internal/testutil"
|
|
)
|
|
|
|
func resetFormulaSearchCaches() {
|
|
beads.ResetCaches()
|
|
git.ResetCaches()
|
|
}
|
|
|
|
func resetFormulaSearchTestContext(t *testing.T) {
|
|
t.Helper()
|
|
t.Setenv("BEADS_DIR", "")
|
|
t.Setenv("GT_ROOT", "")
|
|
resetFormulaSearchCaches()
|
|
t.Cleanup(resetFormulaSearchCaches)
|
|
}
|
|
|
|
func runGitForFormulaTest(t *testing.T, dir string, args ...string) {
|
|
t.Helper()
|
|
cmd := exec.Command("git", args...)
|
|
cmd.Dir = dir
|
|
output, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
t.Fatalf("git %v failed: %v\n%s", args, err, output)
|
|
}
|
|
}
|
|
|
|
func initFormulaTestRepo(t *testing.T, repoDir string) {
|
|
t.Helper()
|
|
if err := os.MkdirAll(repoDir, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
runGitForFormulaTest(t, repoDir, "init")
|
|
if err := testutil.ForceRepoLocalHooksPath(repoDir); err != nil {
|
|
t.Fatalf("force repo-local hooks path: %v", err)
|
|
}
|
|
runGitForFormulaTest(t, repoDir, "config", "user.email", "test@example.com")
|
|
runGitForFormulaTest(t, repoDir, "config", "user.name", "Test User")
|
|
if err := os.WriteFile(filepath.Join(repoDir, "README.md"), []byte("# Test\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
runGitForFormulaTest(t, repoDir, "add", "README.md")
|
|
runGitForFormulaTest(t, repoDir, "commit", "-m", "init")
|
|
}
|
|
|
|
func writeFormulaFixture(t *testing.T, dir, formulaName, description string) string {
|
|
t.Helper()
|
|
if err := os.MkdirAll(dir, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
formulaPath := filepath.Join(dir, formulaName+FormulaExtTOML)
|
|
content := fmt.Sprintf(
|
|
"formula = %q\ndescription = %q\n[[steps]]\nid = \"step1\"\ntitle = \"Step 1\"\n",
|
|
formulaName,
|
|
description,
|
|
)
|
|
if err := os.WriteFile(formulaPath, []byte(content), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return formulaPath
|
|
}
|
|
|
|
func canonicalTestPath(path string) string {
|
|
resolved, err := filepath.EvalSymlinks(filepath.Clean(path))
|
|
if err != nil {
|
|
return filepath.Clean(path)
|
|
}
|
|
return resolved
|
|
}
|
|
|
|
func TestParse_BasicFormula(t *testing.T) {
|
|
jsonData := `{
|
|
"formula": "mol-test",
|
|
"description": "Test workflow",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"vars": {
|
|
"component": {
|
|
"description": "Component name",
|
|
"required": true
|
|
},
|
|
"framework": {
|
|
"description": "Target framework",
|
|
"default": "react",
|
|
"enum": ["react", "vue", "angular"]
|
|
}
|
|
},
|
|
"steps": [
|
|
{"id": "design", "title": "Design {{component}}", "type": "task", "priority": 1},
|
|
{"id": "implement", "title": "Implement {{component}}", "type": "task", "depends_on": ["design"]},
|
|
{"id": "test", "title": "Test {{component}} with {{framework}}", "type": "task", "depends_on": ["implement"]}
|
|
]
|
|
}`
|
|
p := NewParser()
|
|
formula, err := p.Parse([]byte(jsonData))
|
|
if err != nil {
|
|
t.Fatalf("Parse failed: %v", err)
|
|
}
|
|
|
|
// Check basic fields
|
|
if formula.Formula != "mol-test" {
|
|
t.Errorf("Formula = %q, want mol-test", formula.Formula)
|
|
}
|
|
if formula.Description != "Test workflow" {
|
|
t.Errorf("Description = %q, want 'Test workflow'", formula.Description)
|
|
}
|
|
if formula.Version != 1 {
|
|
t.Errorf("Version = %d, want 1", formula.Version)
|
|
}
|
|
if formula.Type != TypeWorkflow {
|
|
t.Errorf("Type = %q, want workflow", formula.Type)
|
|
}
|
|
|
|
// Check vars
|
|
if len(formula.Vars) != 2 {
|
|
t.Fatalf("len(Vars) = %d, want 2", len(formula.Vars))
|
|
}
|
|
if v := formula.Vars["component"]; v == nil || !v.Required {
|
|
t.Error("component var should be required")
|
|
}
|
|
if v := formula.Vars["framework"]; v == nil || v.Default == nil || *v.Default != "react" {
|
|
t.Error("framework var should have default 'react'")
|
|
}
|
|
if v := formula.Vars["framework"]; v == nil || len(v.Enum) != 3 {
|
|
t.Error("framework var should have 3 enum values")
|
|
}
|
|
|
|
// Check steps
|
|
if len(formula.Steps) != 3 {
|
|
t.Fatalf("len(Steps) = %d, want 3", len(formula.Steps))
|
|
}
|
|
if formula.Steps[0].ID != "design" {
|
|
t.Errorf("Steps[0].ID = %q, want 'design'", formula.Steps[0].ID)
|
|
}
|
|
if formula.Steps[1].DependsOn[0] != "design" {
|
|
t.Errorf("Steps[1].DependsOn = %v, want [design]", formula.Steps[1].DependsOn)
|
|
}
|
|
}
|
|
|
|
func TestDefaultSearchPaths_UsesResolvedBeadsDirForWorktree(t *testing.T) {
|
|
resetFormulaSearchTestContext(t)
|
|
|
|
root := t.TempDir()
|
|
mainRepo := filepath.Join(root, "main-repo")
|
|
initFormulaTestRepo(t, mainRepo)
|
|
|
|
worktreeDir := filepath.Join(root, "worktree")
|
|
runGitForFormulaTest(t, mainRepo, "worktree", "add", worktreeDir, "HEAD")
|
|
t.Cleanup(func() {
|
|
cmd := exec.Command("git", "worktree", "remove", "--force", worktreeDir)
|
|
cmd.Dir = mainRepo
|
|
_ = cmd.Run()
|
|
})
|
|
|
|
mainFormulaDir := filepath.Join(mainRepo, ".beads", "formulas")
|
|
if err := os.MkdirAll(filepath.Join(mainRepo, ".beads", "dolt"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
writeFormulaFixture(t, mainFormulaDir, "shared", "shared formula")
|
|
|
|
t.Chdir(worktreeDir)
|
|
resetFormulaSearchCaches()
|
|
|
|
paths := DefaultSearchPaths()
|
|
if len(paths) == 0 {
|
|
t.Fatal("DefaultSearchPaths() returned no paths")
|
|
}
|
|
|
|
gotResolved := canonicalTestPath(paths[0])
|
|
wantResolved := canonicalTestPath(filepath.Join(mainRepo, ".beads", "formulas"))
|
|
if gotResolved != wantResolved {
|
|
t.Fatalf("DefaultSearchPaths()[0] = %q, want %q", gotResolved, wantResolved)
|
|
}
|
|
|
|
parser := NewParser()
|
|
f, err := parser.LoadByName("shared")
|
|
if err != nil {
|
|
t.Fatalf("LoadByName(shared) failed: %v", err)
|
|
}
|
|
if !strings.HasPrefix(f.Source, wantResolved) {
|
|
t.Fatalf("formula source = %q, want prefix %q", f.Source, wantResolved)
|
|
}
|
|
}
|
|
|
|
func TestDefaultSearchPaths_FallsBackToCwdFormulaDirWithoutBeadsProject(t *testing.T) {
|
|
resetFormulaSearchTestContext(t)
|
|
|
|
root := t.TempDir()
|
|
formulaDir := filepath.Join(root, ".beads", "formulas")
|
|
writeFormulaFixture(t, formulaDir, "local-only", "cwd fallback")
|
|
|
|
t.Chdir(root)
|
|
resetFormulaSearchCaches()
|
|
|
|
paths := DefaultSearchPaths()
|
|
if len(paths) == 0 {
|
|
t.Fatal("DefaultSearchPaths() returned no paths")
|
|
}
|
|
want := filepath.Join(root, ".beads", "formulas")
|
|
if filepath.Clean(paths[0]) != filepath.Clean(want) {
|
|
t.Fatalf("DefaultSearchPaths()[0] = %q, want %q", paths[0], want)
|
|
}
|
|
|
|
parser := NewParser()
|
|
if _, err := parser.LoadByName("local-only"); err != nil {
|
|
t.Fatalf("LoadByName(local-only) failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidate_ValidFormula(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-valid",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{ID: "step1", Title: "Step 1"},
|
|
{ID: "step2", Title: "Step 2", DependsOn: []string{"step1"}},
|
|
},
|
|
}
|
|
|
|
if err := formula.Validate(); err != nil {
|
|
t.Errorf("Validate failed for valid formula: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidate_MissingName(t *testing.T) {
|
|
formula := &Formula{
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{{ID: "step1", Title: "Step 1"}},
|
|
}
|
|
|
|
err := formula.Validate()
|
|
if err == nil {
|
|
t.Error("Validate should fail for formula without name")
|
|
}
|
|
}
|
|
|
|
func TestValidate_DuplicateStepID(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-dup",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{ID: "step1", Title: "Step 1"},
|
|
{ID: "step1", Title: "Step 1 again"}, // duplicate
|
|
},
|
|
}
|
|
|
|
err := formula.Validate()
|
|
if err == nil {
|
|
t.Error("Validate should fail for duplicate step IDs")
|
|
}
|
|
}
|
|
|
|
func TestValidate_InvalidDependency(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-bad-dep",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{ID: "step1", Title: "Step 1", DependsOn: []string{"nonexistent"}},
|
|
},
|
|
}
|
|
|
|
err := formula.Validate()
|
|
if err == nil {
|
|
t.Error("Validate should fail for dependency on nonexistent step")
|
|
}
|
|
}
|
|
|
|
func TestValidate_RequiredWithDefault(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-bad-var",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Vars: map[string]*VarDef{
|
|
"bad": {Required: true, Default: StringPtr("value")}, // can't have both
|
|
},
|
|
Steps: []*Step{{ID: "step1", Title: "Step 1"}},
|
|
}
|
|
|
|
err := formula.Validate()
|
|
if err == nil {
|
|
t.Error("Validate should fail for required var with default")
|
|
}
|
|
}
|
|
|
|
func TestValidate_InvalidPriority(t *testing.T) {
|
|
p := 10 // invalid: must be 0-4
|
|
formula := &Formula{
|
|
Formula: "mol-bad-priority",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{ID: "step1", Title: "Step 1", Priority: &p},
|
|
},
|
|
}
|
|
|
|
err := formula.Validate()
|
|
if err == nil {
|
|
t.Error("Validate should fail for priority > 4")
|
|
}
|
|
}
|
|
|
|
func TestValidate_ChildSteps(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-children",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{
|
|
ID: "epic1",
|
|
Title: "Epic 1",
|
|
Children: []*Step{
|
|
{ID: "child1", Title: "Child 1"},
|
|
{ID: "child2", Title: "Child 2", DependsOn: []string{"child1"}},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
if err := formula.Validate(); err != nil {
|
|
t.Errorf("Validate failed for valid nested formula: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidate_ChildStepsInvalidDependsOn(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-bad-child-dep",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{
|
|
ID: "epic1",
|
|
Title: "Epic 1",
|
|
Children: []*Step{
|
|
{ID: "child1", Title: "Child 1"},
|
|
{ID: "child2", Title: "Child 2", DependsOn: []string{"nonexistent"}},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
err := formula.Validate()
|
|
if err == nil {
|
|
t.Error("Validate should fail for child depends_on referencing unknown step")
|
|
}
|
|
}
|
|
|
|
func TestValidate_ChildStepsInvalidPriority(t *testing.T) {
|
|
p := 10 // invalid
|
|
formula := &Formula{
|
|
Formula: "mol-bad-child-priority",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{
|
|
ID: "epic1",
|
|
Title: "Epic 1",
|
|
Children: []*Step{
|
|
{ID: "child1", Title: "Child 1", Priority: &p},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
err := formula.Validate()
|
|
if err == nil {
|
|
t.Error("Validate should fail for child with invalid priority")
|
|
}
|
|
}
|
|
|
|
func TestValidate_BondPoints(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-compose",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{ID: "step1", Title: "Step 1"},
|
|
{ID: "step2", Title: "Step 2"},
|
|
},
|
|
Compose: &ComposeRules{
|
|
BondPoints: []*BondPoint{
|
|
{ID: "after-step1", AfterStep: "step1"},
|
|
{ID: "before-step2", BeforeStep: "step2"},
|
|
},
|
|
},
|
|
}
|
|
|
|
if err := formula.Validate(); err != nil {
|
|
t.Errorf("Validate failed for valid bond points: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidate_BondPointBothAnchors(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-bad-bond",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{{ID: "step1", Title: "Step 1"}},
|
|
Compose: &ComposeRules{
|
|
BondPoints: []*BondPoint{
|
|
{ID: "bad", AfterStep: "step1", BeforeStep: "step1"}, // can't have both
|
|
},
|
|
},
|
|
}
|
|
|
|
err := formula.Validate()
|
|
if err == nil {
|
|
t.Error("Validate should fail for bond point with both after_step and before_step")
|
|
}
|
|
}
|
|
|
|
func TestExtractVariables(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-vars",
|
|
Description: "Build {{project}} for {{env}}",
|
|
Steps: []*Step{
|
|
{ID: "s1", Title: "Deploy {{project}} to {{env}}"},
|
|
{ID: "s2", Title: "Notify {{owner}}"},
|
|
},
|
|
}
|
|
|
|
vars := ExtractVariables(formula)
|
|
want := map[string]bool{"project": true, "env": true, "owner": true}
|
|
|
|
if len(vars) != len(want) {
|
|
t.Errorf("ExtractVariables found %d vars, want %d", len(vars), len(want))
|
|
}
|
|
for _, v := range vars {
|
|
if !want[v] {
|
|
t.Errorf("Unexpected variable: %q", v)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSubstitute(t *testing.T) {
|
|
tests := []struct {
|
|
input string
|
|
vars map[string]string
|
|
want string
|
|
}{
|
|
{
|
|
input: "Deploy {{project}} to {{env}}",
|
|
vars: map[string]string{"project": "myapp", "env": "prod"},
|
|
want: "Deploy myapp to prod",
|
|
},
|
|
{
|
|
input: "{{name}} version {{version}}",
|
|
vars: map[string]string{"name": "beads"},
|
|
want: "beads version {{version}}", // unresolved kept
|
|
},
|
|
{
|
|
input: "No variables here",
|
|
vars: map[string]string{"unused": "value"},
|
|
want: "No variables here",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
got := Substitute(tt.input, tt.vars)
|
|
if got != tt.want {
|
|
t.Errorf("Substitute(%q, %v) = %q, want %q", tt.input, tt.vars, got, tt.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestValidateVars(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-vars",
|
|
Vars: map[string]*VarDef{
|
|
"required_var": {Required: true},
|
|
"enum_var": {Enum: []string{"a", "b", "c"}},
|
|
"pattern_var": {Pattern: `^[a-z]+$`},
|
|
"optional_var": {Default: StringPtr("default")},
|
|
},
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
values map[string]string
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "missing required",
|
|
values: map[string]string{},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "all provided",
|
|
values: map[string]string{"required_var": "value"},
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "valid enum",
|
|
values: map[string]string{"required_var": "x", "enum_var": "a"},
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "invalid enum",
|
|
values: map[string]string{"required_var": "x", "enum_var": "invalid"},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "valid pattern",
|
|
values: map[string]string{"required_var": "x", "pattern_var": "abc"},
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "invalid pattern",
|
|
values: map[string]string{"required_var": "x", "pattern_var": "123"},
|
|
wantErr: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := ValidateVars(formula, tt.values)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("ValidateVars() error = %v, wantErr %v", err, tt.wantErr)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestApplyDefaults(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-defaults",
|
|
Vars: map[string]*VarDef{
|
|
"with_default": {Default: StringPtr("default_value")},
|
|
"without_default": {},
|
|
},
|
|
}
|
|
|
|
values := map[string]string{"without_default": "provided"}
|
|
result := ApplyDefaults(formula, values)
|
|
|
|
if result["with_default"] != "default_value" {
|
|
t.Errorf("with_default = %q, want 'default_value'", result["with_default"])
|
|
}
|
|
if result["without_default"] != "provided" {
|
|
t.Errorf("without_default = %q, want 'provided'", result["without_default"])
|
|
}
|
|
}
|
|
|
|
func TestParseFile_AndResolve(t *testing.T) {
|
|
// Create temp directory with test formulas
|
|
dir := t.TempDir()
|
|
formulaDir := filepath.Join(dir, ".beads", "formulas")
|
|
if err := os.MkdirAll(formulaDir, 0755); err != nil {
|
|
t.Fatalf("mkdir: %v", err)
|
|
}
|
|
|
|
// Write parent formula
|
|
parent := `{
|
|
"formula": "base-workflow",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"vars": {
|
|
"project": {
|
|
"description": "Project name",
|
|
"required": true
|
|
}
|
|
},
|
|
"steps": [
|
|
{"id": "init", "title": "Initialize {{project}}"}
|
|
]
|
|
}`
|
|
if err := os.WriteFile(filepath.Join(formulaDir, "base-workflow.formula.json"), []byte(parent), 0644); err != nil {
|
|
t.Fatalf("write parent: %v", err)
|
|
}
|
|
|
|
// Write child formula that extends parent
|
|
child := `{
|
|
"formula": "extended-workflow",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"extends": ["base-workflow"],
|
|
"vars": {
|
|
"env": {
|
|
"default": "dev"
|
|
}
|
|
},
|
|
"steps": [
|
|
{"id": "deploy", "title": "Deploy {{project}} to {{env}}", "depends_on": ["init"]}
|
|
]
|
|
}`
|
|
childPath := filepath.Join(formulaDir, "extended-workflow.formula.json")
|
|
if err := os.WriteFile(childPath, []byte(child), 0644); err != nil {
|
|
t.Fatalf("write child: %v", err)
|
|
}
|
|
|
|
// Parse and resolve
|
|
p := NewParser(formulaDir)
|
|
formula, err := p.ParseFile(childPath)
|
|
if err != nil {
|
|
t.Fatalf("ParseFile: %v", err)
|
|
}
|
|
|
|
resolved, err := p.Resolve(formula)
|
|
if err != nil {
|
|
t.Fatalf("Resolve: %v", err)
|
|
}
|
|
|
|
// Check inheritance
|
|
if len(resolved.Vars) != 2 {
|
|
t.Errorf("len(Vars) = %d, want 2 (inherited + child)", len(resolved.Vars))
|
|
}
|
|
if resolved.Vars["project"] == nil {
|
|
t.Error("inherited var 'project' not found")
|
|
}
|
|
if resolved.Vars["env"] == nil {
|
|
t.Error("child var 'env' not found")
|
|
}
|
|
|
|
// Check steps (parent + child)
|
|
if len(resolved.Steps) != 2 {
|
|
t.Errorf("len(Steps) = %d, want 2", len(resolved.Steps))
|
|
}
|
|
if resolved.Steps[0].ID != "init" {
|
|
t.Errorf("Steps[0].ID = %q, want 'init' (inherited)", resolved.Steps[0].ID)
|
|
}
|
|
if resolved.Steps[1].ID != "deploy" {
|
|
t.Errorf("Steps[1].ID = %q, want 'deploy' (child)", resolved.Steps[1].ID)
|
|
}
|
|
}
|
|
|
|
func TestResolve_CircularExtends(t *testing.T) {
|
|
dir := t.TempDir()
|
|
formulaDir := filepath.Join(dir, ".beads", "formulas")
|
|
if err := os.MkdirAll(formulaDir, 0755); err != nil {
|
|
t.Fatalf("mkdir: %v", err)
|
|
}
|
|
|
|
// Write formulas that extend each other (cycle)
|
|
formulaA := `{
|
|
"formula": "cycle-a",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"extends": ["cycle-b"],
|
|
"steps": [{"id": "a", "title": "A"}]
|
|
}`
|
|
formulaB := `{
|
|
"formula": "cycle-b",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"extends": ["cycle-a"],
|
|
"steps": [{"id": "b", "title": "B"}]
|
|
}`
|
|
if err := os.WriteFile(filepath.Join(formulaDir, "cycle-a.formula.json"), []byte(formulaA), 0644); err != nil {
|
|
t.Fatalf("write a: %v", err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(formulaDir, "cycle-b.formula.json"), []byte(formulaB), 0644); err != nil {
|
|
t.Fatalf("write b: %v", err)
|
|
}
|
|
|
|
p := NewParser(formulaDir)
|
|
formula, err := p.ParseFile(filepath.Join(formulaDir, "cycle-a.formula.json"))
|
|
if err != nil {
|
|
t.Fatalf("ParseFile: %v", err)
|
|
}
|
|
|
|
_, err = p.Resolve(formula)
|
|
if err == nil {
|
|
t.Error("Resolve should fail for circular extends")
|
|
}
|
|
|
|
// Verify the error message shows the full cycle chain
|
|
errStr := err.Error()
|
|
if !strings.Contains(errStr, "cycle-a") {
|
|
t.Errorf("error should mention cycle-a: %v", err)
|
|
}
|
|
if !strings.Contains(errStr, "cycle-b") {
|
|
t.Errorf("error should mention cycle-b: %v", err)
|
|
}
|
|
if !strings.Contains(errStr, "->") {
|
|
t.Errorf("error should show cycle chain with '->': %v", err)
|
|
}
|
|
}
|
|
|
|
func TestGetStepByID(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-nested",
|
|
Steps: []*Step{
|
|
{
|
|
ID: "epic1",
|
|
Title: "Epic 1",
|
|
Children: []*Step{
|
|
{ID: "child1", Title: "Child 1"},
|
|
{
|
|
ID: "child2",
|
|
Title: "Child 2",
|
|
Children: []*Step{
|
|
{ID: "grandchild", Title: "Grandchild"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{ID: "step2", Title: "Step 2"},
|
|
},
|
|
}
|
|
|
|
tests := []struct {
|
|
id string
|
|
want string
|
|
}{
|
|
{"epic1", "Epic 1"},
|
|
{"child1", "Child 1"},
|
|
{"grandchild", "Grandchild"},
|
|
{"step2", "Step 2"},
|
|
{"nonexistent", ""},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
step := formula.GetStepByID(tt.id)
|
|
if tt.want == "" {
|
|
if step != nil {
|
|
t.Errorf("GetStepByID(%q) = %v, want nil", tt.id, step)
|
|
}
|
|
} else {
|
|
if step == nil || step.Title != tt.want {
|
|
t.Errorf("GetStepByID(%q).Title = %v, want %q", tt.id, step, tt.want)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestFormulaType_IsValid(t *testing.T) {
|
|
tests := []struct {
|
|
t FormulaType
|
|
want bool
|
|
}{
|
|
{TypeWorkflow, true},
|
|
{TypeExpansion, true},
|
|
{TypeAspect, true},
|
|
{TypeConvoy, true},
|
|
{"invalid", false},
|
|
{"", false},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
if got := tt.t.IsValid(); got != tt.want {
|
|
t.Errorf("%q.IsValid() = %v, want %v", tt.t, got, tt.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestValidate_NeedsField tests validation of the needs field (bd-hr39)
|
|
func TestValidate_NeedsField(t *testing.T) {
|
|
// Valid needs reference
|
|
formula := &Formula{
|
|
Formula: "mol-needs",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{ID: "step1", Title: "Step 1"},
|
|
{ID: "step2", Title: "Step 2", Needs: []string{"step1"}},
|
|
},
|
|
}
|
|
|
|
if err := formula.Validate(); err != nil {
|
|
t.Errorf("Validate failed for valid needs reference: %v", err)
|
|
}
|
|
|
|
// Invalid needs reference
|
|
formulaBad := &Formula{
|
|
Formula: "mol-bad-needs",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{ID: "step1", Title: "Step 1"},
|
|
{ID: "step2", Title: "Step 2", Needs: []string{"nonexistent"}},
|
|
},
|
|
}
|
|
|
|
err := formulaBad.Validate()
|
|
if err == nil {
|
|
t.Error("Validate should fail for needs referencing unknown step")
|
|
}
|
|
}
|
|
|
|
// TestValidate_WaitsForField tests validation of the waits_for field (bd-j4cr)
|
|
func TestValidate_WaitsForField(t *testing.T) {
|
|
// Valid waits_for value
|
|
formula := &Formula{
|
|
Formula: "mol-waits-for",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{ID: "fanout", Title: "Fanout"},
|
|
{ID: "aggregate", Title: "Aggregate", Needs: []string{"fanout"}, WaitsFor: "all-children"},
|
|
},
|
|
}
|
|
|
|
if err := formula.Validate(); err != nil {
|
|
t.Errorf("Validate failed for valid waits_for: %v", err)
|
|
}
|
|
|
|
// Invalid waits_for value
|
|
formulaBad := &Formula{
|
|
Formula: "mol-bad-waits-for",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{ID: "step1", Title: "Step 1", WaitsFor: "invalid-gate"},
|
|
},
|
|
}
|
|
|
|
err := formulaBad.Validate()
|
|
if err == nil {
|
|
t.Error("Validate should fail for invalid waits_for value")
|
|
}
|
|
}
|
|
|
|
// TestValidate_WaitsForChildrenOf tests the children-of(step) syntax (gt-8tmz.38)
|
|
func TestValidate_WaitsForChildrenOf(t *testing.T) {
|
|
// Valid children-of() syntax
|
|
formula := &Formula{
|
|
Formula: "mol-children-of",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{ID: "survey-workers", Title: "Survey Workers"},
|
|
{ID: "aggregate", Title: "Aggregate", Needs: []string{"survey-workers"}, WaitsFor: "children-of(survey-workers)"},
|
|
},
|
|
}
|
|
|
|
if err := formula.Validate(); err != nil {
|
|
t.Errorf("Validate failed for valid children-of(): %v", err)
|
|
}
|
|
|
|
// Invalid: reference to unknown step
|
|
formulaBad := &Formula{
|
|
Formula: "mol-bad-children-of",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{ID: "step1", Title: "Step 1", WaitsFor: "children-of(unknown-step)"},
|
|
},
|
|
}
|
|
|
|
if err := formulaBad.Validate(); err == nil {
|
|
t.Error("Validate should fail for children-of() with unknown step")
|
|
}
|
|
|
|
// Invalid: empty step ID
|
|
formulaEmpty := &Formula{
|
|
Formula: "mol-empty-children-of",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{ID: "step1", Title: "Step 1", WaitsFor: "children-of()"},
|
|
},
|
|
}
|
|
|
|
if err := formulaEmpty.Validate(); err == nil {
|
|
t.Error("Validate should fail for children-of() with empty step ID")
|
|
}
|
|
}
|
|
|
|
// TestParseWaitsFor tests the ParseWaitsFor helper function (gt-8tmz.38)
|
|
func TestParseWaitsFor(t *testing.T) {
|
|
tests := []struct {
|
|
input string
|
|
wantGate string
|
|
wantSpawn string
|
|
wantNil bool
|
|
}{
|
|
{"", "", "", true},
|
|
{"all-children", "all-children", "", false},
|
|
{"any-children", "any-children", "", false},
|
|
{"children-of(survey)", "all-children", "survey", false},
|
|
{"children-of(my-step)", "all-children", "my-step", false},
|
|
{"invalid", "", "", true},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.input, func(t *testing.T) {
|
|
spec := ParseWaitsFor(tt.input)
|
|
if tt.wantNil {
|
|
if spec != nil {
|
|
t.Errorf("ParseWaitsFor(%q) = %+v, want nil", tt.input, spec)
|
|
}
|
|
return
|
|
}
|
|
if spec == nil {
|
|
t.Fatalf("ParseWaitsFor(%q) = nil, want non-nil", tt.input)
|
|
}
|
|
if spec.Gate != tt.wantGate {
|
|
t.Errorf("ParseWaitsFor(%q).Gate = %q, want %q", tt.input, spec.Gate, tt.wantGate)
|
|
}
|
|
if spec.SpawnerID != tt.wantSpawn {
|
|
t.Errorf("ParseWaitsFor(%q).SpawnerID = %q, want %q", tt.input, spec.SpawnerID, tt.wantSpawn)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestValidate_ChildNeedsAndWaitsFor tests needs and waits_for in child steps
|
|
func TestValidate_ChildNeedsAndWaitsFor(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-child-fields",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{
|
|
ID: "epic1",
|
|
Title: "Epic 1",
|
|
Children: []*Step{
|
|
{ID: "child1", Title: "Child 1"},
|
|
{ID: "child2", Title: "Child 2", Needs: []string{"child1"}, WaitsFor: "any-children"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
if err := formula.Validate(); err != nil {
|
|
t.Errorf("Validate failed for valid child needs/waits_for: %v", err)
|
|
}
|
|
|
|
// Invalid child needs
|
|
formulaBadNeeds := &Formula{
|
|
Formula: "mol-bad-child-needs",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{
|
|
ID: "epic1",
|
|
Title: "Epic 1",
|
|
Children: []*Step{
|
|
{ID: "child1", Title: "Child 1", Needs: []string{"nonexistent"}},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
if err := formulaBadNeeds.Validate(); err == nil {
|
|
t.Error("Validate should fail for child with invalid needs reference")
|
|
}
|
|
|
|
// Invalid child waits_for
|
|
formulaBadWaitsFor := &Formula{
|
|
Formula: "mol-bad-child-waits-for",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{
|
|
ID: "epic1",
|
|
Title: "Epic 1",
|
|
Children: []*Step{
|
|
{ID: "child1", Title: "Child 1", WaitsFor: "bad-value"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
if err := formulaBadWaitsFor.Validate(); err == nil {
|
|
t.Error("Validate should fail for child with invalid waits_for")
|
|
}
|
|
}
|
|
|
|
// TestParse_NeedsAndWaitsFor tests JSON parsing of needs and waits_for fields
|
|
func TestParse_NeedsAndWaitsFor(t *testing.T) {
|
|
jsonData := `{
|
|
"formula": "mol-deacon",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"steps": [
|
|
{"id": "inbox-check", "title": "Check inbox"},
|
|
{"id": "health-scan", "title": "Check health", "needs": ["inbox-check"]},
|
|
{"id": "aggregate", "title": "Aggregate results", "needs": ["health-scan"], "waits_for": "all-children"}
|
|
]
|
|
}`
|
|
p := NewParser()
|
|
formula, err := p.Parse([]byte(jsonData))
|
|
if err != nil {
|
|
t.Fatalf("Parse failed: %v", err)
|
|
}
|
|
|
|
// Validate parsed formula
|
|
if err := formula.Validate(); err != nil {
|
|
t.Errorf("Validate failed: %v", err)
|
|
}
|
|
|
|
// Check needs field
|
|
if len(formula.Steps[1].Needs) != 1 || formula.Steps[1].Needs[0] != "inbox-check" {
|
|
t.Errorf("Steps[1].Needs = %v, want [inbox-check]", formula.Steps[1].Needs)
|
|
}
|
|
|
|
// Check waits_for field
|
|
if formula.Steps[2].WaitsFor != "all-children" {
|
|
t.Errorf("Steps[2].WaitsFor = %q, want 'all-children'", formula.Steps[2].WaitsFor)
|
|
}
|
|
}
|
|
|
|
// gt-8tmz.8: Tests for on_complete/for-each runtime expansion
|
|
|
|
func TestParse_OnComplete(t *testing.T) {
|
|
jsonData := `{
|
|
"formula": "mol-patrol",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"steps": [
|
|
{
|
|
"id": "survey-workers",
|
|
"title": "Survey workers",
|
|
"on_complete": {
|
|
"for_each": "output.polecats",
|
|
"bond": "mol-polecat-arm",
|
|
"vars": {
|
|
"polecat_name": "{item.name}",
|
|
"rig": "{item.rig}"
|
|
},
|
|
"parallel": true
|
|
}
|
|
},
|
|
{
|
|
"id": "aggregate",
|
|
"title": "Aggregate results",
|
|
"needs": ["survey-workers"],
|
|
"waits_for": "all-children"
|
|
}
|
|
]
|
|
}`
|
|
p := NewParser()
|
|
formula, err := p.Parse([]byte(jsonData))
|
|
if err != nil {
|
|
t.Fatalf("Parse failed: %v", err)
|
|
}
|
|
|
|
// Validate parsed formula
|
|
if err := formula.Validate(); err != nil {
|
|
t.Errorf("Validate failed: %v", err)
|
|
}
|
|
|
|
// Check on_complete field
|
|
oc := formula.Steps[0].OnComplete
|
|
if oc == nil {
|
|
t.Fatal("Steps[0].OnComplete is nil")
|
|
}
|
|
if oc.ForEach != "output.polecats" {
|
|
t.Errorf("ForEach = %q, want 'output.polecats'", oc.ForEach)
|
|
}
|
|
if oc.Bond != "mol-polecat-arm" {
|
|
t.Errorf("Bond = %q, want 'mol-polecat-arm'", oc.Bond)
|
|
}
|
|
if len(oc.Vars) != 2 {
|
|
t.Errorf("len(Vars) = %d, want 2", len(oc.Vars))
|
|
}
|
|
if oc.Vars["polecat_name"] != "{item.name}" {
|
|
t.Errorf("Vars[polecat_name] = %q, want '{item.name}'", oc.Vars["polecat_name"])
|
|
}
|
|
if !oc.Parallel {
|
|
t.Error("Parallel should be true")
|
|
}
|
|
}
|
|
|
|
func TestValidate_OnComplete_Valid(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-valid",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{
|
|
ID: "survey",
|
|
Title: "Survey",
|
|
OnComplete: &OnCompleteSpec{
|
|
ForEach: "output.items",
|
|
Bond: "mol-item",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
if err := formula.Validate(); err != nil {
|
|
t.Errorf("Validate failed for valid on_complete: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidate_OnComplete_MissingBond(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-invalid",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{
|
|
ID: "survey",
|
|
Title: "Survey",
|
|
OnComplete: &OnCompleteSpec{
|
|
ForEach: "output.items",
|
|
// Bond is missing
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
err := formula.Validate()
|
|
if err == nil {
|
|
t.Error("expected validation error for missing bond")
|
|
}
|
|
if !strings.Contains(err.Error(), "bond is required") {
|
|
t.Errorf("expected 'bond is required' error, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidate_OnComplete_MissingForEach(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-invalid",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{
|
|
ID: "survey",
|
|
Title: "Survey",
|
|
OnComplete: &OnCompleteSpec{
|
|
Bond: "mol-item",
|
|
// ForEach is missing
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
err := formula.Validate()
|
|
if err == nil {
|
|
t.Error("expected validation error for missing for_each")
|
|
}
|
|
if !strings.Contains(err.Error(), "for_each is required") {
|
|
t.Errorf("expected 'for_each is required' error, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidate_OnComplete_InvalidForEachPath(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-invalid",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{
|
|
ID: "survey",
|
|
Title: "Survey",
|
|
OnComplete: &OnCompleteSpec{
|
|
ForEach: "items", // Should start with "output."
|
|
Bond: "mol-item",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
err := formula.Validate()
|
|
if err == nil {
|
|
t.Error("expected validation error for invalid for_each path")
|
|
}
|
|
if !strings.Contains(err.Error(), "must start with 'output.'") {
|
|
t.Errorf("expected 'must start with output.' error, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidate_OnComplete_ParallelAndSequential(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-invalid",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{
|
|
ID: "survey",
|
|
Title: "Survey",
|
|
OnComplete: &OnCompleteSpec{
|
|
ForEach: "output.items",
|
|
Bond: "mol-item",
|
|
Parallel: true,
|
|
Sequential: true, // Can't have both
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
err := formula.Validate()
|
|
if err == nil {
|
|
t.Error("expected validation error for parallel + sequential")
|
|
}
|
|
if !strings.Contains(err.Error(), "cannot set both parallel and sequential") {
|
|
t.Errorf("expected 'cannot set both' error, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidate_OnComplete_Sequential(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-valid",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{
|
|
ID: "process-queue",
|
|
Title: "Process queue",
|
|
OnComplete: &OnCompleteSpec{
|
|
ForEach: "output.branches",
|
|
Bond: "mol-merge",
|
|
Sequential: true,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
if err := formula.Validate(); err != nil {
|
|
t.Errorf("Validate failed for sequential on_complete: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidate_OnComplete_InChildren(t *testing.T) {
|
|
formula := &Formula{
|
|
Formula: "mol-valid",
|
|
Version: 1,
|
|
Type: TypeWorkflow,
|
|
Steps: []*Step{
|
|
{
|
|
ID: "parent",
|
|
Title: "Parent",
|
|
Children: []*Step{
|
|
{
|
|
ID: "child",
|
|
Title: "Child",
|
|
OnComplete: &OnCompleteSpec{
|
|
ForEach: "output.items",
|
|
Bond: "mol-item",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
if err := formula.Validate(); err != nil {
|
|
t.Errorf("Validate failed for on_complete in child: %v", err)
|
|
}
|
|
}
|
|
|
|
// bd-4bt1: Tests for gate field parsing
|
|
|
|
func TestParse_GateField(t *testing.T) {
|
|
jsonData := `{
|
|
"formula": "mol-release",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"steps": [
|
|
{
|
|
"id": "run-tests",
|
|
"title": "Run CI tests",
|
|
"gate": {
|
|
"type": "gh:run",
|
|
"id": "ci-tests",
|
|
"timeout": "1h"
|
|
}
|
|
},
|
|
{"id": "deploy", "title": "Deploy to prod", "depends_on": ["run-tests"]}
|
|
]
|
|
}`
|
|
p := NewParser()
|
|
formula, err := p.Parse([]byte(jsonData))
|
|
if err != nil {
|
|
t.Fatalf("Parse failed: %v", err)
|
|
}
|
|
|
|
// Validate parsed formula
|
|
if err := formula.Validate(); err != nil {
|
|
t.Errorf("Validate failed: %v", err)
|
|
}
|
|
|
|
// Check gate field
|
|
gate := formula.Steps[0].Gate
|
|
if gate == nil {
|
|
t.Fatal("Steps[0].Gate is nil")
|
|
}
|
|
if gate.Type != "gh:run" {
|
|
t.Errorf("Gate.Type = %q, want 'gh:run'", gate.Type)
|
|
}
|
|
if gate.ID != "ci-tests" {
|
|
t.Errorf("Gate.ID = %q, want 'ci-tests'", gate.ID)
|
|
}
|
|
if gate.Timeout != "1h" {
|
|
t.Errorf("Gate.Timeout = %q, want '1h'", gate.Timeout)
|
|
}
|
|
}
|
|
|
|
func TestParse_GateFieldTOML(t *testing.T) {
|
|
tomlData := `
|
|
formula = "mol-release"
|
|
version = 1
|
|
type = "workflow"
|
|
|
|
[[steps]]
|
|
id = "wait-for-approval"
|
|
title = "Wait for human approval"
|
|
[steps.gate]
|
|
type = "human"
|
|
timeout = "24h"
|
|
|
|
[[steps]]
|
|
id = "proceed"
|
|
title = "Proceed after approval"
|
|
depends_on = ["wait-for-approval"]
|
|
`
|
|
p := NewParser()
|
|
formula, err := p.ParseTOML([]byte(tomlData))
|
|
if err != nil {
|
|
t.Fatalf("ParseTOML failed: %v", err)
|
|
}
|
|
|
|
// Validate parsed formula
|
|
if err := formula.Validate(); err != nil {
|
|
t.Errorf("Validate failed: %v", err)
|
|
}
|
|
|
|
// Check gate field
|
|
gate := formula.Steps[0].Gate
|
|
if gate == nil {
|
|
t.Fatal("Steps[0].Gate is nil")
|
|
}
|
|
if gate.Type != "human" {
|
|
t.Errorf("Gate.Type = %q, want 'human'", gate.Type)
|
|
}
|
|
if gate.Timeout != "24h" {
|
|
t.Errorf("Gate.Timeout = %q, want '24h'", gate.Timeout)
|
|
}
|
|
}
|
|
|
|
func TestParse_GateFieldMinimal(t *testing.T) {
|
|
// Test gate with only type (minimal valid gate)
|
|
jsonData := `{
|
|
"formula": "mol-timer",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"steps": [
|
|
{
|
|
"id": "wait",
|
|
"title": "Wait for timer",
|
|
"gate": {"type": "timer"}
|
|
}
|
|
]
|
|
}`
|
|
p := NewParser()
|
|
formula, err := p.Parse([]byte(jsonData))
|
|
if err != nil {
|
|
t.Fatalf("Parse failed: %v", err)
|
|
}
|
|
|
|
gate := formula.Steps[0].Gate
|
|
if gate == nil {
|
|
t.Fatal("Steps[0].Gate is nil")
|
|
}
|
|
if gate.Type != "timer" {
|
|
t.Errorf("Gate.Type = %q, want 'timer'", gate.Type)
|
|
}
|
|
if gate.ID != "" {
|
|
t.Errorf("Gate.ID = %q, want empty", gate.ID)
|
|
}
|
|
if gate.Timeout != "" {
|
|
t.Errorf("Gate.Timeout = %q, want empty", gate.Timeout)
|
|
}
|
|
}
|
|
|
|
func TestParse_GateFieldWithAllTypes(t *testing.T) {
|
|
// Test various gate types mentioned in the spec
|
|
tests := []struct {
|
|
name string
|
|
gateType string
|
|
id string
|
|
}{
|
|
{"github_run", "gh:run", "test-workflow"},
|
|
{"github_pr", "gh:pr", "123"},
|
|
{"timer", "timer", ""},
|
|
{"human", "human", ""},
|
|
{"bead", "bead", "bd-xyz"},
|
|
{"mail", "mail", "from:witness"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
jsonData := fmt.Sprintf(`{
|
|
"formula": "mol-test",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"steps": [
|
|
{"id": "step1", "title": "Test step", "gate": {"type": "%s", "id": "%s"}}
|
|
]
|
|
}`, tt.gateType, tt.id)
|
|
|
|
p := NewParser()
|
|
formula, err := p.Parse([]byte(jsonData))
|
|
if err != nil {
|
|
t.Fatalf("Parse failed: %v", err)
|
|
}
|
|
|
|
gate := formula.Steps[0].Gate
|
|
if gate == nil {
|
|
t.Fatal("Gate is nil")
|
|
}
|
|
if gate.Type != tt.gateType {
|
|
t.Errorf("Gate.Type = %q, want %q", gate.Type, tt.gateType)
|
|
}
|
|
if gate.ID != tt.id {
|
|
t.Errorf("Gate.ID = %q, want %q", gate.ID, tt.id)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestParse_GateInChildStep(t *testing.T) {
|
|
jsonData := `{
|
|
"formula": "mol-nested",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"steps": [
|
|
{
|
|
"id": "epic",
|
|
"title": "Release Epic",
|
|
"children": [
|
|
{
|
|
"id": "child-gate",
|
|
"title": "Wait for CI",
|
|
"gate": {"type": "gh:run", "id": "ci", "timeout": "30m"}
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}`
|
|
p := NewParser()
|
|
formula, err := p.Parse([]byte(jsonData))
|
|
if err != nil {
|
|
t.Fatalf("Parse failed: %v", err)
|
|
}
|
|
|
|
child := formula.Steps[0].Children[0]
|
|
if child.Gate == nil {
|
|
t.Fatal("Child gate is nil")
|
|
}
|
|
if child.Gate.Type != "gh:run" {
|
|
t.Errorf("Child Gate.Type = %q, want 'gh:run'", child.Gate.Type)
|
|
}
|
|
}
|
|
|
|
// TestParseTOML_SnakeCaseFields verifies that snake_case fields like depends_on
|
|
// are correctly parsed from TOML. This tests the fix for GitHub issue #1449.
|
|
func TestParseTOML_SnakeCaseFields(t *testing.T) {
|
|
tomlData := `
|
|
formula = "mol-snake-test"
|
|
version = 1
|
|
type = "workflow"
|
|
|
|
[[steps]]
|
|
id = "step1"
|
|
title = "First Step"
|
|
|
|
[[steps]]
|
|
id = "step2"
|
|
title = "Second Step"
|
|
depends_on = ["step1"]
|
|
|
|
[[steps]]
|
|
id = "step3"
|
|
title = "Third Step"
|
|
needs = ["step2"]
|
|
waits_for = "all-children"
|
|
`
|
|
p := NewParser()
|
|
formula, err := p.ParseTOML([]byte(tomlData))
|
|
if err != nil {
|
|
t.Fatalf("ParseTOML failed: %v", err)
|
|
}
|
|
|
|
if len(formula.Steps) != 3 {
|
|
t.Fatalf("len(Steps) = %d, want 3", len(formula.Steps))
|
|
}
|
|
|
|
// Test depends_on (the field that was broken before the fix)
|
|
step2 := formula.Steps[1]
|
|
if len(step2.DependsOn) != 1 || step2.DependsOn[0] != "step1" {
|
|
t.Errorf("Steps[1].DependsOn = %v, want [step1]", step2.DependsOn)
|
|
}
|
|
|
|
// Test needs (worked before, should still work)
|
|
step3 := formula.Steps[2]
|
|
if len(step3.Needs) != 1 || step3.Needs[0] != "step2" {
|
|
t.Errorf("Steps[2].Needs = %v, want [step2]", step3.Needs)
|
|
}
|
|
|
|
// Test waits_for (another snake_case field)
|
|
if step3.WaitsFor != "all-children" {
|
|
t.Errorf("Steps[2].WaitsFor = %q, want 'all-children'", step3.WaitsFor)
|
|
}
|
|
}
|
|
|
|
// Tests for simple string vars in TOML [vars] section
|
|
|
|
func TestParseTOML_SimpleStringVars(t *testing.T) {
|
|
// Test that simple string assignments work in [vars] section
|
|
tomlData := `
|
|
formula = "mol-patrol"
|
|
version = 1
|
|
type = "workflow"
|
|
|
|
[vars]
|
|
wisp_type = "patrol"
|
|
rig_name = "mayor"
|
|
|
|
[[steps]]
|
|
id = "start"
|
|
title = "Start {{wisp_type}} on {{rig_name}}"
|
|
`
|
|
p := NewParser()
|
|
formula, err := p.ParseTOML([]byte(tomlData))
|
|
if err != nil {
|
|
t.Fatalf("ParseTOML failed: %v", err)
|
|
}
|
|
|
|
// Validate parsed formula
|
|
if err := formula.Validate(); err != nil {
|
|
t.Errorf("Validate failed: %v", err)
|
|
}
|
|
|
|
// Check vars were parsed correctly
|
|
if len(formula.Vars) != 2 {
|
|
t.Fatalf("len(Vars) = %d, want 2", len(formula.Vars))
|
|
}
|
|
|
|
// Simple string should become Default
|
|
if v := formula.Vars["wisp_type"]; v == nil {
|
|
t.Error("wisp_type var not found")
|
|
} else if v.Default == nil || *v.Default != "patrol" {
|
|
t.Errorf("wisp_type.Default = %v, want 'patrol'", v.Default)
|
|
}
|
|
|
|
if v := formula.Vars["rig_name"]; v == nil {
|
|
t.Error("rig_name var not found")
|
|
} else if v.Default == nil || *v.Default != "mayor" {
|
|
t.Errorf("rig_name.Default = %v, want 'mayor'", v.Default)
|
|
}
|
|
}
|
|
|
|
// be-58b: Tests for step override in extends
|
|
|
|
func TestResolve_ChildStepOverridesParentByID(t *testing.T) {
|
|
dir := t.TempDir()
|
|
formulaDir := filepath.Join(dir, "formulas")
|
|
if err := os.MkdirAll(formulaDir, 0755); err != nil {
|
|
t.Fatalf("mkdir: %v", err)
|
|
}
|
|
|
|
// Parent formula with workspace-setup step
|
|
parent := `{
|
|
"formula": "mol-base",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"steps": [
|
|
{"id": "workspace-setup", "title": "Parent workspace setup"},
|
|
{"id": "build", "title": "Build", "depends_on": ["workspace-setup"]}
|
|
]
|
|
}`
|
|
if err := os.WriteFile(filepath.Join(formulaDir, "mol-base.formula.json"), []byte(parent), 0644); err != nil {
|
|
t.Fatalf("write parent: %v", err)
|
|
}
|
|
|
|
// Child overrides workspace-setup with different title
|
|
child := `{
|
|
"formula": "mol-child",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"extends": ["mol-base"],
|
|
"steps": [
|
|
{"id": "workspace-setup", "title": "Child workspace setup"}
|
|
]
|
|
}`
|
|
childPath := filepath.Join(formulaDir, "mol-child.formula.json")
|
|
if err := os.WriteFile(childPath, []byte(child), 0644); err != nil {
|
|
t.Fatalf("write child: %v", err)
|
|
}
|
|
|
|
p := NewParser(formulaDir)
|
|
formula, err := p.ParseFile(childPath)
|
|
if err != nil {
|
|
t.Fatalf("ParseFile: %v", err)
|
|
}
|
|
|
|
resolved, err := p.Resolve(formula)
|
|
if err != nil {
|
|
t.Fatalf("Resolve: %v", err)
|
|
}
|
|
|
|
// Should have 2 steps (override, not 3 from concatenation)
|
|
if len(resolved.Steps) != 2 {
|
|
t.Fatalf("len(Steps) = %d, want 2", len(resolved.Steps))
|
|
}
|
|
|
|
// workspace-setup should have child's title
|
|
if resolved.Steps[0].Title != "Child workspace setup" {
|
|
t.Errorf("Steps[0].Title = %q, want 'Child workspace setup'", resolved.Steps[0].Title)
|
|
}
|
|
|
|
// build should still be present
|
|
if resolved.Steps[1].ID != "build" {
|
|
t.Errorf("Steps[1].ID = %q, want 'build'", resolved.Steps[1].ID)
|
|
}
|
|
}
|
|
|
|
func TestResolve_OverridePreservesParentPosition(t *testing.T) {
|
|
dir := t.TempDir()
|
|
formulaDir := filepath.Join(dir, "formulas")
|
|
if err := os.MkdirAll(formulaDir, 0755); err != nil {
|
|
t.Fatalf("mkdir: %v", err)
|
|
}
|
|
|
|
parent := `{
|
|
"formula": "mol-base",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"steps": [
|
|
{"id": "step-a", "title": "A"},
|
|
{"id": "step-b", "title": "B"},
|
|
{"id": "step-c", "title": "C"}
|
|
]
|
|
}`
|
|
if err := os.WriteFile(filepath.Join(formulaDir, "mol-base.formula.json"), []byte(parent), 0644); err != nil {
|
|
t.Fatalf("write parent: %v", err)
|
|
}
|
|
|
|
// Child overrides step-b (middle step) — should keep position [1]
|
|
child := `{
|
|
"formula": "mol-child",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"extends": ["mol-base"],
|
|
"steps": [
|
|
{"id": "step-b", "title": "B-override"}
|
|
]
|
|
}`
|
|
childPath := filepath.Join(formulaDir, "mol-child.formula.json")
|
|
if err := os.WriteFile(childPath, []byte(child), 0644); err != nil {
|
|
t.Fatalf("write child: %v", err)
|
|
}
|
|
|
|
p := NewParser(formulaDir)
|
|
formula, err := p.ParseFile(childPath)
|
|
if err != nil {
|
|
t.Fatalf("ParseFile: %v", err)
|
|
}
|
|
|
|
resolved, err := p.Resolve(formula)
|
|
if err != nil {
|
|
t.Fatalf("Resolve: %v", err)
|
|
}
|
|
|
|
// Should have 3 steps, not 4
|
|
if len(resolved.Steps) != 3 {
|
|
t.Fatalf("len(Steps) = %d, want 3", len(resolved.Steps))
|
|
}
|
|
|
|
// Order should be preserved: A, B-override, C
|
|
wantIDs := []string{"step-a", "step-b", "step-c"}
|
|
for i, wantID := range wantIDs {
|
|
if resolved.Steps[i].ID != wantID {
|
|
t.Errorf("Steps[%d].ID = %q, want %q", i, resolved.Steps[i].ID, wantID)
|
|
}
|
|
}
|
|
|
|
// The overridden step should have child's title
|
|
if resolved.Steps[1].Title != "B-override" {
|
|
t.Errorf("Steps[1].Title = %q, want 'B-override'", resolved.Steps[1].Title)
|
|
}
|
|
}
|
|
|
|
func TestResolve_ChildNewStepsAppendedAfterParent(t *testing.T) {
|
|
dir := t.TempDir()
|
|
formulaDir := filepath.Join(dir, "formulas")
|
|
if err := os.MkdirAll(formulaDir, 0755); err != nil {
|
|
t.Fatalf("mkdir: %v", err)
|
|
}
|
|
|
|
parent := `{
|
|
"formula": "mol-base",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"steps": [
|
|
{"id": "init", "title": "Init"}
|
|
]
|
|
}`
|
|
if err := os.WriteFile(filepath.Join(formulaDir, "mol-base.formula.json"), []byte(parent), 0644); err != nil {
|
|
t.Fatalf("write parent: %v", err)
|
|
}
|
|
|
|
// Child adds new steps and overrides init
|
|
child := `{
|
|
"formula": "mol-child",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"extends": ["mol-base"],
|
|
"steps": [
|
|
{"id": "init", "title": "Custom Init"},
|
|
{"id": "deploy", "title": "Deploy", "depends_on": ["init"]}
|
|
]
|
|
}`
|
|
childPath := filepath.Join(formulaDir, "mol-child.formula.json")
|
|
if err := os.WriteFile(childPath, []byte(child), 0644); err != nil {
|
|
t.Fatalf("write child: %v", err)
|
|
}
|
|
|
|
p := NewParser(formulaDir)
|
|
formula, err := p.ParseFile(childPath)
|
|
if err != nil {
|
|
t.Fatalf("ParseFile: %v", err)
|
|
}
|
|
|
|
resolved, err := p.Resolve(formula)
|
|
if err != nil {
|
|
t.Fatalf("Resolve: %v", err)
|
|
}
|
|
|
|
// 2 steps: init (overridden) + deploy (new)
|
|
if len(resolved.Steps) != 2 {
|
|
t.Fatalf("len(Steps) = %d, want 2", len(resolved.Steps))
|
|
}
|
|
|
|
if resolved.Steps[0].ID != "init" || resolved.Steps[0].Title != "Custom Init" {
|
|
t.Errorf("Steps[0] = {%s, %s}, want {init, Custom Init}", resolved.Steps[0].ID, resolved.Steps[0].Title)
|
|
}
|
|
if resolved.Steps[1].ID != "deploy" {
|
|
t.Errorf("Steps[1].ID = %q, want 'deploy'", resolved.Steps[1].ID)
|
|
}
|
|
}
|
|
|
|
func TestResolve_MultipleOverrides(t *testing.T) {
|
|
dir := t.TempDir()
|
|
formulaDir := filepath.Join(dir, "formulas")
|
|
if err := os.MkdirAll(formulaDir, 0755); err != nil {
|
|
t.Fatalf("mkdir: %v", err)
|
|
}
|
|
|
|
parent := `{
|
|
"formula": "mol-base",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"steps": [
|
|
{"id": "step-a", "title": "A"},
|
|
{"id": "step-b", "title": "B"},
|
|
{"id": "step-c", "title": "C"},
|
|
{"id": "step-d", "title": "D"}
|
|
]
|
|
}`
|
|
if err := os.WriteFile(filepath.Join(formulaDir, "mol-base.formula.json"), []byte(parent), 0644); err != nil {
|
|
t.Fatalf("write parent: %v", err)
|
|
}
|
|
|
|
// Child overrides step-a and step-c
|
|
child := `{
|
|
"formula": "mol-child",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"extends": ["mol-base"],
|
|
"steps": [
|
|
{"id": "step-a", "title": "A-new"},
|
|
{"id": "step-c", "title": "C-new"}
|
|
]
|
|
}`
|
|
childPath := filepath.Join(formulaDir, "mol-child.formula.json")
|
|
if err := os.WriteFile(childPath, []byte(child), 0644); err != nil {
|
|
t.Fatalf("write child: %v", err)
|
|
}
|
|
|
|
p := NewParser(formulaDir)
|
|
formula, err := p.ParseFile(childPath)
|
|
if err != nil {
|
|
t.Fatalf("ParseFile: %v", err)
|
|
}
|
|
|
|
resolved, err := p.Resolve(formula)
|
|
if err != nil {
|
|
t.Fatalf("Resolve: %v", err)
|
|
}
|
|
|
|
if len(resolved.Steps) != 4 {
|
|
t.Fatalf("len(Steps) = %d, want 4", len(resolved.Steps))
|
|
}
|
|
|
|
wantTitles := []string{"A-new", "B", "C-new", "D"}
|
|
for i, want := range wantTitles {
|
|
if resolved.Steps[i].Title != want {
|
|
t.Errorf("Steps[%d].Title = %q, want %q", i, resolved.Steps[i].Title, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestResolve_NeedsReferencesToOverriddenStepStillResolve(t *testing.T) {
|
|
dir := t.TempDir()
|
|
formulaDir := filepath.Join(dir, "formulas")
|
|
if err := os.MkdirAll(formulaDir, 0755); err != nil {
|
|
t.Fatalf("mkdir: %v", err)
|
|
}
|
|
|
|
parent := `{
|
|
"formula": "mol-base",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"steps": [
|
|
{"id": "workspace-setup", "title": "Parent setup"},
|
|
{"id": "build", "title": "Build", "needs": ["workspace-setup"]},
|
|
{"id": "test", "title": "Test", "depends_on": ["build"]}
|
|
]
|
|
}`
|
|
if err := os.WriteFile(filepath.Join(formulaDir, "mol-base.formula.json"), []byte(parent), 0644); err != nil {
|
|
t.Fatalf("write parent: %v", err)
|
|
}
|
|
|
|
// Child overrides workspace-setup; build's needs reference should still resolve
|
|
child := `{
|
|
"formula": "mol-child",
|
|
"version": 1,
|
|
"type": "workflow",
|
|
"extends": ["mol-base"],
|
|
"steps": [
|
|
{"id": "workspace-setup", "title": "Custom setup"}
|
|
]
|
|
}`
|
|
childPath := filepath.Join(formulaDir, "mol-child.formula.json")
|
|
if err := os.WriteFile(childPath, []byte(child), 0644); err != nil {
|
|
t.Fatalf("write child: %v", err)
|
|
}
|
|
|
|
p := NewParser(formulaDir)
|
|
formula, err := p.ParseFile(childPath)
|
|
if err != nil {
|
|
t.Fatalf("ParseFile: %v", err)
|
|
}
|
|
|
|
resolved, err := p.Resolve(formula)
|
|
if err != nil {
|
|
t.Fatalf("Resolve should succeed (needs refs still valid): %v", err)
|
|
}
|
|
|
|
// 3 steps: workspace-setup (overridden), build, test
|
|
if len(resolved.Steps) != 3 {
|
|
t.Fatalf("len(Steps) = %d, want 3", len(resolved.Steps))
|
|
}
|
|
|
|
// build should still reference workspace-setup
|
|
if resolved.Steps[1].Needs[0] != "workspace-setup" {
|
|
t.Errorf("Steps[1].Needs = %v, want [workspace-setup]", resolved.Steps[1].Needs)
|
|
}
|
|
}
|
|
|
|
func TestParseTOML_MixedVarFormats(t *testing.T) {
|
|
// Test mixing simple strings and full table definitions
|
|
tomlData := `
|
|
formula = "mol-mixed"
|
|
version = 1
|
|
type = "workflow"
|
|
|
|
[vars]
|
|
simple_var = "simple_value"
|
|
|
|
[vars.complex_var]
|
|
description = "A complex variable"
|
|
default = "complex_default"
|
|
required = false
|
|
enum = ["a", "b", "c"]
|
|
|
|
[vars.required_var]
|
|
description = "A required variable"
|
|
required = true
|
|
|
|
[[steps]]
|
|
id = "step1"
|
|
title = "Test"
|
|
`
|
|
p := NewParser()
|
|
formula, err := p.ParseTOML([]byte(tomlData))
|
|
if err != nil {
|
|
t.Fatalf("ParseTOML failed: %v", err)
|
|
}
|
|
|
|
// Validate parsed formula
|
|
if err := formula.Validate(); err != nil {
|
|
t.Errorf("Validate failed: %v", err)
|
|
}
|
|
|
|
// Check vars count
|
|
if len(formula.Vars) != 3 {
|
|
t.Fatalf("len(Vars) = %d, want 3", len(formula.Vars))
|
|
}
|
|
|
|
// Check simple var
|
|
if v := formula.Vars["simple_var"]; v == nil {
|
|
t.Error("simple_var not found")
|
|
} else if v.Default == nil || *v.Default != "simple_value" {
|
|
t.Errorf("simple_var.Default = %v, want 'simple_value'", v.Default)
|
|
}
|
|
|
|
// Check complex var
|
|
if v := formula.Vars["complex_var"]; v == nil {
|
|
t.Error("complex_var not found")
|
|
} else {
|
|
if v.Description != "A complex variable" {
|
|
t.Errorf("complex_var.Description = %q, want 'A complex variable'", v.Description)
|
|
}
|
|
if v.Default == nil || *v.Default != "complex_default" {
|
|
t.Errorf("complex_var.Default = %v, want 'complex_default'", v.Default)
|
|
}
|
|
if len(v.Enum) != 3 {
|
|
t.Errorf("len(complex_var.Enum) = %d, want 3", len(v.Enum))
|
|
}
|
|
}
|
|
|
|
// Check required var
|
|
if v := formula.Vars["required_var"]; v == nil {
|
|
t.Error("required_var not found")
|
|
} else {
|
|
if !v.Required {
|
|
t.Error("required_var.Required should be true")
|
|
}
|
|
if v.Description != "A required variable" {
|
|
t.Errorf("required_var.Description = %q, want 'A required variable'", v.Description)
|
|
}
|
|
}
|
|
}
|