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 <noreply@anthropic.com>
This commit is contained in:
Jim Wordelman 2026-05-16 12:30:25 -07:00
commit 88e13542e6
64 changed files with 1079 additions and 653 deletions

View file

@ -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.

View file

@ -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)

View file

@ -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())
}
})

View file

@ -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) {

View file

@ -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{}

View file

@ -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" {

View file

@ -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) {

View file

@ -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{}

View file

@ -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()
})
}

View file

@ -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)

View file

@ -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")
}
})

View file

@ -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).

View file

@ -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

View file

@ -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 {

View file

@ -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())
}
})

View file

@ -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.

View file

@ -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)

View file

@ -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)

View file

@ -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)

View file

@ -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) {

View file

@ -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.

View file

@ -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)

View file

@ -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())
}
})
}

View file

@ -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())
}
})

View file

@ -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.

View file

@ -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())
}
})

View file

@ -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)

View file

@ -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) {

View file

@ -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) {

View file

@ -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())
}
})
}

View file

@ -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) {

View file

@ -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())
}
})

View file

@ -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{}

View file

@ -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)

View file

@ -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
}

View file

@ -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.

View file

@ -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.

View file

@ -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.

View file

@ -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())
}
})
}

View file

@ -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) {

View file

@ -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

View file

@ -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)

View file

@ -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.

View file

@ -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.

View file

@ -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

View file

@ -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")
}
})

View file

@ -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())
}
})

View file

@ -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())
}
})

View file

@ -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, "{")

View file

@ -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.

View file

@ -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

View file

@ -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) {

View file

@ -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.

View file

@ -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())
}
})

View file

@ -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)

View file

@ -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) {

View file

@ -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)

View file

@ -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)

View file

@ -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)

View file

@ -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)

View file

@ -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()

View file

@ -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")

View file

@ -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")
}

View file

@ -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) {