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:
parent
d858810830
commit
88e13542e6
64 changed files with 1079 additions and 653 deletions
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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())
|
||||
}
|
||||
})
|
||||
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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{}
|
||||
|
|
|
|||
|
|
@ -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" {
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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{}
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
})
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
}
|
||||
})
|
||||
|
|
|
|||
|
|
@ -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).
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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())
|
||||
}
|
||||
})
|
||||
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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())
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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())
|
||||
}
|
||||
})
|
||||
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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())
|
||||
}
|
||||
})
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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())
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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())
|
||||
}
|
||||
})
|
||||
|
||||
|
|
|
|||
|
|
@ -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{}
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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())
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
}
|
||||
})
|
||||
|
|
|
|||
|
|
@ -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())
|
||||
}
|
||||
})
|
||||
|
||||
|
|
|
|||
|
|
@ -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())
|
||||
}
|
||||
})
|
||||
|
||||
|
|
|
|||
|
|
@ -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, "{")
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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())
|
||||
}
|
||||
})
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue