@gencow/core 0.1.24 → 0.1.26

package/src/__tests__/workflow.test.ts

@@ -8,7 +8,7 @@ import { v } from "../v.js";
 import { registerWorkflowsApi } from "../workflows-api.js";
 
 const WORKFLOW_TABLE_SETUP = [
-    `CREATE TABLE IF NOT EXISTS _gencow_workflows (
+  `CREATE TABLE IF NOT EXISTS _gencow_workflows (
         id TEXT PRIMARY KEY,
         name TEXT NOT NULL,
         args JSONB NOT NULL DEFAULT '{}'::jsonb,
@@ -25,7 +25,7 @@ const WORKFLOW_TABLE_SETUP = [
         completed_at TIMESTAMPTZ,
         user_id TEXT
     )`,
-    `CREATE TABLE IF NOT EXISTS _gencow_workflow_steps (
+  `CREATE TABLE IF NOT EXISTS _gencow_workflow_steps (
         id SERIAL PRIMARY KEY,
         workflow_id TEXT NOT NULL REFERENCES _gencow_workflows(id) ON DELETE CASCADE,
         step_name TEXT NOT NULL,
@@ -37,7 +37,7 @@ const WORKFLOW_TABLE_SETUP = [
         completed_at TIMESTAMPTZ,
         UNIQUE(workflow_id, step_name)
     )`,
-    `CREATE TABLE IF NOT EXISTS _gencow_workflow_events (
+  `CREATE TABLE IF NOT EXISTS _gencow_workflow_events (
         id TEXT PRIMARY KEY,
         workflow_id TEXT NOT NULL REFERENCES _gencow_workflows(id) ON DELETE CASCADE,
         event_name TEXT NOT NULL,
@@ -48,155 +48,171 @@ const WORKFLOW_TABLE_SETUP = [
 ] as const;
 
 describe("workflow()", () => {
-    let client: PGlite;
-    let db: ReturnType<typeof drizzle>;
-
-    function buildCtx(userId: string | null) {
-        return {
-            db,
-            unsafeDb: db,
-            auth: {
-                getUserIdentity: () => (
-                    userId
-                        ? { id: userId, email: `${userId}@workflow.test` }
-                        : null
-                ),
-                requireAuth: () => {
-                    if (!userId) throw new Error("Authentication required");
-                    return { id: userId, email: `${userId}@workflow.test` };
-                },
-            },
-            storage: {} as any,
-            scheduler: {
-                runAfter: () => "unused",
-                runAt: () => "unused",
-                cancel: () => false,
-                cron: () => {},
-                registerAction: () => {},
-                executeAction: async () => {},
-            },
-            realtime: { emit: () => {}, refresh: () => {} },
-            retry: async (fn: () => Promise<unknown>) => fn(),
-        };
+  let client: PGlite;
+  let db: ReturnType<typeof drizzle>;
+
+  function buildCtx(userId: string | null) {
+    return {
+      db,
+      unsafeDb: db,
+      auth: {
+        getUserIdentity: () => (userId ? { id: userId, email: `${userId}@workflow.test` } : null),
+        requireAuth: () => {
+          if (!userId) throw new Error("Authentication required");
+          return { id: userId, email: `${userId}@workflow.test` };
+        },
+      },
+      storage: {} as any,
+      scheduler: {
+        runAfter: () => "unused",
+        runAt: () => "unused",
+        cancel: () => false,
+        cron: () => {},
+        registerAction: () => {},
+        executeAction: async () => {},
+      },
+      realtime: { emit: () => {}, refresh: () => {} },
+      retry: async (fn: () => Promise<unknown>) => fn(),
+    };
+  }
+
+  beforeAll(async () => {
+    client = new PGlite();
+    db = drizzle({ client });
+    for (const stmt of WORKFLOW_TABLE_SETUP) {
+      await client.exec(stmt);
     }
-
-    beforeAll(async () => {
-        client = new PGlite();
-        db = drizzle(client);
-        for (const stmt of WORKFLOW_TABLE_SETUP) {
-            await client.exec(stmt);
-        }
-        registerWorkflowsApi();
+    registerWorkflowsApi();
+  });
+
+  afterAll(async () => {
+    await client.close();
+  });
+
+  it("start mutation inserts workflow row and schedules resume action", async () => {
+    const name = `agents.workflowStart${Date.now()}`;
+    const start = workflow(name, {
+      args: { topic: v.string() },
+      handler: async () => ({ ok: true }),
     });
 
-    afterAll(async () => {
-        await client.close();
-    });
-
-    it("start mutation inserts workflow row and schedules resume action", async () => {
-        const name = `agents.workflowStart${Date.now()}`;
-        const start = workflow(name, {
-            args: { topic: v.string() },
-            handler: async () => ({ ok: true }),
-        });
-
-        const scheduled: Array<{ delayMs: number; action: string; args: unknown }> = [];
-        const result = await start.handler({
-            db,
-            unsafeDb: db,
-            auth: {
-                getUserIdentity: () => ({ id: "user_workflow_start", email: "owner@test.dev" }),
-                requireAuth: () => ({ id: "user_workflow_start", email: "owner@test.dev" }),
-            },
-            storage: {} as any,
-            scheduler: {
-                runAfter: (delayMs, action, args) => {
-                    scheduled.push({ delayMs, action, args });
-                    return "job-start-1";
-                },
-                runAt: () => "unused",
-                cancel: () => false,
-                cron: () => {},
-                registerAction: () => {},
-                executeAction: async () => {},
-            },
-            realtime: { emit: () => {}, refresh: () => {} },
-            retry: async (fn) => fn(),
-        }, { topic: "durable execution" });
-
-        expect(result.status).toBe("pending");
-        expect(result.name).toBe(name);
-        expect(result.scheduledJobId).toBe("job-start-1");
-        expect(scheduled).toEqual([
-            {
-                delayMs: 0,
-                action: getWorkflowResumeActionName(name),
-                args: { workflowId: result.id },
-            },
-        ]);
-
-        const rowResult = await db.execute(sql`
+    const scheduled: Array<{ delayMs: number; action: string; args: unknown }> = [];
+    const result = await start.handler(
+      {
+        db,
+        unsafeDb: db,
+        auth: {
+          getUserIdentity: () => ({ id: "user_workflow_start", email: "owner@test.dev" }),
+          requireAuth: () => ({ id: "user_workflow_start", email: "owner@test.dev" }),
+        },
+        storage: {} as any,
+        scheduler: {
+          runAfter: (delayMs, action, args) => {
+            scheduled.push({ delayMs, action, args });
+            return "job-start-1";
+          },
+          runAt: () => "unused",
+          cancel: () => false,
+          cron: () => {},
+          registerAction: () => {},
+          executeAction: async () => {},
+        },
+        realtime: { emit: () => {}, refresh: () => {} },
+        retry: async (fn) => fn(),
+      },
+      { topic: "durable execution" },
+    );
+
+    expect(result.status).toBe("pending");
+    expect(result.name).toBe(name);
+    expect(result.scheduledJobId).toBe("job-start-1");
+    expect(scheduled).toEqual([
+      {
+        delayMs: 0,
+        action: getWorkflowResumeActionName(name),
+        args: { workflowId: result.id },
+      },
+    ]);
+
+    const rowResult = await db.execute(sql`
             SELECT id, name, status, max_retries, user_id, args, realtime_token
             FROM _gencow_workflows
             WHERE id = ${result.id}
         `);
-        const row = (rowResult as { rows: Array<{ id: string; name: string; status: string; max_retries: number; user_id: string | null; args: unknown; realtime_token: string }> }).rows[0];
-
-        expect(row.id).toBe(result.id);
-        expect(row.name).toBe(name);
-        expect(row.status).toBe("pending");
-        expect(row.max_retries).toBe(3);
-        expect(row.user_id).toBe("user_workflow_start");
-        expect(row.args).toEqual({ value: { topic: "durable execution" } });
-        expect(row.realtime_token.length).toBeGreaterThan(10);
+    const row = (
+      rowResult as {
+        rows: Array<{
+          id: string;
+          name: string;
+          status: string;
+          max_retries: number;
+          user_id: string | null;
+          args: unknown;
+          realtime_token: string;
+        }>;
+      }
+    ).rows[0];
+
+    expect(row.id).toBe(result.id);
+    expect(row.name).toBe(name);
+    expect(row.status).toBe("pending");
+    expect(row.max_retries).toBe(3);
+    expect(row.user_id).toBe("user_workflow_start");
+    expect(row.args).toEqual({ value: { topic: "durable execution" } });
+    expect(row.realtime_token.length).toBeGreaterThan(10);
+  });
+
+  it("scheduler enqueue failure rolls back the workflow row", async () => {
+    const name = `agents.workflowRollback${Date.now()}`;
+    const start = workflow(name, {
+      args: { topic: v.string() },
+      handler: async () => ({ ok: true }),
     });
 
-    it("scheduler enqueue failure rolls back the workflow row", async () => {
-        const name = `agents.workflowRollback${Date.now()}`;
-        const start = workflow(name, {
-            args: { topic: v.string() },
-            handler: async () => ({ ok: true }),
-        });
-
-        await expect(start.handler({
-            db,
-            unsafeDb: db,
-            auth: {
-                getUserIdentity: () => null,
-                requireAuth: () => {
-                    throw new Error("not used");
-                },
+    await expect(
+      start.handler(
+        {
+          db,
+          unsafeDb: db,
+          auth: {
+            getUserIdentity: () => null,
+            requireAuth: () => {
+              throw new Error("not used");
             },
-            storage: {} as any,
-            scheduler: {
-                runAfter: () => {
-                    throw new Error("scheduler unavailable");
-                },
-                runAt: () => "unused",
-                cancel: () => false,
-                cron: () => {},
-                registerAction: () => {},
-                executeAction: async () => {},
+          },
+          storage: {} as any,
+          scheduler: {
+            runAfter: () => {
+              throw new Error("scheduler unavailable");
             },
-            realtime: { emit: () => {}, refresh: () => {} },
-            retry: async (fn) => fn(),
-        }, { topic: "should rollback" })).rejects.toThrow("scheduler unavailable");
-
-        const countResult = await db.execute(sql`
+            runAt: () => "unused",
+            cancel: () => false,
+            cron: () => {},
+            registerAction: () => {},
+            executeAction: async () => {},
+          },
+          realtime: { emit: () => {}, refresh: () => {} },
+          retry: async (fn) => fn(),
+        },
+        { topic: "should rollback" },
+      ),
+    ).rejects.toThrow("scheduler unavailable");
+
+    const countResult = await db.execute(sql`
             SELECT count(*)::int AS c
             FROM _gencow_workflows
             WHERE name = ${name}
         `);
-        const count = (countResult as { rows: Array<{ c: number }> }).rows[0]?.c ?? 0;
-        expect(count).toBe(0);
-    });
+    const count = (countResult as { rows: Array<{ c: number }> }).rows[0]?.c ?? 0;
+    expect(count).toBe(0);
+  });
 
-    it("workflows.get returns full snapshot for the owner and hides private workflows from others", async () => {
-        const getWorkflow = getQueryDef("workflows.get");
-        expect(getWorkflow).toBeDefined();
+  it("workflows.get returns full snapshot for the owner and hides private workflows from others", async () => {
+    const getWorkflow = getQueryDef("workflows.get");
+    expect(getWorkflow).toBeDefined();
 
-        const workflowId = `wf_owned_${Date.now()}`;
-        await db.execute(sql`
+    const workflowId = `wf_owned_${Date.now()}`;
+    await db.execute(sql`
             INSERT INTO _gencow_workflows (
                 id,
                 name,
@@ -230,7 +246,7 @@ describe("workflow()", () => {
                 'owner_workflow'
             )
         `);
-        await db.execute(sql`
+    await db.execute(sql`
             INSERT INTO _gencow_workflow_steps (
                 workflow_id,
                 step_name,
@@ -264,41 +280,43 @@ describe("workflow()", () => {
                 )
         `);
 
-        const ownerSnapshot = await getWorkflow!.handler(buildCtx("owner_workflow") as any, { id: workflowId });
-        expect(ownerSnapshot).toMatchObject({
-            id: workflowId,
-            name: "agents.report",
-            status: "running",
-            derivedStatus: "running",
-            currentStep: "analyze",
-            args: { topic: "market map" },
-            result: null,
-            retryCount: 1,
-            maxRetries: 3,
-        });
-        expect(ownerSnapshot?.realtimeKey).toMatch(new RegExp(`^__gencow\\.workflow\\.state\\.${workflowId}\\.`));
-        expect(ownerSnapshot?.steps).toHaveLength(2);
-        expect(ownerSnapshot?.steps[0]).toMatchObject({
-            name: "search",
-            status: "completed",
-            output: { hits: 2 },
-        });
-        expect(ownerSnapshot?.steps[1]).toMatchObject({
-            name: "analyze",
-            status: "running",
-            output: null,
-        });
-
-        const strangerSnapshot = await getWorkflow!.handler(buildCtx("stranger_workflow") as any, { id: workflowId });
-        expect(strangerSnapshot).toBeNull();
+    const ownerSnapshot = await getWorkflow!.handler(buildCtx("owner_workflow") as any, { id: workflowId });
+    expect(ownerSnapshot).toMatchObject({
+      id: workflowId,
+      name: "agents.report",
+      status: "running",
+      derivedStatus: "running",
+      currentStep: "analyze",
+      args: { topic: "market map" },
+      result: null,
+      retryCount: 1,
+      maxRetries: 3,
+    });
+    expect(ownerSnapshot?.realtimeKey).toMatch(new RegExp(`^__gencow\\.workflow\\.state\\.${workflowId}\\.`));
+    expect(ownerSnapshot?.steps).toHaveLength(2);
+    expect(ownerSnapshot?.steps[0]).toMatchObject({
+      name: "search",
+      status: "completed",
+      output: { hits: 2 },
+    });
+    expect(ownerSnapshot?.steps[1]).toMatchObject({
+      name: "analyze",
+      status: "running",
+      output: null,
+    });
+
+    const strangerSnapshot = await getWorkflow!.handler(buildCtx("stranger_workflow") as any, {
+      id: workflowId,
     });
+    expect(strangerSnapshot).toBeNull();
+  });
 
-    it("workflows.get allows ownerless public workflows to be polled without auth", async () => {
-        const getWorkflow = getQueryDef("workflows.get");
-        expect(getWorkflow).toBeDefined();
+  it("workflows.get allows ownerless public workflows to be polled without auth", async () => {
+    const getWorkflow = getQueryDef("workflows.get");
+    expect(getWorkflow).toBeDefined();
 
-        const workflowId = `wf_public_${Date.now()}`;
-        await db.execute(sql`
+    const workflowId = `wf_public_${Date.now()}`;
+    await db.execute(sql`
             INSERT INTO _gencow_workflows (
                 id,
                 name,
@@ -333,23 +351,23 @@ describe("workflow()", () => {
             )
         `);
 
-        const snapshot = await getWorkflow!.handler(buildCtx(null) as any, { id: workflowId });
-        expect(snapshot).toMatchObject({
-            id: workflowId,
-            status: "completed",
-            derivedStatus: "completed",
-            result: { report: "done" },
-            steps: [],
-        });
-        expect(snapshot?.realtimeKey).toMatch(new RegExp(`^__gencow\\.workflow\\.state\\.${workflowId}\\.`));
+    const snapshot = await getWorkflow!.handler(buildCtx(null) as any, { id: workflowId });
+    expect(snapshot).toMatchObject({
+      id: workflowId,
+      status: "completed",
+      derivedStatus: "completed",
+      result: { report: "done" },
+      steps: [],
     });
+    expect(snapshot?.realtimeKey).toMatch(new RegExp(`^__gencow\\.workflow\\.state\\.${workflowId}\\.`));
+  });
 
-    it("workflows.signal persists an event and wakes waiting workflows for the owner only", async () => {
-        const signalWorkflow = getRegisteredMutations().find((item) => item.name === "workflows.signal");
-        expect(signalWorkflow).toBeDefined();
+  it("workflows.signal persists an event and wakes waiting workflows for the owner only", async () => {
+    const signalWorkflow = getRegisteredMutations().find((item) => item.name === "workflows.signal");
+    expect(signalWorkflow).toBeDefined();
 
-        const workflowId = `wf_signal_${Date.now()}`;
-        await db.execute(sql`
+    const workflowId = `wf_signal_${Date.now()}`;
+    await db.execute(sql`
             INSERT INTO _gencow_workflows (
                 id,
                 name,
@@ -384,83 +402,88 @@ describe("workflow()", () => {
             )
         `);
 
-        const scheduled: Array<{ delayMs: number; action: string; args: unknown }> = [];
-        const accepted = await signalWorkflow!.handler({
-            ...buildCtx("signal_owner"),
-            scheduler: {
-                runAfter: (delayMs, action, args) => {
-                    scheduled.push({ delayMs, action, args });
-                    return "job-signal-1";
-                },
-                runAt: () => "unused",
-                cancel: () => false,
-                cron: () => {},
-                registerAction: () => {},
-                executeAction: async () => {},
-            },
-        } as any, {
-            id: workflowId,
-            event: "approval",
-            payload: { approved: true },
-        });
-
-        expect(accepted).toEqual({
-            ok: true,
-            workflowId,
-            event: "approval",
-            scheduledJobId: "job-signal-1",
-        });
-        expect(scheduled).toEqual([
-            {
-                delayMs: 0,
-                action: getWorkflowResumeActionName("agents.waiting"),
-                args: { workflowId },
-            },
-        ]);
-
-        const eventResult = await db.execute(sql`
+    const scheduled: Array<{ delayMs: number; action: string; args: unknown }> = [];
+    const accepted = await signalWorkflow!.handler(
+      {
+        ...buildCtx("signal_owner"),
+        scheduler: {
+          runAfter: (delayMs, action, args) => {
+            scheduled.push({ delayMs, action, args });
+            return "job-signal-1";
+          },
+          runAt: () => "unused",
+          cancel: () => false,
+          cron: () => {},
+          registerAction: () => {},
+          executeAction: async () => {},
+        },
+      } as any,
+      {
+        id: workflowId,
+        event: "approval",
+        payload: { approved: true },
+      },
+    );
+
+    expect(accepted).toEqual({
+      ok: true,
+      workflowId,
+      event: "approval",
+      scheduledJobId: "job-signal-1",
+    });
+    expect(scheduled).toEqual([
+      {
+        delayMs: 0,
+        action: getWorkflowResumeActionName("agents.waiting"),
+        args: { workflowId },
+      },
+    ]);
+
+    const eventResult = await db.execute(sql`
             SELECT workflow_id, event_name, payload, consumed_at IS NULL AS is_unconsumed
             FROM _gencow_workflow_events
             WHERE workflow_id = ${workflowId}
         `);
-        const eventRow = (eventResult as {
-            rows: Array<{
-                workflow_id: string;
-                event_name: string;
-                payload: unknown;
-                is_unconsumed: boolean;
-            }>;
-        }).rows[0];
-        expect(eventRow).toEqual({
-            workflow_id: workflowId,
-            event_name: "approval",
-            payload: { value: { approved: true } },
-            is_unconsumed: true,
-        });
-
-        const denied = await signalWorkflow!.handler(buildCtx("someone_else") as any, {
-            id: workflowId,
-            event: "approval",
-            payload: { approved: false },
-        });
-        expect(denied).toEqual({
-            ok: false,
-            workflowId,
-            event: "approval",
-            scheduledJobId: null,
-        });
+    const eventRow = (
+      eventResult as {
+        rows: Array<{
+          workflow_id: string;
+          event_name: string;
+          payload: unknown;
+          is_unconsumed: boolean;
+        }>;
+      }
+    ).rows[0];
+    expect(eventRow).toEqual({
+      workflow_id: workflowId,
+      event_name: "approval",
+      payload: { value: { approved: true } },
+      is_unconsumed: true,
+    });
+
+    const denied = await signalWorkflow!.handler(buildCtx("someone_else") as any, {
+      id: workflowId,
+      event: "approval",
+      payload: { approved: false },
+    });
+    expect(denied).toEqual({
+      ok: false,
+      workflowId,
+      event: "approval",
+      scheduledJobId: null,
     });
+  });
 
-    it("workflows.list requires auth and filters to the current owner", async () => {
-        const listWorkflows = getQueryDef("workflows.list");
-        expect(listWorkflows).toBeDefined();
+  it("workflows.list requires auth and filters to the current owner", async () => {
+    const listWorkflows = getQueryDef("workflows.list");
+    expect(listWorkflows).toBeDefined();
 
-        const userACompleted = `wf_user_a_completed_${Date.now()}`;
-        const userAWaiting = `wf_user_a_waiting_${Date.now()}`;
-        const userASleeping = `wf_user_a_sleeping_${Date.now()}`;
-        const userBRunning = `wf_user_b_running_${Date.now()}`;
+    const userACompleted = `wf_user_a_completed_${Date.now()}`;
+    const userAWaiting = `wf_user_a_waiting_${Date.now()}`;
+    const userASleeping = `wf_user_a_sleeping_${Date.now()}`;
+    const userBRunning = `wf_user_b_running_${Date.now()}`;
 
-        await db.execute(sql`
+    await db.execute(sql`
             INSERT INTO _gencow_workflows (
                 id,
                 name,
@@ -544,40 +567,40 @@ describe("workflow()", () => {
                 )
         `);
 
-        const ownWorkflows = await listWorkflows!.handler(buildCtx("workflow_user_a") as any, { limit: 10 });
-        expect(ownWorkflows.map((item: any) => item.id)).toEqual([userAWaiting, userASleeping, userACompleted]);
-        expect(ownWorkflows.every((item: any) => item.name === "agents.sync")).toBe(true);
-        expect(ownWorkflows.some((item: any) => item.id === userBRunning)).toBe(false);
-        expect(ownWorkflows.find((item: any) => item.id === userAWaiting)?.derivedStatus).toBe("waiting");
-        expect(ownWorkflows.find((item: any) => item.id === userASleeping)?.derivedStatus).toBe("sleeping");
-
-        const completedOnly = await listWorkflows!.handler(
-            buildCtx("workflow_user_a") as any,
-            { limit: 10, status: "completed" }
-        );
-        expect(completedOnly).toHaveLength(1);
-        expect(completedOnly[0]?.id).toBe(userACompleted);
-
-        const waitingOnly = await listWorkflows!.handler(
-            buildCtx("workflow_user_a") as any,
-            { limit: 10, status: "waiting" }
-        );
-        expect(waitingOnly).toHaveLength(1);
-        expect(waitingOnly[0]?.id).toBe(userAWaiting);
-
-        const sleepingOnly = await listWorkflows!.handler(
-            buildCtx("workflow_user_a") as any,
-            { limit: 10, status: "sleeping" }
-        );
-        expect(sleepingOnly).toHaveLength(1);
-        expect(sleepingOnly[0]?.id).toBe(userASleeping);
-
-        await expect(
-            listWorkflows!.handler(buildCtx(null) as any, { limit: 10 })
-        ).rejects.toThrow("Authentication required");
-
-        await expect(
-            listWorkflows!.handler(buildCtx("workflow_user_a") as any, { limit: 10, status: "mystery" })
-        ).rejects.toThrow('Argument "status": expected one of pending, running, completed, failed');
+    const ownWorkflows = await listWorkflows!.handler(buildCtx("workflow_user_a") as any, { limit: 10 });
+    expect(ownWorkflows.map((item: any) => item.id)).toEqual([userAWaiting, userASleeping, userACompleted]);
+    expect(ownWorkflows.every((item: any) => item.name === "agents.sync")).toBe(true);
+    expect(ownWorkflows.some((item: any) => item.id === userBRunning)).toBe(false);
+    expect(ownWorkflows.find((item: any) => item.id === userAWaiting)?.derivedStatus).toBe("waiting");
+    expect(ownWorkflows.find((item: any) => item.id === userASleeping)?.derivedStatus).toBe("sleeping");
+
+    const completedOnly = await listWorkflows!.handler(buildCtx("workflow_user_a") as any, {
+      limit: 10,
+      status: "completed",
+    });
+    expect(completedOnly).toHaveLength(1);
+    expect(completedOnly[0]?.id).toBe(userACompleted);
+
+    const waitingOnly = await listWorkflows!.handler(buildCtx("workflow_user_a") as any, {
+      limit: 10,
+      status: "waiting",
     });
+    expect(waitingOnly).toHaveLength(1);
+    expect(waitingOnly[0]?.id).toBe(userAWaiting);
+
+    const sleepingOnly = await listWorkflows!.handler(buildCtx("workflow_user_a") as any, {
+      limit: 10,
+      status: "sleeping",
+    });
+    expect(sleepingOnly).toHaveLength(1);
+    expect(sleepingOnly[0]?.id).toBe(userASleeping);
+
+    await expect(listWorkflows!.handler(buildCtx(null) as any, { limit: 10 })).rejects.toThrow(
+      "Authentication required",
+    );
+
+    await expect(
+      listWorkflows!.handler(buildCtx("workflow_user_a") as any, { limit: 10, status: "mystery" }),
+    ).rejects.toThrow('Argument "status": expected one of pending, running, completed, failed');
+  });
 });