@nickmeriano/task 0.9.0 → 0.11.0

package/src/claim.test.ts

@@ -10,12 +10,20 @@
  *    and already-claimed tickets — open asks never exclude a ticket.
  * 4. `task claim --release` deletes the branch both sides and the ticket is
  *    claimable again.
+ * 5. `task claim --lock-only` takes the same lock without touching the
+ *    checkout — a branch-pinned (even dirty) session can hold it — and
+ *    `--release` works on it symmetrically.
+ * 6. Deletions are verified: against a remote that silently drops deletion
+ *    pushes (TAS-8b7s9), release and sweep fail loudly instead of lying.
+ * 7. `task sweep` deletes claim branches whose tickets are done, canceled or
+ *    missing on the current checkout, and leaves live ones — and any branch
+ *    named outside the claim scheme — alone.
  */
 
 import assert from "node:assert/strict"
 import { test } from "node:test"
 import { execFile, spawnSync } from "node:child_process"
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
 import { readFileSync } from "node:fs"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
@@ -46,11 +54,16 @@ interface CliResult {
 
 /** The CLI as callers see it — a subprocess with an exit code. */
 function cli(cwd: string, ...args: string[]): Promise<CliResult> {
+  return cliEnv(cwd, {}, ...args)
+}
+
+/** Like cli(), with extra env — the delete-dropping git shim rides in PATH. */
+function cliEnv(cwd: string, env: Record<string, string>, ...args: string[]): Promise<CliResult> {
   return new Promise((resolve) => {
     execFile(
       process.execPath,
       ["--experimental-strip-types", CLI, ...args],
-      { cwd },
+      { cwd, env: { ...process.env, ...env } },
       (error, stdout, stderr) => {
         resolve({ code: error ? ((error as { code?: number }).code ?? 1) : 0, stdout, stderr })
       },
@@ -58,6 +71,26 @@ function cli(cwd: string, ...args: string[]): Promise<CliResult> {
   })
 }
 
+/**
+ * A PATH whose `git` silently swallows branch-deletion pushes — exit 0,
+ * nothing deleted — and delegates everything else to the real git. This is
+ * the observed cloud-proxy behavior TAS-8b7s9 documents: the deletion "works"
+ * while the ref survives, which is exactly what verified release must catch.
+ * POSIX-only by construction, like the failure it reproduces.
+ */
+function deleteDroppingPath(): string {
+  const dir = mkdtempSync(join(tmpdir(), "task-fake-git-"))
+  process.on("exit", () => rmSync(dir, { recursive: true, force: true }))
+  const real = spawnSync("sh", ["-c", "command -v git"], { encoding: "utf8" }).stdout.trim()
+  const shim = join(dir, "git")
+  writeFileSync(
+    shim,
+    `#!/bin/sh\nfor a in "$@"; do case "$a" in --delete) exit 0;; esac; done\nexec "${real}" "$@"\n`,
+  )
+  chmodSync(shim, 0o755)
+  return `${dir}:${process.env.PATH ?? ""}`
+}
+
 interface Fixture {
   bare: string
   clone: () => string
@@ -150,9 +183,54 @@ test("two concurrent claims of one ticket: exactly one wins", async () => {
     sh(winner, "git", "show", `origin/main:.task/tickets/${keys.one}/ticket.md`),
     /status: todo/,
   )
+  // The trailer contract (trailers.ts): the flip commit names its op and
+  // ticket in machine-readable trailers — pinned here because automation
+  // keys on them.
+  assert.equal(sh(winner, "git", "log", "-1", "--format=%(trailers:key=Task-Op,valueonly)"), "claim")
+  assert.equal(
+    sh(winner, "git", "log", "-1", "--format=%(trailers:key=Task-Id,valueonly)"),
+    `CLM-${keys.one}`,
+  )
   void bare
 })
 
+test("claim --dry-run: the real gates, the real exit codes, zero writes", async () => {
+  const { clone, keys } = fixture()
+  const dir = clone()
+  const branch = `task/claim/clm-${keys.one}`
+
+  // Would claim: exit 0 — and nothing moved. No branch local or remote, the
+  // checkout still on main, the ticket still todo.
+  const yes = await cli(dir, "claim", keys.one, "--dry-run")
+  assert.equal(yes.code, 0, yes.stderr)
+  assert.match(yes.stdout, /would claim CLM-/)
+  assert.equal(sh(dir, "git", "rev-parse", "--abbrev-ref", "HEAD"), "main")
+  assert.equal(sh(dir, "git", "branch", "--list", branch), "")
+  assert.equal(sh(dir, "git", "ls-remote", "--heads", "origin", branch), "")
+  assert.match(readFileSync(join(dir, ".task", "tickets", keys.one, "ticket.md"), "utf8"), /status: todo/)
+
+  // The gates are the real command's gates: blocked exits 2, a ticket someone
+  // else claimed exits 1 — the codes a scheduler scripts against.
+  assert.equal((await cli(dir, "claim", keys.blocked, "--dry-run")).code, 2)
+  const other = clone()
+  assert.equal((await cli(other, "claim", keys.one)).code, 0)
+  assert.equal((await cli(dir, "claim", keys.one, "--dry-run")).code, 1)
+
+  // --next --dry-run names the top of the queue without taking it.
+  const next = await cli(dir, "claim", "--next", "--dry-run", "--json")
+  assert.equal(next.code, 0, next.stderr)
+  const picked = JSON.parse(next.stdout) as { task: { key: string }; dryRun: boolean }
+  assert.equal(picked.dryRun, true)
+  assert.equal(picked.task.key, keys.jumper)
+  assert.equal(sh(dir, "git", "ls-remote", "--heads", "origin", `task/claim/clm-${keys.jumper}`), "")
+
+  // A dry run reserves nothing — the real claim right after still works.
+  assert.equal((await cli(dir, "claim", keys.jumper)).code, 0)
+
+  // No stop-before-writing seam exists for --release or --lock-only.
+  assert.equal((await cli(other, "claim", keys.two, "--lock-only", "--dry-run")).code, 1)
+})
+
 test("unclaimable tickets exit 2, before anything touches origin", async () => {
   const { clone, keys } = fixture()
   const dir = clone()
@@ -470,3 +548,209 @@ test("release requires a reason and leaves it as a comment on the ticket", async
   const after = await cli(dir, "show", keys.one, "--json")
   assert.equal((JSON.parse(after.stdout) as { comments: unknown[] }).comments.length, 1)
 })
+
+test("--lock-only claims from a dirty, branch-pinned checkout without touching it", async () => {
+  const { clone, keys } = fixture()
+  const dir = clone()
+  const branch = `task/claim/clm-${keys.one}`
+
+  // The branch-pinned session: a provisioned branch, uncommitted tracked work.
+  sh(dir, "git", "checkout", "--quiet", "-b", "pinned")
+  const gitignore = join(dir, ".task", ".gitignore")
+  writeFileSync(gitignore, `${readFileSync(gitignore, "utf8")}\nwip\n`)
+
+  const claimed = await cli(dir, "claim", keys.one, "--lock-only", "--json")
+  assert.equal(claimed.code, 0, claimed.stderr)
+  const parsed = JSON.parse(claimed.stdout) as {
+    task: { status: string }
+    branch: string
+    deliveredBy: string
+  }
+  assert.equal(parsed.branch, branch)
+  assert.equal(parsed.deliveredBy, "pinned")
+  assert.equal(parsed.task.status, "in_progress")
+
+  // The checkout is exactly where it was: same branch, same dirty file, and
+  // the local ticket file never flipped — the claim lives on origin only.
+  assert.equal(sh(dir, "git", "rev-parse", "--abbrev-ref", "HEAD"), "pinned")
+  assert.match(sh(dir, "git", "status", "--porcelain", "-uno"), /\.task\/\.gitignore/)
+  assert.match(readFileSync(join(dir, ".task", "tickets", keys.one, "ticket.md"), "utf8"), /status: todo/)
+
+  // On origin the claim is a real flip commit built on the default branch,
+  // carrying the delivery branch as a trailer.
+  assert.ok(sh(dir, "git", "ls-remote", "--heads", "origin", branch).includes(`refs/heads/${branch}`))
+  assert.equal(
+    sh(dir, "git", "rev-parse", `origin/${branch}~1`),
+    sh(dir, "git", "rev-parse", "origin/main"),
+  )
+  assert.match(sh(dir, "git", "show", `origin/${branch}:.task/tickets/${keys.one}/ticket.md`), /status: in_progress/)
+  const message = sh(dir, "git", "log", "-1", "--format=%B", `origin/${branch}`)
+  assert.match(message, /lock-only/)
+  assert.match(message, new RegExp(`Delivered-By: pinned`))
+  // Delivered-By shares one contiguous trailer block with the Task-Op/Task-Id
+  // contract (trailers.ts) — git must parse all three.
+  assert.equal(
+    sh(dir, "git", "log", "-1", "--format=%(trailers:key=Task-Op,valueonly)", `origin/${branch}`),
+    "claim",
+  )
+  assert.equal(
+    sh(dir, "git", "log", "-1", "--format=%(trailers:key=Delivered-By,valueonly)", `origin/${branch}`),
+    "pinned",
+  )
+
+  // The lock is the same lock: both claim flavors lose to it from elsewhere.
+  const other = clone()
+  assert.equal((await cli(other, "claim", keys.one)).code, 1)
+  assert.equal((await cli(other, "claim", keys.one, "--lock-only")).code, 1)
+
+  // Release is symmetric: no local branch to delete, the origin one goes, and
+  // the pinned checkout still isn't touched.
+  const released = await cli(dir, "claim", "--release", keys.one, "--comment", "handing back a lock-only claim")
+  assert.equal(released.code, 0, released.stderr)
+  assert.equal(sh(dir, "git", "rev-parse", "--abbrev-ref", "HEAD"), "pinned")
+  assert.equal(sh(dir, "git", "ls-remote", "--heads", "origin", branch), "")
+  assert.equal((await cli(other, "claim", keys.one)).code, 0)
+})
+
+test("--lock-only validates against origin's default branch, not the checkout", async () => {
+  const { clone, keys } = fixture()
+  const dir = clone()
+
+  // Not todo on the base tree → exit 2, and nothing minted on origin.
+  const parked = await cli(dir, "claim", keys.parked, "--lock-only")
+  assert.equal(parked.code, 2)
+  assert.match(parked.stderr, /is backlog on origin\/main/)
+
+  // A local promote that hasn't landed on the default branch doesn't count:
+  // the flip commit is built on origin/main, where the ticket is still backlog.
+  assert.equal((await cli(dir, "promote", keys.parked)).code, 0)
+  const promoted = await cli(dir, "claim", keys.parked, "--lock-only")
+  assert.equal(promoted.code, 2)
+  assert.match(promoted.stderr, /is backlog on origin\/main/)
+  assert.equal(sh(dir, "git", "ls-remote", "--heads", "origin", `task/claim/clm-${keys.parked}`), "")
+
+  // Blocked on the base tree refuses too.
+  const blocked = await cli(dir, "claim", keys.blocked, "--lock-only")
+  assert.equal(blocked.code, 2)
+  assert.match(blocked.stderr, new RegExp(`blocked by CLM-${keys.one}`))
+})
+
+test("plain claim warns when it moves the checkout off a non-default branch", async () => {
+  const { clone, keys } = fixture()
+  const dir = clone()
+  sh(dir, "git", "checkout", "--quiet", "-b", "feature")
+
+  const claimed = await cli(dir, "claim", keys.one)
+  assert.equal(claimed.code, 0, claimed.stderr)
+  assert.match(claimed.stdout, /moved you off feature/)
+  assert.match(claimed.stdout, /--lock-only/)
+
+  // From the default branch there is nothing to warn about.
+  const other = clone()
+  const quiet = await cli(other, "claim", keys.two)
+  assert.equal(quiet.code, 0, quiet.stderr)
+  assert.doesNotMatch(quiet.stdout, /moved you off/)
+})
+
+test("sweep deletes done/canceled/missing claims and keeps live ones", async () => {
+  const { clone, keys } = fixture()
+  const a = clone()
+  assert.equal((await cli(a, "claim", keys.one)).code, 0)
+  assert.equal((await cli(a, "claim", keys.two)).code, 0)
+  assert.equal((await cli(a, "claim", keys.person)).code, 0)
+
+  // A second checkout is where the tickets' fates land (a merge, normally):
+  // one finishes, person is canceled, two stays live — plus a branch under
+  // the namespace whose ticket never existed.
+  const b = clone()
+  assert.equal((await cli(b, "move", keys.one, "done")).code, 0)
+  assert.equal((await cli(b, "move", keys.person, "canceled")).code, 0)
+  sh(b, "git", "push", "--quiet", "origin", "main:refs/heads/task/claim/clm-zz9zz")
+  // Namespace squatters sweep must NOT touch: a pre-migration numeric claim
+  // (its branch may head an open PR carrying unmerged work — the TAS-31 case)
+  // and a branch matching no board's prefix. Skipped and reported, never
+  // deleted — sweep's jurisdiction is exactly the names `claim` mints.
+  sh(b, "git", "push", "--quiet", "origin", "main:refs/heads/task/claim/clm-31")
+  sh(b, "git", "push", "--quiet", "origin", "main:refs/heads/task/claim/other-zz9zz")
+
+  const swept = await cli(b, "sweep", "--json")
+  assert.equal(swept.code, 0, swept.stderr)
+  const { sweep } = JSON.parse(swept.stdout) as {
+    sweep: {
+      swept: { branch: string; reason: string }[]
+      kept: { branch: string; status: string }[]
+      skipped: string[]
+      failed: unknown[]
+    }
+  }
+  assert.deepEqual(
+    sweep.swept.map((s) => [s.branch, s.reason]).sort(),
+    [
+      [`task/claim/clm-${keys.one}`, "done"],
+      [`task/claim/clm-${keys.person}`, "canceled"],
+      ["task/claim/clm-zz9zz", "missing"],
+    ].sort(),
+  )
+  assert.deepEqual(sweep.kept, [
+    { branch: `task/claim/clm-${keys.two}`, ticket: `CLM-${keys.two}`, status: "todo" },
+  ])
+  assert.deepEqual(sweep.skipped.sort(), ["task/claim/clm-31", "task/claim/other-zz9zz"])
+  assert.equal(sweep.failed.length, 0)
+
+  // Origin agrees: the live claim and the out-of-scheme branches survive,
+  // and a re-run is a no-op.
+  const remote = sh(b, "git", "ls-remote", "--heads", "origin", "task/claim/*")
+  assert.deepEqual(
+    remote.split("\n").map((l) => l.split("refs/heads/")[1]).sort(),
+    ["task/claim/clm-31", `task/claim/clm-${keys.two}`, "task/claim/other-zz9zz"].sort(),
+  )
+  const again = await cli(b, "sweep", "--json")
+  assert.equal(again.code, 0)
+  assert.equal((JSON.parse(again.stdout) as { sweep: { swept: unknown[] } }).sweep.swept.length, 0)
+})
+
+test(
+  "verified deletion: a remote that drops deletions makes release and sweep fail loudly",
+  { skip: process.platform === "win32" },
+  async () => {
+    const { clone, keys } = fixture()
+    const path = deleteDroppingPath()
+    const dir = clone()
+    assert.equal((await cli(dir, "claim", keys.one)).code, 0)
+
+    // Release under the shim: git says the deletion worked, the ref survives —
+    // pre-TAS-8b7s9 this reported "released" and left a stale lock behind.
+    const released = await cliEnv(
+      dir, { PATH: path },
+      "claim", "--release", keys.one, "--comment", "should not land",
+    )
+    assert.notEqual(released.code, 0)
+    assert.match(released.stderr, /origin still has/)
+    assert.doesNotMatch(released.stdout, /released CLM/)
+    assert.ok(
+      sh(dir, "git", "ls-remote", "--heads", "origin", `task/claim/clm-${keys.one}`).includes(
+        `clm-${keys.one}`,
+      ),
+    )
+    // No release, no comment: the failure must not read as a done release.
+    const shown = await cli(dir, "show", keys.one, "--json")
+    assert.equal((JSON.parse(shown.stdout) as { comments: unknown[] }).comments.length, 0)
+
+    // Sweep under the shim reports the failed deletion and exits non-zero.
+    const b = clone()
+    assert.equal((await cli(b, "move", keys.one, "done")).code, 0)
+    const blocked = await cliEnv(b, { PATH: path }, "sweep", "--json")
+    assert.equal(blocked.code, 1)
+    const { sweep } = JSON.parse(blocked.stdout) as {
+      sweep: { swept: unknown[]; failed: { branch: string; error: string }[] }
+    }
+    assert.equal(sweep.swept.length, 0)
+    assert.equal(sweep.failed.length, 1)
+    assert.match(sweep.failed[0].error, /origin still has/)
+
+    // A capable runner heals it: the same sweep with real git succeeds.
+    const healed = await cli(b, "sweep")
+    assert.equal(healed.code, 0, healed.stderr)
+    assert.equal(sh(b, "git", "ls-remote", "--heads", "origin", `task/claim/clm-${keys.one}`), "")
+  },
+)