@cplieger/actions 1.0.1 → 1.0.2

package/src/registry.test.ts

@@ -1,271 +0,0 @@
-// @vitest-environment happy-dom
-// Targeted tests for registry.ts: tombstone eviction, Set-based listener
-// iteration, pendingCount/recentLog correctness, _resetForTest.
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import {
-  record,
-  subscribe,
-  recentLog,
-  pendingCount,
-  isPending,
-  _resetForTest,
-} from "./registry.js";
-import type { ActionInstance } from "./types.js";
-
-function makeInstance(overrides: Partial<ActionInstance> = {}): ActionInstance {
-  return {
-    id: `id-${Math.random().toString(36).slice(2)}`,
-    name: "test.action",
-    status: "pending",
-    args: {},
-    dispatchedAt: Date.now(),
-    startedAt: Date.now(),
-    ...overrides,
-  };
-}
-
-beforeEach(() => {
-  _resetForTest();
-});
-
-describe("tombstone eviction", () => {
-  it("evicts oldest non-pending entry when log exceeds MAX_LOG_SIZE (200)", () => {
-    for (let i = 0; i < 200; i++) {
-      record(makeInstance({ id: `a-${i}`, status: "success" }));
-    }
-    expect(recentLog()).toHaveLength(200);
-    record(makeInstance({ id: "overflow", status: "success" }));
-    expect(recentLog()).toHaveLength(200);
-  });
-
-  it("preserves pending entries during soft eviction", () => {
-    for (let i = 0; i < 200; i++) {
-      record(makeInstance({ id: `p-${i}`, status: "pending" }));
-    }
-    record(makeInstance({ id: "extra", status: "pending" }));
-    expect(recentLog()).toHaveLength(201);
-    expect(pendingCount()).toBe(201);
-  });
-
-  it("hard cap (1000) force-evicts pending entries and decrements pendingCount", () => {
-    for (let i = 0; i < 1000; i++) {
-      record(makeInstance({ id: `h-${i}`, status: "pending" }));
-    }
-    expect(pendingCount()).toBe(1000);
-    record(makeInstance({ id: "hard-overflow", status: "pending" }));
-    expect(pendingCount()).toBe(1000);
-    expect(recentLog()).toHaveLength(1000);
-  });
-
-  it("compaction splices leading nulls when head > 256", () => {
-    for (let i = 0; i < 260; i++) {
-      record(makeInstance({ id: `c-${i}`, status: "success" }));
-    }
-    for (let i = 0; i < 260; i++) {
-      record(makeInstance({ id: `d-${i}`, status: "success" }));
-    }
-    const log = recentLog();
-    expect(log.length).toBeLessThanOrEqual(200);
-    for (const entry of log) {
-      expect(entry).not.toBeNull();
-    }
-  });
-});
-
-describe("listener iteration", () => {
-  it("listener can unsubscribe itself during notification", () => {
-    const calls: string[] = [];
-    const unsub = subscribe(() => {
-      calls.push("self");
-      unsub();
-    });
-    subscribe(() => calls.push("other"));
-    record(makeInstance());
-    expect(calls).toContain("self");
-    expect(calls).toContain("other");
-    calls.length = 0;
-    record(makeInstance());
-    expect(calls).toEqual(["other"]);
-  });
-
-  it("listener that unsubscribes a later listener prevents it from firing", () => {
-    const calls: string[] = [];
-    // eslint-disable-next-line prefer-const
-    let unsubB: (() => void) | undefined;
-    subscribe(() => {
-      calls.push("A");
-      unsubB?.();
-    });
-    unsubB = subscribe(() => {
-      calls.push("B");
-    });
-    record(makeInstance());
-    expect(calls).toEqual(["A"]);
-  });
-
-  it("listener added during iteration fires for the current event", () => {
-    const calls: string[] = [];
-    subscribe(() => {
-      calls.push("first");
-      subscribe(() => calls.push("dynamic"));
-    });
-    record(makeInstance());
-    expect(calls).toContain("first");
-    expect(calls).toContain("dynamic");
-  });
-
-  it("throwing listener does not prevent other listeners from firing", () => {
-    const calls: string[] = [];
-
-    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-    subscribe(() => {
-      throw new Error("boom");
-    });
-    subscribe(() => calls.push("survived"));
-    record(makeInstance());
-    expect(calls).toEqual(["survived"]);
-    expect(consoleSpy).toHaveBeenCalledWith("[actions] registry listener threw", expect.any(Error));
-    consoleSpy.mockRestore();
-  });
-});
-
-describe("recentLog", () => {
-  it("never returns null entries", () => {
-    for (let i = 0; i < 250; i++) {
-      record(makeInstance({ id: `r-${i}`, status: "success" }));
-    }
-    const log = recentLog();
-    for (const entry of log) {
-      expect(entry).not.toBeNull();
-      expect(entry).not.toBeUndefined();
-    }
-  });
-
-  it("returns entries in insertion order", () => {
-    record(makeInstance({ id: "first", status: "success" }));
-    record(makeInstance({ id: "second", status: "success" }));
-    record(makeInstance({ id: "third", status: "success" }));
-    const log = recentLog();
-    expect(log.map((e) => e.id)).toEqual(["first", "second", "third"]);
-  });
-});
-
-describe("_resetForTest", () => {
-  it("clears all state including pendingCount and listeners", () => {
-    const listener = vi.fn();
-    subscribe(listener);
-    record(makeInstance({ id: "pre", status: "pending" }));
-    expect(pendingCount()).toBe(1);
-    expect(listener).toHaveBeenCalledTimes(1);
-    _resetForTest();
-    listener.mockClear();
-    expect(recentLog()).toHaveLength(0);
-    expect(pendingCount()).toBe(0);
-    expect(pendingCount(["test.action"])).toBe(0);
-    record(makeInstance({ id: "post", status: "pending" }));
-    expect(listener).not.toHaveBeenCalled();
-  });
-});
-
-describe("pendingN tracking", () => {
-  it("increments on new pending, decrements on transition to success", () => {
-    record(makeInstance({ id: "t1", status: "pending" }));
-    expect(pendingCount()).toBe(1);
-    record(makeInstance({ id: "t1", status: "success", completedAt: Date.now() }));
-    expect(pendingCount()).toBe(0);
-  });
-
-  it("handles pending -> error transition", () => {
-    record(makeInstance({ id: "t2", status: "pending" }));
-    expect(pendingCount()).toBe(1);
-    record(makeInstance({ id: "t2", status: "error", error: { message: "fail" } }));
-    expect(pendingCount()).toBe(0);
-  });
-
-  it("handles pending -> cancelled transition", () => {
-    record(makeInstance({ id: "t3", status: "pending" }));
-    record(makeInstance({ id: "t3", status: "cancelled" }));
-    expect(pendingCount()).toBe(0);
-  });
-
-  it("does not double-decrement on repeated terminal transitions", () => {
-    record(makeInstance({ id: "t4", status: "pending" }));
-    record(makeInstance({ id: "t4", status: "success" }));
-    record(makeInstance({ id: "t4", status: "success" }));
-    expect(pendingCount()).toBe(0);
-  });
-
-  it("handles non-pending to pending transition (unusual but valid)", () => {
-    record(makeInstance({ id: "t5", status: "success" }));
-    expect(pendingCount()).toBe(0);
-    record(makeInstance({ id: "t5", status: "pending" }));
-    expect(pendingCount()).toBe(1);
-  });
-});
-
-describe("pendingByName index", () => {
-  it("isPending returns true for pending action, false after completion", () => {
-    record(makeInstance({ id: "p1", name: "chat.send", status: "pending" }));
-    expect(isPending("chat.send")).toBe(true);
-    record(makeInstance({ id: "p1", name: "chat.send", status: "success" }));
-    expect(isPending("chat.send")).toBe(false);
-  });
-
-  it("isPending returns false for unknown action name", () => {
-    expect(isPending("nonexistent")).toBe(false);
-  });
-
-  it("tracks multiple pending instances of the same name", () => {
-    record(makeInstance({ id: "a1", name: "file.upload", status: "pending" }));
-    record(makeInstance({ id: "a2", name: "file.upload", status: "pending" }));
-    expect(isPending("file.upload")).toBe(true);
-    expect(pendingCount(["file.upload"])).toBe(2);
-    record(makeInstance({ id: "a1", name: "file.upload", status: "success" }));
-    expect(isPending("file.upload")).toBe(true);
-    expect(pendingCount(["file.upload"])).toBe(1);
-    record(
-      makeInstance({ id: "a2", name: "file.upload", status: "error", error: { message: "fail" } }),
-    );
-    expect(isPending("file.upload")).toBe(false);
-    expect(pendingCount(["file.upload"])).toBe(0);
-  });
-
-  it("retry (terminal→pending) re-adds to pendingByName", () => {
-    record(makeInstance({ id: "r1", name: "git.push", status: "pending" }));
-    record(
-      makeInstance({ id: "r1", name: "git.push", status: "error", error: { message: "timeout" } }),
-    );
-    expect(isPending("git.push")).toBe(false);
-    record(makeInstance({ id: "r1", name: "git.push", status: "pending" }));
-    expect(isPending("git.push")).toBe(true);
-    expect(pendingCount(["git.push"])).toBe(1);
-  });
-
-  it("pending→pending re-record does not duplicate in index", () => {
-    record(makeInstance({ id: "d1", name: "chat.send", status: "pending" }));
-    record(makeInstance({ id: "d1", name: "chat.send", status: "pending" }));
-    expect(pendingCount(["chat.send"])).toBe(1);
-    expect(pendingCount()).toBe(1);
-  });
-
-  it("hard-cap eviction removes from pendingByName", () => {
-    for (let i = 0; i < 1000; i++) {
-      record(makeInstance({ id: `hc-${i}`, name: "bulk.op", status: "pending" }));
-    }
-    expect(isPending("bulk.op")).toBe(true);
-    record(makeInstance({ id: "hc-overflow", name: "bulk.op", status: "pending" }));
-    expect(pendingCount()).toBe(1000);
-    const pending = recentLog().filter((i) => i.status === "pending" && i.name === "bulk.op");
-    expect(pending.find((e) => e.id === "hc-0")).toBeUndefined();
-  });
-
-  it("_resetForTest clears pendingByName", () => {
-    record(makeInstance({ id: "z1", name: "action.a", status: "pending" }));
-    record(makeInstance({ id: "z2", name: "action.b", status: "pending" }));
-    expect(isPending("action.a")).toBe(true);
-    expect(isPending("action.b")).toBe(true);
-    _resetForTest();
-    expect(isPending("action.a")).toBe(false);
-    expect(isPending("action.b")).toBe(false);
-  });
-});

