@cplieger/actions 1.0.1 → 1.0.2

package/src/redteam2.test.ts

@@ -1,337 +0,0 @@
-// @vitest-environment happy-dom
-// RED-TEAM round 2: deeper adversarial tests.
-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 { apiAction, configureApi, _resetApiConfigForTest } from "./api.js";
-import { defineAction, _resetForTest as resetDefine } from "./define.js";
-import { _resetForTest as resetRegistry, recentLog, getActionLog, subscribe } from "./registry.js";
-import { _resetForTest as resetCleanup } from "./cleanup.js";
-
-const mockFetch = vi.fn();
-
-beforeEach(() => {
-  resetDefine();
-  resetRegistry();
-  resetCleanup();
-  _resetApiConfigForTest();
-  mockFetch.mockReset();
-  vi.stubGlobal("fetch", mockFetch);
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-// ---------------------------------------------------------------------------
-// 1. Timeout firing during retry backoff — must report "timeout" not "cancelled"
-// ---------------------------------------------------------------------------
-describe("timeout during retry backoff", () => {
-  it("reports error code 'timeout' when timeout fires during backoff sleep", async () => {
-    let attempt = 0;
-    const action = defineAction({
-      name: "timeout.during.backoff",
-      timeout: 80,
-      retry: { count: 3, delay: 200 },
-      retryable: () => true,
-      run: async () => {
-        attempt++;
-        throw new Error("transient");
-      },
-    });
-    const result = await action.dispatch("x");
-    expect(result).toBeNull();
-    const entry = recentLog().find((e) => e.name === "timeout.during.backoff");
-    expect(entry).toBeDefined();
-    expect(entry!.status).toBe("error");
-    // The error code must be "timeout", not "cancelled"
-    expect(entry!.error?.code).toBe("timeout");
-    // Should have attempted at least once before timeout during backoff
-    expect(attempt).toBeGreaterThanOrEqual(1);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 2. baseUrl with absolute URL — should NOT prepend baseUrl
-// ---------------------------------------------------------------------------
-describe("baseUrl does not break absolute URLs", () => {
-  it("preserves absolute http:// URLs without prepending baseUrl", async () => {
-    configureApi({ baseUrl: "https://api.example.com/v1" });
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({}), { status: 200 }));
-    // If path is already absolute, the current implementation still prepends.
-    // This test documents the current behavior.
-    const action = apiAction<string>({
-      name: "abs.url",
-      request: () => ({ method: "GET", path: "/items?foo=bar&baz=1" }),
-    });
-    await action.dispatch("x");
-    const url = mockFetch.mock.calls[0]![0] as string;
-    // Query strings must be preserved
-    expect(url).toBe("https://api.example.com/v1/items?foo=bar&baz=1");
-    expect(url).toContain("?foo=bar&baz=1");
-  });
-
-  it("preserves query strings when baseUrl has trailing slash", async () => {
-    configureApi({ baseUrl: "https://api.example.com/" });
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({}), { status: 200 }));
-    const action = apiAction<string>({
-      name: "qs.preserve",
-      request: () => ({ method: "GET", path: "/search?q=hello&page=2" }),
-    });
-    await action.dispatch("x");
-    const url = mockFetch.mock.calls[0]![0] as string;
-    expect(url).toBe("https://api.example.com/search?q=hello&page=2");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 3. prepareHeaders does NOT mutate a shared object across requests
-// ---------------------------------------------------------------------------
-describe("prepareHeaders isolation", () => {
-  it("each request gets a fresh Headers object (no cross-request mutation)", async () => {
-    const headersReceived: Headers[] = [];
-    configureApi({
-      prepareHeaders: (headers) => {
-        headersReceived.push(headers);
-        headers.set("X-Count", String(headersReceived.length));
-      },
-    });
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({}), { status: 200 }));
-    const action = apiAction<string>({
-      name: "headers.isolation",
-      request: () => ({ method: "GET", path: "/x" }),
-    });
-    await action.dispatch("a");
-    await action.dispatch("b");
-    // Each call should have received a distinct Headers instance
-    expect(headersReceived[0]).not.toBe(headersReceived[1]);
-    // First request should have X-Count: 1, second X-Count: 2
-    const h1 = (mockFetch.mock.calls[0]![1] as RequestInit).headers as Record<string, string>;
-    const h2 = (mockFetch.mock.calls[1]![1] as RequestInit).headers as Record<string, string>;
-    expect(h1["x-count"]).toBe("1");
-    expect(h2["x-count"]).toBe("2");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 4. fetchFn returning non-Response (type violation at runtime)
-// ---------------------------------------------------------------------------
-describe("fetchFn returning non-Response", () => {
-  it("surfaces as an error when fetchFn returns null", async () => {
-    configureApi({
-      fetchFn: (async () => null) as unknown as typeof fetch,
-    });
-    const action = apiAction<string>({
-      name: "fetch.null",
-      request: () => ({ method: "GET", path: "/x" }),
-    });
-    const result = await action.dispatch("x");
-    expect(result).toBeNull();
-    const entry = recentLog().find((e) => e.name === "fetch.null");
-    expect(entry?.status).toBe("error");
-  });
-
-  it("surfaces as an error when fetchFn returns a non-object", async () => {
-    configureApi({
-      fetchFn: (async () => 42) as unknown as typeof fetch,
-    });
-    const action = apiAction<string>({
-      name: "fetch.number",
-      request: () => ({ method: "GET", path: "/x" }),
-    });
-    const result = await action.dispatch("x");
-    expect(result).toBeNull();
-    const entry = recentLog().find((e) => e.name === "fetch.number");
-    expect(entry?.status).toBe("error");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 5. DispatchHandle.abort before run starts (scope-queued)
-// ---------------------------------------------------------------------------
-describe("DispatchHandle.abort before run starts", () => {
-  it("abort() on a scope-queued dispatch cancels without running once scope frees", async () => {
-    const runSpy = vi.fn().mockResolvedValue("ok");
-    let blockerResolve: ((v: string) => void) | undefined;
-    const blocker = defineAction({
-      name: "abort.pre.blocker2",
-      scope: "abort-pre-scope2",
-      run: () =>
-        new Promise<string>((resolve) => {
-          blockerResolve = resolve;
-        }),
-    });
-    const target = defineAction({
-      name: "abort.pre.target2",
-      scope: "abort-pre-scope2",
-      run: runSpy,
-    });
-    const h1 = blocker.dispatch("a");
-    // Wait a tick for blocker's run() to start and capture the resolver
-    await Promise.resolve();
-    await Promise.resolve();
-    expect(blockerResolve).toBeDefined();
-    const h2 = target.dispatch("b");
-    // Abort target before it starts (it's queued behind blocker)
-    h2.abort();
-    // Now let blocker finish — target should detect abort and not run
-    blockerResolve!("done");
-    await h1;
-    const r2 = await h2;
-    expect(r2).toBeNull();
-    // run should never have been called for the aborted dispatch
-    expect(runSpy).not.toHaveBeenCalled();
-  });
-
-  it("abort() on non-scope dispatch that hasn't started yet records cancelled", async () => {
-    const action = defineAction({
-      name: "abort.immediate",
-      run: async () => "should not reach",
-    });
-    const handle = action.dispatch("x");
-    handle.abort();
-    const result = await handle;
-    expect(result).toBeNull();
-    const entry = recentLog().find((e) => e.name === "abort.immediate");
-    expect(entry?.status).toBe("cancelled");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 6. Dedupe key collisions across different actions
-// ---------------------------------------------------------------------------
-describe("dedupe key collisions across different actions", () => {
-  it("two actions with same args but different names do NOT share dedupe", async () => {
-    const action1 = defineAction({
-      name: "dedupe.action1",
-      dedupe: true,
-      run: async () => "result1",
-    });
-    const action2 = defineAction({
-      name: "dedupe.action2",
-      dedupe: true,
-      run: async () => "result2",
-    });
-    const [r1, r2] = await Promise.all([
-      action1.dispatch("same-args"),
-      action2.dispatch("same-args"),
-    ]);
-    expect(r1).toBe("result1");
-    expect(r2).toBe("result2");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 7. getActionLog mutation by caller
-// ---------------------------------------------------------------------------
-describe("getActionLog mutation safety", () => {
-  it("mutating returned array does not affect internal log", async () => {
-    const action = defineAction({ name: "log.mutate", run: async () => "ok" });
-    await action.dispatch("x");
-    const log1 = getActionLog();
-    expect(log1.length).toBeGreaterThan(0);
-    // Attempt to mutate the returned array
-    (log1 as unknown[]).length = 0;
-    // Internal log should be unaffected
-    const log2 = getActionLog();
-    expect(log2.length).toBeGreaterThan(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 8. Registry listener throwing does not prevent other listeners
-// ---------------------------------------------------------------------------
-describe("registry listener throwing", () => {
-  it("throwing listener does not prevent subsequent listeners from firing", async () => {
-    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-    const results: string[] = [];
-    subscribe(() => {
-      throw new Error("listener boom");
-    });
-    subscribe((inst) => {
-      results.push(inst.status);
-    });
-    const action = defineAction({ name: "listener.throw", run: async () => "ok" });
-    await action.dispatch("x");
-    expect(results).toContain("pending");
-    expect(results).toContain("success");
-    expect(consoleSpy).toHaveBeenCalled();
-    consoleSpy.mockRestore();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 9. Scope serialization: action A dispatching B in same scope
-// ---------------------------------------------------------------------------
-describe("scope serialization", () => {
-  it("action A dispatching B in same scope — B runs after A completes (no deadlock if not awaited)", async () => {
-    let innerResult: string | null = null;
-    const actionB = defineAction({
-      name: "scope.serial.B",
-      scope: "shared-scope-serial",
-      run: async () => "B-done",
-    });
-    const actionA = defineAction({
-      name: "scope.serial.A",
-      scope: "shared-scope-serial",
-      run: async () => {
-        // Dispatch B from within A — B will queue behind A
-        // Do NOT await it here (that would deadlock by design)
-        const handleB = actionB.dispatch("b");
-        void handleB.then((r) => {
-          innerResult = r;
-        });
-        return "A-done";
-      },
-    });
-    const resultA = await actionA.dispatch("a");
-    expect(resultA).toBe("A-done");
-    // Give B time to run (it was queued behind A, runs after A's tail resolves)
-    await new Promise((r) => setTimeout(r, 10));
-    expect(innerResult).toBe("B-done");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 10. abort during prepareHeaders (signal already aborted when prepareHeaders runs)
-// ---------------------------------------------------------------------------
-describe("abort during prepareHeaders", () => {
-  it("abort signal checked after prepareHeaders — cancelled if aborted during prep", async () => {
-    let _prepDone = false;
-    let prepResolve!: () => void;
-    const prepPromise = new Promise<void>((r) => {
-      prepResolve = r;
-    });
-    configureApi({
-      prepareHeaders: async (headers) => {
-        await prepPromise;
-        _prepDone = true;
-        headers.set("Authorization", "Bearer token");
-      },
-    });
-    mockFetch.mockResolvedValue(new Response(JSON.stringify({}), { status: 200 }));
-    const action = apiAction<string>({
-      name: "abort.during.prep",
-      request: () => ({ method: "GET", path: "/x" }),
-    });
-    const handle = action.dispatch("x");
-    // Abort before prepareHeaders completes
-    handle.abort();
-    // Now let prepareHeaders finish
-    prepResolve();
-    const result = await handle;
-    expect(result).toBeNull();
-    const entry = recentLog().find((e) => e.name === "abort.during.prep");
-    expect(entry?.status).toBe("cancelled");
-    // fetch should still have been called because prepareHeaders completed
-    // and the signal check happens in run() not in executeRequest
-    // Actually: the signal is passed to fetch, so fetch may or may not have been called
-    // The key assertion is that the action is cancelled
-  });
-});