@intentius/chant 0.57.0 → 0.59.0

package/src/cli/handlers/operator.test.ts

@@ -11,7 +11,10 @@ const loadChantConfigMock = vi.fn();
 const readLeaseMock = vi.fn();
 const readConvergeLedgerMock = vi.fn();
 const appendGateResolutionMock = vi.fn();
+const appendPendingGateMock = vi.fn();
 const readGateResolutionsMock = vi.fn();
+const readGateLedgerMock = vi.fn();
+const readRunLedgerMock = vi.fn();
 const pushLifecycleMock = vi.fn();
 
 vi.mock("../../op/operator", async () => {
@@ -40,12 +43,18 @@ vi.mock("../../lifecycle/converge-ledger", async () => {
   const actual = await vi.importActual<typeof import("../../lifecycle/converge-ledger")>("../../lifecycle/converge-ledger");
   return { ...actual, readConvergeLedger: (...args: unknown[]) => readConvergeLedgerMock(...args) };
 });
+vi.mock("../../lifecycle/run-ledger", async () => {
+  const actual = await vi.importActual<typeof import("../../lifecycle/run-ledger")>("../../lifecycle/run-ledger");
+  return { ...actual, readRunLedger: (...args: unknown[]) => readRunLedgerMock(...args) };
+});
 vi.mock("../../lifecycle/gate-ledger", async () => {
   const actual = await vi.importActual<typeof import("../../lifecycle/gate-ledger")>("../../lifecycle/gate-ledger");
   return {
     ...actual,
     appendGateResolution: (...args: unknown[]) => appendGateResolutionMock(...args),
+    appendPendingGate: (...args: unknown[]) => appendPendingGateMock(...args),
     readGateResolutions: (...args: unknown[]) => readGateResolutionsMock(...args),
+    readGateLedger: (...args: unknown[]) => readGateLedgerMock(...args),
   };
 });
 vi.mock("../../lifecycle/git", async () => {
@@ -71,6 +80,8 @@ beforeEach(() => {
   loadProfilesMock.mockResolvedValue({});
   discoverOpsMock.mockResolvedValue({ ops: new Map([["fountain-apply", {}]]), errors: [] });
   pushLifecycleMock.mockResolvedValue(true);
+  readGateResolutionsMock.mockResolvedValue({ records: [], malformed: 0 });
+  readGateLedgerMock.mockResolvedValue({ resolutions: [], pending: [], malformed: 0 });
 });
 
 describe("runOperator", () => {
@@ -84,7 +95,7 @@ describe("runOperator", () => {
 
   test("--once runs exactly one round and exits 0 when nothing failed", async () => {
     discoverConvergeOpsMock.mockResolvedValue({ ops: [{ config: { name: "staging-converge" } }], errors: [] });
-    runOperatorRoundMock.mockResolvedValue([{ kind: "ticked", op: "staging-converge", env: "staging", result: { op: "staging-converge", records: [], totalMs: 1, ok: true } }]);
+    runOperatorRoundMock.mockResolvedValue([{ kind: "ticked", op: "staging-converge", env: "staging", result: { op: "staging-converge", records: [], totalMs: 1, status: "ok", startedAt: "2026-01-01T00:00:00.000Z" } }]);
 
     const code = await runOperator(ctx({ once: true }));
     expect(code).toBe(0);
@@ -147,7 +158,7 @@ describe("runOperatorStatus", () => {
 
   test("--json emits one row per discovered ConvergeOp with last tick, lease, and pending gates", async () => {
     discoverConvergeOpsMock.mockResolvedValue({
-      ops: [{ config: { name: "staging-converge", searchAttributes: { Env: "staging" } } }],
+      ops: [{ config: { name: "staging-converge", labels: { Env: "staging" } } }],
       errors: [],
     });
     readConvergeLedgerMock.mockResolvedValue({
@@ -185,7 +196,7 @@ describe("runOperatorStatus", () => {
   // and the only affordance a renderer could offer was a shell command.
   test("a gated outcome's approval url rides onto the pending-gate row", async () => {
     discoverConvergeOpsMock.mockResolvedValue({
-      ops: [{ config: { name: "staging-converge", searchAttributes: { Env: "staging" } } }],
+      ops: [{ config: { name: "staging-converge", labels: { Env: "staging" } } }],
       errors: [],
     });
     readConvergeLedgerMock.mockResolvedValue({
@@ -223,7 +234,7 @@ describe("runOperatorStatus", () => {
 
   test("the human render prints the address under the pending gate", async () => {
     discoverConvergeOpsMock.mockResolvedValue({
-      ops: [{ config: { name: "staging-converge", searchAttributes: { Env: "staging" } } }],
+      ops: [{ config: { name: "staging-converge", labels: { Env: "staging" } } }],
       errors: [],
     });
     readConvergeLedgerMock.mockResolvedValue({
@@ -253,7 +264,7 @@ describe("runOperatorStatus", () => {
 
   test("a gate resolved after the tick that recorded it is no longer pending", async () => {
     discoverConvergeOpsMock.mockResolvedValue({
-      ops: [{ config: { name: "staging-converge", searchAttributes: { Env: "staging" } } }],
+      ops: [{ config: { name: "staging-converge", labels: { Env: "staging" } } }],
       errors: [],
     });
     readConvergeLedgerMock.mockResolvedValue({
@@ -283,6 +294,51 @@ describe("runOperatorStatus", () => {
     expect(printed[0].pendingGates).toEqual([]);
     logSpy.mockRestore();
   });
+  // #2119 — a gate a plain `chant run <op>` stopped at is a pending fact on
+  // that op's own ledger, with no converge tick anywhere behind it.
+  test("lists a pending fact for a non-converge op", async () => {
+    discoverConvergeOpsMock.mockResolvedValue({ ops: [], errors: [] });
+    discoverOpsMock.mockResolvedValue({ ops: new Map([["prod-apply", {}]]), errors: [] });
+    readGateLedgerMock.mockResolvedValue({
+      resolutions: [],
+      pending: [{
+        version: 1, kind: "pending", op: "prod-apply", gate: "rollout-gate",
+        description: "release manager signs off",
+        timestamp: "2026-01-01T00:00:00.000Z", expiresAt: "2099-01-01T00:00:00.000Z",
+        url: "https://pr.example/9",
+      }],
+      malformed: 0,
+    });
+
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+    expect(await runOperatorStatus(ctx({}))).toBe(0);
+    const out = logSpy.mock.calls.map((c) => String(c[0])).join("\n");
+    expect(out).toContain("pending gates (no converge tick)");
+    expect(out).toContain("chant approve prod-apply rollout-gate");
+    expect(out).toContain("expires: 2099-01-01T00:00:00.000Z");
+    expect(out).toContain("approve at: https://pr.example/9");
+    logSpy.mockRestore();
+  });
+
+  test("an expired pending fact is not listed", async () => {
+    discoverConvergeOpsMock.mockResolvedValue({ ops: [], errors: [] });
+    discoverOpsMock.mockResolvedValue({ ops: new Map([["prod-apply", {}]]), errors: [] });
+    readGateLedgerMock.mockResolvedValue({
+      resolutions: [],
+      pending: [{
+        version: 1, kind: "pending", op: "prod-apply", gate: "rollout-gate",
+        timestamp: "2026-01-01T00:00:00.000Z", expiresAt: "2026-01-03T00:00:00.000Z",
+      }],
+      malformed: 0,
+    });
+
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+    expect(await runOperatorStatus(ctx({}))).toBe(0);
+    expect(logSpy.mock.calls.map((c) => String(c[0])).join("\n")).not.toContain("pending gates");
+    logSpy.mockRestore();
+    errSpy.mockRestore();
+  });
 });
 
 describe("runApprove", () => {
@@ -310,6 +366,30 @@ describe("runApprove", () => {
     errSpy.mockRestore();
   });
 
+  // #2192 — every example README teaches `--approver you`; the handler read
+  // only `--actor` and fell through to $GITHUB_ACTOR / $USER, so the ledger
+  // recorded the shell user. Same precedence as `chant run approve`.
+  test("--approver wins over --actor and over the CI/shell identity", async () => {
+    vi.stubEnv("GITHUB_ACTOR", "ci-bot");
+    vi.stubEnv("USER", "alex");
+    appendGateResolutionMock.mockResolvedValue({
+      commit: "sha",
+      record: { version: 1, op: "deploy-gated", gate: "approve-deploy", resolvedBy: "you", timestamp: "2026-01-01T00:00:00.000Z" },
+    });
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
+
+    const code = await runApprove(ctx({
+      path: "deploy-gated", extraPositional: "approve-deploy", approver: "you", actor: "alex",
+    }));
+
+    expect(code).toBe(0);
+    expect(appendGateResolutionMock).toHaveBeenCalledWith(
+      expect.objectContaining({ op: "deploy-gated", gate: "approve-deploy", resolvedBy: "you" }),
+    );
+    errSpy.mockRestore();
+    vi.unstubAllEnvs();
+  });
+
   // #2028 — the resolution's link is typed, so a reader is not sniffing
   // free-text `note` for something that looks like a URL.
   test("--url is recorded typed, alongside --note's prose", async () => {
@@ -361,6 +441,43 @@ describe("runApprove", () => {
     errSpy.mockRestore();
   });
 
+  // #2119 — `--expire` clears a standing pending fact without approving it.
+  test("--expire supersedes the standing pending fact and writes no resolution", async () => {
+    readGateLedgerMock.mockResolvedValue({
+      resolutions: [],
+      pending: [{
+        version: 1, kind: "pending", op: "fountain-apply", gate: "rollout-gate",
+        description: "release manager signs off",
+        timestamp: "2026-01-01T00:00:00.000Z", expiresAt: "2099-01-01T00:00:00.000Z",
+      }],
+      malformed: 0,
+    });
+    appendPendingGateMock.mockResolvedValue({ commit: "sha", record: {} });
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
+
+    const code = await runApprove(ctx({ path: "fountain-apply", extraPositional: "rollout-gate", expire: true }));
+
+    expect(code).toBe(0);
+    expect(appendGateResolutionMock).not.toHaveBeenCalled();
+    const written = appendPendingGateMock.mock.calls[0][0];
+    expect(written.op).toBe("fountain-apply");
+    expect(written.gate).toBe("rollout-gate");
+    expect(written.description).toBe("release manager signs off");
+    // Already expired the moment it is written: the next run re-decides.
+    expect(written.expiresAt).toBe(written.timestamp);
+    expect(pushLifecycleMock).toHaveBeenCalled();
+    errSpy.mockRestore();
+  });
+
+  test("--expire with nothing standing writes nothing and still exits 0", async () => {
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
+    const code = await runApprove(ctx({ path: "fountain-apply", extraPositional: "rollout-gate", expire: true }));
+    expect(code).toBe(0);
+    expect(appendPendingGateMock).not.toHaveBeenCalled();
+    expect(appendGateResolutionMock).not.toHaveBeenCalled();
+    errSpy.mockRestore();
+  });
+
   test("warns (but still records) when the op isn't among discovered *.op.ts declarations", async () => {
     discoverOpsMock.mockResolvedValue({ ops: new Map(), errors: [] });
     appendGateResolutionMock.mockResolvedValue({
@@ -396,10 +513,65 @@ describe("runOperatorLog", () => {
 
   beforeEach(() => {
     discoverConvergeOpsMock.mockResolvedValue({
-      ops: [{ config: { name: "staging-converge", searchAttributes: { Env: "staging" } } }],
+      ops: [{ config: { name: "staging-converge", labels: { Env: "staging" } } }],
       errors: [],
     });
     readGateResolutionsMock.mockResolvedValue({ records: [], malformed: 0 });
+    readRunLedgerMock.mockResolvedValue({ records: [], malformed: 0 });
+  });
+
+  /** One Op-run record (#2118) as `readRunLedger` returns it. */
+  function run(over: Record<string, unknown> = {}) {
+    return {
+      version: 1,
+      id: "99999999-8888-7777-6666-555555555555",
+      op: "staging-converge",
+      env: "staging",
+      started: "2026-01-01T00:29:00.000Z",
+      ended: "2026-01-01T00:30:00.000Z",
+      status: "ok",
+      labels: { Converge: "true", Env: "staging" },
+      outcomes: { Drift: false },
+      phases: [{ name: "Converge", status: "ok", steps: [{ fn: "convergeTick", status: "ok", durationMs: 60_000 }] }],
+      ...over,
+    };
+  }
+
+  test("run records are merged into the timeline, ordered by the instant they ended (#2118)", async () => {
+    readConvergeLedgerMock.mockResolvedValue({
+      records: [
+        tick({ id: "t1", timestamp: "2026-01-01T00:00:00.000Z" }),
+        tick({ id: "t2", timestamp: "2026-01-01T01:00:00.000Z" }),
+      ],
+      malformed: 0,
+    });
+    readRunLedgerMock.mockResolvedValue({ records: [run({ id: "r1" })], malformed: 0 });
+
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+    expect(await runOperatorLog(ctx({ json: true }))).toBe(0);
+
+    const printed = JSON.parse(logSpy.mock.calls[0][0] as string);
+    expect(printed.entries.map((e: { kind: string; record: { id: string } }) => [e.kind, e.record.id])).toEqual([
+      ["tick", "t1"],
+      ["run", "r1"],
+      ["tick", "t2"],
+    ]);
+    expect(readRunLedgerMock).toHaveBeenCalledWith("staging", "staging-converge", expect.anything());
+    logSpy.mockRestore();
+  });
+
+  test("a run renders one line naming its status and captured outcomes", async () => {
+    readConvergeLedgerMock.mockResolvedValue({ records: [], malformed: 0 });
+    readRunLedgerMock.mockResolvedValue({ records: [run({ id: "r1", status: "gated" })], malformed: 0 });
+
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+    expect(await runOperatorLog(ctx({}))).toBe(0);
+
+    const out = logSpy.mock.calls.map((c) => String(c[0])).join("\n");
+    expect(out).toContain("staging-converge@staging");
+    expect(out).toContain("run gated phases=1 steps=1");
+    expect(out).toContain("Drift=false");
+    logSpy.mockRestore();
   });
 
   test("--json emits the whole tick history, not just the newest row", async () => {
@@ -416,7 +588,7 @@ describe("runOperatorLog", () => {
 
     const printed = JSON.parse(logSpy.mock.calls[0][0] as string);
     expect(printed.entries.map((e: { record: { id: string } }) => e.record.id)).toEqual(["t1", "t2", "t3"]);
-    expect(printed.malformed).toEqual({ converge: 0, gates: 0 });
+    expect(printed.malformed).toEqual({ converge: 0, gates: 0, runs: 0 });
     logSpy.mockRestore();
   });
 
@@ -488,8 +660,8 @@ describe("runOperatorLog", () => {
   test("--op restricts to one ConvergeOp", async () => {
     discoverConvergeOpsMock.mockResolvedValue({
       ops: [
-        { config: { name: "staging-converge", searchAttributes: { Env: "staging" } } },
-        { config: { name: "other-converge", searchAttributes: { Env: "staging" } } },
+        { config: { name: "staging-converge", labels: { Env: "staging" } } },
+        { config: { name: "other-converge", labels: { Env: "staging" } } },
       ],
       errors: [],
     });
@@ -507,8 +679,8 @@ describe("runOperatorLog", () => {
   test("two ConvergeOps sharing one environment read that ledger once", async () => {
     discoverConvergeOpsMock.mockResolvedValue({
       ops: [
-        { config: { name: "staging-converge", searchAttributes: { Env: "staging" } } },
-        { config: { name: "other-converge", searchAttributes: { Env: "staging" } } },
+        { config: { name: "staging-converge", labels: { Env: "staging" } } },
+        { config: { name: "other-converge", labels: { Env: "staging" } } },
       ],
       errors: [],
     });