convex-effect-workflows 0.1.0

package/src/component/core.test.ts

@@ -0,0 +1,829 @@
+/// <reference types="vite/client" />
+
+import { describe, expect, test, vi } from "vitest";
+import { api } from "./_generated/api.js";
+import { initConvexTest } from "./setup.test.js";
+
+import { MAX_INLINE_PAYLOAD_BYTES } from "../shared/constants.js";
+
+describe("component core invariants", () => {
+  test("createExecution is idempotent by executionId", async () => {
+    const t = initConvexTest();
+
+    const first = await t.mutation(api.executions.createExecution, {
+      workflowName: "testWorkflow",
+      executionId: "exec-1",
+      payload: { a: 1 },
+    });
+
+    const second = await t.mutation(api.executions.createExecution, {
+      workflowName: "testWorkflow",
+      executionId: "exec-1",
+      payload: { a: 2 },
+    });
+
+    expect(first.created).toBe(true);
+    expect(second.created).toBe(false);
+    expect(first.executionId).toBe(second.executionId);
+  });
+
+  test("journal step enforces unique (executionId, stepNumber)", async () => {
+    const t = initConvexTest();
+
+    await t.mutation(api.executions.createExecution, {
+      workflowName: "testWorkflow",
+      executionId: "exec-2",
+      payload: {},
+    });
+
+    await t.mutation(api.journalSteps.appendJournalStep, {
+      executionId: "exec-2",
+      stepNumber: 0,
+      kind: "activity",
+      name: "stepA",
+      signature: {
+        kind: "activity",
+        opName: "stepA",
+      },
+      input: { x: 1 },
+    });
+
+    await expect(
+      t.mutation(api.journalSteps.appendJournalStep, {
+        executionId: "exec-2",
+        stepNumber: 0,
+        kind: "activity",
+        name: "stepA",
+        signature: {
+          kind: "activity",
+          opName: "stepA",
+        },
+        input: { x: 2 },
+      }),
+    ).rejects.toThrow(/Duplicate journal step/);
+  });
+
+  test("onComplete is idempotent for duplicate workId", async () => {
+    const t = initConvexTest();
+
+    await t.mutation(api.executions.createExecution, {
+      workflowName: "testWorkflow",
+      executionId: "exec-3",
+      payload: {},
+    });
+
+    await t.mutation(api.journalSteps.appendJournalStep, {
+      executionId: "exec-3",
+      stepNumber: 0,
+      kind: "activity",
+      name: "activityA",
+      signature: {
+        kind: "activity",
+        opName: "activityA",
+      },
+      input: null,
+    });
+
+    await t.mutation(api.journalSteps.suspendJournalStep, {
+      executionId: "exec-3",
+      stepNumber: 0,
+      workId: "work-1",
+    });
+
+    const first = await t.mutation(api.onComplete.handleActivityCompletion, {
+      workId: "work-1",
+      context: {
+        executionId: "exec-3",
+        stepNumber: 0,
+        generation: 0,
+      },
+      result: {
+        kind: "success",
+        returnValue: { ok: true },
+      },
+    });
+
+    const second = await t.mutation(api.onComplete.handleActivityCompletion, {
+      workId: "work-1",
+      context: {
+        executionId: "exec-3",
+        stepNumber: 0,
+        generation: 0,
+      },
+      result: {
+        kind: "success",
+        returnValue: { ok: true },
+      },
+    });
+
+    expect(first.processed).toBe(true);
+    expect(second.processed).toBe(false);
+  });
+
+  test("stale generation callbacks are ignored", async () => {
+    const t = initConvexTest();
+
+    await t.mutation(api.executions.createExecution, {
+      workflowName: "testWorkflow",
+      executionId: "exec-stale",
+      payload: {},
+    });
+
+    await t.mutation(api.journalSteps.appendJournalStep, {
+      executionId: "exec-stale",
+      stepNumber: 0,
+      kind: "activity",
+      name: "activityA",
+      signature: {
+        kind: "activity",
+        opName: "activityA",
+      },
+      input: null,
+    });
+
+    await t.mutation(api.journalSteps.suspendJournalStep, {
+      executionId: "exec-stale",
+      stepNumber: 0,
+      workId: "work-stale",
+    });
+
+    await t.mutation(api.executions.interruptExecution, {
+      executionId: "exec-stale",
+      reason: "manual",
+    });
+
+    const result = await t.mutation(api.onComplete.handleActivityCompletion, {
+      workId: "work-stale",
+      context: {
+        executionId: "exec-stale",
+        stepNumber: 0,
+        generation: 0,
+      },
+      result: {
+        kind: "success",
+        returnValue: { ok: true },
+      },
+    });
+
+    const step = await t.query(api.journalSteps.getJournalStep, {
+      executionId: "exec-stale",
+      stepNumber: 0,
+    });
+
+    expect(result.stale).toBe(true);
+    expect(step).toBeTruthy();
+    expect(step!.state).toBe("suspended");
+  });
+
+  test("interruptExecution is a no-op for terminal executions", async () => {
+    const t = initConvexTest();
+
+    await t.mutation(api.executions.createExecution, {
+      workflowName: "testWorkflow",
+      executionId: "exec-interrupt-completed",
+      payload: {},
+    });
+
+    await t.mutation(api.executions.completeExecution, {
+      executionId: "exec-interrupt-completed",
+      generation: 0,
+      kind: "success",
+      result: { ok: true },
+    });
+
+    const beforeCompleted = await t.query(api.executions.getExecution, {
+      executionId: "exec-interrupt-completed",
+    });
+
+    const completedInterrupt = await t.mutation(api.executions.interruptExecution, {
+      executionId: "exec-interrupt-completed",
+      reason: "late-interrupt",
+    });
+
+    const afterCompleted = await t.query(api.executions.getExecution, {
+      executionId: "exec-interrupt-completed",
+    });
+
+    expect(beforeCompleted).toBeTruthy();
+    expect(afterCompleted).toBeTruthy();
+    expect(completedInterrupt.generation).toBe(beforeCompleted!.generation);
+    expect(afterCompleted!.status).toBe("completed");
+    expect(afterCompleted!.generation).toBe(beforeCompleted!.generation);
+    expect(afterCompleted!.completedAt).toBe(beforeCompleted!.completedAt);
+    expect(afterCompleted!.error).toBe(beforeCompleted!.error);
+
+    await t.mutation(api.executions.createExecution, {
+      workflowName: "testWorkflow",
+      executionId: "exec-interrupt-interrupted",
+      payload: {},
+    });
+
+    const firstInterrupt = await t.mutation(api.executions.interruptExecution, {
+      executionId: "exec-interrupt-interrupted",
+      reason: "first",
+    });
+
+    const beforeSecondInterrupt = await t.query(api.executions.getExecution, {
+      executionId: "exec-interrupt-interrupted",
+    });
+
+    const secondInterrupt = await t.mutation(api.executions.interruptExecution, {
+      executionId: "exec-interrupt-interrupted",
+      reason: "second",
+    });
+
+    const afterSecondInterrupt = await t.query(api.executions.getExecution, {
+      executionId: "exec-interrupt-interrupted",
+    });
+
+    expect(firstInterrupt.generation).toBe(1);
+    expect(beforeSecondInterrupt).toBeTruthy();
+    expect(afterSecondInterrupt).toBeTruthy();
+    expect(secondInterrupt.generation).toBe(beforeSecondInterrupt!.generation);
+    expect(afterSecondInterrupt!.status).toBe("interrupted");
+    expect(afterSecondInterrupt!.generation).toBe(beforeSecondInterrupt!.generation);
+    expect(afterSecondInterrupt!.completedAt).toBe(beforeSecondInterrupt!.completedAt);
+    expect(afterSecondInterrupt!.error).toBe(beforeSecondInterrupt!.error);
+  });
+
+  test("large execution payload is offloaded", async () => {
+    const t = initConvexTest();
+    const huge = "x".repeat(MAX_INLINE_PAYLOAD_BYTES + 2048);
+
+    await t.mutation(api.executions.createExecution, {
+      workflowName: "testWorkflow",
+      executionId: "exec-large",
+      payload: { huge },
+    });
+
+    const execution = await t.query(api.executions.getExecution, {
+      executionId: "exec-large",
+    });
+
+    expect(execution).toBeTruthy();
+    expect(execution!.payloadRef).toBeDefined();
+    expect(execution!.payloadSize).toBeGreaterThan(MAX_INLINE_PAYLOAD_BYTES);
+  });
+
+  test("retry attempts record distinct journal rows and spans", async () => {
+    const t = initConvexTest();
+
+    await t.mutation(api.executions.createExecution, {
+      workflowName: "testWorkflow",
+      executionId: "exec-retry",
+      payload: {},
+    });
+
+    const execution = await t.query(api.executions.getExecution, {
+      executionId: "exec-retry",
+    });
+    expect(execution).toBeTruthy();
+
+    await t.mutation(api.journalSteps.appendJournalStep, {
+      executionId: "exec-retry",
+      stepNumber: 0,
+      kind: "activity",
+      name: "chargeCard",
+      attempt: 1,
+      signature: {
+        kind: "activity",
+        opName: "chargeCard",
+        attempt: 1,
+      },
+      input: { amount: 100 },
+    });
+
+    await t.mutation(api.spans.createSpan, {
+      executionId: "exec-retry",
+      traceId: execution!.traceId,
+      name: "chargeCard",
+      kind: "activity",
+      stepNumber: 0,
+      attempt: 1,
+    });
+
+    await t.mutation(api.journalSteps.appendJournalStep, {
+      executionId: "exec-retry",
+      stepNumber: 1,
+      kind: "activity",
+      name: "chargeCard",
+      attempt: 2,
+      signature: {
+        kind: "activity",
+        opName: "chargeCard",
+        attempt: 2,
+      },
+      input: { amount: 100 },
+    });
+
+    await t.mutation(api.spans.createSpan, {
+      executionId: "exec-retry",
+      traceId: execution!.traceId,
+      name: "chargeCard",
+      kind: "activity",
+      stepNumber: 1,
+      attempt: 2,
+    });
+
+    const steps = await t.query(api.journalSteps.listJournalSteps, {
+      executionId: "exec-retry",
+      limit: 10,
+    });
+    const spans = await t.query(api.spans.listExecutionSpans, {
+      executionId: "exec-retry",
+      limit: 10,
+    });
+
+    expect(steps.page).toHaveLength(2);
+    expect(steps.page.map((s: any) => s.attempt)).toEqual([1, 2]);
+    expect(spans.page).toHaveLength(2);
+    expect(spans.page.map((s: any) => s.attempt)).toEqual([1, 2]);
+  });
+
+  test("determinism mismatch is explicit", async () => {
+    const t = initConvexTest();
+
+    await t.mutation(api.executions.createExecution, {
+      workflowName: "testWorkflow",
+      executionId: "exec-determinism",
+      payload: {},
+    });
+
+    await t.mutation(api.journalSteps.appendJournalStep, {
+      executionId: "exec-determinism",
+      stepNumber: 0,
+      kind: "activity",
+      name: "activityA",
+      signature: {
+        kind: "activity",
+        opName: "activityA",
+      },
+      input: null,
+    });
+
+    await expect(
+      t.query(api.journalSteps.assertReplayStepSignature, {
+        executionId: "exec-determinism",
+        stepNumber: 0,
+        expectedSignature: {
+          kind: "activity",
+          opName: "activityA_changed",
+        },
+      }),
+    ).rejects.toThrow(/Determinism violation/);
+  });
+
+  test("deferred result transitions from unresolved to resolved once", async () => {
+    const t = initConvexTest();
+
+    await t.mutation(api.deferreds.registerDeferred, {
+      executionId: "exec-deferred",
+      deferredName: "waitForApproval",
+    });
+
+    const before = await t.query(api.deferreds.deferredResult, {
+      executionId: "exec-deferred",
+      deferredName: "waitForApproval",
+    });
+    expect(before).toBeNull();
+
+    const first = await t.mutation(api.deferreds.deferredDone, {
+      executionId: "exec-deferred",
+      deferredName: "waitForApproval",
+      exit: { ok: true },
+    });
+    const second = await t.mutation(api.deferreds.deferredDone, {
+      executionId: "exec-deferred",
+      deferredName: "waitForApproval",
+      exit: { ok: true },
+    });
+
+    const after = await t.query(api.deferreds.deferredResult, {
+      executionId: "exec-deferred",
+      deferredName: "waitForApproval",
+    });
+
+    expect(first.changed).toBe(true);
+    expect(second.changed).toBe(false);
+    expect(after).toEqual({ ok: true });
+  });
+
+  test("scheduled deferred wake resolves after timers advance", async () => {
+    vi.useFakeTimers();
+    try {
+      const t = initConvexTest();
+
+      await t.mutation(api.clocks.scheduleDeferredWake, {
+        executionId: "exec-clock",
+        deferredName: "clock/wake",
+        delayMs: 5_000,
+        exit: { woke: true },
+      });
+
+      const before = await t.query(api.deferreds.deferredResult, {
+        executionId: "exec-clock",
+        deferredName: "clock/wake",
+      });
+      expect(before).toBeNull();
+
+      await t.finishAllScheduledFunctions(() => {
+        vi.runAllTimers();
+      });
+
+      const after = await t.query(api.deferreds.deferredResult, {
+        executionId: "exec-clock",
+        deferredName: "clock/wake",
+      });
+      expect(after).toEqual({ woke: true });
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  test("execution metrics aggregate statuses and durations", async () => {
+    const t = initConvexTest();
+
+    await t.mutation(api.executions.createExecution, {
+      workflowName: "metricsWorkflow",
+      executionId: "exec-metrics-1",
+      payload: {},
+    });
+    await t.mutation(api.executions.createExecution, {
+      workflowName: "metricsWorkflow",
+      executionId: "exec-metrics-2",
+      payload: {},
+    });
+
+    await t.mutation(api.executions.completeExecution, {
+      executionId: "exec-metrics-1",
+      generation: 0,
+      kind: "success",
+      result: { ok: true },
+    });
+    await t.mutation(api.executions.completeExecution, {
+      executionId: "exec-metrics-2",
+      generation: 0,
+      kind: "failure",
+      error: "boom",
+    });
+
+    const metrics = await t.query(api.dashboard.executionMetrics, {
+      workflowName: "metricsWorkflow",
+    });
+
+    expect(metrics.total).toBe(2);
+    expect(metrics.completed).toBe(1);
+    expect(metrics.failed).toBe(1);
+    expect(metrics.successRate).toBe(0.5);
+  });
+
+  test("execution list applies status/tenant/time filters", async () => {
+    const t = initConvexTest();
+
+    await t.mutation(api.executions.createExecution, {
+      workflowName: "filterWorkflow",
+      executionId: "exec-filter-1",
+      payload: {},
+      tenantId: "tenant-a",
+    });
+    await t.mutation(api.executions.createExecution, {
+      workflowName: "filterWorkflow",
+      executionId: "exec-filter-2",
+      payload: {},
+      tenantId: "tenant-b",
+    });
+
+    await t.mutation(api.executions.completeExecution, {
+      executionId: "exec-filter-1",
+      generation: 0,
+      kind: "success",
+      result: { ok: true },
+    });
+    await t.mutation(api.executions.completeExecution, {
+      executionId: "exec-filter-2",
+      generation: 0,
+      kind: "failure",
+      error: "x",
+    });
+
+    const now = Date.now();
+
+    const byStatus = await t.query(api.dashboard.listExecutions, {
+      workflowName: "filterWorkflow",
+      status: "completed",
+      limit: 10,
+    });
+    expect(byStatus.page).toHaveLength(1);
+    expect(byStatus.page[0].executionId).toBe("exec-filter-1");
+
+    const byTenant = await t.query(api.dashboard.listExecutions, {
+      workflowName: "filterWorkflow",
+      tenantId: "tenant-b",
+      limit: 10,
+    });
+    expect(byTenant.page).toHaveLength(1);
+    expect(byTenant.page[0].executionId).toBe("exec-filter-2");
+
+    const byTime = await t.query(api.dashboard.listExecutions, {
+      workflowName: "filterWorkflow",
+      startedAfter: now - 60_000,
+      startedBefore: now + 60_000,
+      limit: 10,
+    });
+    expect(byTime.page.length).toBeGreaterThanOrEqual(2);
+  });
+
+  test("log list filters by level/source/span", async () => {
+    const t = initConvexTest();
+
+    await t.mutation(api.executions.createExecution, {
+      workflowName: "logWorkflow",
+      executionId: "exec-logs",
+      payload: {},
+    });
+
+    await t.mutation(api.logs.appendLog, {
+      executionId: "exec-logs",
+      level: "info",
+      source: "workflow",
+      message: "workflow started",
+      spanId: "span-1",
+    });
+    await t.mutation(api.logs.appendLog, {
+      executionId: "exec-logs",
+      level: "error",
+      source: "activity",
+      message: "activity failed",
+      spanId: "span-2",
+    });
+
+    const levelFiltered = await t.query(api.dashboard.listExecutionLogs, {
+      executionId: "exec-logs",
+      level: "error",
+      limit: 10,
+    });
+    expect(levelFiltered.page).toHaveLength(1);
+    expect(levelFiltered.page[0].message).toBe("activity failed");
+
+    const sourceFiltered = await t.query(api.dashboard.listExecutionLogs, {
+      executionId: "exec-logs",
+      source: "workflow",
+      limit: 10,
+    });
+    expect(sourceFiltered.page).toHaveLength(1);
+    expect(sourceFiltered.page[0].message).toBe("workflow started");
+
+    const spanFiltered = await t.query(api.dashboard.listExecutionLogs, {
+      executionId: "exec-logs",
+      spanId: "span-2",
+      limit: 10,
+    });
+    expect(spanFiltered.page).toHaveLength(1);
+    expect(spanFiltered.page[0].message).toBe("activity failed");
+  });
+
+  test("step list applies state filter with cursor progression", async () => {
+    const t = initConvexTest();
+
+    await t.mutation(api.executions.createExecution, {
+      workflowName: "stepsWorkflow",
+      executionId: "exec-steps-cursor",
+      payload: {},
+    });
+
+    for (let stepNumber = 0; stepNumber < 4; stepNumber++) {
+      await t.mutation(api.journalSteps.appendJournalStep, {
+        executionId: "exec-steps-cursor",
+        stepNumber,
+        kind: "activity",
+        name: `step-${stepNumber}`,
+        signature: {
+          kind: "activity",
+          opName: `step-${stepNumber}`,
+        },
+        input: {},
+      });
+    }
+
+    await t.mutation(api.journalSteps.completeJournalStep, {
+      executionId: "exec-steps-cursor",
+      stepNumber: 0,
+      runResult: { kind: "success", valuePreview: { ok: true } },
+    });
+    await t.mutation(api.journalSteps.completeJournalStep, {
+      executionId: "exec-steps-cursor",
+      stepNumber: 2,
+      runResult: { kind: "success", valuePreview: { ok: true } },
+    });
+
+    const firstPage = await t.query(api.dashboard.listExecutionSteps, {
+      executionId: "exec-steps-cursor",
+      state: "completed",
+      limit: 1,
+    });
+
+    expect(firstPage.page).toHaveLength(1);
+    expect(firstPage.page[0].stepNumber).toBe(0);
+    expect(firstPage.cursor).toBe(0);
+
+    expect(firstPage.cursor).not.toBeNull();
+
+    const secondPage = await t.query(api.dashboard.listExecutionSteps, {
+      executionId: "exec-steps-cursor",
+      state: "completed",
+      afterStepNumber: firstPage.cursor ?? undefined,
+      limit: 1,
+    });
+
+    expect(secondPage.page).toHaveLength(1);
+    expect(secondPage.page[0].stepNumber).toBe(2);
+    expect(secondPage.isDone).toBe(true);
+  });
+
+  test("span list keeps stable pagination when startTime collides", async () => {
+    vi.useFakeTimers();
+    try {
+      vi.setSystemTime(new Date("2026-01-03T00:00:00.000Z"));
+      const t = initConvexTest();
+
+      await t.mutation(api.executions.createExecution, {
+        workflowName: "spansWorkflow",
+        executionId: "exec-spans-cursor",
+        payload: {},
+      });
+
+      const execution = await t.query(api.executions.getExecution, {
+        executionId: "exec-spans-cursor",
+      });
+      expect(execution).toBeTruthy();
+
+      const activityA = await t.mutation(api.spans.createSpan, {
+        executionId: "exec-spans-cursor",
+        traceId: execution!.traceId,
+        name: "activity-a",
+        kind: "activity",
+      });
+      const activityB = await t.mutation(api.spans.createSpan, {
+        executionId: "exec-spans-cursor",
+        traceId: execution!.traceId,
+        name: "activity-b",
+        kind: "activity",
+      });
+      await t.mutation(api.spans.createSpan, {
+        executionId: "exec-spans-cursor",
+        traceId: execution!.traceId,
+        name: "workflow-root",
+        kind: "workflow",
+      });
+
+      const firstPage = await t.query(api.dashboard.listExecutionSpans, {
+        executionId: "exec-spans-cursor",
+        kind: "activity",
+        status: "started",
+        limit: 1,
+      });
+
+      expect(firstPage.page).toHaveLength(1);
+      expect(firstPage.cursor).toBeTruthy();
+
+      expect(firstPage.cursor).not.toBeNull();
+
+      const secondPage = await t.query(api.dashboard.listExecutionSpans, {
+        executionId: "exec-spans-cursor",
+        kind: "activity",
+        status: "started",
+        limit: 1,
+        afterStartTime: firstPage.cursor!.startTime,
+        afterSpanId: firstPage.cursor!.spanId,
+      });
+
+      expect(secondPage.page).toHaveLength(1);
+      expect([activityA.spanId, activityB.spanId]).toContain(secondPage.page[0].spanId);
+      expect(secondPage.page[0].spanId).not.toBe(firstPage.page[0].spanId);
+      expect(secondPage.isDone).toBe(true);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  test("log list keeps stable cursor with duplicate timestamps", async () => {
+    const t = initConvexTest();
+
+    await t.mutation(api.executions.createExecution, {
+      workflowName: "logsWorkflow",
+      executionId: "exec-logs-cursor",
+      payload: {},
+    });
+
+    for (let i = 0; i < 3; i++) {
+      await t.mutation(api.logs.appendLog, {
+        executionId: "exec-logs-cursor",
+        level: "info",
+        source: "activity",
+        spanId: "shared-span",
+        timestamp: 1_700_000_000_000,
+        message: `log-${i}`,
+      });
+    }
+    await t.mutation(api.logs.appendLog, {
+      executionId: "exec-logs-cursor",
+      level: "error",
+      source: "activity",
+      spanId: "shared-span",
+      timestamp: 1_700_000_000_000,
+      message: "ignore-me",
+    });
+
+    const firstPage = await t.query(api.dashboard.listExecutionLogs, {
+      executionId: "exec-logs-cursor",
+      level: "info",
+      source: "activity",
+      spanId: "shared-span",
+      order: "asc",
+      limit: 1,
+    });
+
+    expect(firstPage.page).toHaveLength(1);
+    expect(firstPage.cursor).toBeTruthy();
+
+    expect(firstPage.cursor).not.toBeNull();
+
+    const secondPage = await t.query(api.dashboard.listExecutionLogs, {
+      executionId: "exec-logs-cursor",
+      level: "info",
+      source: "activity",
+      spanId: "shared-span",
+      order: "asc",
+      limit: 1,
+      afterTimestamp: firstPage.cursor!.timestamp,
+      afterLogId: firstPage.cursor!.logId,
+    });
+
+    expect(secondPage.page).toHaveLength(1);
+    expect(secondPage.page[0]._id).not.toBe(firstPage.page[0]._id);
+
+    expect(secondPage.cursor).not.toBeNull();
+
+    const thirdPage = await t.query(api.dashboard.listExecutionLogs, {
+      executionId: "exec-logs-cursor",
+      level: "info",
+      source: "activity",
+      spanId: "shared-span",
+      order: "asc",
+      limit: 2,
+      afterTimestamp: secondPage.cursor!.timestamp,
+      afterLogId: secondPage.cursor!.logId,
+    });
+
+    expect(thirdPage.page).toHaveLength(1);
+    expect(thirdPage.isDone).toBe(true);
+  });
+
+  test("execution list supports stable cursor pagination with same startedAt", async () => {
+    vi.useFakeTimers();
+    try {
+      vi.setSystemTime(new Date("2026-01-02T00:00:00.000Z"));
+      const t = initConvexTest();
+
+      for (let i = 0; i < 4; i++) {
+        await t.mutation(api.executions.createExecution, {
+          workflowName: "cursorWorkflow",
+          executionId: `exec-page-${i}`,
+          payload: { i },
+          tenantId: "tenant-cursor",
+        });
+      }
+
+      const firstPage = await t.query(api.dashboard.listExecutions, {
+        workflowName: "cursorWorkflow",
+        status: "pending",
+        tenantId: "tenant-cursor",
+        limit: 2,
+        order: "asc",
+      });
+
+      expect(firstPage.page).toHaveLength(2);
+      expect(firstPage.cursor).toBeTruthy();
+
+      expect(firstPage.cursor).not.toBeNull();
+
+      const secondPage = await t.query(api.dashboard.listExecutions, {
+        workflowName: "cursorWorkflow",
+        status: "pending",
+        tenantId: "tenant-cursor",
+        limit: 2,
+        order: "asc",
+        cursorStartedAt: firstPage.cursor!.startedAt,
+        cursorExecutionId: firstPage.cursor!.executionId,
+      });
+
+      expect(secondPage.page).toHaveLength(2);
+      const firstIds = firstPage.page.map((row: any) => row.executionId);
+      const secondIds = secondPage.page.map((row: any) => row.executionId);
+      expect(secondIds.some((id: string) => firstIds.includes(id))).toBe(false);
+      expect(secondPage.isDone).toBe(true);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});