beads/cmd/bd/protocol/exit_codes_test.go
beads/crew/lydia d22095501e fix: exit non-zero when all close/update attempts fail (GH#2014)
bd close and bd update now exit 1 when all attempted operations fail
(e.g., closing a blocked issue, updating a nonexistent ID). Partial
success (some closed, some failed) still exits 0.

Adds protocol tests for exit code behavior.

Co-Authored-By: Joseph Turian <turian@gmail.com>
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-23 10:04:06 -08:00

87 lines
2.7 KiB
Go

package protocol
import (
"strings"
"testing"
)
// TestProtocol_CloseBlockedExitsNonZero verifies that closing an issue blocked
// by open dependencies returns exit code 1.
func TestProtocol_CloseBlockedExitsNonZero(t *testing.T) {
w := newWorkspace(t)
blocker := w.create("Blocker issue")
blocked := w.create("Blocked issue")
w.run("dep", "add", blocked, blocker, "--type=blocks")
_, code := w.runExpectError("close", blocked)
if code != 1 {
t.Errorf("expected exit code 1, got %d", code)
}
}
// TestProtocol_CloseUnblockedExitsZero verifies that closing an unblocked
// issue returns exit code 0 (no regression).
func TestProtocol_CloseUnblockedExitsZero(t *testing.T) {
w := newWorkspace(t)
id := w.create("Simple issue")
w.run("close", id)
}
// TestProtocol_UpdateNonexistentExitsNonZero verifies that updating a
// nonexistent issue returns exit code 1.
func TestProtocol_UpdateNonexistentExitsNonZero(t *testing.T) {
w := newWorkspace(t)
_, code := w.runExpectError("update", "nonexistent-xyz", "--status", "in_progress")
if code != 1 {
t.Errorf("expected exit code 1, got %d", code)
}
}
// TestProtocol_ClosePartialFailureExitsZero verifies that when closing
// multiple issues where some succeed and some fail (e.g., blocked), the
// command exits zero (partial success counts as success) and still closes
// the closeable ones.
func TestProtocol_ClosePartialFailureExitsZero(t *testing.T) {
w := newWorkspace(t)
closeable := w.create("Closeable issue")
blocker := w.create("Blocker issue")
blocked := w.create("Blocked issue")
w.run("dep", "add", blocked, blocker, "--type=blocks")
// Close both: closeable should succeed, blocked should fail.
// Partial success (closedCount > 0) exits 0.
w.run("close", closeable, blocked)
// Verify the closeable one was actually closed despite partial failure
out := w.run("show", closeable, "--json")
issues := parseJSONOutput(t, out)
if len(issues) == 0 {
t.Fatal("show returned no issues")
}
status, _ := issues[0]["status"].(string)
if status != "closed" {
t.Errorf("closeable issue should be closed despite partial failure, got status=%q", status)
}
// Verify the blocked one is still open
out2 := w.run("show", blocked, "--json")
issues2 := parseJSONOutput(t, out2)
if len(issues2) > 0 {
status2, _ := issues2[0]["status"].(string)
if status2 == "closed" {
t.Error("blocked issue should NOT be closed")
}
}
}
// TestProtocol_CloseNonexistentExitsNonZero verifies that closing a
// nonexistent issue returns a non-zero exit code.
func TestProtocol_CloseNonexistentExitsNonZero(t *testing.T) {
w := newWorkspace(t)
out, _ := w.runExpectError("close", "nonexistent-xyz")
if !strings.Contains(strings.ToLower(out), "not found") {
t.Logf("output: %s", out)
}
}