package/src/retry-network-delay.test.ts

@@ -1,155 +0,0 @@
-// @vitest-environment happy-dom
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-vi.mock("./notifier.js", () => ({
-  configure: vi.fn(),
-  notifySuccess: vi.fn(),
-  notifyError: vi.fn(),
-  _resetNotifierForTest: vi.fn(),
-}));
-import { defineAction, _resetForTest as resetDefine } from "./define.js";
-import { _resetForTest as resetRegistry } from "./registry.js";
-import { _resetForTest as resetCleanup } from "./cleanup.js";
-import { ActionError, retryNetwork } from "./error.js";
-
-beforeEach(() => {
-  resetDefine();
-  resetRegistry();
-  resetCleanup();
-  vi.clearAllMocks();
-});
-afterEach(() => {
-  if ("onLine" in navigator) {
-    Object.defineProperty(navigator, "onLine", { value: true, configurable: true });
-  }
-});
-
-describe("networkMode: 'online' (default)", () => {
-  it("waits for online event before retrying when navigator.onLine is false", async () => {
-    let attempts = 0;
-    Object.defineProperty(navigator, "onLine", { value: false, configurable: true });
-    const action = defineAction<void, string>({
-      name: "test.online.pause",
-      retryable: retryNetwork,
-      retry: { count: 1, delay: 5 },
-      error: false,
-      run: () => {
-        attempts++;
-        throw new ActionError("offline", { code: "network" });
-      },
-    });
-    const p = action.dispatch();
-    await new Promise((r) => setTimeout(r, 20));
-    expect(attempts).toBe(1);
-    Object.defineProperty(navigator, "onLine", { value: true, configurable: true });
-    window.dispatchEvent(new Event("online"));
-    await p;
-    expect(attempts).toBe(2);
-  });
-
-  it("doesn't pause when online to begin with", async () => {
-    let attempts = 0;
-    const action = defineAction<void, string>({
-      name: "test.online.normal",
-      retryable: retryNetwork,
-      retry: { count: 2, delay: 1 },
-      error: false,
-      run: () => {
-        attempts++;
-        throw new ActionError("blip", { code: "network" });
-      },
-    });
-    await action.dispatch();
-    expect(attempts).toBe(3);
-  });
-
-  it("cancel during offline pause unwinds cleanly without retry", async () => {
-    let attempts = 0;
-    Object.defineProperty(navigator, "onLine", { value: false, configurable: true });
-    const action = defineAction<void, string>({
-      name: "test.online.cancel",
-      retryable: retryNetwork,
-      retry: { count: 5, delay: 1 },
-      error: false,
-      run: () => {
-        attempts++;
-        throw new ActionError("offline", { code: "network" });
-      },
-    });
-    const p = action.dispatch();
-    await new Promise((r) => setTimeout(r, 20));
-    expect(attempts).toBe(1);
-    action.cancel();
-    await p;
-    expect(attempts).toBe(1);
-  });
-});
-
-describe("networkMode: 'always'", () => {
-  it("retries even when navigator.onLine is false", async () => {
-    let attempts = 0;
-    Object.defineProperty(navigator, "onLine", { value: false, configurable: true });
-    const action = defineAction<void, string>({
-      name: "test.always.retry",
-      retryable: retryNetwork,
-      retry: { count: 2, delay: 1 },
-      networkMode: "always",
-      error: false,
-      run: () => {
-        attempts++;
-        throw new ActionError("ignored", { code: "network" });
-      },
-    });
-    await action.dispatch();
-    expect(attempts).toBe(3);
-  });
-});
-
-describe("retry.delay as a function", () => {
-  it("invokes delay function with attempt number and error", async () => {
-    const seen: { attempt: number; code: string | undefined }[] = [];
-    let runs = 0;
-    const action = defineAction<void, string>({
-      name: "test.delay.fn",
-      retryable: retryNetwork,
-      retry: {
-        count: 2,
-        delay: (attempt, err) => {
-          seen.push({ attempt, code: err.code });
-          return 0;
-        },
-      },
-      error: false,
-      run: () => {
-        runs++;
-        throw new ActionError("blip", { code: "network" });
-      },
-    });
-    await action.dispatch();
-    expect(runs).toBe(3);
-    expect(seen).toHaveLength(2);
-    expect(seen[0]?.attempt).toBe(1);
-    expect(seen[1]?.attempt).toBe(2);
-    expect(seen[0]?.code).toBe("network");
-  });
-
-  it("falls back to 0ms if delay function throws", async () => {
-    let attempts = 0;
-    const action = defineAction<void, string>({
-      name: "test.delay.fn_throws",
-      retryable: retryNetwork,
-      retry: {
-        count: 1,
-        delay: () => {
-          throw new Error("bad delay fn");
-        },
-      },
-      error: false,
-      run: () => {
-        attempts++;
-        throw new ActionError("blip", { code: "network" });
-      },
-    });
-    await action.dispatch();
-    expect(attempts).toBe(2);
-  });
-});

