beads/cmd/bd/defer_proxied_integration_test.go
Athos Bernardes fc2351a51c
fix(defer): undefer clears a stray defer_until when status isn't deferred (ga-bq3w5) (#6390)
* fix(defer): undefer clears a stray defer_until when status isn't deferred (ga-bq3w5)

`bd undefer` gated entirely on issue.Status == StatusDeferred. But the
ready-work query hides any issue whose defer_until is in the future
regardless of status, so `bd update <id> --status open --defer <date>`
(an explicit --status wins over --defer's own status=deferred default)
leaves status=open with a live defer_until: permanently invisible to
`bd ready`, with no command able to clear it. `bd undefer` refused with a
technically-true, practically-misleading "is not deferred (status: open)"
and never touched the timestamp actually doing the hiding.

Gate on defer_until instead of status alone: only flip status to open
when the issue really was deferred (mirrors the guard GH#3233 already
gave `bd update --defer=""`), but always clear a stray defer_until so
the issue can return to `bd ready`.

Adds a regression test reproducing the exact shape (status=open + future
defer_until via a single `bd update --status open --defer ...` call).
Confirmed it fails against the pre-fix code and passes with the fix.

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

* fix(defer): mirror the undefer defer_until fix to the proxied-server route (ga-bq3w5)

PR review (bee-ghosttrack, round 1): the previous fix only patched the
embedded backend (undefer.go). runUndeferProxiedServer, used by
proxied-server/beads-team-server installs, still gated solely on
status == deferred and still overwrote status unconditionally — the
exact bug survives on that route, and CI treats it as first-class (15
green Proxied Dolt Cmd shards).

Mirror the same gate/write shape into defer_proxied_server.go: only
refuse when status isn't deferred AND there's no defer_until to clear;
only flip status to open when the issue really was deferred.

Also closes the reviewer's MINOR finding: the existing "open" fixture
can't distinguish the conditional status write from an unconditional
one (writing status=open to an already-open issue is a no-op). Adds
an in_progress case to both the embedded and the new proxied test —
confirmed by mutation that it fails against the unconditional-write
code and passes with the fix.

Shortens the undefer.go rationale comment and documents the
clear-without-clobbering behavior in the command's Long description,
per the reviewer's non-blocking nits.

Verified: go build/vet clean; gofmt clean; golangci-lint (native) 0
issues; BEADS_TEST_EMBEDDED_DOLT=1 go test -run TestEmbeddedUndefer
all 5 subtests PASS. The new proxied-server subtest could not be
executed in this sandbox (no Docker available for the shared Dolt
container), but go vet confirms it compiles and type-checks, and it
mirrors the embedded test byte-for-byte in structure. The windows
cross-lint step in `make ci-pr-lint` fails in this sandbox on files
untouched by this diff (confirmed byte-identical to origin/main) —
a pre-existing local environment gap, not a regression.

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

---------

Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-28 11:18:25 -07:00

186 lines
6.8 KiB
Go

//go:build cgo
package main
import (
"encoding/json"
"strings"
"testing"
"github.com/steveyegge/beads/internal/types"
)
func TestProxiedServerDeferUndefer(t *testing.T) {
requireSharedProxiedServer(t)
t.Parallel()
bd := buildEmbeddedBD(t)
p := newSharedProxiedProject(t, bd, "dfr")
showStatus := func(t *testing.T, id string) (string, interface{}) {
t.Helper()
out, err := bdProxiedRun(t, bd, p.dir, "show", id, "--json")
if err != nil {
t.Fatalf("show %s: %v\n%s", id, err, out)
}
var arr []map[string]interface{}
if err := json.Unmarshal(out, &arr); err != nil {
t.Fatalf("unmarshal: %v\n%s", err, out)
}
if len(arr) == 0 {
t.Fatalf("show returned nothing for %s", id)
}
return arr[0]["status"].(string), arr[0]["defer_until"]
}
t.Run("defer_then_undefer", func(t *testing.T) {
a := bdProxiedCreate(t, bd, p.dir, "Defer target", "--type", "task")
out, err := bdProxiedRun(t, bd, p.dir, "defer", a.ID, "--until", "tomorrow", "--reason", "waiting on X", "--json")
if err != nil {
t.Fatalf("defer: %v\n%s", err, out)
}
var deferred []map[string]interface{}
if err := json.Unmarshal(out, &deferred); err != nil {
t.Fatalf("unmarshal defer: %v\n%s", err, out)
}
if len(deferred) != 1 || deferred[0]["status"] != string(types.StatusDeferred) {
t.Fatalf("expected 1 deferred issue, got %v", deferred)
}
if deferred[0]["defer_until"] == nil {
t.Errorf("expected defer_until to be set")
}
status, deferUntil := showStatus(t, a.ID)
if status != string(types.StatusDeferred) {
t.Errorf("status = %s, want deferred", status)
}
if deferUntil == nil {
t.Errorf("defer_until should be set after defer")
}
// Undefer restores to open and clears defer_until.
if out, err := bdProxiedRun(t, bd, p.dir, "undefer", a.ID); err != nil {
t.Fatalf("undefer: %v\n%s", err, out)
}
status, deferUntil = showStatus(t, a.ID)
if status != string(types.StatusOpen) {
t.Errorf("status = %s, want open after undefer", status)
}
if deferUntil != nil {
t.Errorf("defer_until should be cleared after undefer, got %v", deferUntil)
}
})
t.Run("deferred_excluded_from_ready", func(t *testing.T) {
b := bdProxiedCreate(t, bd, p.dir, "Ready-then-deferred", "--type", "task", "--priority", "1")
if out, err := bdProxiedRun(t, bd, p.dir, "defer", b.ID); err != nil {
t.Fatalf("defer: %v\n%s", err, out)
}
ready := bdProxiedListJSON(t, bd, p, "--ready")
for _, iss := range ready {
if iss.ID == b.ID {
t.Errorf("deferred issue %s should not appear in ready", b.ID)
}
}
})
t.Run("undefer_nondeferred_errors", func(t *testing.T) {
c := bdProxiedCreate(t, bd, p.dir, "Open issue", "--type", "task")
stdout, stderr, _ := bdProxiedRunBuffers(t, bd, p.dir, "undefer", c.ID)
if !strings.Contains(stdout+stderr, "is not deferred") {
t.Errorf("expected 'is not deferred' message, got stdout=%q stderr=%q", stdout, stderr)
}
})
t.Run("undefer_clears_stray_defer_until_when_status_not_deferred", func(t *testing.T) {
// Mirrors TestEmbeddedUndefer's ga-bq3w5 coverage on the proxied-server
// route (runUndeferProxiedServer): a status that is neither "open" nor
// "deferred" makes the conditional status write observable — writing
// status=open here would be a real change, not a no-op.
j := bdProxiedCreate(t, bd, p.dir, "Stray future defer on in_progress issue", "--type", "task")
if out, err := bdProxiedRun(t, bd, p.dir, "update", j.ID, "--status", "in_progress", "--defer", "2099-01-01"); err != nil {
t.Fatalf("update --status in_progress --defer: %v\n%s", err, out)
}
status, deferUntil := showStatus(t, j.ID)
if status != string(types.StatusInProgress) || deferUntil == nil {
t.Fatalf("precondition: expected status=in_progress with defer_until set, got status=%q defer_until=%v", status, deferUntil)
}
stdout, stderr, err := bdProxiedRunBuffers(t, bd, p.dir, "undefer", j.ID)
if err != nil {
t.Fatalf("undefer: %v\nstdout=%s\nstderr=%s", err, stdout, stderr)
}
if strings.Contains(stdout+stderr, "is not deferred") {
t.Errorf("undefer refused instead of clearing the stray defer_until: stdout=%s stderr=%s", stdout, stderr)
}
status, deferUntil = showStatus(t, j.ID)
if status != string(types.StatusInProgress) {
t.Errorf("expected status to stay in_progress (not clobbered to open), got %q", status)
}
if deferUntil != nil {
t.Errorf("expected defer_until cleared after undefer, got %v", deferUntil)
}
})
t.Run("defer_is_idempotent", func(t *testing.T) {
d := bdProxiedCreate(t, bd, p.dir, "Idempotent defer", "--type", "task")
if out, err := bdProxiedRun(t, bd, p.dir, "defer", d.ID); err != nil {
t.Fatalf("first defer: %v\n%s", err, out)
}
// Second defer on an already-deferred issue must not error (ClientFoundRows fix).
if out, err := bdProxiedRun(t, bd, p.dir, "defer", d.ID, "--json"); err != nil {
t.Fatalf("second defer errored (no-op update regression): %v\n%s", err, out)
}
})
t.Run("defer_multiple", func(t *testing.T) {
e := bdProxiedCreate(t, bd, p.dir, "Defer multi 1", "--type", "task")
f := bdProxiedCreate(t, bd, p.dir, "Defer multi 2", "--type", "task")
out, err := bdProxiedRun(t, bd, p.dir, "defer", e.ID, f.ID)
if err != nil {
t.Fatalf("defer multiple: %v\n%s", err, out)
}
if !strings.Contains(string(out), e.ID) || !strings.Contains(string(out), f.ID) {
t.Errorf("expected both IDs in defer output, got:\n%s", out)
}
for _, id := range []string{e.ID, f.ID} {
if status, _ := showStatus(t, id); status != string(types.StatusDeferred) {
t.Errorf("status of %s = %s, want deferred", id, status)
}
}
})
t.Run("undefer_multiple", func(t *testing.T) {
g := bdProxiedCreate(t, bd, p.dir, "Undefer multi 1", "--type", "task")
h := bdProxiedCreate(t, bd, p.dir, "Undefer multi 2", "--type", "task")
if out, err := bdProxiedRun(t, bd, p.dir, "defer", g.ID, h.ID); err != nil {
t.Fatalf("defer: %v\n%s", err, out)
}
out, err := bdProxiedRun(t, bd, p.dir, "undefer", g.ID, h.ID)
if err != nil {
t.Fatalf("undefer multiple: %v\n%s", err, out)
}
if !strings.Contains(string(out), g.ID) || !strings.Contains(string(out), h.ID) {
t.Errorf("expected both IDs in undefer output, got:\n%s", out)
}
for _, id := range []string{g.ID, h.ID} {
if status, _ := showStatus(t, id); status != string(types.StatusOpen) {
t.Errorf("status of %s = %s, want open after undefer", id, status)
}
}
})
t.Run("defer_reason_appended_to_notes", func(t *testing.T) {
i := bdProxiedCreate(t, bd, p.dir, "Defer with reason", "--type", "task")
if out, err := bdProxiedRun(t, bd, p.dir, "defer", i.ID, "--reason", "waiting on API access"); err != nil {
t.Fatalf("defer --reason: %v\n%s", err, out)
}
iss := bdProxiedShow(t, bd, p.dir, i.ID)
if !strings.Contains(iss.Notes, "waiting on API access") {
t.Errorf("expected defer reason appended to notes, got notes=%q", iss.Notes)
}
})
}