beads/cmd/bd/status_embedded_test.go
Julian Knutsen d3554a4ffe
refactor(test): consolidate status presentation coverage (bd-gwzj8) (#5234)
Replace false-green direct Dolt status fixtures with pure presentation tests and retain two distinct embedded command-wiring proofs.

Agent-Signature: codex-unknown-model-unknown-reasoning on behalf of CI Bot
2026-08-01 06:34:26 -07:00

184 lines
5.6 KiB
Go

//go:build cgo
package main
import (
"encoding/json"
"fmt"
"os"
"os/exec"
"strings"
"sync"
"testing"
)
func TestEmbeddedStatus(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
t.Parallel()
bd := buildEmbeddedBD(t)
dir, _, _ := bdInit(t, bd, "--prefix", "ss")
bdCreate(t, bd, dir, "Status open 1", "--type", "task")
bdCreate(t, bd, dir, "Status open 2", "--type", "bug")
ip := bdCreate(t, bd, dir, "Status in_progress", "--type", "task", "--assignee", "alice")
bdUpdate(t, bd, dir, ip.ID, "--status", "in_progress")
closed := bdCreate(t, bd, dir, "Status closed", "--type", "task")
bdClose(t, bd, dir, closed.ID)
bdCreate(t, bd, dir, "Status assigned bob", "--type", "task", "--assignee", "bob")
runStatus := func(t *testing.T, env []string, actor string, args ...string) []byte {
t.Helper()
commandArgs := append([]string{"status"}, args...)
if actor != "" {
commandArgs = append([]string{"--actor", actor}, commandArgs...)
}
cmd := exec.Command(bd, commandArgs...)
cmd.Dir = dir
cmd.Env = env
stdout, stderr, err := runCommandBuffers(t, cmd)
if err != nil {
t.Fatalf("bd status %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), err, stdout.String(), stderr.String())
}
return stdout.Bytes()
}
assertCount := func(t *testing.T, name string, got, want int) {
t.Helper()
if got != want {
t.Errorf("%s = %d, want %d", name, got, want)
}
}
assertPointerCount := func(t *testing.T, name string, got *int, want int) {
t.Helper()
if got == nil {
t.Errorf("%s = nil, want %d", name, want)
return
}
assertCount(t, name, *got, want)
}
t.Run("known_counts_without_activity", func(t *testing.T) {
out := runStatus(t, bdEnv(dir), "", "--json", "--no-activity")
var got StatusOutput
if err := json.Unmarshal(out, &got); err != nil {
t.Fatalf("unmarshal status: %v\n%s", err, out)
}
if got.Summary == nil {
t.Fatalf("status summary is nil: %s", out)
}
assertCount(t, "total issues", got.Summary.TotalIssues, 5)
assertCount(t, "open issues", got.Summary.OpenIssues, 3)
assertCount(t, "in-progress issues", got.Summary.InProgressIssues, 1)
assertCount(t, "closed issues", got.Summary.ClosedIssues, 1)
assertCount(t, "deferred issues", got.Summary.DeferredIssues, 0)
assertPointerCount(t, "blocked issues", got.Summary.BlockedIssues, 0)
assertPointerCount(t, "ready issues", got.Summary.ReadyIssues, 3)
var envelope map[string]json.RawMessage
if err := json.Unmarshal(out, &envelope); err != nil {
t.Fatalf("unmarshal status envelope: %v", err)
}
if _, ok := envelope["recent_activity"]; ok {
t.Errorf("recent_activity present with --no-activity: %s", out)
}
})
t.Run("assigned_counts_without_activity", func(t *testing.T) {
out := runStatus(t, bdEnv(dir), "alice", "--assigned", "--json", "--no-activity")
var got StatusOutput
if err := json.Unmarshal(out, &got); err != nil {
t.Fatalf("unmarshal assigned status: %v\n%s", err, out)
}
if got.Summary == nil {
t.Fatalf("assigned status summary is nil: %s", out)
}
assertCount(t, "assigned total issues", got.Summary.TotalIssues, 1)
assertCount(t, "assigned open issues", got.Summary.OpenIssues, 0)
assertCount(t, "assigned in-progress issues", got.Summary.InProgressIssues, 1)
assertCount(t, "assigned closed issues", got.Summary.ClosedIssues, 0)
assertCount(t, "assigned deferred issues", got.Summary.DeferredIssues, 0)
assertPointerCount(t, "assigned blocked issues", got.Summary.BlockedIssues, 0)
assertPointerCount(t, "assigned ready issues", got.Summary.ReadyIssues, 1)
})
}
// TestEmbeddedStatusConcurrent exercises status operations concurrently.
func TestEmbeddedStatusConcurrent(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
t.Parallel()
bd := buildEmbeddedBD(t)
dir, _, _ := bdInit(t, bd, "--prefix", "ssc")
for i := 0; i < 10; i++ {
bdCreate(t, bd, dir, fmt.Sprintf("concurrent-status-%d", i), "--type", "task")
}
const numWorkers = 8
type workerResult struct {
worker int
err error
}
results := make([]workerResult, numWorkers)
var wg sync.WaitGroup
wg.Add(numWorkers)
for w := 0; w < numWorkers; w++ {
go func(worker int) {
defer wg.Done()
r := workerResult{worker: worker}
queries := [][]string{
{"--json"},
{"--json", "--no-activity"},
{"--json"},
{"--json", "--no-activity"},
{"--json"},
{"--json"},
{"--json", "--no-activity"},
{"--json"},
}
q := queries[worker%len(queries)]
args := append([]string{"status"}, q...)
cmd := exec.Command(bd, args...)
cmd.Dir = dir
cmd.Env = bdEnv(dir)
stdout, stderr, err := runCommandBuffers(t, cmd)
if 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(stdout.String())
start := strings.Index(s, "{")
if start < 0 {
r.err = fmt.Errorf("worker %d: no JSON: %s", worker, s)
results[worker] = r
return
}
var m map[string]interface{}
if err := json.Unmarshal([]byte(s[start:]), &m); err != nil {
r.err = fmt.Errorf("worker %d: JSON parse: %v", worker, err)
results[worker] = r
return
}
results[worker] = r
}(w)
}
wg.Wait()
for _, r := range results {
if r.err != nil && !strings.Contains(r.err.Error(), "one writer at a time") {
t.Errorf("worker %d failed: %v", r.worker, r.err)
}
}
}