@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/cadence-bus-schedule.test.mjs

@@ -1,194 +0,0 @@
-/**
- * cadence-bus-schedule.test.mjs — node:test coverage for the WS4 at-most-once
- * cron gate (grace window + stale fast-forward) added to enqueueTick.
- *
- * Time is injected (`input.now`) so every boundary decision is deterministic.
- * Each test gets its own AGENT_ROOT under tmpdir().
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { promises as fsp } from "node:fs";
-import { readFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { enqueueTick, listInbox, busDepth, getBusPaths } from "./cadence-bus.mjs";
-
-async function makeAgentRoot() {
-  const path = join(tmpdir(), `cadence-sched-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  await fsp.mkdir(path, { recursive: true });
-  return path;
-}
-async function rmRoot(path) { try { await fsp.rm(path, { recursive: true, force: true }); } catch { /* */ } }
-
-function readSchedule(root) {
-  const p = join(root, "state/cadence-bus/schedule.json");
-  return existsSync(p) ? JSON.parse(readFileSync(p, "utf-8")) : {};
-}
-
-const INTERVAL = 300_000; // 5 min
-const GRACE = INTERVAL / 2; // clamp(150s, 120s, 2h) = 150s = 150_000ms
-
-// ---------------------------------------------------------------------------
-// back-compat: no interval → behaves exactly as before
-// ---------------------------------------------------------------------------
-
-test("no intervalMs supplied → every call enqueues (legacy behaviour preserved)", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const a = enqueueTick({ cadence: "inbox-processor", source: "launchd", agentRoot: root });
-    const b = enqueueTick({ cadence: "inbox-processor", source: "launchd", agentRoot: root });
-    const c = enqueueTick({ cadence: "inbox-processor", source: "launchd", agentRoot: root });
-    assert.ok(a.path && b.path && c.path, "all three should land in inbox");
-    assert.equal(busDepth(root).inbox, 3);
-    // No schedule.json is created when no interval is supplied.
-    assert.equal(existsSync(join(root, "state/cadence-bus/schedule.json")), false);
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// first tick + grace suppression
-// ---------------------------------------------------------------------------
-
-test("first interval-bearing tick admits and schedules the next boundary", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const t0 = 1_000_000_000;
-    const r = enqueueTick({ cadence: "backlog-executor", intervalMs: INTERVAL, now: t0, source: "launchd", agentRoot: root });
-    assert.ok(r.path, "first tick admitted");
-    const sched = readSchedule(root);
-    assert.equal(sched["backlog-executor"].nextRunAt, t0 + INTERVAL);
-    assert.equal(sched["backlog-executor"].intervalMs, INTERVAL);
-  } finally { await rmRoot(root); }
-});
-
-test("a duplicate launchd fire before the grace window is suppressed", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const t0 = 1_000_000_000;
-    enqueueTick({ cadence: "backlog-executor", intervalMs: INTERVAL, now: t0, source: "launchd", agentRoot: root });
-    // A second fire a few seconds later — well before nextRunAt - grace.
-    const dup = enqueueTick({ cadence: "backlog-executor", intervalMs: INTERVAL, now: t0 + 5_000, source: "launchd", agentRoot: root });
-    assert.equal(dup.path, null);
-    assert.equal(dup.skipped, "before-grace-window");
-    assert.equal(busDepth(root).inbox, 1, "only the first tick is in inbox");
-  } finally { await rmRoot(root); }
-});
-
-test("a fire within the grace window of the boundary admits and advances", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const t0 = 1_000_000_000;
-    enqueueTick({ cadence: "backlog-executor", intervalMs: INTERVAL, now: t0, source: "launchd", agentRoot: root });
-    // nextRunAt = t0+INTERVAL. Fire at (nextRunAt - grace) exactly → admit.
-    const onTime = t0 + INTERVAL - GRACE;
-    const r = enqueueTick({ cadence: "backlog-executor", intervalMs: INTERVAL, now: onTime, source: "launchd", agentRoot: root });
-    assert.ok(r.path, "within-grace fire admitted");
-    assert.equal(busDepth(root).inbox, 2);
-    // nextRunAt advanced by one interval from the prior boundary.
-    assert.equal(readSchedule(root)["backlog-executor"].nextRunAt, t0 + 2 * INTERVAL);
-  } finally { await rmRoot(root); }
-});
-
-test("steady-state: one admit per interval across many fires", async () => {
-  const root = await makeAgentRoot();
-  try {
-    let t = 2_000_000_000;
-    let admitted = 0;
-    // Simulate launchd firing every interval for 6 periods, plus a spurious
-    // double-fire 2s after each real fire.
-    for (let i = 0; i < 6; i++) {
-      const real = enqueueTick({ cadence: "meeting-prep", intervalMs: INTERVAL, now: t, source: "launchd", agentRoot: root });
-      if (real.path) admitted++;
-      const dbl = enqueueTick({ cadence: "meeting-prep", intervalMs: INTERVAL, now: t + 2_000, source: "launchd", agentRoot: root });
-      if (dbl.path) admitted++;
-      t += INTERVAL;
-    }
-    assert.equal(admitted, 6, "exactly one admit per interval, double-fires suppressed");
-    assert.equal(busDepth(root).inbox, 6);
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// stale fast-forward (the outage fix) — exactly ONE catch-up
-// ---------------------------------------------------------------------------
-
-test("after a multi-period outage, exactly ONE catch-up tick is enqueued (not the burst)", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const t0 = 3_000_000_000;
-    // First tick at t0 → nextRunAt = t0 + INTERVAL.
-    enqueueTick({ cadence: "daily-morning-brief", intervalMs: INTERVAL, now: t0, source: "launchd", agentRoot: root });
-    assert.equal(busDepth(root).inbox, 1);
-
-    // Power outage: the box is off for ~10 intervals. The FIRST fire after
-    // boot is way past nextRunAt + interval → stale fast-forward.
-    const afterOutage = t0 + 10 * INTERVAL + 12_345;
-    const r = enqueueTick({ cadence: "daily-morning-brief", intervalMs: INTERVAL, now: afterOutage, source: "launchd", agentRoot: root });
-    assert.ok(r.path, "one catch-up tick admitted");
-    assert.equal(busDepth(root).inbox, 2, "exactly ONE catch-up — not 10 missed ticks");
-
-    // nextRunAt jumped to the next FUTURE boundary, strictly after now.
-    const next = readSchedule(root)["daily-morning-brief"].nextRunAt;
-    assert.ok(next > afterOutage, `nextRunAt ${next} must be in the future of ${afterOutage}`);
-    // And it's aligned on the interval grid from t0.
-    assert.equal((next - (t0 + INTERVAL)) % INTERVAL, 0, "future boundary stays on the interval grid");
-
-    // The catch-up event is annotated so downstream can see it was a recovery.
-    const inboxIds = listInbox(root);
-    const events = inboxIds.map((id) => JSON.parse(readFileSync(join(getBusPaths(root).inbox, `${id}.json`), "utf-8")));
-    const caught = events.find((e) => e.metadata && e.metadata.schedule_kind === "catch-up");
-    assert.ok(caught, "catch-up event carries schedule_kind metadata");
-    assert.ok(caught.metadata.periods_missed >= 1);
-  } finally { await rmRoot(root); }
-});
-
-test("immediately after a catch-up, the next fire within the same interval is suppressed", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const t0 = 4_000_000_000;
-    enqueueTick({ cadence: "x-cadence", intervalMs: INTERVAL, now: t0, source: "launchd", agentRoot: root });
-    const afterOutage = t0 + 8 * INTERVAL + 1000;
-    enqueueTick({ cadence: "x-cadence", intervalMs: INTERVAL, now: afterOutage, source: "launchd", agentRoot: root });
-    const before = busDepth(root).inbox;
-    // A spurious re-fire 3s later must NOT add a second catch-up.
-    const dup = enqueueTick({ cadence: "x-cadence", intervalMs: INTERVAL, now: afterOutage + 3_000, source: "launchd", agentRoot: root });
-    assert.equal(dup.path, null);
-    assert.equal(busDepth(root).inbox, before, "no duplicate catch-up");
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// grace clamp bounds
-// ---------------------------------------------------------------------------
-
-test("grace is clamped to >=120s for very short intervals", async () => {
-  const root = await makeAgentRoot();
-  try {
-    const shortInterval = 60_000; // 1 min → interval/2 = 30s, clamped up to 120s
-    const t0 = 5_000_000_000;
-    enqueueTick({ cadence: "fast", intervalMs: shortInterval, now: t0, source: "launchd", agentRoot: root });
-    // nextRunAt = t0 + 60s. A fire 100s after t0 is within (nextRunAt - 120s)=t0-60s..
-    // i.e. now >= nextRunAt - grace → t0+100_000 >= (t0+60_000) - 120_000 = t0-60_000. True → admit.
-    const r = enqueueTick({ cadence: "fast", intervalMs: shortInterval, now: t0 + 100_000, source: "launchd", agentRoot: root });
-    assert.ok(r.path, "fire within the clamped 120s grace admits");
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// emergency-stop still wins over the gate
-// ---------------------------------------------------------------------------
-
-test("emergency-stop suppresses even an on-boundary interval tick", async () => {
-  const root = await makeAgentRoot();
-  try {
-    await fsp.writeFile(join(root, ".emergency-stop"), "stop");
-    const r = enqueueTick({ cadence: "y", intervalMs: INTERVAL, now: 6_000_000_000, source: "launchd", agentRoot: root });
-    assert.equal(r.skipped, "emergency-stop");
-    assert.equal(busDepth(root).inbox, 0);
-    // The schedule gate never ran (emergency-stop short-circuits first), so no
-    // schedule.json is created.
-    assert.equal(existsSync(join(root, "state/cadence-bus/schedule.json")), false);
-  } finally { await rmRoot(root); }
-});