beads/cmd/bd/graph_export_test.go
Kevin Glynn a028506ec6
fix(graph): merge components for bd graph --all --html (GH#3592) (#3648)
Merged after maintainer review for release prep. CI was green and PR was approved.
2026-05-02 14:02:24 -07:00

332 lines
8.3 KiB
Go

package main
import (
"bytes"
"fmt"
"io"
"os"
"strings"
"testing"
"github.com/steveyegge/beads/internal/types"
)
// captureGraphOutput captures stdout output during f() execution
func captureGraphOutput(f func()) string {
old := os.Stdout
r, w, _ := os.Pipe()
os.Stdout = w
f()
w.Close()
os.Stdout = old
var buf bytes.Buffer
io.Copy(&buf, r)
return buf.String()
}
func makeTestSubgraph() (*TemplateSubgraph, *GraphLayout) {
issueA := &types.Issue{
ID: "test-a", Title: "Root issue", Status: types.StatusOpen,
Priority: 0, IssueType: types.TypeEpic,
}
issueB := &types.Issue{
ID: "test-b", Title: "Child task", Status: types.StatusInProgress,
Priority: 1, IssueType: types.TypeTask, Assignee: "alice",
}
issueC := &types.Issue{
ID: "test-c", Title: "Blocked task", Status: types.StatusBlocked,
Priority: 2, IssueType: types.TypeBug,
}
issueD := &types.Issue{
ID: "test-d", Title: "Done task", Status: types.StatusClosed,
Priority: 1, IssueType: types.TypeTask,
}
subgraph := &TemplateSubgraph{
Root: issueA,
Issues: []*types.Issue{issueA, issueB, issueC, issueD},
IssueMap: map[string]*types.Issue{
"test-a": issueA, "test-b": issueB,
"test-c": issueC, "test-d": issueD,
},
Dependencies: []*types.Dependency{
{IssueID: "test-b", DependsOnID: "test-a", Type: types.DepBlocks},
{IssueID: "test-c", DependsOnID: "test-b", Type: types.DepBlocks},
{IssueID: "test-b", DependsOnID: "test-a", Type: types.DepParentChild},
},
}
layout := computeLayout(subgraph)
return subgraph, layout
}
func TestRenderGraphDOT(t *testing.T) {
// Not parallel: captureGraphOutput redirects global os.Stdout
subgraph, layout := makeTestSubgraph()
output := captureGraphOutput(func() {
renderGraphDOT(layout, subgraph)
})
// Verify DOT structure
if !strings.HasPrefix(output, "digraph beads {") {
t.Error("DOT output should start with 'digraph beads {'")
}
if !strings.Contains(output, "rankdir=LR") {
t.Error("DOT output should specify left-to-right layout")
}
// Verify nodes are present
for _, id := range []string{"test-a", "test-b", "test-c", "test-d"} {
if !strings.Contains(output, fmt.Sprintf("\"%s\"", id)) {
t.Errorf("DOT output should contain node %q", id)
}
}
// Verify edges exist
if !strings.Contains(output, "\"test-a\" -> \"test-b\"") {
t.Error("DOT output should contain edge test-a -> test-b")
}
if !strings.Contains(output, "\"test-b\" -> \"test-c\"") {
t.Error("DOT output should contain edge test-b -> test-c")
}
// Verify it ends with closing brace
if !strings.HasSuffix(strings.TrimSpace(output), "}") {
t.Error("DOT output should end with '}'")
}
}
func TestRenderGraphDOT_Empty(t *testing.T) {
// Not parallel: captureGraphOutput redirects global os.Stdout
emptySubgraph := &TemplateSubgraph{
Root: &types.Issue{ID: "empty"},
Issues: []*types.Issue{},
IssueMap: map[string]*types.Issue{},
}
layout := &GraphLayout{
Nodes: map[string]*GraphNode{},
Layers: [][]string{},
RootID: "empty",
}
output := captureGraphOutput(func() {
renderGraphDOT(layout, emptySubgraph)
})
if !strings.Contains(output, "digraph beads { }") {
t.Errorf("Empty DOT output should be 'digraph beads { }', got: %s", output)
}
}
func TestDotNodeAttrs(t *testing.T) {
t.Parallel()
tests := []struct {
status types.Status
wantColor string
}{
{types.StatusOpen, "#e8f4fd"},
{types.StatusInProgress, "#fff3cd"},
{types.StatusBlocked, "#f8d7da"},
{types.StatusClosed, "#d4edda"},
}
for _, tt := range tests {
t.Run(string(tt.status), func(t *testing.T) {
node := &GraphNode{
Issue: &types.Issue{
ID: "test", Title: "Test", Status: tt.status,
Priority: 1, IssueType: types.TypeTask,
},
}
_, fillColor, _ := dotNodeAttrs(node)
if fillColor != tt.wantColor {
t.Errorf("status %s: fillColor = %s, want %s", tt.status, fillColor, tt.wantColor)
}
})
}
}
func TestStatusPlainIcon(t *testing.T) {
t.Parallel()
tests := []struct {
status types.Status
want string
}{
{types.StatusOpen, "○"},
{types.StatusInProgress, "◐"},
{types.StatusBlocked, "●"},
{types.StatusClosed, "✓"},
}
for _, tt := range tests {
got := statusPlainIcon(tt.status)
if got != tt.want {
t.Errorf("statusPlainIcon(%s) = %q, want %q", tt.status, got, tt.want)
}
}
}
func TestRenderGraphHTML(t *testing.T) {
// Not parallel: captureGraphOutput redirects global os.Stdout
subgraph, layout := makeTestSubgraph()
output := captureGraphOutput(func() {
renderGraphHTML(layout, subgraph)
})
// Verify HTML structure
if !strings.Contains(output, "<!DOCTYPE html>") {
t.Error("HTML output should contain DOCTYPE")
}
if !strings.Contains(output, "d3.v7.min.js") {
t.Error("HTML output should reference D3.js")
}
// Verify node data is embedded
for _, id := range []string{"test-a", "test-b", "test-c", "test-d"} {
if !strings.Contains(output, id) {
t.Errorf("HTML output should contain node %q", id)
}
}
// Verify it contains all statuses
if !strings.Contains(output, "open") {
t.Error("HTML should contain open status")
}
if !strings.Contains(output, "in_progress") {
t.Error("HTML should contain in_progress status")
}
// Verify interactive elements
if !strings.Contains(output, "forceSimulation") {
t.Error("HTML should contain D3 force simulation")
}
if !strings.Contains(output, "tooltip") {
t.Error("HTML should contain tooltip")
}
}
func TestBuildHTMLGraphData(t *testing.T) {
t.Parallel()
subgraph, layout := makeTestSubgraph()
nodes := buildHTMLGraphData(layout, subgraph)
if len(nodes) != 4 {
t.Errorf("Expected 4 nodes, got %d", len(nodes))
}
// Find the in_progress node and check assignee
found := false
for _, n := range nodes {
if n.ID == "test-b" {
found = true
if n.Assignee != "alice" {
t.Errorf("test-b assignee = %q, want 'alice'", n.Assignee)
}
if n.Status != "in_progress" {
t.Errorf("test-b status = %q, want 'in_progress'", n.Status)
}
}
}
if !found {
t.Error("test-b node not found in HTML data")
}
}
func TestBuildHTMLEdgeData(t *testing.T) {
t.Parallel()
subgraph, layout := makeTestSubgraph()
edges := buildHTMLEdgeData(layout, subgraph)
// Should have 3 edges (2 blocks + 1 parent-child)
if len(edges) != 3 {
t.Errorf("Expected 3 edges, got %d", len(edges))
}
// Verify edge types
hasBlocks := false
hasParentChild := false
for _, e := range edges {
if e.Type == "blocks" {
hasBlocks = true
}
if e.Type == "parent-child" {
hasParentChild = true
}
}
if !hasBlocks {
t.Error("Should have blocks edge")
}
if !hasParentChild {
t.Error("Should have parent-child edge")
}
}
func TestDotEdgeStyle(t *testing.T) {
t.Parallel()
blocks := dotEdgeStyle(types.DepBlocks)
if !strings.Contains(blocks, "solid") {
t.Error("blocks edge should be solid")
}
parentChild := dotEdgeStyle(types.DepParentChild)
if !strings.Contains(parentChild, "dashed") {
t.Error("parent-child edge should be dashed")
}
related := dotEdgeStyle(types.DepRelated)
if related != "" {
t.Errorf("related edge should have no style, got %q", related)
}
}
func TestMergeSubgraphsForHTML_SingleDOCTYPE(t *testing.T) {
// Not parallel: captureGraphOutput redirects global os.Stdout
// Create two disconnected subgraphs (separate components)
issueA := &types.Issue{
ID: "comp-a", Title: "Component A", Status: types.StatusOpen,
Priority: 1, IssueType: types.TypeTask,
}
issueB := &types.Issue{
ID: "comp-b", Title: "Component B", Status: types.StatusInProgress,
Priority: 2, IssueType: types.TypeTask,
}
sg1 := &TemplateSubgraph{
Root: issueA,
Issues: []*types.Issue{issueA},
IssueMap: map[string]*types.Issue{"comp-a": issueA},
}
sg2 := &TemplateSubgraph{
Root: issueB,
Issues: []*types.Issue{issueB},
IssueMap: map[string]*types.Issue{"comp-b": issueB},
}
merged := mergeSubgraphsForHTML([]*TemplateSubgraph{sg1, sg2})
layout := computeLayout(merged)
output := captureGraphOutput(func() {
renderGraphHTML(layout, merged)
})
// Must contain exactly one DOCTYPE declaration
count := strings.Count(output, "<!DOCTYPE html>")
if count != 1 {
t.Errorf("expected exactly 1 <!DOCTYPE html>, got %d", count)
}
// Both issues must appear in the single document
if !strings.Contains(output, "comp-a") {
t.Error("merged HTML should contain comp-a")
}
if !strings.Contains(output, "comp-b") {
t.Error("merged HTML should contain comp-b")
}
}