From 88e13542e6d4bd2bd807ab0b09786958e751e5cc Mon Sep 17 00:00:00 2001 From: Jim Wordelman Date: Sat, 16 May 2026 12:30:25 -0700 Subject: [PATCH] test(embedded): split stdout/stderr in all JSON-parsing helpers (be-0ya2oe) PR #3909 introduced an auto-export warning written to stderr. Tests that called CombinedOutput() and then parsed the result as JSON would choke on the warning text mixed into stdout. Apply the pattern already established in list_embedded_test.go: for every helper or inline call site that parses JSON or an ID from stdout, capture stdout and stderr in separate bytes.Buffers and parse only stdout. Covers 66 test files including duplicates, update, lint, todo, label, count, swarm, close, list, status, types, find-duplicates, and more. Closes TestEmbeddedDuplicates/dry_run and TestEmbeddedUpdate/update_json_output failures from CI run 25967558419 and 25962887732. Co-Authored-By: Claude Sonnet 4.6 --- cmd/bd/backup_embedded_test.go | 11 ++- cmd/bd/blocked_embedded_test.go | 33 ++++--- cmd/bd/bootstrap_embedded_test.go | 49 ++++++---- cmd/bd/branch_embedded_test.go | 11 ++- cmd/bd/children_embedded_test.go | 21 ++-- cmd/bd/close_embedded_test.go | 54 +++++++---- cmd/bd/comment_promote_embedded_test.go | 21 ++-- cmd/bd/comments_cli_embedded_test.go | 51 ++++++---- cmd/bd/compact_embedded_test.go | 21 ++-- cmd/bd/config_embedded_test.go | 21 ++-- cmd/bd/context_embedded_test.go | 23 +++-- cmd/bd/contributor_embedded_test.go | 9 +- cmd/bd/create_embedded_test.go | 31 +++--- cmd/bd/defer_embedded_test.go | 31 +++--- cmd/bd/dep_embedded_test.go | 55 ++++++----- cmd/bd/dolt_embedded_test.go | 11 ++- cmd/bd/duplicate_embedded_test.go | 21 ++-- cmd/bd/duplicates_embedded_test.go | 21 ++-- cmd/bd/epic_embedded_test.go | 31 +++--- cmd/bd/export_embedded_test.go | 11 ++- cmd/bd/federation_embedded_test.go | 11 ++- cmd/bd/find_duplicates_embedded_test.go | 43 +++++---- cmd/bd/flatten_embedded_test.go | 23 +++-- cmd/bd/gate_embedded_test.go | 88 ++++++++++------- cmd/bd/gc_embedded_test.go | 11 ++- cmd/bd/graph_embedded_test.go | 23 +++-- cmd/bd/history_embedded_test.go | 41 +++++--- cmd/bd/hooks_embedded_test.go | 11 ++- cmd/bd/human_embedded_test.go | 11 ++- cmd/bd/import_embedded_test.go | 23 +++-- cmd/bd/info_embedded_test.go | 11 ++- cmd/bd/init_embedded_test.go | 67 +++++++------ cmd/bd/kv_embedded_test.go | 21 ++-- cmd/bd/label_embedded_test.go | 27 ++++-- cmd/bd/lint_embedded_test.go | 14 ++- cmd/bd/list_embedded_test.go | 10 +- cmd/bd/memory_embedded_test.go | 41 +++++--- cmd/bd/migrate_embedded_test.go | 11 ++- cmd/bd/onboard_embedded_test.go | 15 +-- cmd/bd/orphans_embedded_test.go | 11 ++- cmd/bd/prime_embedded_test.go | 19 ++-- cmd/bd/promote_embedded_test.go | 21 ++-- cmd/bd/prune_embedded_test.go | 11 ++- cmd/bd/purge_embedded_test.go | 11 ++- cmd/bd/query_embedded_test.go | 21 ++-- cmd/bd/quickstart_embedded_test.go | 11 ++- cmd/bd/ready_embedded_test.go | 89 ++++++++++------- cmd/bd/rename_prefix_embedded_test.go | 39 +++++--- cmd/bd/reopen_embedded_test.go | 21 ++-- cmd/bd/restore_embedded_test.go | 11 ++- cmd/bd/search_embedded_test.go | 21 ++-- cmd/bd/setup_embedded_test.go | 11 ++- cmd/bd/ship_embedded_test.go | 11 ++- cmd/bd/show_embedded_test.go | 13 ++- cmd/bd/stale_embedded_test.go | 21 ++-- cmd/bd/state_embedded_test.go | 51 ++++++---- cmd/bd/status_embedded_test.go | 53 ++++++---- cmd/bd/supersede_embedded_test.go | 21 ++-- cmd/bd/todo_embedded_test.go | 123 ++++++++++++++++++------ cmd/bd/types_embedded_test.go | 39 +++++--- cmd/bd/update_embedded_test.go | 13 +-- cmd/bd/vc_embedded_test.go | 23 +++-- cmd/bd/version_embedded_test.go | 11 ++- cmd/bd/where_embedded_test.go | 11 ++- 64 files changed, 1076 insertions(+), 650 deletions(-) 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) {