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 TestDefaultSearchPaths_IncludesCwdFormulaDirWithResolvedParentProject(t *testing.T) { resetFormulaSearchTestContext(t) root := t.TempDir() parentFormulaDir := filepath.Join(root, ".beads", "formulas") if err := os.MkdirAll(filepath.Join(root, ".beads", "dolt"), 0o755); err != nil { t.Fatal(err) } writeFormulaFixture(t, parentFormulaDir, "shared", "parent formula") checkout := filepath.Join(root, "checkout") checkoutFormulaDir := filepath.Join(checkout, ".beads", "formulas") writeFormulaFixture(t, checkoutFormulaDir, "checkout-local", "checkout formula") t.Chdir(checkout) resetFormulaSearchCaches() paths := DefaultSearchPaths() if len(paths) < 2 { t.Fatalf("DefaultSearchPaths() returned %d paths, want at least 2", len(paths)) } gotResolved := canonicalTestPath(paths[0]) wantResolved := canonicalTestPath(parentFormulaDir) if gotResolved != wantResolved { t.Fatalf("DefaultSearchPaths()[0] = %q, want %q", gotResolved, wantResolved) } gotCwd := canonicalTestPath(paths[1]) wantCwd := canonicalTestPath(checkoutFormulaDir) if gotCwd != wantCwd { t.Fatalf("DefaultSearchPaths()[1] = %q, want %q", gotCwd, wantCwd) } parser := NewParser() if _, err := parser.LoadByName("checkout-local"); err != nil { t.Fatalf("LoadByName(checkout-local) failed: %v", err) } } func TestDefaultSearchPaths_IncludesCheckoutFormulaDirFromSubdirectory(t *testing.T) { resetFormulaSearchTestContext(t) root := t.TempDir() parentFormulaDir := filepath.Join(root, ".beads", "formulas") if err := os.MkdirAll(filepath.Join(root, ".beads", "dolt"), 0o755); err != nil { t.Fatal(err) } writeFormulaFixture(t, parentFormulaDir, "shared", "parent formula") t.Setenv("BEADS_DIR", filepath.Join(root, ".beads")) checkout := filepath.Join(root, "checkout") initFormulaTestRepo(t, checkout) checkoutFormulaDir := filepath.Join(checkout, ".beads", "formulas") writeFormulaFixture(t, checkoutFormulaDir, "checkout-local", "checkout formula") subdir := filepath.Join(checkout, "cmd") if err := os.MkdirAll(subdir, 0o755); err != nil { t.Fatal(err) } t.Chdir(subdir) resetFormulaSearchCaches() paths := DefaultSearchPaths() if len(paths) < 2 { t.Fatalf("DefaultSearchPaths() returned %d paths, want at least 2", len(paths)) } gotResolved := canonicalTestPath(paths[0]) wantResolved := canonicalTestPath(parentFormulaDir) if gotResolved != wantResolved { t.Fatalf("DefaultSearchPaths()[0] = %q, want %q", gotResolved, wantResolved) } gotCheckout := canonicalTestPath(paths[1]) wantCheckout := canonicalTestPath(checkoutFormulaDir) if gotCheckout != wantCheckout { t.Fatalf("DefaultSearchPaths()[1] = %q, want %q", gotCheckout, wantCheckout) } parser := NewParser() if _, err := parser.LoadByName("checkout-local"); err != nil { t.Fatalf("LoadByName(checkout-local) failed from subdirectory: %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}}"}, {ID: "s3", Gate: &Gate{Type: "gh:{{gate_kind}}", AwaitID: "{{pr_url}}", Timeout: "{{gate_timeout}}"}}, }, } vars := ExtractVariables(formula) want := map[string]bool{ "project": true, "env": true, "owner": true, "gate_kind": true, "pr_url": true, "gate_timeout": 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", "await_id": "12345", "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.AwaitID != "12345" { t.Errorf("Gate.AwaitID = %q, want '12345'", gate.AwaitID) } 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" await_id = "approval-ticket" 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.AwaitID != "approval-ticket" { t.Errorf("Gate.AwaitID = %q, want 'approval-ticket'", gate.AwaitID) } 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) } } } // TestParseTOML_StepMetadata verifies that a `metadata = { ... }` table on a // step is preserved through TOML parsing. Regression for gastownhall/beads#3341. func TestParseTOML_StepMetadata(t *testing.T) { tomlData := ` formula = "repro" description = "Reproduction case" version = 1 type = "workflow" [[steps]] id = "work" title = "Do the work" labels = ["worker"] metadata = { priority_level = "high", origin = "repro" } ` p := NewParser() formula, err := p.ParseTOML([]byte(tomlData)) if err != nil { t.Fatalf("ParseTOML failed: %v", err) } if len(formula.Steps) != 1 { t.Fatalf("len(Steps) = %d, want 1", len(formula.Steps)) } step := formula.Steps[0] if len(step.Metadata) != 2 { t.Fatalf("Steps[0].Metadata has %d entries, want 2 (%v)", len(step.Metadata), step.Metadata) } if got := step.Metadata["priority_level"]; got != "high" { t.Errorf("Steps[0].Metadata[priority_level] = %v, want \"high\"", got) } if got := step.Metadata["origin"]; got != "repro" { t.Errorf("Steps[0].Metadata[origin] = %v, want \"repro\"", got) } } // TestParseJSON_StepMetadata verifies that `"metadata": { ... }` on a step is // preserved through JSON parsing. Regression for gastownhall/beads#3341. func TestParseJSON_StepMetadata(t *testing.T) { jsonData := `{ "formula": "repro", "version": 1, "type": "workflow", "steps": [ { "id": "work", "title": "Do the work", "metadata": {"priority_level": "high", "origin": "repro"} } ] }` p := NewParser() formula, err := p.Parse([]byte(jsonData)) if err != nil { t.Fatalf("Parse failed: %v", err) } if len(formula.Steps) != 1 { t.Fatalf("len(Steps) = %d, want 1", len(formula.Steps)) } step := formula.Steps[0] if len(step.Metadata) != 2 { t.Fatalf("Steps[0].Metadata has %d entries, want 2 (%v)", len(step.Metadata), step.Metadata) } if got := step.Metadata["priority_level"]; got != "high" { t.Errorf("Steps[0].Metadata[priority_level] = %v, want \"high\"", got) } }