diff --git a/cmd/bd/backup_embedded_test.go b/cmd/bd/backup_embedded_test.go index 026808203..10ed7368e 100644 --- a/cmd/bd/backup_embedded_test.go +++ b/cmd/bd/backup_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -19,11 +20,13 @@ func bdBackup(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd backup %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd backup %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdBackupFail runs "bd backup" expecting failure. Returns combined output. diff --git a/cmd/bd/blocked_embedded_test.go b/cmd/bd/blocked_embedded_test.go index b065ffaa9..d248cb0b5 100644 --- a/cmd/bd/blocked_embedded_test.go +++ b/cmd/bd/blocked_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -27,12 +28,14 @@ func TestEmbeddedBlocked(t *testing.T) { cmd := exec.Command(bd, "blocked") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd blocked failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd blocked failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } // No blocked issues on fresh db - _ = out + _ = stdout.String() }) // ===== With Blocked Issue ===== @@ -52,12 +55,14 @@ func TestEmbeddedBlocked(t *testing.T) { cmd = exec.Command(bd, "blocked") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd blocked failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd blocked failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(out), blocked.ID) { - t.Errorf("expected %s in blocked output: %s", blocked.ID, out) + if !strings.Contains(stdout.String(), blocked.ID) { + t.Errorf("expected %s in blocked output: %s", blocked.ID, stdout.String()) } }) @@ -67,11 +72,13 @@ func TestEmbeddedBlocked(t *testing.T) { cmd := exec.Command(bd, "blocked", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd blocked --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd blocked --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.IndexAny(s, "[{") if start < 0 { t.Fatalf("no JSON in blocked --json output: %s", s) diff --git a/cmd/bd/bootstrap_embedded_test.go b/cmd/bd/bootstrap_embedded_test.go index 65c2a8835..0a889df7f 100644 --- a/cmd/bd/bootstrap_embedded_test.go +++ b/cmd/bd/bootstrap_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -20,11 +21,13 @@ func bdBootstrap(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd bootstrap %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd bootstrap %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func bdBootstrapAllowError(t *testing.T, bd, dir string, args ...string) (string, error) { @@ -57,20 +60,26 @@ func TestBootstrapNoWorkspace(t *testing.T) { }) t.Run("json_output", func(t *testing.T) { - out, err := bdBootstrapAllowError(t, bd, dir, "--json") + cmd := exec.Command(bd, "bootstrap", "--json") + cmd.Dir = dir + cmd.Env = bdEnv(dir) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + err := cmd.Run() if err == nil { t.Fatal("expected bd bootstrap --json to exit non-zero without a workspace") } - s := strings.TrimSpace(out) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { - t.Fatalf("expected JSON object in output, got: %s", out) + t.Fatalf("expected JSON object in output:\nstdout: %s\nstderr: %s", s, stderr.String()) } var payload map[string]interface{} if err := json.Unmarshal([]byte(s[start:]), &payload); err != nil { - t.Fatalf("parse bootstrap JSON: %v\n%s", err, s) + t.Fatalf("parse bootstrap JSON: %v\nstdout: %s", err, s) } if action, _ := payload["action"].(string); action != "none" { t.Fatalf("action = %q, want %q", action, "none") @@ -147,12 +156,14 @@ func TestEmbeddedBootstrap(t *testing.T) { bcmd.Dir = dir bcmd.Env = bdEnv(dir) bcmd.Stdin = strings.NewReader("y\n") - out, err := bcmd.CombinedOutput() - if err != nil { - t.Fatalf("bootstrap init failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + bcmd.Stdout = &stdout + bcmd.Stderr = &stderr + if err := bcmd.Run(); err != nil { + t.Fatalf("bootstrap init failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(out), "Created fresh database") { - t.Errorf("expected 'Created fresh database': %s", out) + if !strings.Contains(stdout.String(), "Created fresh database") { + t.Errorf("expected 'Created fresh database': %s", stdout.String()) } }) @@ -193,12 +204,14 @@ func TestEmbeddedBootstrap(t *testing.T) { bcmd.Dir = dir bcmd.Env = bdEnv(dir) bcmd.Stdin = strings.NewReader("y\n") - out, err := bcmd.CombinedOutput() - if err != nil { - t.Fatalf("bootstrap jsonl-import failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + bcmd.Stdout = &stdout + bcmd.Stderr = &stderr + if err := bcmd.Run(); err != nil { + t.Fatalf("bootstrap jsonl-import failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(out), "Imported") { - t.Errorf("expected 'Imported' in output: %s", out) + if !strings.Contains(stdout.String(), "Imported") { + t.Errorf("expected 'Imported' in output: %s", stdout.String()) } }) diff --git a/cmd/bd/branch_embedded_test.go b/cmd/bd/branch_embedded_test.go index 07ab83ab3..03ba3e1d3 100644 --- a/cmd/bd/branch_embedded_test.go +++ b/cmd/bd/branch_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdBranch(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd branch %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd branch %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func TestEmbeddedBranch(t *testing.T) { diff --git a/cmd/bd/children_embedded_test.go b/cmd/bd/children_embedded_test.go index 7f2a5c493..312af8ce8 100644 --- a/cmd/bd/children_embedded_test.go +++ b/cmd/bd/children_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdChildren(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd children %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd children %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func TestEmbeddedChildren(t *testing.T) { @@ -59,11 +62,13 @@ func TestEmbeddedChildren(t *testing.T) { cmd := exec.Command(bd, "children", parent.ID, "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd children --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd children --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "[") if start >= 0 { var issues []map[string]interface{} diff --git a/cmd/bd/close_embedded_test.go b/cmd/bd/close_embedded_test.go index 82fd49d14..e16cdc793 100644 --- a/cmd/bd/close_embedded_test.go +++ b/cmd/bd/close_embedded_test.go @@ -315,11 +315,13 @@ func TestEmbeddedClose(t *testing.T) { cmd := exec.Command(bd, "close", blocker.ID, "--suggest-next", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd close --suggest-next --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd close --suggest-next --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := string(out) + s := stdout.String() if !strings.Contains(s, "unblocked") { t.Logf("JSON output did not contain 'unblocked' key: %s", s) } @@ -355,11 +357,13 @@ func TestEmbeddedClose(t *testing.T) { cmd := exec.Command(bd, "close", toClose.ID, "--claim-next", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd close --claim-next --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd close --claim-next --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := string(out) + s := stdout.String() start := strings.Index(s, "{") if start < 0 { start = strings.Index(s, "[") @@ -387,9 +391,11 @@ func TestEmbeddedClose(t *testing.T) { env := bdEnv(dir) env = append(env, "CLAUDE_SESSION_ID=env-sess") cmd.Env = env - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd close with env session failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd close with env session failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } session := querySessionSQL(t, beadsDir, issue.ID) if session != "env-sess" { @@ -404,11 +410,13 @@ func TestEmbeddedClose(t *testing.T) { cmd := exec.Command(bd, "close", issue.ID, "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd close --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd close --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := string(out) + s := stdout.String() start := strings.Index(s, "[") if start < 0 { start = strings.Index(s, "{") @@ -426,9 +434,11 @@ func TestEmbeddedClose(t *testing.T) { cmd := exec.Command(bd, "done", issue.ID) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd done failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd done failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } got := bdShow(t, bd, dir, issue.ID) if got.Status != types.StatusClosed { @@ -441,9 +451,11 @@ func TestEmbeddedClose(t *testing.T) { cmd := exec.Command(bd, "done", issue.ID, "the reason") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd done with reason failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd done with reason failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } got := bdShow(t, bd, dir, issue.ID) if got.CloseReason != "the reason" { diff --git a/cmd/bd/comment_promote_embedded_test.go b/cmd/bd/comment_promote_embedded_test.go index 942ba05c0..2f7613872 100644 --- a/cmd/bd/comment_promote_embedded_test.go +++ b/cmd/bd/comment_promote_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "os" "os/exec" "strings" @@ -16,11 +17,13 @@ func bdComment(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd comments add %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd comments add %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdCommentList runs "bd comments list" and returns stdout. @@ -29,11 +32,13 @@ func bdCommentList(t *testing.T, bd, dir, issueID string) string { cmd := exec.Command(bd, "comments", "list", issueID) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd comments list %s failed: %v\n%s", issueID, err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd comments list %s failed: %v\nstdout:\n%s\nstderr:\n%s", issueID, err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func TestEmbeddedComments(t *testing.T) { diff --git a/cmd/bd/comments_cli_embedded_test.go b/cmd/bd/comments_cli_embedded_test.go index eb0b5513f..15eb92b34 100644 --- a/cmd/bd/comments_cli_embedded_test.go +++ b/cmd/bd/comments_cli_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -20,11 +21,13 @@ func bdComments(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd comments %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd comments %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func TestEmbeddedCommentsCLI(t *testing.T) { @@ -51,11 +54,13 @@ func TestEmbeddedCommentsCLI(t *testing.T) { cmd := exec.Command(bd, "comments", "add", issue.ID, "JSON comment text", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd comments add --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd comments add --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { t.Fatalf("no JSON in output: %s", s) @@ -115,11 +120,13 @@ func TestEmbeddedCommentsCLI(t *testing.T) { cmd := exec.Command(bd, "comments", issue.ID, "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd comments list --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd comments list --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "[") if start >= 0 { var comments []map[string]interface{} @@ -146,11 +153,13 @@ func TestEmbeddedCommentsCLI(t *testing.T) { cmd := exec.Command(bd, "comments", issue.ID, "--local-time") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd comments list --local-time failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd comments list --local-time failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - _ = out + _ = stdout.String() }) // ===== Round-trip ===== @@ -162,11 +171,13 @@ func TestEmbeddedCommentsCLI(t *testing.T) { cmd := exec.Command(bd, "comments", issue.ID, "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("list failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("list failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "[") if start >= 0 { var comments []map[string]interface{} diff --git a/cmd/bd/compact_embedded_test.go b/cmd/bd/compact_embedded_test.go index 53871e450..d9b1fe620 100644 --- a/cmd/bd/compact_embedded_test.go +++ b/cmd/bd/compact_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -18,11 +19,13 @@ func bdCompact(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd compact %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd compact %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdCompactFail runs "bd compact" expecting failure. @@ -139,12 +142,14 @@ func TestEmbeddedCompact(t *testing.T) { cmd := exec.Command(bd, "--json", "compact", "--dry-run") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd --json compact --dry-run failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd --json compact --dry-run failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } // Should produce some output without crashing - _ = out + _ = stdout.String() }) } diff --git a/cmd/bd/config_embedded_test.go b/cmd/bd/config_embedded_test.go index 2fdb671fe..89ab143de 100644 --- a/cmd/bd/config_embedded_test.go +++ b/cmd/bd/config_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdConfig(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd config %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd config %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdConfigFail runs "bd config" expecting failure. @@ -46,11 +49,13 @@ func bdConfigListJSON(t *testing.T, bd, dir string) map[string]string { cmd := exec.Command(bd, "config", "list", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd config list --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd config list --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { t.Fatalf("no JSON object in config list output: %s", s) diff --git a/cmd/bd/context_embedded_test.go b/cmd/bd/context_embedded_test.go index 95d92923d..8c7025ee9 100644 --- a/cmd/bd/context_embedded_test.go +++ b/cmd/bd/context_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -24,12 +25,14 @@ func TestEmbeddedContext(t *testing.T) { cmd := exec.Command(bd, "context") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd context failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd context failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(out), "embedded") && !strings.Contains(string(out), ".beads") { - t.Errorf("expected embedded mode or .beads in context output: %s", out) + if !strings.Contains(stdout.String(), "embedded") && !strings.Contains(stdout.String(), ".beads") { + t.Errorf("expected embedded mode or .beads in context output: %s", stdout.String()) } }) @@ -37,11 +40,13 @@ func TestEmbeddedContext(t *testing.T) { cmd := exec.Command(bd, "context", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd context --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd context --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if len(strings.TrimSpace(string(out))) == 0 { + if len(strings.TrimSpace(stdout.String())) == 0 { t.Error("expected non-empty context --json output") } }) diff --git a/cmd/bd/contributor_embedded_test.go b/cmd/bd/contributor_embedded_test.go index ac24d40c4..c1e4b4ea4 100644 --- a/cmd/bd/contributor_embedded_test.go +++ b/cmd/bd/contributor_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -99,9 +100,11 @@ func initContributor(t *testing.T, bd, prefix string) (projectDir, planningDir s cmd.Dir = projectDir cmd.Env = append(bdEnv(projectDir), "BD_NON_INTERACTIVE=0") cmd.Stdin = strings.NewReader("y\n" + planningDir + "\n") - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd init --contributor failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd init --contributor failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } // Sanity: planning .beads dir should exist (created by wizard). diff --git a/cmd/bd/create_embedded_test.go b/cmd/bd/create_embedded_test.go index 17afa40c9..3f7a7ec39 100644 --- a/cmd/bd/create_embedded_test.go +++ b/cmd/bd/create_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -86,11 +87,13 @@ func bdShow(t *testing.T, bd, dir, id string) *types.Issue { cmd := exec.Command(bd, "show", id, "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd show %s --json failed: %v\n%s", id, err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd show %s --json failed: %v\nstdout:\n%s\nstderr:\n%s", id, err, stdout.String(), stderr.String()) } - return parseIssueJSON(t, out) + return parseIssueJSON(t, stdout.Bytes()) } // openStore opens an EmbeddedDoltStore for direct verification queries. @@ -503,15 +506,17 @@ func TestEmbeddedCreate(t *testing.T) { cmd := exec.Command(bd, "create", "--dry-run", "Dry run issue", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd create --dry-run failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd create --dry-run failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } // Dry run should not persist anything. Create a real issue and verify // the dry-run issue doesn't exist. - if strings.Contains(string(out), "error") { - t.Errorf("dry-run produced error output: %s", out) + if strings.Contains(stdout.String(), "error") { + t.Errorf("dry-run produced error output: %s", stdout.String()) } }) @@ -578,9 +583,11 @@ A new feature cmd := exec.Command(bd, "create", "-f", mdFile, "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd create -f failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd create -f failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } // Verify both issues were created diff --git a/cmd/bd/defer_embedded_test.go b/cmd/bd/defer_embedded_test.go index 41c0f3f92..3b40ae14b 100644 --- a/cmd/bd/defer_embedded_test.go +++ b/cmd/bd/defer_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdDefer(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd defer %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd defer %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdUndefer runs "bd undefer" with the given args and returns stdout. @@ -33,11 +36,13 @@ func bdUndefer(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd undefer %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd undefer %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // getIssueStatus returns the status of an issue via bd show --json. @@ -46,11 +51,13 @@ func getIssueStatus(t *testing.T, bd, dir, id string) string { cmd := exec.Command(bd, "show", id, "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd show %s --json failed: %v\n%s", id, err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd show %s --json failed: %v\nstdout:\n%s\nstderr:\n%s", id, err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) // show --json may return an array or object start := strings.IndexAny(s, "[{") if start < 0 { diff --git a/cmd/bd/dep_embedded_test.go b/cmd/bd/dep_embedded_test.go index a7fff3b8f..c808d5063 100644 --- a/cmd/bd/dep_embedded_test.go +++ b/cmd/bd/dep_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -20,11 +21,13 @@ func bdDep(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd dep %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd dep %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdDepFail runs "bd dep" expecting failure. @@ -49,11 +52,13 @@ func bdDepJSON(t *testing.T, bd, dir string, args ...string) map[string]interfac cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd dep --json %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd dep --json %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.IndexAny(s, "{[") if start < 0 { t.Fatalf("no JSON in dep output: %s", s) @@ -72,11 +77,13 @@ func bdDepWithInput(t *testing.T, bd, dir, input string, args ...string) string cmd.Dir = dir cmd.Env = bdEnv(dir) cmd.Stdin = strings.NewReader(input) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd dep %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd dep %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func TestEmbeddedDep(t *testing.T) { @@ -295,12 +302,14 @@ func TestEmbeddedDep(t *testing.T) { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("dep list --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("dep list --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(out), issueD.ID) { - t.Errorf("expected dependency ID in JSON: %s", out) + if !strings.Contains(stdout.String(), issueD.ID) { + t.Errorf("expected dependency ID in JSON: %s", stdout.String()) } }) @@ -353,12 +362,14 @@ func TestEmbeddedDep(t *testing.T) { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("dep tree --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("dep tree --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(out), epic.ID) { - t.Errorf("expected epic ID in JSON tree: %s", out) + if !strings.Contains(stdout.String(), epic.ID) { + t.Errorf("expected epic ID in JSON tree: %s", stdout.String()) } }) diff --git a/cmd/bd/dolt_embedded_test.go b/cmd/bd/dolt_embedded_test.go index f9090d357..7e776e1a8 100644 --- a/cmd/bd/dolt_embedded_test.go +++ b/cmd/bd/dolt_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdDolt(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd dolt %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd dolt %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdDoltFail runs "bd dolt" expecting failure and returns stderr+stdout. diff --git a/cmd/bd/duplicate_embedded_test.go b/cmd/bd/duplicate_embedded_test.go index 61a55167b..a66700936 100644 --- a/cmd/bd/duplicate_embedded_test.go +++ b/cmd/bd/duplicate_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdDuplicate(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd duplicate %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd duplicate %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdDuplicateFail runs "bd duplicate" expecting failure. @@ -100,11 +103,13 @@ func TestEmbeddedDuplicate(t *testing.T) { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("duplicate --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("duplicate --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { t.Fatalf("no JSON: %s", s) diff --git a/cmd/bd/duplicates_embedded_test.go b/cmd/bd/duplicates_embedded_test.go index ed898623d..5180b47de 100644 --- a/cmd/bd/duplicates_embedded_test.go +++ b/cmd/bd/duplicates_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdDuplicates(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd duplicates %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd duplicates %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdDuplicatesJSON runs "bd duplicates --json" and parses the result. @@ -33,11 +36,13 @@ func bdDuplicatesJSON(t *testing.T, bd, dir string, args ...string) map[string]i cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd duplicates --json %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd duplicates --json %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { t.Fatalf("no JSON in duplicates output: %s", s) diff --git a/cmd/bd/epic_embedded_test.go b/cmd/bd/epic_embedded_test.go index b1f2efa73..7086d5972 100644 --- a/cmd/bd/epic_embedded_test.go +++ b/cmd/bd/epic_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -21,11 +22,13 @@ func bdEpic(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd epic %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd epic %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdEpicJSON runs "bd epic" with --json and parses the result. @@ -36,11 +39,13 @@ func bdEpicJSON(t *testing.T, bd, dir string, args ...string) interface{} { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd epic --json %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd epic --json %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.IndexAny(s, "{[") if start < 0 { t.Fatalf("no JSON in epic output: %s", s) @@ -159,12 +164,14 @@ func TestEmbeddedEpic(t *testing.T) { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir4 cmd.Env = bdEnv(dir4) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("epic close-eligible --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("epic close-eligible --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } // Should produce valid JSON (empty array or object) - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.IndexAny(s, "{[") if start < 0 { t.Fatalf("no JSON: %s", s) diff --git a/cmd/bd/export_embedded_test.go b/cmd/bd/export_embedded_test.go index 8497a8ad4..cfa287cd6 100644 --- a/cmd/bd/export_embedded_test.go +++ b/cmd/bd/export_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -20,11 +21,13 @@ func bdExport(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd export %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd export %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func TestEmbeddedExport(t *testing.T) { diff --git a/cmd/bd/federation_embedded_test.go b/cmd/bd/federation_embedded_test.go index 1bd93280f..8ec230e0a 100644 --- a/cmd/bd/federation_embedded_test.go +++ b/cmd/bd/federation_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdFederation(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd federation %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd federation %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdFederationFail runs "bd federation" expecting failure. diff --git a/cmd/bd/find_duplicates_embedded_test.go b/cmd/bd/find_duplicates_embedded_test.go index 6f62e53c9..75f2445a0 100644 --- a/cmd/bd/find_duplicates_embedded_test.go +++ b/cmd/bd/find_duplicates_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdFindDups(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd find-duplicates %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd find-duplicates %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdFindDupsFail runs "bd find-duplicates" expecting failure. @@ -47,11 +50,13 @@ func bdFindDupsJSON(t *testing.T, bd, dir string, args ...string) map[string]int cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd find-duplicates --json %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd find-duplicates --json %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { t.Fatalf("no JSON object in find-duplicates output: %s", s) @@ -260,12 +265,14 @@ func TestEmbeddedFindDuplicates(t *testing.T) { cmd := exec.Command(bd, "find-dups", "--json", "--threshold", "0.3") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd find-dups alias failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd find-dups alias failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(out), "pairs") { - t.Errorf("expected JSON with 'pairs' from alias: %s", out) + if !strings.Contains(stdout.String(), "pairs") { + t.Errorf("expected JSON with 'pairs' from alias: %s", stdout.String()) } }) @@ -322,15 +329,17 @@ func TestEmbeddedFindDuplicatesConcurrent(t *testing.T) { cmd := exec.Command(bd, args...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - r.err = fmt.Errorf("worker %d find-duplicates: %v\n%s", worker, err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + r.err = fmt.Errorf("worker %d find-duplicates: %v\nstdout:\n%s\nstderr:\n%s", worker, err, stdout.String(), stderr.String()) results[worker] = r return } // Verify JSON is parseable - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { r.err = fmt.Errorf("worker %d: no JSON in output: %s", worker, s) diff --git a/cmd/bd/flatten_embedded_test.go b/cmd/bd/flatten_embedded_test.go index d09734618..dbc544151 100644 --- a/cmd/bd/flatten_embedded_test.go +++ b/cmd/bd/flatten_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -18,11 +19,13 @@ func bdFlatten(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd flatten %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd flatten %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdFlattenFail runs "bd flatten" expecting failure. @@ -118,12 +121,14 @@ func TestEmbeddedFlatten(t *testing.T) { cmd := exec.Command(bd, "count") cmd.Dir = dir cmd.Env = bdEnv(dir) - countOut, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd count after flatten failed: %v\n%s", err, countOut) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd count after flatten failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if strings.Contains(string(countOut), ": 0") { - t.Errorf("expected issues to survive flatten: %s", countOut) + if strings.Contains(stdout.String(), ": 0") { + t.Errorf("expected issues to survive flatten: %s", stdout.String()) } }) } diff --git a/cmd/bd/gate_embedded_test.go b/cmd/bd/gate_embedded_test.go index d74e719e4..8eabeaa51 100644 --- a/cmd/bd/gate_embedded_test.go +++ b/cmd/bd/gate_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -21,11 +22,13 @@ func bdGate(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd gate %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd gate %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdGateFail runs "bd gate" expecting failure. @@ -49,11 +52,13 @@ func bdGateListJSON(t *testing.T, bd, dir string, args ...string) []map[string]i cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd gate list --json %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd gate list --json %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "[") if start < 0 { return nil @@ -388,13 +393,15 @@ func TestEmbeddedGateCreate(t *testing.T) { cmd := exec.Command(bd, "gate", "create", "--blocks", task.ID, "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd gate create --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd gate create --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } var gate types.Issue - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { t.Fatalf("no JSON in output: %s", s) @@ -417,13 +424,15 @@ func TestEmbeddedGateCreate(t *testing.T) { "--type", "timer", "--timeout", "2h", "--reason", "Wait for cooldown", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd gate create --type=timer failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd gate create --type=timer failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } var gate types.Issue - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if err := json.Unmarshal([]byte(s[start:]), &gate); err != nil { t.Fatalf("parse gate JSON: %v\n%s", err, s) @@ -446,13 +455,15 @@ func TestEmbeddedGateCreate(t *testing.T) { "--type", "gh:pr", "--await-id", "42", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd gate create --type=gh:pr failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd gate create --type=gh:pr failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } var gate types.Issue - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if err := json.Unmarshal([]byte(s[start:]), &gate); err != nil { t.Fatalf("parse gate JSON: %v\n%s", err, s) @@ -483,12 +494,14 @@ func TestEmbeddedGateCreate(t *testing.T) { cmd := exec.Command(bd, "ready") cmd.Dir = freshDir cmd.Env = bdEnv(freshDir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd ready failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd ready failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(out), "Ready test task") { - t.Fatalf("task should appear in ready before gate: %s", out) + if !strings.Contains(stdout.String(), "Ready test task") { + t.Fatalf("task should appear in ready before gate: %s", stdout.String()) } // Create gate blocking the task @@ -498,13 +511,16 @@ func TestEmbeddedGateCreate(t *testing.T) { cmd = exec.Command(bd, "ready") cmd.Dir = freshDir cmd.Env = bdEnv(freshDir) - out, err = cmd.CombinedOutput() - if err != nil { + stdout.Reset() + stderr.Reset() + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { // bd ready exits 0 even with no results - t.Fatalf("bd ready failed: %v\n%s", err, out) + t.Fatalf("bd ready failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if strings.Contains(string(out), "Ready test task") { - t.Errorf("task should NOT appear in ready while gate is open: %s", out) + if strings.Contains(stdout.String(), "Ready test task") { + t.Errorf("task should NOT appear in ready while gate is open: %s", stdout.String()) } }) @@ -541,12 +557,14 @@ func TestEmbeddedGateCreate(t *testing.T) { cmd := exec.Command(bd, "ready") cmd.Dir = freshDir cmd.Env = bdEnv(freshDir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd ready failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd ready failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(out), "Unblock test task") { - t.Errorf("task should reappear in ready after gate resolved: %s", out) + if !strings.Contains(stdout.String(), "Unblock test task") { + t.Errorf("task should reappear in ready after gate resolved: %s", stdout.String()) } }) diff --git a/cmd/bd/gc_embedded_test.go b/cmd/bd/gc_embedded_test.go index 59ceab894..91477a620 100644 --- a/cmd/bd/gc_embedded_test.go +++ b/cmd/bd/gc_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -18,11 +19,13 @@ func bdGC(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd gc %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd gc %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdGCFail runs "bd gc" expecting failure. diff --git a/cmd/bd/graph_embedded_test.go b/cmd/bd/graph_embedded_test.go index fda2ce4dc..cd085e322 100644 --- a/cmd/bd/graph_embedded_test.go +++ b/cmd/bd/graph_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -18,11 +19,13 @@ func bdGraph(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd graph %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd graph %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func TestEmbeddedGraph(t *testing.T) { @@ -106,12 +109,14 @@ func TestEmbeddedGraph(t *testing.T) { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("graph --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("graph --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(out), epic.ID) { - t.Errorf("expected epic ID in JSON output: %s", out) + if !strings.Contains(stdout.String(), epic.ID) { + t.Errorf("expected epic ID in JSON output: %s", stdout.String()) } }) diff --git a/cmd/bd/history_embedded_test.go b/cmd/bd/history_embedded_test.go index 5c7a52f45..f719ca374 100644 --- a/cmd/bd/history_embedded_test.go +++ b/cmd/bd/history_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdHistory(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd history %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd history %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdHistoryFail runs "bd history" expecting failure. @@ -47,11 +50,13 @@ func bdHistoryJSON(t *testing.T, bd, dir string, args ...string) []map[string]in cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd history --json %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd history --json %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "[") if start < 0 { return nil @@ -175,11 +180,13 @@ func TestEmbeddedHistory(t *testing.T) { cmd := exec.Command(bd, "history", "--json", "hi-nonexistent999") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd history --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd history --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) var entries []map[string]interface{} if err := json.Unmarshal([]byte(s), &entries); err != nil { t.Fatalf("expected valid JSON for empty history, got prose:\n%s\n(parse error: %v)", s, err) @@ -196,11 +203,13 @@ func TestEmbeddedHistory(t *testing.T) { cmd := exec.Command(bd, "history", "--json", "--limit", "2", "hi-nonexistent999") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd history --json --limit 2 failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd history --json --limit 2 failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) var entries []map[string]interface{} if err := json.Unmarshal([]byte(s), &entries); err != nil { t.Fatalf("expected valid JSON for empty history with --limit, got prose:\n%s\n(parse error: %v)", s, err) diff --git a/cmd/bd/hooks_embedded_test.go b/cmd/bd/hooks_embedded_test.go index 657b5b593..6a08ccb6f 100644 --- a/cmd/bd/hooks_embedded_test.go +++ b/cmd/bd/hooks_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -18,11 +19,13 @@ func bdHooks(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd hooks %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd hooks %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func TestEmbeddedHooks(t *testing.T) { diff --git a/cmd/bd/human_embedded_test.go b/cmd/bd/human_embedded_test.go index 180417d63..633ac345b 100644 --- a/cmd/bd/human_embedded_test.go +++ b/cmd/bd/human_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -18,11 +19,13 @@ func bdHuman(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd human %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd human %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func TestEmbeddedHuman(t *testing.T) { diff --git a/cmd/bd/import_embedded_test.go b/cmd/bd/import_embedded_test.go index 121fe0a8f..0991bf348 100644 --- a/cmd/bd/import_embedded_test.go +++ b/cmd/bd/import_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -23,11 +24,13 @@ func bdImport(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd import %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd import %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // writeJSONLFile writes issues as JSONL to the given path. @@ -174,12 +177,14 @@ func TestEmbeddedImport(t *testing.T) { showCmd := exec.Command(bd, "show", id, "--json") showCmd.Dir = dir showCmd.Env = bdEnv(dir) - showOut, err := showCmd.CombinedOutput() - if err != nil { - t.Fatalf("bd show %s failed: %v\n%s", id, err, showOut) + var stdout, stderr bytes.Buffer + showCmd.Stdout = &stdout + showCmd.Stderr = &stderr + if err := showCmd.Run(); err != nil { + t.Fatalf("bd show %s failed: %v\nstdout:\n%s\nstderr:\n%s", id, err, stdout.String(), stderr.String()) } - if !strings.Contains(string(showOut), "Updated Title") { - t.Errorf("expected 'Updated Title' after upsert, got: %s", showOut) + if !strings.Contains(stdout.String(), "Updated Title") { + t.Errorf("expected 'Updated Title' after upsert, got: %s", stdout.String()) } }) } diff --git a/cmd/bd/info_embedded_test.go b/cmd/bd/info_embedded_test.go index 56030a52a..75753cd20 100644 --- a/cmd/bd/info_embedded_test.go +++ b/cmd/bd/info_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -18,11 +19,13 @@ func bdInfo(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd info %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd info %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func TestEmbeddedInfo(t *testing.T) { diff --git a/cmd/bd/init_embedded_test.go b/cmd/bd/init_embedded_test.go index 456f0848b..2f7988be6 100644 --- a/cmd/bd/init_embedded_test.go +++ b/cmd/bd/init_embedded_test.go @@ -144,11 +144,13 @@ func runBDInit(t *testing.T, bd, dir string, extraArgs ...string) string { cmd := exec.Command(bd, args...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd init %s failed: %v\n%s", strings.Join(extraArgs, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd init %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(extraArgs, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdInitFail runs bd init --quiet expecting failure. Returns combined output. @@ -325,12 +327,14 @@ func TestEmbeddedInit(t *testing.T) { cmd := exec.Command(bd, "init", "--prefix", "nq") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd init failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd init failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(out), "bd initialized successfully") { - t.Errorf("expected success message, got: %s", out) + if !strings.Contains(stdout.String(), "bd initialized successfully") { + t.Errorf("expected success message, got: %s", stdout.String()) } }) @@ -472,12 +476,14 @@ func TestEmbeddedInit(t *testing.T) { cmd = exec.Command(bd, "list") cmd.Dir = cloneDir cmd.Env = bdEnv(cloneDir) - listOut, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd list failed: %v\n%s", err, listOut) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd list failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(listOut), "Remote issue") { - t.Fatalf("cloned database missing remote issue:\n%s", listOut) + if !strings.Contains(stdout.String(), "Remote issue") { + t.Fatalf("cloned database missing remote issue:\n%s", stdout.String()) } cloneBeadsDir := filepath.Join(cloneDir, ".beads") @@ -708,12 +714,14 @@ func TestEmbeddedInit(t *testing.T) { } logCmd := exec.Command("git", "log", "--oneline", "-n", "1") logCmd.Dir = dir - logOut, err := logCmd.CombinedOutput() - if err != nil { - t.Fatalf("git log failed: %v\n%s", err, logOut) + var stdout, stderr bytes.Buffer + logCmd.Stdout = &stdout + logCmd.Stderr = &stderr + if err := logCmd.Run(); err != nil { + t.Fatalf("git log failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(logOut), "bd init: initialize beads issue tracking") { - t.Fatalf("expected init commit to succeed, got log: %s", logOut) + if !strings.Contains(stdout.String(), "bd init: initialize beads issue tracking") { + t.Fatalf("expected init commit to succeed, got log: %s", stdout.String()) } }) @@ -750,21 +758,26 @@ func TestEmbeddedInit(t *testing.T) { cmd := exec.Command(bd, "init", "--prefix", "jl", "--from-jsonl", "--quiet") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("--from-jsonl should succeed now that CreateIssuesWithFullOptions is implemented: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("--from-jsonl should succeed now that CreateIssuesWithFullOptions is implemented: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } if _, err := os.Stat(filepath.Join(dir, ".hook-ran")); err == nil { t.Fatal("expected --from-jsonl auto-commit to bypass git hooks") } logCmd := exec.Command("git", "log", "--oneline", "-n", "1") logCmd.Dir = dir - logOut, err := logCmd.CombinedOutput() - if err != nil { - t.Fatalf("git log failed: %v\n%s", err, logOut) + stdout.Reset() + stderr.Reset() + logCmd.Stdout = &stdout + logCmd.Stderr = &stderr + if err := logCmd.Run(); err != nil { + t.Fatalf("git log failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(logOut), "bd init: initialize beads issue tracking") { - t.Fatalf("expected init commit to succeed, got log: %s", logOut) + if !strings.Contains(stdout.String(), "bd init: initialize beads issue tracking") { + t.Fatalf("expected init commit to succeed, got log: %s", stdout.String()) } }) diff --git a/cmd/bd/kv_embedded_test.go b/cmd/bd/kv_embedded_test.go index 4954131c9..d8ce28b37 100644 --- a/cmd/bd/kv_embedded_test.go +++ b/cmd/bd/kv_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdKV(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd kv %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd kv %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdKVFail runs "bd kv" expecting failure. @@ -46,11 +49,13 @@ func bdKVListJSON(t *testing.T, bd, dir string) map[string]string { cmd := exec.Command(bd, "kv", "list", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd kv list --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd kv list --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { return map[string]string{} diff --git a/cmd/bd/label_embedded_test.go b/cmd/bd/label_embedded_test.go index edb567837..7c422e839 100644 --- a/cmd/bd/label_embedded_test.go +++ b/cmd/bd/label_embedded_test.go @@ -20,11 +20,13 @@ func bdLabel(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd label %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd label %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func bdLabelJSONOutput(t *testing.T, bd, dir string, args ...string) string { @@ -67,7 +69,7 @@ func bdLabelListJSON(t *testing.T, bd, dir, issueID string) []string { } var labels []string if err := json.Unmarshal([]byte(s[start:]), &labels); err != nil { - t.Fatalf("parse label list JSON: %v\n%s", err, s) + t.Fatalf("parse label list JSON: %v\nstdout: %s", err, s) } return labels } @@ -82,7 +84,7 @@ func bdLabelListAllJSON(t *testing.T, bd, dir string) []map[string]interface{} { } var results []map[string]interface{} if err := json.Unmarshal([]byte(s[start:]), &results); err != nil { - t.Fatalf("parse label list-all JSON: %v\n%s", err, s) + t.Fatalf("parse label list-all JSON: %v\nstdout: %s", err, s) } return results } @@ -192,10 +194,19 @@ func TestEmbeddedLabel(t *testing.T) { t.Run("label_remove_json", func(t *testing.T) { issue := bdCreate(t, bd, dir, "JSON rm label", "--type", "task", "--label", "jsonrm") - s := strings.TrimSpace(bdLabelJSONOutput(t, bd, dir, "remove", issue.ID, "jsonrm", "--json")) + cmd := exec.Command(bd, "label", "remove", issue.ID, "jsonrm", "--json") + cmd.Dir = dir + cmd.Env = bdEnv(dir) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd label remove --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) + } + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "[") if start < 0 { - t.Fatalf("no JSON array in output: %s", s) + t.Fatalf("no JSON array in output:\nstdout: %s\nstderr: %s", s, stderr.String()) } if !json.Valid([]byte(s[start:])) { t.Errorf("expected valid JSON: %s", s) diff --git a/cmd/bd/lint_embedded_test.go b/cmd/bd/lint_embedded_test.go index e37f40e18..f41ff2e91 100644 --- a/cmd/bd/lint_embedded_test.go +++ b/cmd/bd/lint_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -36,21 +37,24 @@ func bdLintJSON(t *testing.T, bd, dir string, args ...string) map[string]interfa cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + err := cmd.Run() // lint exits 1 on warnings even with --json, so ignore exit error if err != nil { if _, ok := err.(*exec.ExitError); !ok { - t.Fatalf("bd lint --json %s failed: %v\n%s", strings.Join(args, " "), err, out) + t.Fatalf("bd lint --json %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { - t.Fatalf("no JSON object in lint output: %s", s) + t.Fatalf("no JSON object in lint output:\nstdout: %s\nstderr: %s", s, stderr.String()) } var m map[string]interface{} if err := json.Unmarshal([]byte(s[start:]), &m); err != nil { - t.Fatalf("parse lint JSON: %v\n%s", err, s) + t.Fatalf("parse lint JSON: %v\nstdout: %s", err, s) } return m } diff --git a/cmd/bd/list_embedded_test.go b/cmd/bd/list_embedded_test.go index da878e737..2cdc43630 100644 --- a/cmd/bd/list_embedded_test.go +++ b/cmd/bd/list_embedded_test.go @@ -23,11 +23,13 @@ func bdList(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd list %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd list %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdListJSON runs "bd list --json" and parses the result as an array of IssueWithCounts. diff --git a/cmd/bd/memory_embedded_test.go b/cmd/bd/memory_embedded_test.go index 93e7fcdc0..78e15b29e 100644 --- a/cmd/bd/memory_embedded_test.go +++ b/cmd/bd/memory_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -18,11 +19,13 @@ func bdRemember(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd remember %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd remember %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdRememberFail runs "bd remember" expecting failure. @@ -46,11 +49,13 @@ func bdRecall(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd recall %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd recall %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdRecallFail runs "bd recall" expecting failure. @@ -74,11 +79,13 @@ func bdMemories(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd memories %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd memories %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdForget runs "bd forget" with the given args and returns stdout. @@ -88,11 +95,13 @@ func bdForget(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd forget %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd forget %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdForgetFail runs "bd forget" expecting failure. diff --git a/cmd/bd/migrate_embedded_test.go b/cmd/bd/migrate_embedded_test.go index c8b1ce58d..8af9cbf46 100644 --- a/cmd/bd/migrate_embedded_test.go +++ b/cmd/bd/migrate_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdMigrate(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd migrate %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd migrate %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdMigrateFail runs "bd migrate" expecting failure. diff --git a/cmd/bd/onboard_embedded_test.go b/cmd/bd/onboard_embedded_test.go index 0b4f83b4c..09eaa8883 100644 --- a/cmd/bd/onboard_embedded_test.go +++ b/cmd/bd/onboard_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -24,15 +25,17 @@ func TestEmbeddedOnboard(t *testing.T) { cmd := exec.Command(bd, "onboard") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd onboard failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd onboard failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if len(strings.TrimSpace(string(out))) == 0 { + if len(strings.TrimSpace(stdout.String())) == 0 { t.Error("expected non-empty onboard output") } - if !strings.Contains(string(out), "prime") && !strings.Contains(string(out), "bd") { - t.Errorf("expected 'prime' or 'bd' in onboard output: %s", out) + if !strings.Contains(stdout.String(), "prime") && !strings.Contains(stdout.String(), "bd") { + t.Errorf("expected 'prime' or 'bd' in onboard output: %s", stdout.String()) } }) } diff --git a/cmd/bd/orphans_embedded_test.go b/cmd/bd/orphans_embedded_test.go index 688280364..d50973992 100644 --- a/cmd/bd/orphans_embedded_test.go +++ b/cmd/bd/orphans_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdOrphans(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd orphans %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd orphans %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func TestEmbeddedOrphans(t *testing.T) { diff --git a/cmd/bd/prime_embedded_test.go b/cmd/bd/prime_embedded_test.go index d1fefba87..b1c82cf05 100644 --- a/cmd/bd/prime_embedded_test.go +++ b/cmd/bd/prime_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -18,11 +19,13 @@ func bdPrime(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd prime %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd prime %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func TestEmbeddedPrime(t *testing.T) { @@ -72,9 +75,11 @@ func TestEmbeddedPrime(t *testing.T) { cmd := exec.Command(bd, "remember", "always use -race flag in tests", "--key", "prime-test-mem") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd remember failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd remember failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } // Prime should include the memory diff --git a/cmd/bd/promote_embedded_test.go b/cmd/bd/promote_embedded_test.go index f45b3b045..a5a94d7fc 100644 --- a/cmd/bd/promote_embedded_test.go +++ b/cmd/bd/promote_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdPromote(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd promote %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd promote %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdPromoteFail runs "bd promote" expecting failure. @@ -95,11 +98,13 @@ func TestEmbeddedPromoteCLI(t *testing.T) { cmd := exec.Command(bd, "promote", issue.ID, "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd promote --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd promote --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { t.Fatalf("no JSON object in output: %s", s) diff --git a/cmd/bd/prune_embedded_test.go b/cmd/bd/prune_embedded_test.go index 5f200ee7a..c7c6b8549 100644 --- a/cmd/bd/prune_embedded_test.go +++ b/cmd/bd/prune_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "os" "os/exec" "strings" @@ -16,11 +17,13 @@ func bdPrune(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd prune %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd prune %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdPruneFail runs "bd prune" expecting failure and returns combined output. diff --git a/cmd/bd/purge_embedded_test.go b/cmd/bd/purge_embedded_test.go index 926bde597..210d20b35 100644 --- a/cmd/bd/purge_embedded_test.go +++ b/cmd/bd/purge_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -18,11 +19,13 @@ func bdPurge(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd purge %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd purge %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdPurgeFail runs "bd purge" expecting failure. diff --git a/cmd/bd/query_embedded_test.go b/cmd/bd/query_embedded_test.go index 2e5e8b4fd..a11adff68 100644 --- a/cmd/bd/query_embedded_test.go +++ b/cmd/bd/query_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdQuery(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd query %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd query %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdQueryJSON runs "bd query --json" and returns parsed results. @@ -33,11 +36,13 @@ func bdQueryJSON(t *testing.T, bd, dir string, args ...string) []map[string]inte cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd query --json %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd query --json %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "[") if start < 0 { return nil diff --git a/cmd/bd/quickstart_embedded_test.go b/cmd/bd/quickstart_embedded_test.go index 23183419c..dc1355f29 100644 --- a/cmd/bd/quickstart_embedded_test.go +++ b/cmd/bd/quickstart_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -24,11 +25,13 @@ func TestEmbeddedQuickstart(t *testing.T) { cmd := exec.Command(bd, "quickstart") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd quickstart failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd quickstart failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if len(strings.TrimSpace(string(out))) == 0 { + if len(strings.TrimSpace(stdout.String())) == 0 { t.Error("expected non-empty quickstart output") } }) diff --git a/cmd/bd/ready_embedded_test.go b/cmd/bd/ready_embedded_test.go index 3af710d11..e3ce3d3b4 100644 --- a/cmd/bd/ready_embedded_test.go +++ b/cmd/bd/ready_embedded_test.go @@ -32,12 +32,14 @@ func TestEmbeddedReady(t *testing.T) { cmd := exec.Command(bd, "ready") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd ready failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd ready failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(out), "Ready test issue") { - t.Errorf("expected issue in ready output: %s", out) + if !strings.Contains(stdout.String(), "Ready test issue") { + t.Errorf("expected issue in ready output: %s", stdout.String()) } }) @@ -47,11 +49,13 @@ func TestEmbeddedReady(t *testing.T) { cmd := exec.Command(bd, "ready", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd ready --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd ready --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.IndexAny(s, "[{") if start < 0 { t.Fatalf("no JSON in ready --json output: %s", s) @@ -89,13 +93,15 @@ func TestEmbeddedReady(t *testing.T) { cmd := exec.Command(bd, "ready", "--claim", "--json", "--label", "missing-label") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd ready --claim --json with no matches failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd ready --claim --json with no matches failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } var empty []types.IssueWithCounts - if err := json.Unmarshal(bytes.TrimSpace(out), &empty); err != nil { - t.Fatalf("parse empty claim JSON: %v\n%s", err, out) + if err := json.Unmarshal(bytes.TrimSpace(stdout.Bytes()), &empty); err != nil { + t.Fatalf("parse empty claim JSON: %v\n%s", err, stdout.String()) } if len(empty) != 0 { t.Fatalf("expected no claimed issues for unmatched label, got %d", len(empty)) @@ -104,16 +110,19 @@ func TestEmbeddedReady(t *testing.T) { cmd = exec.Command(bd, "ready", "--claim", "--json", "--label", "ready-claim-json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err = cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd ready --claim --json failed: %v\n%s", err, out) + stdout.Reset() + stderr.Reset() + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd ready --claim --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } var claimed []types.IssueWithCounts - if err := json.Unmarshal(bytes.TrimSpace(out), &claimed); err != nil { - t.Fatalf("parse claim JSON: %v\n%s", err, out) + if err := json.Unmarshal(bytes.TrimSpace(stdout.Bytes()), &claimed); err != nil { + t.Fatalf("parse claim JSON: %v\n%s", err, stdout.String()) } if len(claimed) != 1 { - t.Fatalf("expected one claimed issue, got %d: %s", len(claimed), out) + t.Fatalf("expected one claimed issue, got %d: %s", len(claimed), stdout.String()) } if claimed[0].ID != issue.ID { t.Fatalf("claimed ID = %s, want %s", claimed[0].ID, issue.ID) @@ -143,13 +152,15 @@ func TestEmbeddedReady(t *testing.T) { cmd = exec.Command(bd, "ready") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd ready failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd ready failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } // The blocked issue should not appear in ready output - if strings.Contains(string(out), "Blocked by blocker") { - t.Errorf("blocked issue should not appear in ready output: %s", out) + if strings.Contains(stdout.String(), "Blocked by blocker") { + t.Errorf("blocked issue should not appear in ready output: %s", stdout.String()) } }) @@ -162,15 +173,17 @@ func TestEmbeddedReady(t *testing.T) { cmd := exec.Command(bd, "ready", "--exclude-label", "triage:pending") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd ready --exclude-label failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd ready --exclude-label failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if strings.Contains(string(out), "Triage pending item") { - t.Errorf("triage:pending issue should not appear with --exclude-label: %s", out) + if strings.Contains(stdout.String(), "Triage pending item") { + t.Errorf("triage:pending issue should not appear with --exclude-label: %s", stdout.String()) } - if !strings.Contains(string(out), "Normal ready item") { - t.Errorf("normal issue should still appear with --exclude-label: %s", out) + if !strings.Contains(stdout.String(), "Normal ready item") { + t.Errorf("normal issue should still appear with --exclude-label: %s", stdout.String()) } }) @@ -182,12 +195,14 @@ func TestEmbeddedReady(t *testing.T) { cmd := exec.Command(bd, "-C", dir, "ready") cmd.Dir = tmpDir // Run from a directory with no .beads/ cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd -C %s ready failed: %v\n%s", dir, err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd -C %s ready failed: %v\nstdout:\n%s\nstderr:\n%s", dir, err, stdout.String(), stderr.String()) } - if !strings.Contains(string(out), "Ready test issue") { - t.Errorf("expected issue in ready -C output: %s", out) + if !strings.Contains(stdout.String(), "Ready test issue") { + t.Errorf("expected issue in ready -C output: %s", stdout.String()) } }) diff --git a/cmd/bd/rename_prefix_embedded_test.go b/cmd/bd/rename_prefix_embedded_test.go index 66b7f5740..c58d2b45d 100644 --- a/cmd/bd/rename_prefix_embedded_test.go +++ b/cmd/bd/rename_prefix_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -18,11 +19,13 @@ func bdRenamePrefix(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd rename-prefix %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd rename-prefix %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdRenamePrefixFail runs "bd rename-prefix" expecting failure. @@ -63,15 +66,17 @@ func TestEmbeddedRenamePrefix(t *testing.T) { cmd := exec.Command(bd, "list") cmd.Dir = dir cmd.Env = bdEnv(dir) - listOut, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd list after rename failed: %v\n%s", err, listOut) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd list after rename failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(listOut), "new-") { - t.Errorf("expected 'new-' prefix in list output: %s", listOut) + if !strings.Contains(stdout.String(), "new-") { + t.Errorf("expected 'new-' prefix in list output: %s", stdout.String()) } - if strings.Contains(string(listOut), "old-") { - t.Errorf("unexpected 'old-' prefix still in list output: %s", listOut) + if strings.Contains(stdout.String(), "old-") { + t.Errorf("unexpected 'old-' prefix still in list output: %s", stdout.String()) } }) @@ -90,12 +95,14 @@ func TestEmbeddedRenamePrefix(t *testing.T) { cmd := exec.Command(bd, "list") cmd.Dir = dir cmd.Env = bdEnv(dir) - listOut, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd list after dry-run rename failed: %v\n%s", err, listOut) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd list after dry-run rename failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if strings.Contains(string(listOut), "xx-") { - t.Errorf("dry-run should not have changed prefix: %s", listOut) + if strings.Contains(stdout.String(), "xx-") { + t.Errorf("dry-run should not have changed prefix: %s", stdout.String()) } }) diff --git a/cmd/bd/reopen_embedded_test.go b/cmd/bd/reopen_embedded_test.go index 472a9f26a..7061fc81a 100644 --- a/cmd/bd/reopen_embedded_test.go +++ b/cmd/bd/reopen_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -20,11 +21,13 @@ func bdReopen(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd reopen %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd reopen %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func TestEmbeddedReopen(t *testing.T) { @@ -105,11 +108,13 @@ func TestEmbeddedReopen(t *testing.T) { cmd := exec.Command(bd, "reopen", issue.ID, "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd reopen --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd reopen --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "[") if start < 0 { start = strings.Index(s, "{") diff --git a/cmd/bd/restore_embedded_test.go b/cmd/bd/restore_embedded_test.go index 623734cdd..e385e508f 100644 --- a/cmd/bd/restore_embedded_test.go +++ b/cmd/bd/restore_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "context" "fmt" "os" @@ -22,11 +23,13 @@ func bdRestore(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd restore %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd restore %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdRestoreFail runs "bd restore" expecting failure. diff --git a/cmd/bd/search_embedded_test.go b/cmd/bd/search_embedded_test.go index e45aa9689..dc9632a92 100644 --- a/cmd/bd/search_embedded_test.go +++ b/cmd/bd/search_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdSearch(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd search %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd search %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdSearchJSON runs "bd search --json" and returns parsed results. @@ -33,11 +36,13 @@ func bdSearchJSON(t *testing.T, bd, dir string, args ...string) []map[string]int cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd search --json %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd search --json %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "[") if start < 0 { // No results — empty array diff --git a/cmd/bd/setup_embedded_test.go b/cmd/bd/setup_embedded_test.go index 2a56b96cd..56e426548 100644 --- a/cmd/bd/setup_embedded_test.go +++ b/cmd/bd/setup_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -18,11 +19,13 @@ func bdSetup(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd setup %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd setup %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func TestEmbeddedSetup(t *testing.T) { diff --git a/cmd/bd/ship_embedded_test.go b/cmd/bd/ship_embedded_test.go index 26eb2d8a4..7ea42b318 100644 --- a/cmd/bd/ship_embedded_test.go +++ b/cmd/bd/ship_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -18,11 +19,13 @@ func bdShip(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd ship %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd ship %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdShipFail runs "bd ship" expecting failure. diff --git a/cmd/bd/show_embedded_test.go b/cmd/bd/show_embedded_test.go index 4b0b6e113..bb071ff1b 100644 --- a/cmd/bd/show_embedded_test.go +++ b/cmd/bd/show_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -307,12 +308,14 @@ func TestEmbeddedShow(t *testing.T) { cmd := exec.Command(bd, "view", issue.ID, "--short") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd view failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd view failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(out), issue.ID) { - t.Errorf("expected ID in view alias output: %s", out) + if !strings.Contains(stdout.String(), issue.ID) { + t.Errorf("expected ID in view alias output: %s", stdout.String()) } }) diff --git a/cmd/bd/stale_embedded_test.go b/cmd/bd/stale_embedded_test.go index 415a0d89c..dad6c0934 100644 --- a/cmd/bd/stale_embedded_test.go +++ b/cmd/bd/stale_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -21,11 +22,13 @@ func bdStale(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd stale %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd stale %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdStaleFail runs "bd stale" expecting failure. @@ -49,11 +52,13 @@ func bdStaleJSON(t *testing.T, bd, dir string, args ...string) []map[string]inte cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd stale --json %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd stale --json %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "[") if start < 0 { t.Fatalf("no JSON array in stale output: %s", s) diff --git a/cmd/bd/state_embedded_test.go b/cmd/bd/state_embedded_test.go index 2fc62d620..3c3ab6ce8 100644 --- a/cmd/bd/state_embedded_test.go +++ b/cmd/bd/state_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdState(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd state %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd state %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdSetState runs "bd set-state" with the given args and returns stdout. @@ -33,11 +36,13 @@ func bdSetState(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd set-state %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd set-state %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func TestEmbeddedState(t *testing.T) { @@ -64,11 +69,13 @@ func TestEmbeddedState(t *testing.T) { cmd := exec.Command(bd, "set-state", issue.ID, "env=staging", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd set-state --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd set-state --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start >= 0 { var m map[string]interface{} @@ -106,11 +113,13 @@ func TestEmbeddedState(t *testing.T) { cmd := exec.Command(bd, "state", issue.ID, "phase", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd state --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd state --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - _ = out + _ = stdout.String() }) t.Run("state_query_nonexistent_dimension", func(t *testing.T) { @@ -133,11 +142,13 @@ func TestEmbeddedState(t *testing.T) { cmd := exec.Command(bd, "state", "list", issue.ID, "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd state list --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd state list --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - _ = out + _ = stdout.String() }) t.Run("state_list_no_dimensions", func(t *testing.T) { diff --git a/cmd/bd/status_embedded_test.go b/cmd/bd/status_embedded_test.go index 698f6a988..553d562ed 100644 --- a/cmd/bd/status_embedded_test.go +++ b/cmd/bd/status_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdStatus(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd status %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd status %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdStatusJSON runs "bd status --json" and parses the result. @@ -33,11 +36,13 @@ func bdStatusJSON(t *testing.T, bd, dir string, args ...string) map[string]inter cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd status --json %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd status --json %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { t.Fatalf("no JSON object in status output: %s", s) @@ -129,12 +134,14 @@ func TestEmbeddedStatus(t *testing.T) { cmd := exec.Command(bd, args...) cmd.Dir = dir cmd.Env = env - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd status --assigned --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd status --assigned --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { t.Fatalf("no JSON: %s", s) @@ -183,12 +190,14 @@ func TestEmbeddedStatus(t *testing.T) { cmd := exec.Command(bd, "stats", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd stats alias failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd stats alias failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - if !strings.Contains(string(out), "summary") { - t.Errorf("expected 'summary' in stats alias output: %s", out) + if !strings.Contains(stdout.String(), "summary") { + t.Errorf("expected 'summary' in stats alias output: %s", stdout.String()) } }) @@ -254,15 +263,17 @@ func TestEmbeddedStatusConcurrent(t *testing.T) { cmd := exec.Command(bd, args...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - r.err = fmt.Errorf("worker %d status: %v\n%s", worker, err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + r.err = fmt.Errorf("worker %d status: %v\nstdout:\n%s\nstderr:\n%s", worker, err, stdout.String(), stderr.String()) results[worker] = r return } // Verify JSON parses - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { r.err = fmt.Errorf("worker %d: no JSON: %s", worker, s) diff --git a/cmd/bd/supersede_embedded_test.go b/cmd/bd/supersede_embedded_test.go index bae0fac8d..ea53b58d1 100644 --- a/cmd/bd/supersede_embedded_test.go +++ b/cmd/bd/supersede_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdSupersede(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd supersede %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd supersede %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdSupersedeFail runs "bd supersede" expecting failure. @@ -99,11 +102,13 @@ func TestEmbeddedSupersede(t *testing.T) { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("supersede --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("supersede --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { t.Fatalf("no JSON: %s", s) diff --git a/cmd/bd/todo_embedded_test.go b/cmd/bd/todo_embedded_test.go index aa77bc073..7821e2924 100644 --- a/cmd/bd/todo_embedded_test.go +++ b/cmd/bd/todo_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdTodo(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd todo %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd todo %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func TestEmbeddedTodo(t *testing.T) { @@ -51,11 +54,13 @@ func TestEmbeddedTodo(t *testing.T) { cmd := exec.Command(bd, "todo", "add", "JSON todo", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd todo add --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd todo add --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { t.Fatalf("no JSON in output: %s", s) @@ -100,11 +105,13 @@ func TestEmbeddedTodo(t *testing.T) { cmd := exec.Command(bd, "todo", "list", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd todo list --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd todo list --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "[") if start < 0 { t.Fatalf("no JSON array in output: %s", s) @@ -125,11 +132,13 @@ func TestEmbeddedTodo(t *testing.T) { cmd := exec.Command(bd, "todo", "add", "Done test", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd todo add failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd todo add failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") var m map[string]interface{} json.Unmarshal([]byte(s[start:]), &m) @@ -146,17 +155,41 @@ func TestEmbeddedTodo(t *testing.T) { cmd1 := exec.Command(bd, "todo", "add", "Multi done 1", "--json") cmd1.Dir = dir cmd1.Env = bdEnv(dir) - out1, _ := cmd1.CombinedOutput() + var stdout1, stderr1 bytes.Buffer + cmd1.Stdout = &stdout1 + cmd1.Stderr = &stderr1 + if err := cmd1.Run(); err != nil { + t.Fatalf("bd todo add Multi done 1 --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout1.String(), stderr1.String()) + } + s1 := strings.TrimSpace(stdout1.String()) + start1 := strings.Index(s1, "{") + if start1 < 0 { + t.Fatalf("no JSON in todo add output:\nstdout: %s\nstderr: %s", s1, stderr1.String()) + } var m1 map[string]interface{} - json.Unmarshal([]byte(strings.TrimSpace(string(out1))[strings.Index(strings.TrimSpace(string(out1)), "{"):]), &m1) + if err := json.Unmarshal([]byte(s1[start1:]), &m1); err != nil { + t.Fatalf("parse todo add JSON: %v\nstdout: %s", err, s1) + } id1 := m1["id"].(string) cmd2 := exec.Command(bd, "todo", "add", "Multi done 2", "--json") cmd2.Dir = dir cmd2.Env = bdEnv(dir) - out2, _ := cmd2.CombinedOutput() + var stdout2, stderr2 bytes.Buffer + cmd2.Stdout = &stdout2 + cmd2.Stderr = &stderr2 + if err := cmd2.Run(); err != nil { + t.Fatalf("bd todo add Multi done 2 --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout2.String(), stderr2.String()) + } + s2 := strings.TrimSpace(stdout2.String()) + start2 := strings.Index(s2, "{") + if start2 < 0 { + t.Fatalf("no JSON in todo add output:\nstdout: %s\nstderr: %s", s2, stderr2.String()) + } var m2 map[string]interface{} - json.Unmarshal([]byte(strings.TrimSpace(string(out2))[strings.Index(strings.TrimSpace(string(out2)), "{"):]), &m2) + if err := json.Unmarshal([]byte(s2[start2:]), &m2); err != nil { + t.Fatalf("parse todo add JSON: %v\nstdout: %s", err, s2) + } id2 := m2["id"].(string) bdTodo(t, bd, dir, "done", id1, id2) @@ -174,9 +207,21 @@ func TestEmbeddedTodo(t *testing.T) { cmd := exec.Command(bd, "todo", "add", "Reason done", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, _ := cmd.CombinedOutput() + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd todo add Reason done --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) + } + s := strings.TrimSpace(stdout.String()) + start := strings.Index(s, "{") + if start < 0 { + t.Fatalf("no JSON in todo add output:\nstdout: %s\nstderr: %s", s, stderr.String()) + } var m map[string]interface{} - json.Unmarshal([]byte(strings.TrimSpace(string(out))[strings.Index(strings.TrimSpace(string(out)), "{"):]), &m) + if err := json.Unmarshal([]byte(s[start:]), &m); err != nil { + t.Fatalf("parse todo add JSON: %v\nstdout: %s", err, s) + } id := m["id"].(string) bdTodo(t, bd, dir, "done", id, "--reason", "No longer needed") @@ -190,17 +235,31 @@ func TestEmbeddedTodo(t *testing.T) { cmd := exec.Command(bd, "todo", "add", "JSON done", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, _ := cmd.CombinedOutput() + var addStdout, addStderr bytes.Buffer + cmd.Stdout = &addStdout + cmd.Stderr = &addStderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd todo add JSON done --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, addStdout.String(), addStderr.String()) + } + s := strings.TrimSpace(addStdout.String()) + start := strings.Index(s, "{") + if start < 0 { + t.Fatalf("no JSON in todo add output:\nstdout: %s\nstderr: %s", s, addStderr.String()) + } var m map[string]interface{} - json.Unmarshal([]byte(strings.TrimSpace(string(out))[strings.Index(strings.TrimSpace(string(out)), "{"):]), &m) + if err := json.Unmarshal([]byte(s[start:]), &m); err != nil { + t.Fatalf("parse todo add JSON: %v\nstdout: %s", err, s) + } id := m["id"].(string) doneCmd := exec.Command(bd, "todo", "done", id, "--json") doneCmd.Dir = dir doneCmd.Env = bdEnv(dir) - doneOut, err := doneCmd.CombinedOutput() - if err != nil { - t.Fatalf("bd todo done --json failed: %v\n%s", err, doneOut) + var stdout, stderr bytes.Buffer + doneCmd.Stdout = &stdout + doneCmd.Stderr = &stderr + if err := doneCmd.Run(); err != nil { + t.Fatalf("bd todo done --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } }) @@ -210,11 +269,13 @@ func TestEmbeddedTodo(t *testing.T) { cmd := exec.Command(bd, "todo", "list", "--all", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd todo list --all --json failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd todo list --all --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "[") if start < 0 { t.Fatalf("no JSON array: %s", s) diff --git a/cmd/bd/types_embedded_test.go b/cmd/bd/types_embedded_test.go index 82c3338e6..f3e2112cf 100644 --- a/cmd/bd/types_embedded_test.go +++ b/cmd/bd/types_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdTypes(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd types %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd types %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdTypesJSON runs "bd types --json" and parses the result. @@ -33,11 +36,13 @@ func bdTypesJSON(t *testing.T, bd, dir string, args ...string) map[string]interf cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd types --json %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd types --json %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { t.Fatalf("no JSON object in types output: %s", s) @@ -139,9 +144,11 @@ func TestEmbeddedTypes(t *testing.T) { cmd := exec.Command(bd, "config", "set", "types.custom", "spike,research,ops") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd config set failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd config set failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } m := bdTypesJSON(t, bd, dir) @@ -206,16 +213,18 @@ func TestEmbeddedTypesConcurrent(t *testing.T) { cmd := exec.Command(bd, args...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - r.err = fmt.Errorf("worker %d types: %v\n%s", worker, err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + r.err = fmt.Errorf("worker %d types: %v\nstdout:\n%s\nstderr:\n%s", worker, err, stdout.String(), stderr.String()) results[worker] = r return } // For JSON workers, verify parse if worker%2 == 0 { - s := strings.TrimSpace(string(out)) + s := strings.TrimSpace(stdout.String()) start := strings.Index(s, "{") if start < 0 { r.err = fmt.Errorf("worker %d: no JSON: %s", worker, s) diff --git a/cmd/bd/update_embedded_test.go b/cmd/bd/update_embedded_test.go index c00fa1624..391b12d1f 100644 --- a/cmd/bd/update_embedded_test.go +++ b/cmd/bd/update_embedded_test.go @@ -52,11 +52,13 @@ func bdShowJSON(t *testing.T, bd, dir, id string) string { cmd := exec.Command(bd, "show", id, "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd show %s --json failed: %v\n%s", id, err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd show %s --json failed: %v\nstdout:\n%s\nstderr:\n%s", id, err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // hasLabel checks if a label is present in the issue's labels. @@ -746,8 +748,7 @@ func TestEmbeddedUpdate(t *testing.T) { var stdout, stderr bytes.Buffer cmd.Stdout = &stdout cmd.Stderr = &stderr - err := cmd.Run() - if err != nil { + if err := cmd.Run(); err != nil { t.Fatalf("bd update --json failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } s := stdout.String() diff --git a/cmd/bd/vc_embedded_test.go b/cmd/bd/vc_embedded_test.go index 2cb978d5a..0a5a86d75 100644 --- a/cmd/bd/vc_embedded_test.go +++ b/cmd/bd/vc_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdVC(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd vc %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd vc %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } // bdVCFail runs "bd vc" expecting failure. @@ -97,14 +100,16 @@ func TestEmbeddedVC(t *testing.T) { cmd := exec.Command(bd, "vc", "commit", "-m", "json commit", "--json") cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd vc commit --json failed unexpectedly: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd vc commit --json failed unexpectedly: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } // Verify valid JSON with committed field (true or false are both valid) var result map[string]interface{} - if jsonErr := json.Unmarshal(out, &result); jsonErr != nil { - t.Fatalf("failed to parse JSON: %v\n%s", jsonErr, out) + if jsonErr := json.Unmarshal(stdout.Bytes(), &result); jsonErr != nil { + t.Fatalf("failed to parse JSON: %v\n%s", jsonErr, stdout.String()) } if _, ok := result["committed"]; !ok { t.Error("expected 'committed' field in JSON output") diff --git a/cmd/bd/version_embedded_test.go b/cmd/bd/version_embedded_test.go index 735e9ddd0..ff455edeb 100644 --- a/cmd/bd/version_embedded_test.go +++ b/cmd/bd/version_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "fmt" "os" "os/exec" @@ -21,11 +22,13 @@ func TestEmbeddedVersion(t *testing.T) { t.Run("version_output", func(t *testing.T) { cmd := exec.Command(bd, "version") - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd version failed: %v\n%s", err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd version failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String()) } - s := string(out) + s := stdout.String() if len(strings.TrimSpace(s)) == 0 { t.Error("expected non-empty version output") } diff --git a/cmd/bd/where_embedded_test.go b/cmd/bd/where_embedded_test.go index a16e9651e..20bce23d6 100644 --- a/cmd/bd/where_embedded_test.go +++ b/cmd/bd/where_embedded_test.go @@ -3,6 +3,7 @@ package main import ( + "bytes" "encoding/json" "fmt" "os" @@ -19,11 +20,13 @@ func bdWhere(t *testing.T, bd, dir string, args ...string) string { cmd := exec.Command(bd, fullArgs...) cmd.Dir = dir cmd.Env = bdEnv(dir) - out, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("bd where %s failed: %v\n%s", strings.Join(args, " "), err, out) + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Fatalf("bd where %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String()) } - return string(out) + return stdout.String() } func bdWhereAllowError(t *testing.T, bd, dir string, args ...string) (string, error) {