@polderlabs/bizar 6.2.4 → 6.3.0

package/plugins/bizar/tests/dispose.test.ts

@@ -1,336 +0,0 @@
-/**
- * Plugin dispose tests.
- *
- * Tests (LOW-47, HIGH-21):
- * - dispose walks the in-memory map
- * - each running instance receives an abort call
- * - serve child receives SIGTERM
- * - bg/*.json files persist (not deleted on dispose)
- * - SIGTERM handler marks all running instances as failed (HIGH-20)
- * - SIGTERM handler calls process.exit(0)
- */
-
-import { describe, it, expect, beforeEach, vi } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-type BackgroundStatus = "pending" | "running" | "done" | "failed" | "killed" | "timed_out";
-
-interface BackgroundState {
-  instanceId: string;
-  sessionId: string;
-  status: BackgroundStatus;
-  error?: string;
-  completedAt?: number;
-}
-
-// ---------------------------------------------------------------------------
-// State for tracking dispose side-effects
-// ---------------------------------------------------------------------------
-
-const disposeState = {
-  abortCalls: [] as string[], // sessionIds that received abort
-  sigtermSent: false,
-  processExitCalled: false,
-  eventStreamClosed: false,
-  inMemoryMapCleared: false,
-};
-
-function resetDisposeState() {
-  disposeState.abortCalls.length = 0;
-  disposeState.sigtermSent = false;
-  disposeState.processExitCalled = false;
-  disposeState.eventStreamClosed = false;
-  disposeState.inMemoryMapCleared = false;
-}
-
-// ---------------------------------------------------------------------------
-// Fake dispose implementation matching the spec §5.3
-// ---------------------------------------------------------------------------
-
-async function dispose(
-  instances: Map<string, BackgroundState>,
-  _proc: { kill: (signal: string) => void } | null,
-  eventSource: { close: () => void } | null,
-): Promise<void> {
-  // Step 1: Mark all running/pending instances as failed
-  for (const inst of instances.values()) {
-    if (inst.status === "running" || inst.status === "pending") {
-      inst.status = "failed";
-      inst.error = "plugin shutting down";
-      inst.completedAt = Date.now();
-    }
-  }
-
-  // Step 2: Best-effort abort calls for running instances
-  const abortPromises = [...instances.values()]
-    .filter((i) => i.status === "failed" && i.error === "plugin shutting down" && i.sessionId)
-    .map((i) => {
-      disposeState.abortCalls.push(i.sessionId);
-      return Promise.resolve();
-    });
-  await Promise.allSettled(abortPromises);
-
-  // Step 3: Kill serve child
-  if (_proc) {
-    try {
-      _proc.kill("SIGTERM");
-      disposeState.sigtermSent = true;
-    } catch {
-      // ignore
-    }
-  }
-
-  // Step 4: Close SSE
-  if (eventSource) {
-    eventSource.close();
-    disposeState.eventStreamClosed = true;
-  }
-
-  // Step 5: Exit
-  disposeState.processExitCalled = true;
-}
-
-// ---------------------------------------------------------------------------
-// In-memory map for tests
-// ---------------------------------------------------------------------------
-
-function makeInstances(): Map<string, BackgroundState> {
-  const m = new Map<string, BackgroundState>();
-  m.set("bgr_running", { instanceId: "bgr_running", sessionId: "sess_running", status: "running" });
-  m.set("bgr_pending", { instanceId: "bgr_pending", sessionId: "sess_pending", status: "pending" });
-  m.set("bgr_done", { instanceId: "bgr_done", sessionId: "sess_done", status: "done", completedAt: Date.now() - 60_000 });
-  m.set("bgr_failed", { instanceId: "bgr_failed", sessionId: "sess_failed", status: "failed", error: "already failed", completedAt: Date.now() });
-  m.set("bgr_killed", { instanceId: "bgr_killed", sessionId: "sess_killed", status: "killed", completedAt: Date.now() - 30_000 });
-  return m;
-}
-
-// ---------------------------------------------------------------------------
-// dispose walks the in-memory map (LOW-47, HIGH-21)
-// ---------------------------------------------------------------------------
-
-describe("dispose — walks in-memory map (LOW-47, HIGH-21)", () => {
-  beforeEach(() => resetDisposeState());
-
-  it("marks all running instances as failed", async () => {
-    const instances = makeInstances();
-    await dispose(instances, null, null);
-
-    expect(instances.get("bgr_running")!.status).toBe("failed");
-    expect(instances.get("bgr_running")!.error).toBe("plugin shutting down");
-    expect(instances.get("bgr_pending")!.status).toBe("failed");
-  });
-
-  it("does NOT re-mark done/failed/killed instances", async () => {
-    const instances = makeInstances();
-    await dispose(instances, null, null);
-
-    // These were already in terminal states — should stay as-is (not overwritten)
-    expect(instances.get("bgr_done")!.status).toBe("done");
-    expect(instances.get("bgr_failed")!.status).toBe("failed");
-    expect(instances.get("bgr_killed")!.status).toBe("killed");
-  });
-
-  it("sets completedAt on newly-failed instances", async () => {
-    const instances = makeInstances();
-    const before = Date.now();
-    await dispose(instances, null, null);
-    const after = Date.now();
-
-    const completedAt = instances.get("bgr_running")!.completedAt!;
-    expect(completedAt).toBeGreaterThanOrEqual(before);
-    expect(completedAt).toBeLessThanOrEqual(after);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Each running instance receives an abort call
-// ---------------------------------------------------------------------------
-
-describe("dispose — abort calls to running instances", () => {
-  beforeEach(() => resetDisposeState());
-
-  it("each running instance receives exactly one abort call", async () => {
-    const instances = makeInstances();
-    await dispose(instances, null, null);
-
-    // Both running and pending should have had abort attempted
-    expect(disposeState.abortCalls).toContain("sess_running");
-    expect(disposeState.abortCalls).toContain("sess_pending");
-    // Done/failed/killed should not be aborted (already terminal)
-    expect(disposeState.abortCalls).not.toContain("sess_done");
-  });
-
-  it("no abort calls for already-terminal instances", async () => {
-    const instances = makeInstances();
-    await dispose(instances, null, null);
-    // sess_done, sess_failed, sess_killed are all terminal — no abort
-    const terminalAborts = disposeState.abortCalls.filter(
-      (s) => s === "sess_done" || s === "sess_failed" || s === "sess_killed",
-    );
-    expect(terminalAborts).toHaveLength(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Serve child receives SIGTERM
-// ---------------------------------------------------------------------------
-
-describe("dispose — serve child SIGTERM", () => {
-  beforeEach(() => resetDisposeState());
-
-  it("proc.kill('SIGTERM') is called when proc is present", async () => {
-    const instances = makeInstances();
-    const fakeProc = { kill: vi.fn() };
-    await dispose(instances, fakeProc as unknown as { kill: (signal: string) => void }, null);
-
-    expect(fakeProc.kill).toHaveBeenCalledWith("SIGTERM");
-    expect(disposeState.sigtermSent).toBe(true);
-  });
-
-  it("no SIGTERM when proc is null (serve never started)", async () => {
-    const instances = makeInstances();
-    await dispose(instances, null, null);
-    expect(disposeState.sigtermSent).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// bg/*.json files persist (not deleted on dispose) (LOW-47)
-// ---------------------------------------------------------------------------
-
-describe("dispose — bg/*.json files persist (LOW-47)", () => {
-  beforeEach(() => resetDisposeState());
-
-  it("dispose does not delete bg/*.json files", async () => {
-    // bg/*.json files are not deleted by dispose — they represent
-    // the on-disk state that allows recovery on restart.
-    // The plugin marks instances as failed in the JSON files on dispose.
-    const instances = makeInstances();
-    await dispose(instances, null, null);
-
-    // The in-memory map still has all entries (not cleared)
-    // The JSON files on disk are NOT deleted — dispose marks them failed
-    // This is by design so restart recovery can read them
-    expect(instances.size).toBe(5);
-  });
-
-  it("state files are preserved for restart recovery", () => {
-    // On restart, the plugin reads bg/*.json and marks orphaned
-    // running/pending instances as failed (per §5.4).
-    // The files persist so this recovery is possible.
-    expect(true).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// SSE stream is closed
-// ---------------------------------------------------------------------------
-
-describe("dispose — SSE stream closed", () => {
-  beforeEach(() => resetDisposeState());
-
-  it("eventSource.close() is called when eventSource is present", async () => {
-    const instances = makeInstances();
-    const fakeEventSource = { close: vi.fn() };
-    await dispose(instances, null, fakeEventSource as unknown as { close: () => void });
-
-    expect(fakeEventSource.close).toHaveBeenCalled();
-    expect(disposeState.eventStreamClosed).toBe(true);
-  });
-
-  it("no close when eventSource is null", async () => {
-    const instances = makeInstances();
-    await dispose(instances, null, null);
-    expect(disposeState.eventStreamClosed).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// process.exit(0) is called last
-// ---------------------------------------------------------------------------
-
-describe("dispose — process.exit(0)", () => {
-  beforeEach(() => resetDisposeState());
-
-  it("process.exit(0) is called after all cleanup steps", async () => {
-    const instances = makeInstances();
-    await dispose(instances, null, null);
-    expect(disposeState.processExitCalled).toBe(true);
-  });
-
-  it("exit is called after abort, SIGTERM, and close", () => {
-    // Verified by the order in the dispose() implementation above:
-    // 1. mark failed, 2. abort, 3. SIGTERM, 4. close, 5. exit
-    expect(true).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// SIGTERM signal handler sequence (HIGH-20) — parallel to dispose
-// ---------------------------------------------------------------------------
-
-describe("SIGTERM signal handler (HIGH-20)", () => {
-  beforeEach(() => resetDisposeState());
-
-  it("marks instances failed BEFORE abort calls (correct order)", async () => {
-    // Per §5.3: first mark all in-memory instances as failed, THEN abort
-    // This ensures the state is correct even if abort fails
-    const instances = makeInstances();
-
-    let markFailedCalled = false;
-    let abortCalled = false;
-
-    // Patch to track order
-    const origDispose = dispose;
-    async function trackedDispose(
-      insts: Map<string, BackgroundState>,
-      proc: { kill: (signal: string) => void } | null,
-      es: { close: () => void } | null,
-    ) {
-      // Step 1: mark failed
-      for (const i of insts.values()) {
-        if (i.status === "running" || i.status === "pending") {
-          i.status = "failed";
-          i.error = "plugin shutting down";
-        }
-      }
-      markFailedCalled = true;
-      expect(abortCalled).toBe(false); // abort not called yet
-
-      // Step 2: abort
-      for (const i of insts.values()) {
-        if (i.sessionId) disposeState.abortCalls.push(i.sessionId);
-      }
-      abortCalled = true;
-
-      // Steps 3-5
-      if (proc) proc.kill("SIGTERM");
-      if (es) es.close();
-      disposeState.processExitCalled = true;
-    }
-
-    await trackedDispose(instances, null, null);
-    expect(markFailedCalled).toBe(true);
-    expect(abortCalled).toBe(true);
-  });
-
-  it("shuttingDown guard prevents re-entry", () => {
-    let shuttingDown = false;
-    let callCount = 0;
-
-    function sigHandler() {
-      if (shuttingDown) return;
-      shuttingDown = true;
-      callCount++;
-    }
-
-    sigHandler();
-    sigHandler(); // second call should be no-op
-    sigHandler(); // third call should be no-op
-
-    expect(callCount).toBe(1);
-  });
-});