Use GetDependentsWithMetadata to filter parent-child edges directly instead of N+1 dependency lookups. Use IDPrefix filter instead of scanning all issues for hierarchical children. ~36x faster on synthetic hierarchies. Co-Authored-By: Cardosaum <Cardosaum@users.noreply.github.com> Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
919 lines
30 KiB
Go
919 lines
30 KiB
Go
//go:build cgo
|
|
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"path/filepath"
|
|
"slices"
|
|
"sort"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/steveyegge/beads/internal/formula"
|
|
"github.com/steveyegge/beads/internal/storage/dolt"
|
|
"github.com/steveyegge/beads/internal/testutil"
|
|
"github.com/steveyegge/beads/internal/types"
|
|
)
|
|
|
|
// =============================================================================
|
|
// Beads Template Tests (for bd template instantiate)
|
|
// =============================================================================
|
|
|
|
// TestExtractVariables tests the {{variable}} pattern extraction
|
|
func TestExtractVariables(t *testing.T) {
|
|
t.Parallel()
|
|
tests := []struct {
|
|
name string
|
|
input string
|
|
expected []string
|
|
}{
|
|
{name: "single variable", input: "Release {{version}}", expected: []string{"version"}},
|
|
{name: "multiple variables", input: "Release {{version}} on {{date}}", expected: []string{"version", "date"}},
|
|
{name: "no variables", input: "Just plain text", expected: nil},
|
|
{name: "duplicate variables", input: "{{version}} and {{version}} again", expected: []string{"version"}},
|
|
{name: "variable with underscore", input: "{{my_variable}}", expected: []string{"my_variable"}},
|
|
{name: "variable with numbers", input: "{{var123}}", expected: []string{"var123"}},
|
|
{name: "invalid variable format", input: "{{123invalid}}", expected: nil},
|
|
{name: "empty braces", input: "{{}}", expected: nil},
|
|
{name: "handlebars else keyword ignored", input: "{{ready}} then {{else}} or {{other}}", expected: []string{"ready", "other"}},
|
|
{name: "handlebars this keyword ignored", input: "{{this}} and {{name}}", expected: []string{"name"}},
|
|
{name: "multiple handlebars keywords ignored", input: "{{else}} {{this}} {{root}} {{index}} {{key}} {{first}} {{last}} {{actual_var}}", expected: []string{"actual_var"}},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := extractVariables(tt.input)
|
|
if len(result) != len(tt.expected) {
|
|
t.Errorf("extractVariables(%q) = %v, want %v", tt.input, result, tt.expected)
|
|
return
|
|
}
|
|
for i, v := range result {
|
|
if v != tt.expected[i] {
|
|
t.Errorf("extractVariables(%q)[%d] = %q, want %q", tt.input, i, v, tt.expected[i])
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestSubstituteVariables tests the variable substitution
|
|
func TestSubstituteVariables(t *testing.T) {
|
|
t.Parallel()
|
|
tests := []struct {
|
|
name string
|
|
input string
|
|
vars map[string]string
|
|
expected string
|
|
}{
|
|
{name: "single variable", input: "Release {{version}}", vars: map[string]string{"version": "1.2.0"}, expected: "Release 1.2.0"},
|
|
{name: "multiple variables", input: "Release {{version}} on {{date}}", vars: map[string]string{"version": "1.2.0", "date": "2024-01-15"}, expected: "Release 1.2.0 on 2024-01-15"},
|
|
{name: "missing variable unchanged", input: "Release {{version}}", vars: map[string]string{}, expected: "Release {{version}}"},
|
|
{name: "partial substitution", input: "{{found}} and {{missing}}", vars: map[string]string{"found": "yes"}, expected: "yes and {{missing}}"},
|
|
{name: "no variables", input: "Just plain text", vars: map[string]string{"version": "1.0"}, expected: "Just plain text"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := substituteVariables(tt.input, tt.vars)
|
|
if result != tt.expected {
|
|
t.Errorf("substituteVariables(%q, %v) = %q, want %q", tt.input, tt.vars, result, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// templateTestHelper provides helpers for Beads template tests
|
|
type templateTestHelper struct {
|
|
s *dolt.DoltStore
|
|
ctx context.Context
|
|
t *testing.T
|
|
}
|
|
|
|
func (h *templateTestHelper) createIssue(title, description string, issueType types.IssueType, priority int) *types.Issue {
|
|
issue := &types.Issue{
|
|
Title: title,
|
|
Description: description,
|
|
Priority: priority,
|
|
IssueType: issueType,
|
|
Status: types.StatusOpen,
|
|
}
|
|
if err := h.s.CreateIssue(h.ctx, issue, "test-user"); err != nil {
|
|
h.t.Fatalf("Failed to create issue: %v", err)
|
|
}
|
|
return issue
|
|
}
|
|
|
|
func (h *templateTestHelper) addParentChild(childID, parentID string) {
|
|
dep := &types.Dependency{
|
|
IssueID: childID,
|
|
DependsOnID: parentID,
|
|
Type: types.DepParentChild,
|
|
}
|
|
if err := h.s.AddDependency(h.ctx, dep, "test-user"); err != nil {
|
|
h.t.Fatalf("Failed to add parent-child dependency: %v", err)
|
|
}
|
|
}
|
|
|
|
func (h *templateTestHelper) addLabel(issueID, label string) {
|
|
if err := h.s.AddLabel(h.ctx, issueID, label, "test-user"); err != nil {
|
|
h.t.Fatalf("Failed to add label: %v", err)
|
|
}
|
|
}
|
|
|
|
// createIssueWithID creates an issue with a specific ID (for testing hierarchical IDs)
|
|
func (h *templateTestHelper) createIssueWithID(id, title, description string, issueType types.IssueType, priority int) *types.Issue {
|
|
issue := &types.Issue{
|
|
ID: id,
|
|
Title: title,
|
|
Description: description,
|
|
Priority: priority,
|
|
IssueType: issueType,
|
|
Status: types.StatusOpen,
|
|
}
|
|
if err := h.s.CreateIssue(h.ctx, issue, "test-user"); err != nil {
|
|
h.t.Fatalf("Failed to create issue with ID %s: %v", id, err)
|
|
}
|
|
return issue
|
|
}
|
|
|
|
func (h *templateTestHelper) createHierarchy(rootID string, descendantIDs ...string) {
|
|
h.createIssueWithID(rootID, rootID, "", types.TypeEpic, 1)
|
|
for _, id := range descendantIDs {
|
|
h.createIssueWithID(id, id, "", types.TypeTask, 2)
|
|
}
|
|
}
|
|
|
|
func issueIDs(issues []*types.Issue) []string {
|
|
ids := make([]string, 0, len(issues))
|
|
for _, issue := range issues {
|
|
ids = append(ids, issue.ID)
|
|
}
|
|
sort.Strings(ids)
|
|
return ids
|
|
}
|
|
|
|
func requireIssueIDs(t testing.TB, issues []*types.Issue, want ...string) {
|
|
t.Helper()
|
|
|
|
got := issueIDs(issues)
|
|
want = slices.Clone(want)
|
|
sort.Strings(want)
|
|
|
|
if !slices.Equal(got, want) {
|
|
t.Fatalf("issue IDs = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func newTemplateBenchmarkStore(b *testing.B) (*dolt.DoltStore, context.Context) {
|
|
b.Helper()
|
|
|
|
if testDoltServerPort == 0 {
|
|
b.Skip("Dolt test server not available, skipping")
|
|
}
|
|
if testutil.DoltContainerCrashed() {
|
|
b.Skipf("Dolt test server crashed: %v", testutil.DoltContainerCrashError())
|
|
}
|
|
|
|
ctx := context.Background()
|
|
testDB := filepath.Join(b.TempDir(), ".beads", "beads.db")
|
|
database := fmt.Sprintf("benchdb_%d", time.Now().UnixNano())
|
|
|
|
s, err := dolt.New(ctx, &dolt.Config{
|
|
Path: testDB,
|
|
ServerHost: "127.0.0.1",
|
|
ServerPort: testDoltServerPort,
|
|
Database: database,
|
|
CreateIfMissing: true,
|
|
})
|
|
if err != nil {
|
|
b.Fatalf("Failed to create benchmark dolt store: %v", err)
|
|
}
|
|
|
|
b.Cleanup(func() {
|
|
s.Close()
|
|
dropTestDatabase(database, testDoltServerPort)
|
|
})
|
|
|
|
if err := s.SetConfig(ctx, "issue_prefix", "bench"); err != nil {
|
|
b.Fatalf("Failed to set issue_prefix: %v", err)
|
|
}
|
|
if err := s.SetConfig(ctx, "types.custom", "molecule,gate,convoy,merge-request,slot,agent,role,rig,event,message"); err != nil {
|
|
b.Fatalf("Failed to set types.custom: %v", err)
|
|
}
|
|
|
|
return s, ctx
|
|
}
|
|
|
|
func createBenchmarkIssue(b *testing.B, ctx context.Context, s *dolt.DoltStore, id string, priority int, issueType types.IssueType) {
|
|
b.Helper()
|
|
|
|
issue := &types.Issue{
|
|
ID: id,
|
|
Title: id,
|
|
Priority: priority,
|
|
IssueType: issueType,
|
|
Status: types.StatusOpen,
|
|
}
|
|
if err := s.CreateIssue(ctx, issue, "benchmark"); err != nil {
|
|
b.Fatalf("CreateIssue(%s): %v", id, err)
|
|
}
|
|
}
|
|
|
|
func seedHierarchicalTemplateGraph(b *testing.B, ctx context.Context, s *dolt.DoltStore, rootID string, directChildren, grandchildrenPerNode, unrelatedIssueCount int) int {
|
|
b.Helper()
|
|
|
|
createBenchmarkIssue(b, ctx, s, rootID, 1, types.TypeEpic)
|
|
|
|
expectedIssues := 1
|
|
for childIndex := 1; childIndex <= directChildren; childIndex++ {
|
|
childID := fmt.Sprintf("%s.%d", rootID, childIndex)
|
|
createBenchmarkIssue(b, ctx, s, childID, 2, types.TypeTask)
|
|
expectedIssues++
|
|
|
|
for grandchildIndex := 1; grandchildIndex <= grandchildrenPerNode; grandchildIndex++ {
|
|
createBenchmarkIssue(b, ctx, s, fmt.Sprintf("%s.%d", childID, grandchildIndex), 3, types.TypeTask)
|
|
expectedIssues++
|
|
}
|
|
}
|
|
|
|
for noiseIndex := 0; noiseIndex < unrelatedIssueCount; noiseIndex++ {
|
|
createBenchmarkIssue(b, ctx, s, fmt.Sprintf("bench-noise-%04d", noiseIndex), 4, types.TypeTask)
|
|
}
|
|
|
|
return expectedIssues
|
|
}
|
|
|
|
// TestTemplateSuite consolidates template loading, cloning, and variable extraction
|
|
// tests that share one DB to reduce Dolt store initialization overhead.
|
|
func TestTemplateSuite(t *testing.T) {
|
|
t.Parallel()
|
|
tmpDir := t.TempDir()
|
|
testDB := filepath.Join(tmpDir, ".beads", "beads.db")
|
|
s := newTestStore(t, testDB)
|
|
ctx := context.Background()
|
|
h := &templateTestHelper{s: s, ctx: ctx, t: t}
|
|
|
|
// --- LoadTemplateSubgraph tests ---
|
|
|
|
t.Run("LoadTemplate_EpicWithNoChildren", func(t *testing.T) {
|
|
epic := h.createIssue("Template Epic", "Description", types.TypeEpic, 1)
|
|
h.addLabel(epic.ID, BeadsTemplateLabel)
|
|
|
|
subgraph, err := loadTemplateSubgraph(ctx, s, epic.ID)
|
|
if err != nil {
|
|
t.Fatalf("loadTemplateSubgraph failed: %v", err)
|
|
}
|
|
if subgraph.Root.ID != epic.ID {
|
|
t.Errorf("Root ID = %s, want %s", subgraph.Root.ID, epic.ID)
|
|
}
|
|
if len(subgraph.Issues) != 1 {
|
|
t.Errorf("Issues count = %d, want 1", len(subgraph.Issues))
|
|
}
|
|
})
|
|
|
|
t.Run("LoadTemplate_EpicWithChildren", func(t *testing.T) {
|
|
epic := h.createIssue("Template {{name}}", "Epic for {{name}}", types.TypeEpic, 1)
|
|
h.addLabel(epic.ID, BeadsTemplateLabel)
|
|
|
|
child1 := h.createIssue("Task 1 for {{name}}", "", types.TypeTask, 2)
|
|
child2 := h.createIssue("Task 2 for {{name}}", "", types.TypeTask, 2)
|
|
h.addParentChild(child1.ID, epic.ID)
|
|
h.addParentChild(child2.ID, epic.ID)
|
|
|
|
subgraph, err := loadTemplateSubgraph(ctx, s, epic.ID)
|
|
if err != nil {
|
|
t.Fatalf("loadTemplateSubgraph failed: %v", err)
|
|
}
|
|
if len(subgraph.Issues) != 3 {
|
|
t.Errorf("Issues count = %d, want 3", len(subgraph.Issues))
|
|
}
|
|
vars := extractAllVariables(subgraph)
|
|
if len(vars) != 1 || vars[0] != "name" {
|
|
t.Errorf("Variables = %v, want [name]", vars)
|
|
}
|
|
})
|
|
|
|
t.Run("LoadTemplate_NestedChildren", func(t *testing.T) {
|
|
epic := h.createIssue("Nested Template", "", types.TypeEpic, 1)
|
|
child := h.createIssue("Child Task", "", types.TypeTask, 2)
|
|
grandchild := h.createIssue("Grandchild Task", "", types.TypeTask, 3)
|
|
|
|
h.addParentChild(child.ID, epic.ID)
|
|
h.addParentChild(grandchild.ID, child.ID)
|
|
|
|
subgraph, err := loadTemplateSubgraph(ctx, s, epic.ID)
|
|
if err != nil {
|
|
t.Fatalf("loadTemplateSubgraph failed: %v", err)
|
|
}
|
|
if len(subgraph.Issues) != 3 {
|
|
t.Errorf("Issues count = %d, want 3 (epic + child + grandchild)", len(subgraph.Issues))
|
|
}
|
|
})
|
|
|
|
// --- CloneSubgraph tests ---
|
|
|
|
t.Run("Clone_SimpleTemplate", func(t *testing.T) {
|
|
epic := h.createIssue("Release {{version}}", "Release notes for {{version}}", types.TypeEpic, 1)
|
|
h.addLabel(epic.ID, BeadsTemplateLabel)
|
|
|
|
subgraph, err := loadTemplateSubgraph(ctx, s, epic.ID)
|
|
if err != nil {
|
|
t.Fatalf("loadTemplateSubgraph failed: %v", err)
|
|
}
|
|
|
|
vars := map[string]string{"version": "2.0.0"}
|
|
opts := CloneOptions{Vars: vars, Actor: "test-user"}
|
|
result, err := cloneSubgraph(ctx, s, subgraph, opts)
|
|
if err != nil {
|
|
t.Fatalf("cloneSubgraph failed: %v", err)
|
|
}
|
|
|
|
if result.Created != 1 {
|
|
t.Errorf("Created = %d, want 1", result.Created)
|
|
}
|
|
if result.NewEpicID == epic.ID {
|
|
t.Error("NewEpicID should be different from template ID")
|
|
}
|
|
|
|
newEpic, err := s.GetIssue(ctx, result.NewEpicID)
|
|
if err != nil {
|
|
t.Fatalf("Failed to get cloned issue: %v", err)
|
|
}
|
|
if newEpic.Title != "Release 2.0.0" {
|
|
t.Errorf("Title = %q, want %q", newEpic.Title, "Release 2.0.0")
|
|
}
|
|
if newEpic.Description != "Release notes for 2.0.0" {
|
|
t.Errorf("Description = %q, want %q", newEpic.Description, "Release notes for 2.0.0")
|
|
}
|
|
})
|
|
|
|
t.Run("Clone_TemplateWithChildren", func(t *testing.T) {
|
|
epic := h.createIssue("Deploy {{service}}", "", types.TypeEpic, 1)
|
|
child1 := h.createIssue("Build {{service}}", "", types.TypeTask, 2)
|
|
child2 := h.createIssue("Test {{service}}", "", types.TypeTask, 2)
|
|
|
|
h.addParentChild(child1.ID, epic.ID)
|
|
h.addParentChild(child2.ID, epic.ID)
|
|
h.addLabel(epic.ID, BeadsTemplateLabel)
|
|
|
|
subgraph, err := loadTemplateSubgraph(ctx, s, epic.ID)
|
|
if err != nil {
|
|
t.Fatalf("loadTemplateSubgraph failed: %v", err)
|
|
}
|
|
|
|
vars := map[string]string{"service": "api-gateway"}
|
|
opts := CloneOptions{Vars: vars, Actor: "test-user"}
|
|
result, err := cloneSubgraph(ctx, s, subgraph, opts)
|
|
if err != nil {
|
|
t.Fatalf("cloneSubgraph failed: %v", err)
|
|
}
|
|
if result.Created != 3 {
|
|
t.Errorf("Created = %d, want 3", result.Created)
|
|
}
|
|
|
|
if _, ok := result.IDMapping[epic.ID]; !ok {
|
|
t.Error("ID mapping missing epic")
|
|
}
|
|
if _, ok := result.IDMapping[child1.ID]; !ok {
|
|
t.Error("ID mapping missing child1")
|
|
}
|
|
if _, ok := result.IDMapping[child2.ID]; !ok {
|
|
t.Error("ID mapping missing child2")
|
|
}
|
|
|
|
newEpic, err := s.GetIssue(ctx, result.NewEpicID)
|
|
if err != nil {
|
|
t.Fatalf("Failed to get cloned epic: %v", err)
|
|
}
|
|
if newEpic.Title != "Deploy api-gateway" {
|
|
t.Errorf("Epic title = %q, want %q", newEpic.Title, "Deploy api-gateway")
|
|
}
|
|
|
|
deps, err := s.GetDependencyRecords(ctx, result.IDMapping[child1.ID])
|
|
if err != nil {
|
|
t.Fatalf("Failed to get dependencies: %v", err)
|
|
}
|
|
hasParentChild := false
|
|
for _, dep := range deps {
|
|
if dep.DependsOnID == result.NewEpicID && dep.Type == types.DepParentChild {
|
|
hasParentChild = true
|
|
break
|
|
}
|
|
}
|
|
if !hasParentChild {
|
|
t.Error("Cloned child should have parent-child dependency on cloned epic")
|
|
}
|
|
})
|
|
|
|
t.Run("Clone_StartsWithOpenStatus", func(t *testing.T) {
|
|
epic := h.createIssue("Template", "", types.TypeEpic, 1)
|
|
err := s.UpdateIssue(ctx, epic.ID, map[string]interface{}{"status": "in_progress"}, "test-user")
|
|
if err != nil {
|
|
t.Fatalf("Failed to update status: %v", err)
|
|
}
|
|
|
|
subgraph, err := loadTemplateSubgraph(ctx, s, epic.ID)
|
|
if err != nil {
|
|
t.Fatalf("loadTemplateSubgraph failed: %v", err)
|
|
}
|
|
|
|
opts := CloneOptions{Actor: "test-user"}
|
|
result, err := cloneSubgraph(ctx, s, subgraph, opts)
|
|
if err != nil {
|
|
t.Fatalf("cloneSubgraph failed: %v", err)
|
|
}
|
|
|
|
newEpic, err := s.GetIssue(ctx, result.NewEpicID)
|
|
if err != nil {
|
|
t.Fatalf("Failed to get cloned issue: %v", err)
|
|
}
|
|
if newEpic.Status != types.StatusOpen {
|
|
t.Errorf("Status = %s, want %s", newEpic.Status, types.StatusOpen)
|
|
}
|
|
})
|
|
|
|
t.Run("Clone_AssigneeOverrideRootOnly", func(t *testing.T) {
|
|
epic := h.createIssue("Root Epic", "", types.TypeEpic, 1)
|
|
child := h.createIssue("Child Task", "", types.TypeTask, 2)
|
|
h.addParentChild(child.ID, epic.ID)
|
|
|
|
err := s.UpdateIssue(ctx, epic.ID, map[string]interface{}{"assignee": "template-owner"}, "test-user")
|
|
if err != nil {
|
|
t.Fatalf("Failed to set epic assignee: %v", err)
|
|
}
|
|
err = s.UpdateIssue(ctx, child.ID, map[string]interface{}{"assignee": "child-owner"}, "test-user")
|
|
if err != nil {
|
|
t.Fatalf("Failed to set child assignee: %v", err)
|
|
}
|
|
|
|
subgraph, err := loadTemplateSubgraph(ctx, s, epic.ID)
|
|
if err != nil {
|
|
t.Fatalf("loadTemplateSubgraph failed: %v", err)
|
|
}
|
|
|
|
opts := CloneOptions{Assignee: "new-assignee", Actor: "test-user"}
|
|
result, err := cloneSubgraph(ctx, s, subgraph, opts)
|
|
if err != nil {
|
|
t.Fatalf("cloneSubgraph failed: %v", err)
|
|
}
|
|
|
|
newEpic, err := s.GetIssue(ctx, result.NewEpicID)
|
|
if err != nil {
|
|
t.Fatalf("Failed to get cloned epic: %v", err)
|
|
}
|
|
if newEpic.Assignee != "new-assignee" {
|
|
t.Errorf("Epic assignee = %q, want %q", newEpic.Assignee, "new-assignee")
|
|
}
|
|
|
|
newChildID := result.IDMapping[child.ID]
|
|
newChild, err := s.GetIssue(ctx, newChildID)
|
|
if err != nil {
|
|
t.Fatalf("Failed to get cloned child: %v", err)
|
|
}
|
|
if newChild.Assignee != "child-owner" {
|
|
t.Errorf("Child assignee = %q, want %q", newChild.Assignee, "child-owner")
|
|
}
|
|
})
|
|
|
|
t.Run("Clone_RootOnly_CreatedCountMatchesActual", func(t *testing.T) {
|
|
epic := h.createIssue("Root Epic", "", types.TypeEpic, 1)
|
|
child1 := h.createIssue("Child 1", "", types.TypeTask, 2)
|
|
child2 := h.createIssue("Child 2", "", types.TypeTask, 2)
|
|
h.addParentChild(child1.ID, epic.ID)
|
|
h.addParentChild(child2.ID, epic.ID)
|
|
|
|
subgraph, err := loadTemplateSubgraph(ctx, s, epic.ID)
|
|
if err != nil {
|
|
t.Fatalf("loadTemplateSubgraph failed: %v", err)
|
|
}
|
|
|
|
// With RootOnly=true, only the root should be created
|
|
opts := CloneOptions{RootOnly: true, Actor: "test-user"}
|
|
result, err := cloneSubgraph(ctx, s, subgraph, opts)
|
|
if err != nil {
|
|
t.Fatalf("cloneSubgraph failed: %v", err)
|
|
}
|
|
|
|
if result.Created != 1 {
|
|
t.Errorf("Created = %d, want 1 (only root should be counted when RootOnly=true)", result.Created)
|
|
}
|
|
if len(result.IDMapping) != 1 {
|
|
t.Errorf("IDMapping has %d entries, want 1", len(result.IDMapping))
|
|
}
|
|
})
|
|
|
|
// --- ExtractAllVariables tests ---
|
|
|
|
t.Run("ExtractAllVariables", func(t *testing.T) {
|
|
epic := h.createIssue("Release {{version}}", "For {{product}}", types.TypeEpic, 1)
|
|
child := h.createIssue("Deploy to {{environment}}", "", types.TypeTask, 2)
|
|
h.addParentChild(child.ID, epic.ID)
|
|
|
|
subgraph, err := loadTemplateSubgraph(ctx, s, epic.ID)
|
|
if err != nil {
|
|
t.Fatalf("loadTemplateSubgraph failed: %v", err)
|
|
}
|
|
|
|
vars := extractAllVariables(subgraph)
|
|
varMap := make(map[string]bool)
|
|
for _, v := range vars {
|
|
varMap[v] = true
|
|
}
|
|
if !varMap["version"] {
|
|
t.Error("Missing variable: version")
|
|
}
|
|
if !varMap["product"] {
|
|
t.Error("Missing variable: product")
|
|
}
|
|
if !varMap["environment"] {
|
|
t.Error("Missing variable: environment")
|
|
}
|
|
})
|
|
|
|
// --- LoadTemplateSubgraphWithManyChildren tests (bd-c8d5) ---
|
|
|
|
t.Run("ManyChildren_4Children", func(t *testing.T) {
|
|
epic := h.createIssue("Proto Workflow", "Workflow with 4 steps", types.TypeEpic, 1)
|
|
h.addLabel(epic.ID, BeadsTemplateLabel)
|
|
|
|
child1 := h.createIssue("load-context", "", types.TypeTask, 2)
|
|
child2 := h.createIssue("implement", "", types.TypeTask, 2)
|
|
child3 := h.createIssue("self-review", "", types.TypeTask, 2)
|
|
child4 := h.createIssue("request-shutdown", "", types.TypeTask, 2)
|
|
|
|
h.addParentChild(child1.ID, epic.ID)
|
|
h.addParentChild(child2.ID, epic.ID)
|
|
h.addParentChild(child3.ID, epic.ID)
|
|
h.addParentChild(child4.ID, epic.ID)
|
|
|
|
subgraph, err := loadTemplateSubgraph(ctx, s, epic.ID)
|
|
if err != nil {
|
|
t.Fatalf("loadTemplateSubgraph failed: %v", err)
|
|
}
|
|
|
|
if len(subgraph.Issues) != 5 {
|
|
t.Errorf("Issues count = %d, want 5 (epic + 4 children)", len(subgraph.Issues))
|
|
for _, iss := range subgraph.Issues {
|
|
t.Logf(" - %s: %s", iss.ID, iss.Title)
|
|
}
|
|
}
|
|
|
|
childIDs := []string{child1.ID, child2.ID, child3.ID, child4.ID}
|
|
for _, childID := range childIDs {
|
|
if _, ok := subgraph.IssueMap[childID]; !ok {
|
|
t.Errorf("Child %s not found in subgraph", childID)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("ManyChildren_CloneCreatesAll4", func(t *testing.T) {
|
|
epic := h.createIssue("Polecat Work", "", types.TypeEpic, 1)
|
|
h.addLabel(epic.ID, BeadsTemplateLabel)
|
|
|
|
child1 := h.createIssue("load-context", "", types.TypeTask, 2)
|
|
child2 := h.createIssue("implement", "", types.TypeTask, 2)
|
|
child3 := h.createIssue("self-review", "", types.TypeTask, 2)
|
|
child4 := h.createIssue("request-shutdown", "", types.TypeTask, 2)
|
|
|
|
h.addParentChild(child1.ID, epic.ID)
|
|
h.addParentChild(child2.ID, epic.ID)
|
|
h.addParentChild(child3.ID, epic.ID)
|
|
h.addParentChild(child4.ID, epic.ID)
|
|
|
|
subgraph, err := loadTemplateSubgraph(ctx, s, epic.ID)
|
|
if err != nil {
|
|
t.Fatalf("loadTemplateSubgraph failed: %v", err)
|
|
}
|
|
|
|
opts := CloneOptions{Actor: "test-user"}
|
|
result, err := cloneSubgraph(ctx, s, subgraph, opts)
|
|
if err != nil {
|
|
t.Fatalf("cloneSubgraph failed: %v", err)
|
|
}
|
|
|
|
if result.Created != 5 {
|
|
t.Errorf("Created = %d, want 5", result.Created)
|
|
}
|
|
for _, childID := range []string{child1.ID, child2.ID, child3.ID, child4.ID} {
|
|
if _, ok := result.IDMapping[childID]; !ok {
|
|
t.Errorf("Child %s not in ID mapping", childID)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("ManyChildren_HierarchicalIDs", func(t *testing.T) {
|
|
epic := h.createIssueWithID("test-lwuu", "mol-polecat-work", "", types.TypeEpic, 1)
|
|
h.addLabel(epic.ID, BeadsTemplateLabel)
|
|
|
|
child1 := h.createIssueWithID("test-lwuu.1", "load-context", "", types.TypeTask, 2)
|
|
child2 := h.createIssueWithID("test-lwuu.2", "implement", "", types.TypeTask, 2)
|
|
child3 := h.createIssueWithID("test-lwuu.3", "self-review", "", types.TypeTask, 2)
|
|
child8 := h.createIssueWithID("test-lwuu.8", "request-shutdown", "", types.TypeTask, 2)
|
|
|
|
h.addParentChild(child1.ID, epic.ID)
|
|
h.addParentChild(child2.ID, epic.ID)
|
|
h.addParentChild(child3.ID, epic.ID)
|
|
h.addParentChild(child8.ID, epic.ID)
|
|
|
|
subgraph, err := loadTemplateSubgraph(ctx, s, epic.ID)
|
|
if err != nil {
|
|
t.Fatalf("loadTemplateSubgraph failed: %v", err)
|
|
}
|
|
|
|
if len(subgraph.Issues) != 5 {
|
|
t.Errorf("Issues count = %d, want 5", len(subgraph.Issues))
|
|
for _, iss := range subgraph.Issues {
|
|
t.Logf(" - %s: %s", iss.ID, iss.Title)
|
|
}
|
|
}
|
|
|
|
for _, childID := range []string{"test-lwuu.1", "test-lwuu.2", "test-lwuu.3", "test-lwuu.8"} {
|
|
if _, ok := subgraph.IssueMap[childID]; !ok {
|
|
t.Errorf("Child %s not found in subgraph", childID)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("ManyChildren_WrongDepTypeNotLoaded", func(t *testing.T) {
|
|
epic := h.createIssue("Proto with mixed deps", "", types.TypeEpic, 1)
|
|
h.addLabel(epic.ID, BeadsTemplateLabel)
|
|
|
|
child1 := h.createIssue("load-context", "", types.TypeTask, 2)
|
|
child2 := h.createIssue("implement", "", types.TypeTask, 2)
|
|
child3 := h.createIssue("self-review", "", types.TypeTask, 2)
|
|
child4 := h.createIssue("request-shutdown", "", types.TypeTask, 2)
|
|
|
|
h.addParentChild(child1.ID, epic.ID)
|
|
h.addParentChild(child2.ID, epic.ID)
|
|
|
|
// child3 and child4 have "related" dependency (wrong type — not parent-child)
|
|
for _, childID := range []string{child3.ID, child4.ID} {
|
|
blocksDep := &types.Dependency{IssueID: childID, DependsOnID: epic.ID, Type: types.DepRelated}
|
|
if err := s.AddDependency(ctx, blocksDep, "test-user"); err != nil {
|
|
t.Fatalf("Failed to add blocks dependency: %v", err)
|
|
}
|
|
}
|
|
|
|
subgraph, err := loadTemplateSubgraph(ctx, s, epic.ID)
|
|
if err != nil {
|
|
t.Fatalf("loadTemplateSubgraph failed: %v", err)
|
|
}
|
|
|
|
if len(subgraph.Issues) != 3 {
|
|
t.Errorf("Expected 3 issues (without hierarchical ID fallback), got %d", len(subgraph.Issues))
|
|
}
|
|
})
|
|
|
|
t.Run("ManyChildren_HierarchicalWrongDepTypeLoaded", func(t *testing.T) {
|
|
epic := h.createIssueWithID("test-pcat", "Proto with mixed deps", "", types.TypeEpic, 1)
|
|
h.addLabel(epic.ID, BeadsTemplateLabel)
|
|
|
|
child1 := h.createIssueWithID("test-pcat.1", "load-context", "", types.TypeTask, 2)
|
|
child2 := h.createIssueWithID("test-pcat.2", "implement", "", types.TypeTask, 2)
|
|
h.addParentChild(child1.ID, epic.ID)
|
|
h.addParentChild(child2.ID, epic.ID)
|
|
|
|
// child3 has NO dependency at all (broken data)
|
|
_ = h.createIssueWithID("test-pcat.3", "self-review", "", types.TypeTask, 2)
|
|
|
|
// child8 has wrong dependency type (related, not parent-child)
|
|
child8 := h.createIssueWithID("test-pcat.8", "request-shutdown", "", types.TypeTask, 2)
|
|
relatedDep := &types.Dependency{IssueID: child8.ID, DependsOnID: epic.ID, Type: types.DepRelated}
|
|
if err := s.AddDependency(ctx, relatedDep, "test-user"); err != nil {
|
|
t.Fatalf("Failed to add related dependency: %v", err)
|
|
}
|
|
|
|
subgraph, err := loadTemplateSubgraph(ctx, s, epic.ID)
|
|
if err != nil {
|
|
t.Fatalf("loadTemplateSubgraph failed: %v", err)
|
|
}
|
|
|
|
if len(subgraph.Issues) != 5 {
|
|
t.Errorf("Expected 5 issues (root + 4 hierarchical children), got %d", len(subgraph.Issues))
|
|
}
|
|
for _, childID := range []string{"test-pcat.1", "test-pcat.2", "test-pcat.3", "test-pcat.8"} {
|
|
if _, ok := subgraph.IssueMap[childID]; !ok {
|
|
t.Errorf("Child %s not found in subgraph", childID)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestResolveProtoIDOrTitle tests proto lookup by ID or title (bd-drcx).
|
|
// Kept separate from TestTemplateSuite because title-based search is affected by shared data.
|
|
func TestResolveProtoIDOrTitle(t *testing.T) {
|
|
t.Parallel()
|
|
tmpDir := t.TempDir()
|
|
testDB := filepath.Join(tmpDir, ".beads", "beads.db")
|
|
s := newTestStore(t, testDB)
|
|
ctx := context.Background()
|
|
h := &templateTestHelper{s: s, ctx: ctx, t: t}
|
|
|
|
proto1 := h.createIssue("mol-polecat-work", "Polecat workflow", types.TypeEpic, 1)
|
|
h.addLabel(proto1.ID, BeadsTemplateLabel)
|
|
|
|
proto2 := h.createIssue("mol-version-bump", "Version bump workflow", types.TypeEpic, 1)
|
|
h.addLabel(proto2.ID, BeadsTemplateLabel)
|
|
|
|
proto3 := h.createIssue("mol-release", "Release workflow", types.TypeEpic, 1)
|
|
h.addLabel(proto3.ID, BeadsTemplateLabel)
|
|
|
|
nonProto := h.createIssue("mol-test", "Not a proto", types.TypeTask, 2)
|
|
|
|
t.Run("resolve by exact ID", func(t *testing.T) {
|
|
resolved, err := resolveProtoIDOrTitle(ctx, s, proto1.ID)
|
|
if err != nil {
|
|
t.Fatalf("Failed to resolve by ID: %v", err)
|
|
}
|
|
if resolved != proto1.ID {
|
|
t.Errorf("Expected %s, got %s", proto1.ID, resolved)
|
|
}
|
|
})
|
|
|
|
t.Run("resolve by exact title", func(t *testing.T) {
|
|
resolved, err := resolveProtoIDOrTitle(ctx, s, "mol-polecat-work")
|
|
if err != nil {
|
|
t.Fatalf("Failed to resolve by title: %v", err)
|
|
}
|
|
if resolved != proto1.ID {
|
|
t.Errorf("Expected %s, got %s", proto1.ID, resolved)
|
|
}
|
|
})
|
|
|
|
t.Run("resolve by title case-insensitive", func(t *testing.T) {
|
|
resolved, err := resolveProtoIDOrTitle(ctx, s, "MOL-POLECAT-WORK")
|
|
if err != nil {
|
|
t.Fatalf("Failed to resolve by title (case-insensitive): %v", err)
|
|
}
|
|
if resolved != proto1.ID {
|
|
t.Errorf("Expected %s, got %s", proto1.ID, resolved)
|
|
}
|
|
})
|
|
|
|
t.Run("resolve by unique partial title", func(t *testing.T) {
|
|
resolved, err := resolveProtoIDOrTitle(ctx, s, "polecat")
|
|
if err != nil {
|
|
t.Fatalf("Failed to resolve by partial title: %v", err)
|
|
}
|
|
if resolved != proto1.ID {
|
|
t.Errorf("Expected %s, got %s", proto1.ID, resolved)
|
|
}
|
|
})
|
|
|
|
t.Run("ambiguous partial title returns error", func(t *testing.T) {
|
|
_, err := resolveProtoIDOrTitle(ctx, s, "mol-")
|
|
if err == nil {
|
|
t.Fatal("Expected error for ambiguous title, got nil")
|
|
}
|
|
if !strings.Contains(err.Error(), "ambiguous") {
|
|
t.Errorf("Expected 'ambiguous' in error, got: %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("non-existent returns error", func(t *testing.T) {
|
|
_, err := resolveProtoIDOrTitle(ctx, s, "nonexistent-proto")
|
|
if err == nil {
|
|
t.Fatal("Expected error for non-existent proto, got nil")
|
|
}
|
|
if !strings.Contains(err.Error(), "no proto found") {
|
|
t.Errorf("Expected 'no proto found' in error, got: %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("non-proto ID returns error", func(t *testing.T) {
|
|
_, err := resolveProtoIDOrTitle(ctx, s, nonProto.ID)
|
|
if err == nil {
|
|
t.Fatal("Expected error for non-proto ID, got nil")
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestFindHierarchicalChildren_DirectChildrenOnly(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tmpDir := t.TempDir()
|
|
testDB := filepath.Join(tmpDir, ".beads", "beads.db")
|
|
s := newTestStore(t, testDB)
|
|
ctx := context.Background()
|
|
h := &templateTestHelper{s: s, ctx: ctx, t: t}
|
|
|
|
h.createHierarchy(
|
|
"test-tree",
|
|
"test-tree.1",
|
|
"test-tree.2",
|
|
"test-tree.1.1",
|
|
"test-tree.2.1",
|
|
"test-tree.2.1.1",
|
|
)
|
|
h.createIssueWithID("test-other.1", "test-other.1", "", types.TypeTask, 2)
|
|
|
|
children, err := findHierarchicalChildren(ctx, s, "test-tree")
|
|
if err != nil {
|
|
t.Fatalf("findHierarchicalChildren(root) failed: %v", err)
|
|
}
|
|
requireIssueIDs(t, children, "test-tree.1", "test-tree.2")
|
|
|
|
nestedChildren, err := findHierarchicalChildren(ctx, s, "test-tree.2")
|
|
if err != nil {
|
|
t.Fatalf("findHierarchicalChildren(child) failed: %v", err)
|
|
}
|
|
requireIssueIDs(t, nestedChildren, "test-tree.2.1")
|
|
}
|
|
|
|
func BenchmarkLoadTemplateSubgraph_HierarchicalChildren(b *testing.B) {
|
|
s, ctx := newTemplateBenchmarkStore(b)
|
|
|
|
expectedIssues := seedHierarchicalTemplateGraph(b, ctx, s, "bench-root", 150, 4, 3000)
|
|
b.ReportAllocs()
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
subgraph, loadErr := loadTemplateSubgraph(ctx, s, "bench-root")
|
|
if loadErr != nil {
|
|
b.Fatalf("loadTemplateSubgraph failed: %v", loadErr)
|
|
}
|
|
if len(subgraph.Issues) != expectedIssues {
|
|
b.Fatalf("Issues count = %d, want %d", len(subgraph.Issues), expectedIssues)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestExtractRequiredVariables_IgnoresUndeclaredVars tests that handlebars in
|
|
// description text that are NOT defined in VarDefs are ignored (gt-ky9loa).
|
|
func TestExtractRequiredVariables_IgnoresUndeclaredVars(t *testing.T) {
|
|
t.Parallel()
|
|
tests := []struct {
|
|
name string
|
|
issues []*types.Issue
|
|
varDefs map[string]formula.VarDef
|
|
wantRequired []string
|
|
}{
|
|
{
|
|
name: "declared var without default is required",
|
|
issues: []*types.Issue{{Title: "Deploy {{component}}", Description: "Deploy the component"}},
|
|
varDefs: map[string]formula.VarDef{"component": {Required: true}},
|
|
wantRequired: []string{"component"},
|
|
},
|
|
{
|
|
name: "declared var with default is not required",
|
|
issues: []*types.Issue{{Title: "Deploy {{component}}", Description: "Deploy the component"}},
|
|
varDefs: map[string]formula.VarDef{"component": {Default: formula.StringPtr("api")}},
|
|
wantRequired: []string{},
|
|
},
|
|
{
|
|
name: "undeclared var in description is ignored when VarDefs exists",
|
|
issues: []*types.Issue{{
|
|
Title: "Generate report",
|
|
Description: "Output format:\n**Ready**: {{ready_count}}\n**Done**: {{done_count}}",
|
|
}},
|
|
varDefs: map[string]formula.VarDef{},
|
|
wantRequired: []string{},
|
|
},
|
|
{
|
|
name: "mix of declared and undeclared vars",
|
|
issues: []*types.Issue{{
|
|
Title: "Deploy {{component}} to {{env}}",
|
|
Description: "Shows: {{status_count}} items processed",
|
|
}},
|
|
varDefs: map[string]formula.VarDef{
|
|
"component": {Required: true},
|
|
"env": {Default: formula.StringPtr("prod")},
|
|
},
|
|
wantRequired: []string{"component"},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
subgraph := &TemplateSubgraph{Issues: tt.issues, VarDefs: tt.varDefs}
|
|
got := extractRequiredVariables(subgraph)
|
|
|
|
gotMap := make(map[string]bool)
|
|
for _, v := range got {
|
|
gotMap[v] = true
|
|
}
|
|
wantMap := make(map[string]bool)
|
|
for _, v := range tt.wantRequired {
|
|
wantMap[v] = true
|
|
}
|
|
|
|
if len(got) != len(tt.wantRequired) {
|
|
t.Errorf("extractRequiredVariables() = %v, want %v", got, tt.wantRequired)
|
|
return
|
|
}
|
|
for _, v := range tt.wantRequired {
|
|
if !gotMap[v] {
|
|
t.Errorf("extractRequiredVariables() missing expected var %q, got %v", v, got)
|
|
}
|
|
}
|
|
for _, v := range got {
|
|
if !wantMap[v] {
|
|
t.Errorf("extractRequiredVariables() has unexpected var %q, want %v", v, tt.wantRequired)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|