* 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>
186 lines
6.8 KiB
Go
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)
|
|
}
|
|
})
|
|
}
|