beads/cmd/bd/list_test.go
Robin Carswell 34a580c1e9
feat: add --exclude-label flag to bd ready and bd list
Co-authored-by: Robin Carswell <2803445+rjc123@users.noreply.github.com>
2026-04-24 08:17:14 -07:00

1649 lines
48 KiB
Go

//go:build cgo
package main
import (
"context"
"path/filepath"
"slices"
"strings"
"testing"
"time"
"github.com/steveyegge/beads/internal/storage/dolt"
"github.com/steveyegge/beads/internal/types"
"github.com/steveyegge/beads/internal/ui"
"github.com/steveyegge/beads/internal/utils"
)
// listTestHelper provides test setup and assertion methods
type listTestHelper struct {
t *testing.T
ctx context.Context
store *dolt.DoltStore
issues []*types.Issue
}
func newListTestHelper(t *testing.T, store *dolt.DoltStore) *listTestHelper {
return &listTestHelper{t: t, ctx: context.Background(), store: store}
}
func (h *listTestHelper) createTestIssues() {
now := time.Now()
h.issues = []*types.Issue{
{
Title: "Bug Issue",
Description: "Test bug",
Priority: 0,
IssueType: types.TypeBug,
Status: types.StatusOpen,
},
{
Title: "Feature Issue",
Description: "Test feature",
Priority: 1,
IssueType: types.TypeFeature,
Status: types.StatusInProgress,
Assignee: testUserAlice,
},
{
Title: "Task Issue",
Description: "Test task",
Priority: 2,
IssueType: types.TypeTask,
Status: types.StatusClosed,
ClosedAt: &now,
},
}
for _, issue := range h.issues {
if err := h.store.CreateIssue(h.ctx, issue, "test-user"); err != nil {
h.t.Fatalf("Failed to create issue: %v", err)
}
}
}
func (h *listTestHelper) addLabel(id, label string) {
if err := h.store.AddLabel(h.ctx, id, label, "test-user"); err != nil {
h.t.Fatalf("Failed to add label: %v", err)
}
}
func (h *listTestHelper) search(filter types.IssueFilter) []*types.Issue {
results, err := h.store.SearchIssues(h.ctx, "", filter)
if err != nil {
h.t.Fatalf("Failed to search issues: %v", err)
}
return results
}
func (h *listTestHelper) assertCount(count, expected int, desc string) {
if count != expected {
h.t.Errorf("Expected %d %s, got %d", expected, desc, count)
}
}
func (h *listTestHelper) assertEqual(expected, actual interface{}, field string) {
if expected != actual {
h.t.Errorf("Expected %s %v, got %v", field, expected, actual)
}
}
func (h *listTestHelper) assertAtMost(count, maxCount int, desc string) {
if count > maxCount {
h.t.Errorf("Expected at most %d %s, got %d", maxCount, desc, count)
}
}
func TestListCommandSuite(t *testing.T) {
t.Parallel()
tmpDir := t.TempDir()
testDB := filepath.Join(tmpDir, ".beads", "beads.db")
s := newTestStore(t, testDB)
t.Run("ListCommand", func(t *testing.T) {
h := newListTestHelper(t, s)
h.createTestIssues()
h.addLabel(h.issues[0].ID, "critical")
t.Run("list all issues", func(t *testing.T) {
results := h.search(types.IssueFilter{})
h.assertCount(len(results), 3, "issues")
})
t.Run("filter by status", func(t *testing.T) {
status := types.StatusOpen
results := h.search(types.IssueFilter{Status: &status})
h.assertCount(len(results), 1, "open issues")
h.assertEqual(types.StatusOpen, results[0].Status, "status")
})
t.Run("filter by priority", func(t *testing.T) {
priority := 0
results := h.search(types.IssueFilter{Priority: &priority})
h.assertCount(len(results), 1, "P0 issues")
h.assertEqual(0, results[0].Priority, "priority")
})
t.Run("filter by assignee", func(t *testing.T) {
assignee := testUserAlice
results := h.search(types.IssueFilter{Assignee: &assignee})
h.assertCount(len(results), 1, "issues for alice")
h.assertEqual(testUserAlice, results[0].Assignee, "assignee")
})
t.Run("filter by issue type", func(t *testing.T) {
issueType := types.TypeBug
results := h.search(types.IssueFilter{IssueType: &issueType})
h.assertCount(len(results), 1, "bug issues")
h.assertEqual(types.TypeBug, results[0].IssueType, "type")
})
t.Run("filter by label", func(t *testing.T) {
results := h.search(types.IssueFilter{Labels: []string{"critical"}})
h.assertCount(len(results), 1, "issues with critical label")
if len(results) > 0 {
h.assertEqual("Bug Issue", results[0].Title, "label-filtered issue title")
}
})
t.Run("filter by title search", func(t *testing.T) {
results := h.search(types.IssueFilter{TitleSearch: "Bug"})
h.assertCount(len(results), 1, "issues matching 'Bug'")
if len(results) > 0 {
h.assertEqual("Bug Issue", results[0].Title, "title-search result")
}
})
t.Run("limit results", func(t *testing.T) {
results := h.search(types.IssueFilter{Limit: 2})
h.assertAtMost(len(results), 2, "issues")
})
t.Run("normalize labels", func(t *testing.T) {
labels := []string{" bug ", "critical", "", "bug", " feature "}
normalized := utils.NormalizeLabels(labels)
expected := []string{"bug", "critical", "feature"}
h.assertCount(len(normalized), len(expected), "normalized labels")
// Check deduplication and trimming
seen := make(map[string]bool)
for _, label := range normalized {
if label == "" {
t.Error("Found empty label after normalization")
}
if label != strings.TrimSpace(label) {
t.Errorf("Label not trimmed: '%s'", label)
}
if seen[label] {
t.Errorf("Duplicate label found: %s", label)
}
seen[label] = true
}
})
t.Run("output dot format", func(t *testing.T) {
// Add a dependency to make the graph more interesting
dep := &types.Dependency{
IssueID: h.issues[0].ID,
DependsOnID: h.issues[1].ID,
Type: types.DepBlocks,
}
if err := h.store.AddDependency(h.ctx, dep, "test-user"); err != nil {
t.Fatalf("Failed to add dependency: %v", err)
}
err := outputDotFormat(h.ctx, h.store, h.issues)
if err != nil {
t.Errorf("outputDotFormat failed: %v", err)
}
})
t.Run("output formatted list dot", func(t *testing.T) {
err := outputFormattedList(h.ctx, h.store, h.issues, "dot")
if err != nil {
t.Errorf("outputFormattedList with dot format failed: %v", err)
}
})
t.Run("output formatted list digraph preset", func(t *testing.T) {
// Dependency already added in previous test, just use it
err := outputFormattedList(h.ctx, h.store, h.issues, "digraph")
if err != nil {
t.Errorf("outputFormattedList with digraph format failed: %v", err)
}
})
t.Run("output formatted list custom template", func(t *testing.T) {
err := outputFormattedList(h.ctx, h.store, h.issues, "{{.ID}} {{.Title}}")
if err != nil {
t.Errorf("outputFormattedList with custom template failed: %v", err)
}
})
t.Run("output formatted list invalid template", func(t *testing.T) {
err := outputFormattedList(h.ctx, h.store, h.issues, "{{.ID")
if err == nil {
t.Error("Expected error for invalid template")
}
})
})
}
func TestListQueryCapabilitiesSuite(t *testing.T) {
t.Parallel()
tmpDir := t.TempDir()
testDB := filepath.Join(tmpDir, ".beads", "beads.db")
s := newTestStore(t, testDB)
ctx := context.Background()
now := time.Now()
yesterday := now.Add(-24 * time.Hour)
twoDaysAgo := now.Add(-48 * time.Hour)
// Create test issues with varied attributes
issue1 := &types.Issue{
Title: "Authentication Bug",
Description: "Login fails with special characters",
Notes: "Needs urgent fix",
Priority: 0,
IssueType: types.TypeBug,
Status: types.StatusOpen,
Assignee: "alice",
}
issue2 := &types.Issue{
Title: "Add OAuth Support",
Description: "", // Empty description
Priority: 2,
IssueType: types.TypeFeature,
Status: types.StatusInProgress,
// No assignee
}
issue3 := &types.Issue{
Title: "Update Documentation",
Description: "Update README with new features",
Notes: "Include OAuth setup",
Priority: 3,
IssueType: types.TypeTask,
Status: types.StatusOpen,
Assignee: "bob",
}
for _, issue := range []*types.Issue{issue1, issue2, issue3} {
if err := s.CreateIssue(ctx, issue, "test-user"); err != nil {
t.Fatalf("Failed to create issue: %v", err)
}
}
// Close issue3 to set closed_at timestamp
if err := s.CloseIssue(ctx, issue3.ID, "test-user", "Testing", ""); err != nil {
t.Fatalf("Failed to close issue3: %v", err)
}
// Add labels
s.AddLabel(ctx, issue1.ID, "critical", "test-user")
s.AddLabel(ctx, issue1.ID, "security", "test-user")
s.AddLabel(ctx, issue3.ID, "docs", "test-user")
t.Run("pattern matching - title contains", func(t *testing.T) {
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
TitleContains: "Auth",
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
if len(results) != 2 {
t.Errorf("Expected 2 results with 'Auth' in title, got %d", len(results))
}
})
t.Run("pattern matching - description contains", func(t *testing.T) {
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
DescriptionContains: "special characters",
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
if len(results) != 1 {
t.Errorf("Expected 1 result, got %d", len(results))
}
if len(results) > 0 && results[0].ID != issue1.ID {
t.Errorf("Expected issue1, got %s", results[0].ID)
}
})
t.Run("pattern matching - notes contains", func(t *testing.T) {
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
NotesContains: "OAuth",
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
if len(results) != 1 {
t.Errorf("Expected 1 result, got %d", len(results))
}
if len(results) > 0 && results[0].ID != issue3.ID {
t.Errorf("Expected issue3, got %s", results[0].ID)
}
})
t.Run("empty description check", func(t *testing.T) {
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
EmptyDescription: true,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
if len(results) != 1 {
t.Errorf("Expected 1 issue with empty description, got %d", len(results))
}
if len(results) > 0 && results[0].ID != issue2.ID {
t.Errorf("Expected issue2, got %s", results[0].ID)
}
})
t.Run("no assignee check", func(t *testing.T) {
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
NoAssignee: true,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
if len(results) != 1 {
t.Errorf("Expected 1 issue with no assignee, got %d", len(results))
}
if len(results) > 0 && results[0].ID != issue2.ID {
t.Errorf("Expected issue2, got %s", results[0].ID)
}
})
t.Run("no labels check", func(t *testing.T) {
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
NoLabels: true,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
if len(results) != 1 {
t.Errorf("Expected 1 issue with no labels, got %d", len(results))
}
if len(results) > 0 && results[0].ID != issue2.ID {
t.Errorf("Expected issue2, got %s", results[0].ID)
}
})
t.Run("exclude label - single", func(t *testing.T) {
// issue1 has "critical" and "security"; issue3 has "docs"; issue2 has none.
// Excluding "critical" should return issue2 and issue3.
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
ExcludeLabels: []string{"critical"},
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
ids := make(map[string]bool)
for _, r := range results {
ids[r.ID] = true
}
if ids[issue1.ID] {
t.Errorf("issue1 (has 'critical') should be excluded")
}
if !ids[issue2.ID] {
t.Errorf("issue2 (no labels) should be included")
}
if !ids[issue3.ID] {
t.Errorf("issue3 (has 'docs', not 'critical') should be included")
}
})
t.Run("exclude label - multiple", func(t *testing.T) {
// Excluding "critical" and "docs" leaves only issue2.
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
ExcludeLabels: []string{"critical", "docs"},
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
if len(results) != 1 {
t.Errorf("Expected 1 issue after excluding critical+docs, got %d", len(results))
}
if len(results) > 0 && results[0].ID != issue2.ID {
t.Errorf("Expected issue2, got %s", results[0].ID)
}
})
t.Run("exclude label - combined with include", func(t *testing.T) {
// Include "security" AND exclude "docs": should return issue1 only.
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
Labels: []string{"security"},
ExcludeLabels: []string{"docs"},
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
if len(results) != 1 {
t.Errorf("Expected 1 issue, got %d", len(results))
}
if len(results) > 0 && results[0].ID != issue1.ID {
t.Errorf("Expected issue1, got %s", results[0].ID)
}
})
t.Run("priority range - min", func(t *testing.T) {
minPrio := 2
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
PriorityMin: &minPrio,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
if len(results) != 2 {
t.Errorf("Expected 2 issues with priority >= 2, got %d", len(results))
}
})
t.Run("priority range - max", func(t *testing.T) {
maxPrio := 1
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
PriorityMax: &maxPrio,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
if len(results) != 1 {
t.Errorf("Expected 1 issue with priority <= 1, got %d", len(results))
}
})
t.Run("priority range - min and max", func(t *testing.T) {
minPrio := 1
maxPrio := 2
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
PriorityMin: &minPrio,
PriorityMax: &maxPrio,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
if len(results) != 1 {
t.Errorf("Expected 1 issue with priority between 1-2, got %d", len(results))
}
})
t.Run("date range - created after", func(t *testing.T) {
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
CreatedAfter: &twoDaysAgo,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
// All issues created recently
if len(results) != 3 {
t.Errorf("Expected 3 issues created after two days ago, got %d", len(results))
}
})
t.Run("date range - updated before", func(t *testing.T) {
futureTime := now.Add(24 * time.Hour)
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
UpdatedBefore: &futureTime,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
// All issues updated before tomorrow
if len(results) != 3 {
t.Errorf("Expected 3 issues, got %d", len(results))
}
})
t.Run("date range - closed after", func(t *testing.T) {
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
ClosedAfter: &yesterday,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
if len(results) != 1 {
t.Errorf("Expected 1 closed issue, got %d", len(results))
}
})
t.Run("combined filters", func(t *testing.T) {
minPrio := 0
maxPrio := 2
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
TitleContains: "Auth",
PriorityMin: &minPrio,
PriorityMax: &maxPrio,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
if len(results) != 2 {
t.Errorf("Expected 2 results matching combined filters, got %d", len(results))
}
})
}
// TestStableTreeOrdering tests that tree display order is stable across multiple invocations
// This test specifically addresses the bug where --tree output was non-deterministic due to
// unstable ordering of root issues and children within the same priority level
func TestStableTreeOrdering(t *testing.T) {
t.Parallel()
tmpDir := t.TempDir()
testDB := filepath.Join(tmpDir, ".beads", "beads.db")
store := newTestStore(t, testDB)
ctx := context.Background()
// Helper to create issue with specific priority for testing sort stability
createIssue := func(title string, priority int) *types.Issue {
issue := &types.Issue{
Title: title,
Priority: priority,
IssueType: types.TypeTask,
Status: types.StatusOpen,
}
if err := store.CreateIssue(ctx, issue, "test-user"); err != nil {
t.Fatalf("Failed to create issue %s: %v", title, err)
}
return issue
}
// Helper to add parent-child dependency
addParentChild := func(child, parent *types.Issue) {
dep := &types.Dependency{
IssueID: child.ID,
DependsOnID: parent.ID,
Type: types.DepParentChild,
CreatedAt: time.Now(),
CreatedBy: "test-user",
}
if err := store.AddDependency(ctx, dep, "test-user"); err != nil {
t.Fatalf("Failed to add dependency %s -> %s: %v", child.ID, parent.ID, err)
}
}
// Create a hierarchy with mixed priorities to test both primary and secondary sort:
// - Multiple root issues with same priority (tests secondary sort by ID)
// - Multiple children with same priority (tests children sorting stability)
// - Mixed priorities (tests primary sort by priority)
// Root issues with different priorities
rootP1A := createIssue("Root P1 A", 1) // Should be first (lowest priority number)
rootP1B := createIssue("Root P1 B", 1) // Should be second (same priority, sorted by ID)
rootP2 := createIssue("Root P2", 2) // Should be third
rootP3 := createIssue("Root P3", 3) // Should be last
// Children with mixed priorities under rootP1A
childP1 := createIssue("Child P1", 1) // Should be first child
childP2A := createIssue("Child P2 A", 2) // Should be second child
childP2B := createIssue("Child P2 B", 2) // Should be third child (same priority, sorted by ID)
childP3 := createIssue("Child P3", 3) // Should be last child
// Add parent-child relationships
addParentChild(childP1, rootP1A)
addParentChild(childP2A, rootP1A)
addParentChild(childP2B, rootP1A)
addParentChild(childP3, rootP1A)
// Test that buildIssueTree produces stable ordering
t.Run("stable_root_ordering", func(t *testing.T) {
// Get only the test issues we created (filter by title pattern)
testIssues := []*types.Issue{rootP1A, rootP1B, rootP2, rootP3}
// Build tree multiple times and verify identical ordering
var rootOrderings [][]string
for i := 0; i < 5; i++ {
roots, _ := buildIssueTree(testIssues)
// Extract root IDs in order
var rootIDs []string
for _, root := range roots {
rootIDs = append(rootIDs, root.ID)
}
rootOrderings = append(rootOrderings, rootIDs)
}
// Verify all runs produce identical root ordering
expectedRootOrder := rootOrderings[0]
for i := 1; i < len(rootOrderings); i++ {
if !slicesEqual(expectedRootOrder, rootOrderings[i]) {
t.Errorf("Root ordering differs between runs:\nRun 1: %v\nRun %d: %v",
expectedRootOrder, i+1, rootOrderings[i])
}
}
// Verify expected sort order (priority first, then ID)
// Since IDs are auto-generated, we'll verify by comparing with sorted slice
expectedRoots := []*types.Issue{rootP1A, rootP1B, rootP2, rootP3}
slices.SortFunc(expectedRoots, compareIssuesByPriority)
var expectedOrder []string
for _, issue := range expectedRoots {
expectedOrder = append(expectedOrder, issue.ID)
}
if !slicesEqual(expectedOrder, expectedRootOrder) {
t.Errorf("Root ordering incorrect:\nExpected: %v\nActual: %v",
expectedOrder, expectedRootOrder)
}
})
t.Run("stable_children_ordering", func(t *testing.T) {
// Get test issues including dependencies
allTestIssues := []*types.Issue{rootP1A, rootP1B, rootP2, rootP3, childP1, childP2A, childP2B, childP3}
// Load dependencies for tree building
allDeps, err := store.GetAllDependencyRecords(ctx)
if err != nil {
t.Fatalf("Failed to get dependencies: %v", err)
}
// Build tree multiple times and verify identical children ordering
var childOrderings [][]string
for i := 0; i < 5; i++ {
_, childrenMap := buildIssueTreeWithDeps(allTestIssues, allDeps)
// Extract children IDs of rootP1A in order
children := childrenMap[rootP1A.ID]
var childIDs []string
for _, child := range children {
childIDs = append(childIDs, child.ID)
}
childOrderings = append(childOrderings, childIDs)
}
// Verify all runs produce identical children ordering
if len(childOrderings) == 0 || len(childOrderings[0]) == 0 {
t.Fatal("No children found for rootP1A")
}
expectedChildOrder := childOrderings[0]
for i := 1; i < len(childOrderings); i++ {
if !slicesEqual(expectedChildOrder, childOrderings[i]) {
t.Errorf("Children ordering differs between runs:\nRun 1: %v\nRun %d: %v",
expectedChildOrder, i+1, childOrderings[i])
}
}
// Verify expected sort order by sorting the expected children and comparing
expectedChildren := []*types.Issue{childP1, childP2A, childP2B, childP3}
slices.SortFunc(expectedChildren, compareIssuesByPriority)
var expectedOrder []string
for _, child := range expectedChildren {
expectedOrder = append(expectedOrder, child.ID)
}
if !slicesEqual(expectedOrder, expectedChildOrder) {
t.Errorf("Children ordering incorrect:\nExpected: %v\nActual: %v",
expectedOrder, expectedChildOrder)
}
})
}
// Helper function to compare string slices for equality
func slicesEqual(a, b []string) bool {
if len(a) != len(b) {
return false
}
for i := range a {
if a[i] != b[i] {
return false
}
}
return true
}
func TestFormatIssueLong(t *testing.T) {
t.Parallel()
tests := []struct {
name string
issue *types.Issue
labels []string
want string // substring to check for
}{
{
name: "open issue",
issue: &types.Issue{
ID: "test-123",
Title: "Test Issue",
Priority: 1,
IssueType: types.TypeBug,
Status: types.StatusOpen,
},
labels: nil,
want: "test-123",
},
{
name: "closed issue",
issue: &types.Issue{
ID: "test-456",
Title: "Closed Issue",
Priority: 0,
IssueType: types.TypeTask,
Status: types.StatusClosed,
},
labels: nil,
want: "test-456",
},
{
name: "issue with assignee",
issue: &types.Issue{
ID: "test-789",
Title: "Assigned Issue",
Priority: 2,
IssueType: types.TypeFeature,
Status: types.StatusInProgress,
Assignee: "alice",
},
labels: nil,
want: "Assignee: alice",
},
{
name: "issue with labels",
issue: &types.Issue{
ID: "test-abc",
Title: "Labeled Issue",
Priority: 1,
IssueType: types.TypeBug,
Status: types.StatusOpen,
},
labels: []string{"critical", "security"},
want: "Labels:",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var buf strings.Builder
formatIssueLong(&buf, tt.issue, tt.labels)
result := buf.String()
if !strings.Contains(result, tt.want) {
t.Errorf("formatIssueLong() = %q, want to contain %q", result, tt.want)
}
})
}
}
func TestFormatIssueCompact(t *testing.T) {
t.Parallel()
tests := []struct {
name string
issue *types.Issue
labels []string
want string
}{
{
name: "basic issue",
issue: &types.Issue{
ID: "test-123",
Title: "Test Issue",
Priority: 1,
IssueType: types.TypeBug,
Status: types.StatusOpen,
},
labels: nil,
want: "Test Issue",
},
{
name: "issue with assignee",
issue: &types.Issue{
ID: "test-456",
Title: "Assigned Issue",
Priority: 2,
IssueType: types.TypeTask,
Status: types.StatusInProgress,
Assignee: "bob",
},
labels: nil,
want: "@bob",
},
{
name: "issue with labels",
issue: &types.Issue{
ID: "test-789",
Title: "Labeled Issue",
Priority: 0,
IssueType: types.TypeFeature,
Status: types.StatusOpen,
},
labels: []string{"urgent"},
want: "[urgent]",
},
{
name: "closed issue",
issue: &types.Issue{
ID: "test-def",
Title: "Closed Issue",
Priority: 3,
IssueType: types.TypeTask,
Status: types.StatusClosed,
},
labels: nil,
want: "Closed Issue",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var buf strings.Builder
formatIssueCompact(&buf, tt.issue, tt.labels, nil, nil, "")
result := buf.String()
if !strings.Contains(result, tt.want) {
t.Errorf("formatIssueCompact() = %q, want to contain %q", result, tt.want)
}
})
}
}
func TestBuildBlockingMaps(t *testing.T) {
t.Parallel()
// Create test dependency records
allDeps := map[string][]*types.Dependency{
"issue-A": {
{IssueID: "issue-A", DependsOnID: "issue-B", Type: types.DepBlocks},
},
"issue-C": {
{IssueID: "issue-C", DependsOnID: "issue-A", Type: types.DepBlocks},
{IssueID: "issue-C", DependsOnID: "issue-B", Type: types.DepRelated}, // Should be ignored (not blocking)
},
}
blockedByMap, blocksMap, _ := buildBlockingMaps(allDeps, nil)
// issue-A is blocked by issue-B
if len(blockedByMap["issue-A"]) != 1 || blockedByMap["issue-A"][0] != "issue-B" {
t.Errorf("issue-A blockedBy = %v, want [issue-B]", blockedByMap["issue-A"])
}
// issue-B blocks issue-A
if len(blocksMap["issue-B"]) != 1 || blocksMap["issue-B"][0] != "issue-A" {
t.Errorf("issue-B blocks = %v, want [issue-A]", blocksMap["issue-B"])
}
// issue-C is blocked by issue-A (related dep is ignored)
if len(blockedByMap["issue-C"]) != 1 || blockedByMap["issue-C"][0] != "issue-A" {
t.Errorf("issue-C blockedBy = %v, want [issue-A]", blockedByMap["issue-C"])
}
// issue-A also blocks issue-C
if len(blocksMap["issue-A"]) != 1 || blocksMap["issue-A"][0] != "issue-C" {
t.Errorf("issue-A blocks = %v, want [issue-C]", blocksMap["issue-A"])
}
}
func TestBuildBlockingMaps_ParentChildSeparation(t *testing.T) {
t.Parallel()
allDeps := map[string][]*types.Dependency{
"child-1": {
{IssueID: "child-1", DependsOnID: "parent-1", Type: types.DepParentChild},
},
"child-2": {
{IssueID: "child-2", DependsOnID: "parent-1", Type: types.DepParentChild},
},
"issue-X": {
{IssueID: "issue-X", DependsOnID: "parent-1", Type: types.DepBlocks},
},
}
_, blocksMap, childrenMap := buildBlockingMaps(allDeps, nil)
// parent-1 should have children, not blocks, for parent-child deps
if len(childrenMap["parent-1"]) != 2 {
t.Errorf("parent-1 children = %v, want 2 children", childrenMap["parent-1"])
}
// parent-1 should only block issue-X (not child-1 or child-2)
if len(blocksMap["parent-1"]) != 1 || blocksMap["parent-1"][0] != "issue-X" {
t.Errorf("parent-1 blocks = %v, want [issue-X]", blocksMap["parent-1"])
}
}
func TestBuildBlockingMaps_ClosedBlockersFiltered(t *testing.T) {
t.Parallel()
// issue-A is blocked by issue-B (open) and issue-C (closed)
// issue-D is blocked by issue-C (closed) only
allDeps := map[string][]*types.Dependency{
"issue-A": {
{IssueID: "issue-A", DependsOnID: "issue-B", Type: types.DepBlocks},
{IssueID: "issue-A", DependsOnID: "issue-C", Type: types.DepBlocks},
},
"issue-D": {
{IssueID: "issue-D", DependsOnID: "issue-C", Type: types.DepBlocks},
},
}
closedIDs := map[string]bool{"issue-C": true}
blockedByMap, blocksMap, _ := buildBlockingMaps(allDeps, closedIDs)
// issue-A should only show issue-B as blocker (issue-C is closed)
if len(blockedByMap["issue-A"]) != 1 || blockedByMap["issue-A"][0] != "issue-B" {
t.Errorf("issue-A blockedBy = %v, want [issue-B]", blockedByMap["issue-A"])
}
// issue-D should have no blockers (issue-C is closed)
if len(blockedByMap["issue-D"]) != 0 {
t.Errorf("issue-D blockedBy = %v, want []", blockedByMap["issue-D"])
}
// issue-B should still show as blocking issue-A
if len(blocksMap["issue-B"]) != 1 || blocksMap["issue-B"][0] != "issue-A" {
t.Errorf("issue-B blocks = %v, want [issue-A]", blocksMap["issue-B"])
}
// issue-C should NOT show as blocking anything (it's closed)
if len(blocksMap["issue-C"]) != 0 {
t.Errorf("issue-C blocks = %v, want [] (closed blocker)", blocksMap["issue-C"])
}
}
func TestBuildBlockingMaps_NilClosedIDs(t *testing.T) {
t.Parallel()
// When closedIDs is nil, all blockers should be included (backward compat)
allDeps := map[string][]*types.Dependency{
"issue-A": {
{IssueID: "issue-A", DependsOnID: "issue-B", Type: types.DepBlocks},
},
}
blockedByMap, blocksMap, _ := buildBlockingMaps(allDeps, nil)
if len(blockedByMap["issue-A"]) != 1 || blockedByMap["issue-A"][0] != "issue-B" {
t.Errorf("issue-A blockedBy = %v, want [issue-B]", blockedByMap["issue-A"])
}
if len(blocksMap["issue-B"]) != 1 || blocksMap["issue-B"][0] != "issue-A" {
t.Errorf("issue-B blocks = %v, want [issue-A]", blocksMap["issue-B"])
}
}
func TestFormatIssueCompactWithDependencies(t *testing.T) {
t.Parallel()
tests := []struct {
name string
issue *types.Issue
blockedBy []string
blocks []string
want string
}{
{
name: "issue with blocked by",
issue: &types.Issue{
ID: "test-123",
Title: "Blocked Issue",
Priority: 1,
IssueType: types.TypeTask,
Status: types.StatusOpen,
},
blockedBy: []string{"test-100"},
blocks: nil,
want: "(blocked by: test-100)",
},
{
name: "issue with blocks",
issue: &types.Issue{
ID: "test-456",
Title: "Blocking Issue",
Priority: 1,
IssueType: types.TypeTask,
Status: types.StatusOpen,
},
blockedBy: nil,
blocks: []string{"test-200", "test-300"},
want: "(blocks: test-200, test-300)",
},
{
name: "issue with both",
issue: &types.Issue{
ID: "test-789",
Title: "Middle Issue",
Priority: 1,
IssueType: types.TypeTask,
Status: types.StatusOpen,
},
blockedBy: []string{"test-100"},
blocks: []string{"test-200"},
want: "(blocked by: test-100, blocks: test-200)",
},
{
name: "issue with no dependencies",
issue: &types.Issue{
ID: "test-abc",
Title: "Independent Issue",
Priority: 1,
IssueType: types.TypeTask,
Status: types.StatusOpen,
},
blockedBy: nil,
blocks: nil,
want: "Independent Issue",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var buf strings.Builder
formatIssueCompact(&buf, tt.issue, nil, tt.blockedBy, tt.blocks, "")
result := buf.String()
if !strings.Contains(result, tt.want) {
t.Errorf("formatIssueCompact() = %q, want to contain %q", result, tt.want)
}
})
}
}
// TestFormatIssueCompactBlockedIcon verifies that dependency-blocked open issues
// show the blocked icon (●) instead of the open icon (○) in compact list output. (GH#2858)
func TestFormatIssueCompactBlockedIcon(t *testing.T) {
t.Parallel()
t.Run("open issue with blockers shows blocked icon", func(t *testing.T) {
issue := &types.Issue{
ID: "test-blocked",
Title: "Blocked by dependency",
Priority: 2,
IssueType: types.TypeTask,
Status: types.StatusOpen,
}
var buf strings.Builder
formatIssueCompact(&buf, issue, nil, []string{"blocker-1"}, nil, "")
result := buf.String()
// Should show blocked icon ● not open icon ○
if strings.Contains(result, ui.StatusIconOpen) {
t.Errorf("dependency-blocked issue should not show open icon ○, got: %q", result)
}
if !strings.Contains(result, ui.StatusIconBlocked) {
t.Errorf("dependency-blocked issue should show blocked icon ●, got: %q", result)
}
})
t.Run("open issue without blockers shows open icon", func(t *testing.T) {
issue := &types.Issue{
ID: "test-open",
Title: "Normal open issue",
Priority: 2,
IssueType: types.TypeTask,
Status: types.StatusOpen,
}
var buf strings.Builder
formatIssueCompact(&buf, issue, nil, nil, nil, "")
result := buf.String()
if !strings.Contains(result, ui.StatusIconOpen) {
t.Errorf("open issue without blockers should show open icon ○, got: %q", result)
}
})
t.Run("in_progress issue with blockers keeps in_progress icon", func(t *testing.T) {
issue := &types.Issue{
ID: "test-wip",
Title: "In progress with blocker",
Priority: 2,
IssueType: types.TypeTask,
Status: types.StatusInProgress,
}
var buf strings.Builder
formatIssueCompact(&buf, issue, nil, []string{"blocker-1"}, nil, "")
result := buf.String()
// Should keep in_progress icon, not override to blocked
if !strings.Contains(result, ui.StatusIconInProgress) {
t.Errorf("in_progress issue should keep its icon even with blockers, got: %q", result)
}
})
}
func TestParseTimeFlag(t *testing.T) {
t.Parallel()
tests := []struct {
name string
input string
wantErr bool
}{
// Absolute formats
{"RFC3339", "2023-01-15T10:30:00Z", false},
{"Date only", "2023-01-15", false},
// Compact duration formats (GH#820)
{"Compact hours", "+6h", false},
{"Compact days", "+1d", false},
{"Compact weeks", "+2w", false},
{"Compact negative", "-3d", false},
// Natural language (GH#820)
{"Natural tomorrow", "tomorrow", false},
{"Natural next monday", "next monday", false},
// Invalid formats
{"Invalid format", "not-a-date", true},
{"Empty string", "", true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
_, err := parseTimeFlag(tt.input)
if (err != nil) != tt.wantErr {
t.Errorf("parseTimeFlag(%q) error = %v, wantErr %v", tt.input, err, tt.wantErr)
}
})
}
}
// TestListTimeBasedFilters tests the time-based scheduling filters (GH#820)
func TestListTimeBasedFilters(t *testing.T) {
t.Parallel()
tmpDir := t.TempDir()
testDB := filepath.Join(tmpDir, ".beads", "beads.db")
s := newTestStore(t, testDB)
ctx := context.Background()
now := time.Now()
yesterday := now.Add(-24 * time.Hour)
tomorrow := now.Add(24 * time.Hour)
nextWeek := now.Add(7 * 24 * time.Hour)
// Create test issues with varied due_at and defer_until values
issueNoSchedule := &types.Issue{
Title: "Issue without scheduling",
Priority: 2,
IssueType: types.TypeTask,
Status: types.StatusOpen,
}
issueDeferredFuture := &types.Issue{
Title: "Deferred until tomorrow",
Priority: 2,
IssueType: types.TypeTask,
Status: types.StatusOpen,
DeferUntil: &tomorrow,
}
issueDeferredPast := &types.Issue{
Title: "Was deferred until yesterday",
Priority: 2,
IssueType: types.TypeTask,
Status: types.StatusOpen,
DeferUntil: &yesterday,
}
issueDueNextWeek := &types.Issue{
Title: "Due next week",
Priority: 1,
IssueType: types.TypeTask,
Status: types.StatusOpen,
DueAt: &nextWeek,
}
issueOverdue := &types.Issue{
Title: "Overdue issue",
Priority: 0,
IssueType: types.TypeBug,
Status: types.StatusOpen,
DueAt: &yesterday,
}
issueOverdueClosed := &types.Issue{
Title: "Overdue but closed",
Priority: 0,
IssueType: types.TypeBug,
Status: types.StatusClosed,
DueAt: &yesterday,
ClosedAt: &now,
}
for _, issue := range []*types.Issue{
issueNoSchedule, issueDeferredFuture, issueDeferredPast,
issueDueNextWeek, issueOverdue, issueOverdueClosed,
} {
if err := s.CreateIssue(ctx, issue, "test-user"); err != nil {
t.Fatalf("Failed to create issue: %v", err)
}
}
t.Run("filter by deferred flag", func(t *testing.T) {
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
Deferred: true,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
// Should find issues with defer_until set (future and past)
if len(results) != 2 {
t.Errorf("Expected 2 deferred issues, got %d", len(results))
}
})
t.Run("filter by defer-after", func(t *testing.T) {
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
DeferAfter: &now,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
// Should find issues deferred after now (tomorrow)
if len(results) != 1 {
t.Errorf("Expected 1 issue deferred after now, got %d", len(results))
}
})
t.Run("filter by defer-before", func(t *testing.T) {
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
DeferBefore: &now,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
// Should find issues deferred before now (yesterday)
if len(results) != 1 {
t.Errorf("Expected 1 issue deferred before now, got %d", len(results))
}
})
t.Run("filter by due-after", func(t *testing.T) {
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
DueAfter: &now,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
// Should find issues due after now (next week)
if len(results) != 1 {
t.Errorf("Expected 1 issue due after now, got %d", len(results))
}
})
t.Run("filter by due-before", func(t *testing.T) {
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
DueBefore: &now,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
// Should find issues due before now (overdue open + closed = 2)
if len(results) != 2 {
t.Errorf("Expected 2 issues due before now, got %d", len(results))
}
})
t.Run("filter by overdue", func(t *testing.T) {
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
Overdue: true,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
// Should find only the open overdue issue (not the closed one)
if len(results) != 1 {
t.Errorf("Expected 1 overdue issue, got %d", len(results))
}
if len(results) > 0 && results[0].ID != issueOverdue.ID {
t.Errorf("Expected issue %s, got %s", issueOverdue.ID, results[0].ID)
}
})
t.Run("combined filters defer and due", func(t *testing.T) {
// Issue with both defer_until and due_at
bothSet := &types.Issue{
Title: "Both deferred and due",
Priority: 1,
IssueType: types.TypeTask,
Status: types.StatusOpen,
DeferUntil: &tomorrow,
DueAt: &nextWeek,
}
if err := s.CreateIssue(ctx, bothSet, "test-user"); err != nil {
t.Fatalf("Failed to create issue: %v", err)
}
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
Deferred: true,
DueAfter: &now,
})
if err != nil {
t.Fatalf("Search failed: %v", err)
}
// Should find the issue with both defer_until set and due_at > now
if len(results) != 1 {
t.Errorf("Expected 1 issue with both filters, got %d", len(results))
}
})
}
// TestHierarchicalChildren tests the --tree --parent functionality for showing all descendants
func TestHierarchicalChildren(t *testing.T) {
t.Parallel()
tmpDir := t.TempDir()
testDB := filepath.Join(tmpDir, ".beads", "beads.db")
store := newTestStore(t, testDB)
ctx := context.Background()
// Helper to create issue
createIssue := func(title string, issueType types.IssueType) *types.Issue {
issue := &types.Issue{
Title: title,
Priority: 2,
IssueType: issueType,
Status: types.StatusOpen,
}
if err := store.CreateIssue(ctx, issue, "test-user"); err != nil {
t.Fatalf("Failed to create issue %s: %v", title, err)
}
return issue
}
// Helper to add dependency
addDep := func(child, parent *types.Issue) {
dep := &types.Dependency{
IssueID: child.ID,
DependsOnID: parent.ID,
Type: types.DepParentChild,
CreatedAt: time.Now(),
CreatedBy: "test-user",
}
if err := store.AddDependency(ctx, dep, "test-user"); err != nil {
t.Fatalf("Failed to add dependency %s -> %s: %v", child.ID, parent.ID, err)
}
}
// Create test hierarchy: Parent -> Child1 (-> Grandchild1.1, Grandchild1.2) + Child2 (-> Grandchild2.1)
parent := createIssue("Parent Epic", types.TypeEpic)
child1 := createIssue("Child 1", types.TypeTask)
child2 := createIssue("Child 2", types.TypeTask)
grandchild11 := createIssue("Grandchild 1.1", types.TypeTask)
grandchild12 := createIssue("Grandchild 1.2", types.TypeTask)
grandchild21 := createIssue("Grandchild 2.1", types.TypeTask)
addDep(child1, parent)
addDep(child2, parent)
addDep(grandchild11, child1)
addDep(grandchild12, child1)
addDep(grandchild21, child2)
// Test full hierarchy (should return all 6 issues)
t.Run("full_hierarchy", func(t *testing.T) {
issues, err := getHierarchicalChildren(ctx, store, "", parent.ID, types.IssueFilter{})
if err != nil {
t.Fatalf("getHierarchicalChildren failed: %v", err)
}
if len(issues) != 6 {
t.Errorf("Expected 6 issues in hierarchy, got %d", len(issues))
}
})
// Test child subset (should return child1 + its 2 grandchildren = 3 total)
t.Run("child_subset", func(t *testing.T) {
issues, err := getHierarchicalChildren(ctx, store, "", child1.ID, types.IssueFilter{})
if err != nil {
t.Fatalf("getHierarchicalChildren for child1 failed: %v", err)
}
if len(issues) != 3 {
t.Errorf("Expected 3 issues in child1 hierarchy, got %d", len(issues))
}
})
// Test leaf node (should return only itself)
t.Run("leaf_node", func(t *testing.T) {
issues, err := getHierarchicalChildren(ctx, store, "", grandchild11.ID, types.IssueFilter{})
if err != nil {
t.Fatalf("getHierarchicalChildren for leaf failed: %v", err)
}
if len(issues) != 1 || issues[0].ID != grandchild11.ID {
t.Errorf("Expected 1 issue (leaf), got %d", len(issues))
}
})
// Test error case - non-existent parent
t.Run("nonexistent_parent", func(t *testing.T) {
_, err := getHierarchicalChildren(ctx, store, "", "nonexistent-id", types.IssueFilter{})
if err == nil || !strings.Contains(err.Error(), "not found") {
t.Error("Expected 'not found' error for nonexistent parent")
}
})
}
// TestFormatDependencyInfoWithParent tests that parent-child deps render as "parent: X" (bd-hcxu)
func TestFormatDependencyInfoWithParent(t *testing.T) {
t.Parallel()
tests := []struct {
name string
blockedBy []string
blocks []string
parent string
want string
}{
{
name: "parent only",
parent: "epic-1",
want: "(parent: epic-1)",
},
{
name: "parent and blocked by",
parent: "epic-1",
blockedBy: []string{"blocker-1"},
want: "(parent: epic-1, blocked by: blocker-1)",
},
{
name: "parent and blocks",
parent: "epic-1",
blocks: []string{"child-1"},
want: "(parent: epic-1, blocks: child-1)",
},
{
name: "parent, blocked by, and blocks",
parent: "epic-1",
blockedBy: []string{"blocker-1"},
blocks: []string{"child-1"},
want: "(parent: epic-1, blocked by: blocker-1, blocks: child-1)",
},
{
name: "no parent, no deps",
want: "",
},
{
name: "blocked by only (no parent)",
blockedBy: []string{"blocker-1"},
want: "(blocked by: blocker-1)",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := formatDependencyInfo(tt.blockedBy, tt.blocks, tt.parent)
if result != tt.want {
t.Errorf("formatDependencyInfo() = %q, want %q", result, tt.want)
}
})
}
}
// TestFormatIssueCompactWithParent tests compact format renders parent correctly (bd-hcxu)
func TestFormatIssueCompactWithParent(t *testing.T) {
t.Parallel()
issue := &types.Issue{
ID: "test-child",
Title: "Child Task",
Priority: 2,
IssueType: types.TypeTask,
Status: types.StatusOpen,
}
t.Run("shows parent annotation", func(t *testing.T) {
var buf strings.Builder
formatIssueCompact(&buf, issue, nil, nil, nil, "test-parent")
result := buf.String()
if !strings.Contains(result, "(parent: test-parent)") {
t.Errorf("Expected '(parent: test-parent)' in output, got %q", result)
}
})
t.Run("does not show blocked by for parent", func(t *testing.T) {
var buf strings.Builder
formatIssueCompact(&buf, issue, nil, nil, nil, "test-parent")
result := buf.String()
if strings.Contains(result, "blocked by") {
t.Errorf("Should not contain 'blocked by' for parent-child dep, got %q", result)
}
})
t.Run("shows parent and blocked by together", func(t *testing.T) {
var buf strings.Builder
formatIssueCompact(&buf, issue, nil, []string{"blocker-1"}, nil, "test-parent")
result := buf.String()
if !strings.Contains(result, "(parent: test-parent, blocked by: blocker-1)") {
t.Errorf("Expected '(parent: test-parent, blocked by: blocker-1)' in output, got %q", result)
}
})
}
// TestGetBlockingInfoForIssues_ParentChildSeparation tests that parent-child deps go to parentMap (bd-hcxu)
func TestGetBlockingInfoForIssues_ParentChildSeparation(t *testing.T) {
t.Parallel()
tmpDir := t.TempDir()
testDB := filepath.Join(tmpDir, ".beads", "beads.db")
store := newTestStore(t, testDB)
ctx := context.Background()
// Create parent and child
parent := &types.Issue{
Title: "Parent Epic",
Priority: 2,
IssueType: types.TypeEpic,
Status: types.StatusOpen,
}
child := &types.Issue{
Title: "Child Task",
Priority: 2,
IssueType: types.TypeTask,
Status: types.StatusOpen,
}
blocker := &types.Issue{
Title: "Blocker Task",
Priority: 1,
IssueType: types.TypeTask,
Status: types.StatusOpen,
}
for _, issue := range []*types.Issue{parent, child, blocker} {
if err := store.CreateIssue(ctx, issue, "test-user"); err != nil {
t.Fatalf("Failed to create issue: %v", err)
}
}
// Add parent-child dep
if err := store.AddDependency(ctx, &types.Dependency{
IssueID: child.ID, DependsOnID: parent.ID, Type: types.DepParentChild,
}, "test-user"); err != nil {
t.Fatalf("Failed to add parent-child dep: %v", err)
}
// Add blocking dep
if err := store.AddDependency(ctx, &types.Dependency{
IssueID: child.ID, DependsOnID: blocker.ID, Type: types.DepBlocks,
}, "test-user"); err != nil {
t.Fatalf("Failed to add blocking dep: %v", err)
}
blockedByMap, blocksMap, parentMap, err := store.GetBlockingInfoForIssues(ctx, []string{child.ID, parent.ID, blocker.ID})
if err != nil {
t.Fatalf("GetBlockingInfoForIssues failed: %v", err)
}
// Child should have parent in parentMap, not in blockedByMap
if parentMap[child.ID] != parent.ID {
t.Errorf("parentMap[%s] = %q, want %q", child.ID, parentMap[child.ID], parent.ID)
}
// Child should have blocker in blockedByMap
if len(blockedByMap[child.ID]) != 1 || blockedByMap[child.ID][0] != blocker.ID {
t.Errorf("blockedByMap[%s] = %v, want [%s]", child.ID, blockedByMap[child.ID], blocker.ID)
}
// Parent should NOT appear in blockedByMap for child
for _, id := range blockedByMap[child.ID] {
if id == parent.ID {
t.Errorf("parent %s should NOT be in blockedByMap for child %s", parent.ID, child.ID)
}
}
// Blocker should show in blocksMap
if len(blocksMap[blocker.ID]) != 1 || blocksMap[blocker.ID][0] != child.ID {
t.Errorf("blocksMap[%s] = %v, want [%s]", blocker.ID, blocksMap[blocker.ID], child.ID)
}
}
// TestListJSON_ParentField tests that bd list --json includes computed parent field (bd-ym8c)
func TestListJSON_ParentField(t *testing.T) {
t.Parallel()
tmpDir := t.TempDir()
testDB := filepath.Join(tmpDir, ".beads", "beads.db")
store := newTestStore(t, testDB)
ctx := context.Background()
parent := &types.Issue{
Title: "Parent Epic",
Priority: 2,
IssueType: types.TypeEpic,
Status: types.StatusOpen,
}
child := &types.Issue{
Title: "Child Task",
Priority: 2,
IssueType: types.TypeTask,
Status: types.StatusOpen,
}
standalone := &types.Issue{
Title: "Standalone Task",
Priority: 2,
IssueType: types.TypeTask,
Status: types.StatusOpen,
}
for _, issue := range []*types.Issue{parent, child, standalone} {
if err := store.CreateIssue(ctx, issue, "test-user"); err != nil {
t.Fatalf("Failed to create issue: %v", err)
}
}
// Add parent-child dep
if err := store.AddDependency(ctx, &types.Dependency{
IssueID: child.ID, DependsOnID: parent.ID, Type: types.DepParentChild,
}, "test-user"); err != nil {
t.Fatalf("Failed to add parent-child dep: %v", err)
}
// Simulate what list.go JSON path does: fetch deps and compute parent
issueIDs := []string{parent.ID, child.ID, standalone.ID}
allDeps, err := store.GetDependencyRecordsForIssues(ctx, issueIDs)
if err != nil {
t.Fatalf("GetDependencyRecordsForIssues failed: %v", err)
}
// Build IssueWithCounts with parent computation
for _, issue := range []*types.Issue{parent, child, standalone} {
var computedParent *string
for _, dep := range allDeps[issue.ID] {
if dep.Type == types.DepParentChild {
computedParent = &dep.DependsOnID
break
}
}
iwc := &types.IssueWithCounts{
Issue: issue,
Parent: computedParent,
}
if issue.ID == child.ID {
if iwc.Parent == nil || *iwc.Parent != parent.ID {
t.Errorf("Child %s should have parent %s, got %v", child.ID, parent.ID, iwc.Parent)
}
} else {
if iwc.Parent != nil {
t.Errorf("Issue %s should have nil parent, got %q", issue.ID, *iwc.Parent)
}
}
}
}
func TestListCommandInit(t *testing.T) {
t.Parallel()
if listCmd == nil {
t.Fatal("listCmd should be initialized")
}
// Verify --exclude-label flag exists and defaults to empty slice
excludeLabelFlag := listCmd.Flags().Lookup("exclude-label")
if excludeLabelFlag == nil {
t.Fatal("--exclude-label flag should exist on bd list")
}
if excludeLabelFlag.DefValue != "[]" {
t.Errorf("--exclude-label default should be '[]', got %q", excludeLabelFlag.DefValue)
}
}