beads/cmd/bd/protocol/exit_codes_test.go
Vishnu J 730fb9867e
Beads #6648: report partial batch-close failure (#6740)
* fix(close): fail partial batch closes

Fixes #6648

* review: exit nonzero on proxied partial close, update tests and changelog

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* review: print close failure summary only for multi-id batches

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* review: machine-readable close failures, and adjudicate --claim-next

Maintainer fixup for the two major findings on #6740 (Beads #6648).

1. --claim-next x partial failure (major). --claim-next rides inside the
   batch transaction and fires whenever something LANDED, so a mixed batch
   claimed a fresh issue and then exited 1, with nothing in the diff, the
   CHANGELOG or the tests saying so.

   Adjudicated as "the claim stands and the report names it", not "the claim
   is suppressed". Suppressing it at cmd/bd -- the site the review named --
   cannot un-claim anything: ExecuteCloseBatch (and the uow provider's twin)
   commit the claim alongside the survivors before the CLI ever sees a
   refusal, so gating the report would only leave an issue assigned to the
   actor with nothing on stdout or stderr saying so. Strictly worse than
   announcing it. The claim is now named in the text summary and in the JSON
   failure payload, so a caller that exits on the nonzero status can still
   see what it owns.

   The review's "unbounded claim leak -- another ready issue on every
   attempt" does not hold, and the new test pins why: on a retry the survivor
   is already closed, so `landed` is 0 and an empty batch earns no claim
   (close_batch.go:146, uow/batch_closer.go:71). The leak is bounded at the
   one claim the first run earned. The defect that remains -- a durable claim
   the caller is never told about -- is what this fixes.

2. --json partial failure carried no machine-readable signal (major). The new
   exit 1 left stdout as the success-shaped array of CLOSED issues and put
   only human refusal prose on stderr, so a JSON consumer could not learn
   WHICH ids failed without scraping it -- the exact fragility #6648 was filed
   about, left in place for the callers most likely to batch. Both routes now
   report through one reportCloseFailures helper modelled on bd update's
   reportUpdateFailures: a compact {"error","failed":[{"id","error"}]} line on
   stderr, stdout keeping the closed-issues array. That also removes the
   summary hand-rolled twice with two denominators (the architectural nit).

Also taken, all non-gating and adjacent to the above:
- CHANGELOG narrowed to the refusals it actually covers, noting that an
  UNRESOLVABLE id still aborts the direct route before any close runs while
  the proxied route refuses it per-argument (the route-parity overclaim).
- Tests for the three deliberately-chosen behaviours that had no pin: the
  --json partial failure (proxied), the --claim-next interaction above
  (embedded, both failure channels), and the single-id summary suppression
  that commit 97151ab8e exists solely to add -- asserted in
  TestParityCloseNothingSettledExits1, which checked stdout but not stderr.

Contributor commits preserved; behaviour of the original fix is unchanged on
every route it already covered. Single-id stderr stays byte-identical.

Validated: go build ./..., go vet ./cmd/bd/..., TestParityClose family,
cmd/bd/protocol, TestEmbeddedClose close/claim-next subtests
(BEADS_TEST_EMBEDDED_DOLT=1), TestProxiedServerClose partial-failure subtests
(BEADS_TEST_PROXIED_SERVER=1), TestMultiIDUpdatePartialFailure.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
Co-authored-by: Julian Knutsen <julianknutsen@users.noreply.github.com>
2026-09-26 13:55:44 -07:00

93 lines
2.8 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) {
t.Parallel()
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) {
t.Parallel()
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) {
t.Parallel()
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_ClosePartialFailureExitsNonZero verifies that when closing
// multiple issues where some succeed and some fail (e.g., blocked), the
// command exits non-zero and still closes the closeable ones.
func TestProtocol_ClosePartialFailureExitsNonZero(t *testing.T) {
t.Parallel()
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, and the
// refusal makes the batch exit 1.
if _, code := w.runExpectError("close", closeable, blocked); code != 1 {
t.Errorf("expected exit code 1, got %d", code)
}
// 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) {
t.Parallel()
w := newWorkspace(t)
out, _ := w.runExpectError("close", "nonexistent-xyz")
if !strings.Contains(strings.ToLower(out), "not found") {
t.Logf("output: %s", out)
}
}