package/src/transport.test.ts

@@ -1,139 +0,0 @@
-// @vitest-environment happy-dom
-// Tests for transportAction error classification and the configureTransport seam.
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { resetActionFramework } from "./__test-helpers__/action-test-setup.js";
-import { configureTransport, transportAction, _resetTransportForTest } from "./transport.js";
-import { recentLog } from "./registry.js";
-
-vi.mock("./notifier.js", () => ({
-  configure: vi.fn(),
-  notifySuccess: vi.fn(),
-  notifyError: vi.fn(),
-  _resetNotifierForTest: vi.fn(),
-}));
-
-const mockSend = vi.fn();
-
-beforeEach(() => {
-  resetActionFramework();
-  vi.clearAllMocks();
-  mockSend.mockReset();
-  configureTransport(mockSend);
-});
-
-const testAction = () =>
-  transportAction<{ chatID: string }>({
-    name: "test.transport",
-    command: ({ chatID }) => ({ type: "cancel", chat_id: chatID }),
-    error: "Test failed",
-  });
-
-describe("transportAction error classification", () => {
-  it("classifies timeout via r.code", async () => {
-    mockSend.mockResolvedValue({
-      ok: false,
-      status: 0,
-      error: "Request timed out",
-      code: "timeout",
-    });
-    const action = testAction();
-    await action.dispatch({ chatID: "c1" });
-    const log = recentLog();
-    expect(log[0]?.status).toBe("error");
-    expect(log[0]?.error?.code).toBe("timeout");
-  });
-
-  it("classifies cancelled via r.code", async () => {
-    mockSend.mockResolvedValue({
-      ok: false,
-      status: 0,
-      error: "Request cancelled",
-      code: "cancelled",
-    });
-    const action = testAction();
-    await action.dispatch({ chatID: "c1" });
-    const log = recentLog();
-    expect(log[0]?.status).toBe("error");
-    expect(log[0]?.error?.code).toBe("cancelled");
-  });
-
-  it("classifies network error via r.code", async () => {
-    mockSend.mockResolvedValue({ ok: false, status: 0, error: "Failed to fetch", code: "network" });
-    const action = testAction();
-    await action.dispatch({ chatID: "c1" });
-    const log = recentLog();
-    expect(log[0]?.status).toBe("error");
-    expect(log[0]?.error?.code).toBe("network");
-  });
-
-  it("HTTP errors without code throw with status only", async () => {
-    mockSend.mockResolvedValue({ ok: false, status: 500, error: "Internal Server Error" });
-    const action = testAction();
-    await action.dispatch({ chatID: "c1" });
-    const log = recentLog();
-    expect(log[0]?.status).toBe("error");
-    expect(log[0]?.error?.status).toBe(500);
-    expect(log[0]?.error?.code).toBeUndefined();
-  });
-
-  it("signal.aborted takes precedence", async () => {
-    mockSend.mockImplementation(async (_cmd, { signal }) => {
-      // Simulate delay so cancel can fire
-      await new Promise((r) => setTimeout(r, 10));
-      if (signal.aborted) return { ok: false, status: 0, error: "cancelled", code: "network" };
-      return { ok: true, status: 200 };
-    });
-    const action = testAction();
-    const promise = action.dispatch({ chatID: "c1" });
-    action.cancel();
-    await promise;
-    const log = recentLog();
-    expect(log[0]?.status).toBe("cancelled");
-  });
-});
-
-describe("transportAction — unconfigured transport", () => {
-  it("throws ActionError with code transport_not_configured when transport is not set", async () => {
-    _resetTransportForTest();
-    const action = transportAction<{ id: string }>({
-      name: "test.no_transport",
-      command: ({ id }) => ({ type: "test", id }),
-      error: false,
-    });
-    const result = await action.dispatch({ id: "x" });
-    expect(result).toBeNull();
-    const log = recentLog();
-    expect(log[0]?.error?.code).toBe("transport_not_configured");
-  });
-});
-
-describe("transportAction — idempotency key", () => {
-  it("adds idempotency_key to command when configured", async () => {
-    mockSend.mockResolvedValue({ ok: true, status: 200 });
-    const action = transportAction<{ chatID: string }>({
-      name: "test.idem_transport",
-      idempotencyKey: true,
-      command: ({ chatID }) => ({ type: "cancel", chat_id: chatID }),
-      error: false,
-    });
-    await action.dispatch({ chatID: "c1" });
-    expect(mockSend).toHaveBeenCalledTimes(1);
-    const sentCmd = mockSend.mock.calls[0]![0] as { idempotency_key?: string };
-    expect(sentCmd.idempotency_key).toEqual(expect.any(String));
-  });
-
-  it("dispatching with a frozen command object does NOT throw", async () => {
-    mockSend.mockResolvedValue({ ok: true, status: 200 });
-    const frozenCmd = Object.freeze({ type: "cancel" as const, chat_id: "c1" });
-    const action = transportAction<void>({
-      name: "test.frozen_cmd",
-      idempotencyKey: true,
-      command: () => frozenCmd,
-      error: "Frozen failed",
-    });
-    await action.dispatch(undefined);
-    expect(mockSend).toHaveBeenCalledTimes(1);
-    const sent = mockSend.mock.calls[0]![0] as { idempotency_key?: string };
-    expect(sent.idempotency_key).toEqual(expect.any(String));
-  });
-});