beads/cmd/bd/show_test.go
Kevin Glynn 0d4b979354
feat: JSON schema contract, bd ping, structured errors, import enhancements (#3368)
* feat: add schema_version to all --json output (beads-5uh)

All bd commands that emit --json output now include a schema_version
field so consumers (Jawnt MCP, BeadsX, gt mail, sync scripts) can
detect format changes without silently breaking.

- Object output: schema_version injected as top-level field
- Array output: wrapped as {"schema_version": 1, "items": [...]}
- Error output: schema_version added to stderr JSON

Central implementation in outputJSON() via wrapWithSchemaVersion()
means all 272 call sites get the field automatically.

Includes:
- Unit tests for wrapping logic (object, struct, slice, nil, roundtrip)
- Updated protocol contract tests for new envelope format
- New schema_version presence test across list/ready/show
- docs/JSON_SCHEMA.md documenting the field contract per command

* feat: add ready/blocked JSON contract tests (beads-clt)

bd ready --json and bd blocked --json already return full issue objects
with dependency counts and blocked_by fields. Add protocol contract
tests to pin this behavior:

- TestJSONContract_ReadyOutputHasFullObjects: verifies dependency_count,
  dependent_count fields on ready items
- TestJSONContract_BlockedOutputHasBlockedBy: verifies blocked_by and
  blocked_by_count fields on blocked items

Update docs/JSON_SCHEMA.md with blocked output contract.

* feat: add bd ping lightweight health-check command (beads-8cc)

New minimal command that confirms bd can reach its database:
1. Resolves the .beads workspace
2. Opens the store (embedded or server)
3. Runs a trivial query (SearchIssues with Limit=1)
4. Reports timing breakdown

Supports --json for structured output with resolve_ms, store_ms,
query_ms, and total_ms fields. Exit 0 on success, 1 on failure.

Registered as read-only command (no auto-push, no file writes).
Includes protocol contract test for JSON output.

* feat: structured JSON errors on stderr when --json active (beads-06n)

All fatal error functions (FatalError, FatalErrorWithHint,
FatalErrorRespectJSON, FatalErrorWithHintRespectJSON) now emit
structured JSON with schema_version when --json is active:

  {"schema_version": 1, "error": "message", "hint": "optional"}

Centralized via jsonStderrError() and jsonStdoutError() helpers.
Replaces ad-hoc json.MarshalIndent calls scattered across error
functions with a consistent, schema-versioned format.

Includes unit tests and updated protocol contract test verifying
schema_version presence in error JSON output.

* feat: enhance bd import with stdin, --dedup, --json (beads-c6i)

Enhance the existing bd import command for bulk JSONL ingest:

- Stdin support: bd import - reads JSONL from stdin for piped workflows
- --dedup flag: skips lines whose title matches an existing open issue
  (case-insensitive) to prevent duplicate creation
- --json flag: structured output with created/skipped counts and IDs

Refactored import to use runImportFromReader() for unified file/stdin
handling. Added filterDuplicatesByTitle() for dedup logic. Updated
docs/JSON_SCHEMA.md with import output contract.

Backward compatible: existing bd import [file] and --dry-run work
exactly as before.

* fix: update tests for schema_version envelope in JSON output

Three test files expected raw JSON arrays or map[string]string, which
broke when schema_version (a number) was added to the output envelope:

- ado_test.go: parse envelope with items array instead of raw []json.RawMessage
- bootstrap_embedded_test.go: use map[string]interface{} for mixed types
- where_embedded_test.go: same map[string]interface{} fix

* fix: drop array envelope wrapping to fix 200+ test failures

The schema_version envelope was wrapping arrays as
{"schema_version": N, "items": [...]} which broke every integration
test that parses --json array output. Objects (show, create, ping)
still get schema_version injected. Arrays (list, ready, blocked)
now pass through unchanged for backwards compatibility.

Also fixes: gofmt on import.go, doc-flags reference to bd import,
uses importIssuesCore result to satisfy unparam lint.

* fix: update remaining tests for schema_version number field

config_embedded_test.go, kv_embedded_test.go, config_nodb_embedded_test.go,
and show_test.go all parsed JSON output into map[string]string but
schema_version is a number. Parse to map[string]interface{} and
skip/assert schema_version appropriately.

---------

Co-authored-by: kev <kglynn@pryoninc.com>
2026-04-20 21:09:48 -07:00

153 lines
4.6 KiB
Go

//go:build cgo && integration
package main
import (
"encoding/json"
"strings"
"testing"
)
func TestShow_ExternalRef(t *testing.T) {
if testing.Short() {
t.Skip("skipping CLI test in short mode")
}
tmpDir := setupCLITestDB(t)
// Create issue with external ref
out := runBDInProcess(t, tmpDir, "create", "External ref test", "-p", "1",
"--external-ref", "https://example.com/spec.md", "--json")
jsonStart := strings.Index(out, "{")
if jsonStart < 0 {
t.Fatalf("No JSON found in create output: %s", out)
}
var issue map[string]interface{}
if err := json.Unmarshal([]byte(out[jsonStart:]), &issue); err != nil {
t.Fatalf("failed to parse create output: %v, output: %s", err, out)
}
id := issue["id"].(string)
// Show the issue and verify external ref is displayed
showOut := runBDInProcess(t, tmpDir, "show", id)
if !strings.Contains(showOut, "External:") {
t.Errorf("expected 'External:' in output, got: %s", showOut)
}
if !strings.Contains(showOut, "https://example.com/spec.md") {
t.Errorf("expected external ref URL in output, got: %s", showOut)
}
}
func TestShow_NoExternalRef(t *testing.T) {
if testing.Short() {
t.Skip("skipping CLI test in short mode")
}
tmpDir := setupCLITestDB(t)
// Create issue WITHOUT external ref
out := runBDInProcess(t, tmpDir, "create", "No ref test", "-p", "1", "--json")
jsonStart := strings.Index(out, "{")
if jsonStart < 0 {
t.Fatalf("No JSON found in create output: %s", out)
}
var issue map[string]interface{}
if err := json.Unmarshal([]byte(out[jsonStart:]), &issue); err != nil {
t.Fatalf("failed to parse create output: %v, output: %s", err, out)
}
id := issue["id"].(string)
// Show the issue - should NOT contain External Ref line
showOut := runBDInProcess(t, tmpDir, "show", id)
if strings.Contains(showOut, "External:") {
t.Errorf("expected no 'External:' line for issue without external ref, got: %s", showOut)
}
}
func TestShow_IDFlag(t *testing.T) {
if testing.Short() {
t.Skip("skipping CLI test in short mode")
}
tmpDir := setupCLITestDB(t)
// Create an issue
out := runBDInProcess(t, tmpDir, "create", "ID flag test", "-p", "1", "--json")
jsonStart := strings.Index(out, "{")
if jsonStart < 0 {
t.Fatalf("No JSON found in create output: %s", out)
}
var issue map[string]interface{}
if err := json.Unmarshal([]byte(out[jsonStart:]), &issue); err != nil {
t.Fatalf("failed to parse create output: %v, output: %s", err, out)
}
id := issue["id"].(string)
// Test 1: Using --id flag works
showOut := runBDInProcess(t, tmpDir, "show", "--id="+id, "--short")
if !strings.Contains(showOut, id) {
t.Errorf("expected issue ID in output, got: %s", showOut)
}
// Test 2: Multiple --id flags work
showOut2 := runBDInProcess(t, tmpDir, "show", "--id="+id, "--id="+id, "--short")
if strings.Count(showOut2, id) != 2 {
t.Errorf("expected issue ID twice in output, got: %s", showOut2)
}
// Test 3: Combining positional and --id flag
showOut3 := runBDInProcess(t, tmpDir, "show", id, "--id="+id, "--short")
if strings.Count(showOut3, id) != 2 {
t.Errorf("expected issue ID twice in output, got: %s", showOut3)
}
// Test 4: No args at all should fail
_, _, err := runBDInProcessAllowError(t, tmpDir, "show")
if err == nil {
t.Error("expected error when no ID provided, but command succeeded")
}
}
func TestShow_NotFoundExitsNonZero(t *testing.T) {
if testing.Short() {
t.Skip("skipping CLI test in short mode")
}
tmpDir := setupCLITestDB(t)
// Show nonexistent issue should return error
_, _, err := runBDInProcessAllowError(t, tmpDir, "show", "test-nonexistent")
if err == nil {
t.Error("expected error for nonexistent issue, but command succeeded")
}
}
func TestShow_NotFoundJSON(t *testing.T) {
if testing.Short() {
t.Skip("skipping CLI test in short mode")
}
tmpDir := setupCLITestDB(t)
// Show nonexistent issue with --json should return error
// and output structured JSON error to stdout
stdout, _, err := runBDInProcessAllowError(t, tmpDir, "show", "test-nonexistent", "--json")
if err == nil {
t.Error("expected error for nonexistent issue with --json, but command succeeded")
}
// Verify stdout contains valid JSON with an error field
if stdout == "" {
t.Fatal("expected JSON error on stdout, got empty output")
}
var errResp map[string]interface{}
if jsonErr := json.Unmarshal([]byte(stdout), &errResp); jsonErr != nil {
t.Fatalf("expected valid JSON error response on stdout, got parse error: %v\nStdout: %s", jsonErr, stdout)
}
if errField, _ := errResp["error"].(string); errField == "" {
t.Errorf("expected non-empty 'error' field in JSON response, got: %s", stdout)
}
}