@sonamu-kit/tasks 0.2.0 → 0.3.0

package/dist/worker.test.js

@@ -1,1164 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
-import { declareWorkflow, OpenWorkflow } from "./client.js";
-import { BackendPostgres } from "./database/backend.js";
-import { KNEX_GLOBAL_CONFIG } from "./testing/connection.js";
-describe("Worker", ()=>{
-    let backend;
-    beforeEach(async ()=>{
-        backend = new BackendPostgres(KNEX_GLOBAL_CONFIG, {
-            namespaceId: randomUUID(),
-            runMigrations: false
-        });
-        await backend.initialize();
-    });
-    afterEach(async ()=>{
-        await backend.stop();
-    });
-    test("passes workflow input to handlers (known slow test)", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "context"
-        }, ({ input })=>input);
-        const worker = client.newWorker();
-        const payload = {
-            value: 10
-        };
-        const handle = await workflow.run(payload);
-        await worker.tick();
-        const result = await handle.result();
-        expect(result).toEqual(payload);
-    });
-    test("processes workflow runs to completion (known slow test)", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "process"
-        }, ({ input })=>input.value * 2);
-        const worker = client.newWorker();
-        const handle = await workflow.run({
-            value: 21
-        });
-        await worker.tick();
-        const result = await handle.result();
-        expect(result).toBe(42);
-    });
-    test("step.run reuses cached results (known slow test)", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        let executionCount = 0;
-        const workflow = client.defineWorkflow({
-            name: "cached-step"
-        }, async ({ step })=>{
-            const first = await step.run({
-                name: "once"
-            }, ()=>{
-                executionCount++;
-                return "value";
-            });
-            const second = await step.run({
-                name: "once"
-            }, ()=>{
-                executionCount++;
-                return "should-not-run";
-            });
-            return {
-                first,
-                second
-            };
-        });
-        const worker = client.newWorker();
-        const handle = await workflow.run();
-        await worker.tick();
-        const result = await handle.result();
-        expect(result).toEqual({
-            first: "value",
-            second: "value"
-        });
-        expect(executionCount).toBe(1);
-    });
-    test("marks workflow for retry when definition is missing", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflowRun = await backend.createWorkflowRun({
-            workflowName: "missing",
-            version: null,
-            idempotencyKey: null,
-            config: {},
-            context: null,
-            input: null,
-            availableAt: null,
-            deadlineAt: null
-        });
-        const worker = client.newWorker();
-        await worker.tick();
-        const updated = await backend.getWorkflowRun({
-            workflowRunId: workflowRun.id
-        });
-        expect(updated?.status).toBe("pending");
-        expect(updated?.error).toBeDefined();
-        expect(updated?.availableAt).not.toBeNull();
-    });
-    test("retries failed workflows automatically (known slow test)", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        let attemptCount = 0;
-        const workflow = client.defineWorkflow({
-            name: "retry-test"
-        }, ()=>{
-            attemptCount++;
-            if (attemptCount < 2) {
-                throw new Error(`Attempt ${String(attemptCount)} failed`);
-            }
-            return {
-                success: true,
-                attempts: attemptCount
-            };
-        });
-        const worker = client.newWorker();
-        // run the workflow
-        const handle = await workflow.run();
-        // first attempt - will fail and reschedule
-        await worker.tick();
-        await sleep(100); // wait for worker to finish
-        expect(attemptCount).toBe(1);
-        await sleep(1100); // wait for backoff delay
-        // second attempt - will succeed
-        await worker.tick();
-        await sleep(100); // wait for worker to finish
-        expect(attemptCount).toBe(2);
-        const result = await handle.result();
-        expect(result).toEqual({
-            success: true,
-            attempts: 2
-        });
-    });
-    test("tick is a no-op when no work is available", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        client.defineWorkflow({
-            name: "noop"
-        }, ()=>null);
-        const worker = client.newWorker();
-        await worker.tick(); // no runs queued
-    });
-    test("handles step functions that return undefined (known slow test)", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "undefined-steps"
-        }, async ({ step })=>{
-            await step.run({
-                name: "step-1"
-            }, ()=>{
-                return; // explicit undefined
-            });
-            await step.run({
-                name: "step-2"
-            }, ()=>{
-            // implicit undefined
-            });
-            return {
-                success: true
-            };
-        });
-        const worker = client.newWorker();
-        const handle = await workflow.run();
-        await worker.tick();
-        const result = await handle.result();
-        expect(result).toEqual({
-            success: true
-        });
-    });
-    test("executes steps synchronously within workflow (known slow test)", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const executionOrder = [];
-        const workflow = client.defineWorkflow({
-            name: "sync-steps"
-        }, async ({ step })=>{
-            executionOrder.push("start");
-            await step.run({
-                name: "step1"
-            }, ()=>{
-                executionOrder.push("step1");
-                return 1;
-            });
-            executionOrder.push("between");
-            await step.run({
-                name: "step2"
-            }, ()=>{
-                executionOrder.push("step2");
-                return 2;
-            });
-            executionOrder.push("end");
-            return executionOrder;
-        });
-        const worker = client.newWorker();
-        const handle = await workflow.run();
-        await worker.tick();
-        const result = await handle.result();
-        expect(result).toEqual([
-            "start",
-            "step1",
-            "between",
-            "step2",
-            "end"
-        ]);
-    });
-    test("executes parallel steps with Promise.all (known slow test)", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const executionTimes = {};
-        const workflow = client.defineWorkflow({
-            name: "parallel"
-        }, async ({ step })=>{
-            const start = Date.now();
-            const [a, b, c] = await Promise.all([
-                step.run({
-                    name: "step-a"
-                }, ()=>{
-                    executionTimes["step-a"] = Date.now() - start;
-                    return "a";
-                }),
-                step.run({
-                    name: "step-b"
-                }, ()=>{
-                    executionTimes["step-b"] = Date.now() - start;
-                    return "b";
-                }),
-                step.run({
-                    name: "step-c"
-                }, ()=>{
-                    executionTimes["step-c"] = Date.now() - start;
-                    return "c";
-                })
-            ]);
-            return {
-                a,
-                b,
-                c
-            };
-        });
-        const worker = client.newWorker();
-        const handle = await workflow.run();
-        await worker.tick();
-        const result = await handle.result();
-        expect(result).toEqual({
-            a: "a",
-            b: "b",
-            c: "c"
-        });
-        // steps should execute at roughly the same time (within 100ms)
-        const times = Object.values(executionTimes);
-        const maxTime = Math.max(...times);
-        const minTime = Math.min(...times);
-        expect(maxTime - minTime).toBeLessThan(100);
-    });
-    test("respects worker concurrency limit", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "concurrency-test"
-        }, ()=>{
-            return "done";
-        });
-        const worker = client.newWorker({
-            concurrency: 2
-        });
-        // create 5 workflow runs, though only 2 (concurrency limit) should be
-        // completed per tick
-        const handles = await Promise.all([
-            workflow.run(),
-            workflow.run(),
-            workflow.run(),
-            workflow.run(),
-            workflow.run()
-        ]);
-        await worker.tick();
-        await sleep(100);
-        let completed = 0;
-        for (const handle of handles){
-            const run = await backend.getWorkflowRun({
-                workflowRunId: handle.workflowRun.id
-            });
-            if (run?.status === "completed") completed++;
-        }
-        expect(completed).toBe(2);
-    });
-    test("worker starts, processes work, and stops gracefully (known slow test)", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "lifecycle"
-        }, ()=>{
-            return "complete";
-        });
-        const worker = client.newWorker();
-        await worker.start();
-        const handle = await workflow.run();
-        await sleep(200);
-        await worker.stop();
-        const result = await handle.result();
-        expect(result).toBe("complete");
-    });
-    test("recovers from crashes during parallel step execution (known slow test)", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        let attemptCount = 0;
-        const workflow = client.defineWorkflow({
-            name: "crash-recovery"
-        }, async ({ step })=>{
-            attemptCount++;
-            const [a, b] = await Promise.all([
-                step.run({
-                    name: "step-a"
-                }, ()=>{
-                    if (attemptCount > 1) return "x"; // should not happen since "a" will be cached
-                    return "a";
-                }),
-                step.run({
-                    name: "step-b"
-                }, ()=>{
-                    if (attemptCount === 1) throw new Error("Simulated crash");
-                    return "b";
-                })
-            ]);
-            return {
-                a,
-                b,
-                attempts: attemptCount
-            };
-        });
-        const worker = client.newWorker();
-        const handle = await workflow.run();
-        // first attempt will fail
-        await worker.tick();
-        await sleep(100);
-        expect(attemptCount).toBe(1);
-        // wait for backoff
-        await sleep(1100);
-        // second attempt should succeed
-        await worker.tick();
-        await sleep(100);
-        const result = await handle.result();
-        expect(result).toEqual({
-            a: "a",
-            b: "b",
-            attempts: 2
-        });
-        expect(attemptCount).toBe(2);
-    });
-    test("reclaims workflow run when heartbeat stops (known slow test)", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "heartbeat-test"
-        }, ()=>"done");
-        const handle = await workflow.run();
-        const workerId = randomUUID();
-        const claimed = await backend.claimWorkflowRun({
-            workerId,
-            leaseDurationMs: 50
-        });
-        expect(claimed).not.toBeNull();
-        // let lease expire before starting worker
-        await sleep(100);
-        // worker should be able to reclaim
-        const worker = client.newWorker();
-        await worker.tick();
-        const result = await handle.result();
-        expect(result).toBe("done");
-    });
-    test("tick() returns count of claimed workflows", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "count-test"
-        }, ()=>"result");
-        // enqueue 3 workflows
-        await workflow.run();
-        await workflow.run();
-        await workflow.run();
-        const worker = client.newWorker({
-            concurrency: 5
-        });
-        // first tick should claim 3 workflows (all available)
-        const claimed = await worker.tick();
-        expect(claimed).toBe(3);
-        // second tick should claim 0 (all already claimed)
-        const claimedAgain = await worker.tick();
-        expect(claimedAgain).toBe(0);
-        await worker.stop();
-    });
-    test("tick() respects concurrency limit", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "concurrency-test"
-        }, async ()=>{
-            await sleep(100);
-            return "done";
-        });
-        // enqueue 10 workflows
-        for(let i = 0; i < 10; i++){
-            await workflow.run();
-        }
-        const worker = client.newWorker({
-            concurrency: 3
-        });
-        // first tick should claim exactly 3 (concurrency limit)
-        const claimed = await worker.tick();
-        expect(claimed).toBe(3);
-        // second tick should claim 0 (all slots occupied)
-        const claimedAgain = await worker.tick();
-        expect(claimedAgain).toBe(0);
-        await worker.stop();
-    });
-    test("worker only sleeps between claims when no work is available (known slow test)", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "adaptive-test"
-        }, async ({ step })=>{
-            await step.run({
-                name: "step-1"
-            }, ()=>"done");
-            return "complete";
-        });
-        // enqueue many workflows
-        const handles = [];
-        for(let i = 0; i < 20; i++){
-            handles.push(await workflow.run());
-        }
-        const worker = client.newWorker({
-            concurrency: 5
-        });
-        const startTime = Date.now();
-        await worker.start();
-        // wait for all workflows to complete
-        await Promise.all(handles.map((h)=>h.result()));
-        await worker.stop();
-        const duration = Date.now() - startTime;
-        // with this conditional sleep, all workflows should complete quickly
-        // without it (with 100ms sleep between ticks), it would take much longer
-        expect(duration).toBeLessThan(3000); // should complete in under 3 seconds
-    });
-    test("only failed steps re-execute on retry (known slow test)", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const executionCounts = {
-            stepA: 0,
-            stepB: 0,
-            stepC: 0
-        };
-        const workflow = client.defineWorkflow({
-            name: "mixed-retry"
-        }, async ({ step })=>{
-            const a = await step.run({
-                name: "step-a"
-            }, ()=>{
-                executionCounts.stepA++;
-                return "a-result";
-            });
-            const b = await step.run({
-                name: "step-b"
-            }, ()=>{
-                executionCounts.stepB++;
-                if (executionCounts.stepB === 1) {
-                    throw new Error("Step B fails on first attempt");
-                }
-                return "b-result";
-            });
-            const c = await step.run({
-                name: "step-c"
-            }, ()=>{
-                executionCounts.stepC++;
-                return "c-result";
-            });
-            return {
-                a,
-                b,
-                c
-            };
-        });
-        const worker = client.newWorker();
-        const handle = await workflow.run();
-        // first workflow attempt
-        // - step-a succeeds
-        // - step-b fails
-        // - step-c never runs (workflow fails at step-b)
-        await worker.tick();
-        await sleep(100);
-        expect(executionCounts.stepA).toBe(1);
-        expect(executionCounts.stepB).toBe(1);
-        expect(executionCounts.stepC).toBe(0);
-        // wait for backoff
-        await sleep(1100);
-        // second workflow attempt
-        // - step-a should be cached (not re-executed)
-        // - step-b should be re-executed (failed previously)
-        // - step-c should execute for first time
-        await worker.tick();
-        await sleep(100);
-        expect(executionCounts.stepA).toBe(1); // still 1, was cached
-        expect(executionCounts.stepB).toBe(2); // incremented, was retried
-        expect(executionCounts.stepC).toBe(1); // incremented, first execution
-        const result = await handle.result();
-        expect(result).toEqual({
-            a: "a-result",
-            b: "b-result",
-            c: "c-result"
-        });
-    });
-    test("step.sleep postpones workflow execution (known slow test)", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        let stepCount = 0;
-        const workflow = client.defineWorkflow({
-            name: "sleep-test"
-        }, async ({ step })=>{
-            const before = await step.run({
-                name: "before-sleep"
-            }, ()=>{
-                stepCount++;
-                return "before";
-            });
-            await step.sleep("pause", "100ms");
-            const after = await step.run({
-                name: "after-sleep"
-            }, ()=>{
-                stepCount++;
-                return "after";
-            });
-            return {
-                before,
-                after
-            };
-        });
-        const worker = client.newWorker();
-        const handle = await workflow.run();
-        // first execution - runs before-sleep, then sleeps
-        await worker.tick();
-        await sleep(50); // wait for processing
-        expect(stepCount).toBe(1);
-        // verify workflow was postponed with sleeping status
-        const slept = await backend.getWorkflowRun({
-            workflowRunId: handle.workflowRun.id
-        });
-        expect(slept?.status).toBe("sleeping");
-        expect(slept?.workerId).toBeNull(); // released during sleep
-        expect(slept?.availableAt).not.toBeNull();
-        if (!slept?.availableAt) throw new Error("availableAt should be set");
-        const delayMs = slept.availableAt.getTime() - Date.now();
-        expect(delayMs).toBeGreaterThan(0);
-        expect(delayMs).toBeLessThan(150); // should be ~100ms
-        // verify sleep step is in "running" state during sleep
-        const attempts = await backend.listStepAttempts({
-            workflowRunId: handle.workflowRun.id
-        });
-        const sleepStep = attempts.data.find((a)=>a.stepName === "pause");
-        expect(sleepStep?.status).toBe("running");
-        // wait for sleep duration
-        await sleep(150);
-        // second execution (after sleep)
-        await worker.tick();
-        await sleep(50); // wait for processing
-        expect(stepCount).toBe(2);
-        // verify sleep step is now "completed"
-        const refreshedAttempts = await backend.listStepAttempts({
-            workflowRunId: handle.workflowRun.id
-        });
-        const completedSleepStep = refreshedAttempts.data.find((a)=>a.stepName === "pause");
-        expect(completedSleepStep?.status).toBe("completed");
-        const result = await handle.result();
-        expect(result).toEqual({
-            before: "before",
-            after: "after"
-        });
-    });
-    test("step.sleep is cached on replay", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        let step1Count = 0;
-        let step2Count = 0;
-        const workflow = client.defineWorkflow({
-            name: "sleep-cache-test"
-        }, async ({ step })=>{
-            await step.run({
-                name: "step-1"
-            }, ()=>{
-                step1Count++;
-                return "one";
-            });
-            // this should only postpone once
-            await step.sleep("wait", "50ms");
-            await step.run({
-                name: "step-2"
-            }, ()=>{
-                step2Count++;
-                return "two";
-            });
-            return "done";
-        });
-        const worker = client.newWorker();
-        const handle = await workflow.run();
-        // first attempt: execute step-1, then sleep (step-2 not executed)
-        await worker.tick();
-        await sleep(50);
-        expect(step1Count).toBe(1);
-        expect(step2Count).toBe(0);
-        await sleep(100); // wait for sleep to complete
-        // second attempt: step-1 is cached (not re-executed), sleep is cached, step-2 executes
-        await worker.tick();
-        await sleep(50);
-        expect(step1Count).toBe(1); // still 1, was cached
-        expect(step2Count).toBe(1); // now 1, executed after sleep
-        const result = await handle.result();
-        expect(result).toBe("done");
-    });
-    test("step.sleep throws error for invalid duration format", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "invalid-duration"
-        }, async ({ step })=>{
-            // @ts-expect-error - testing invalid duration
-            await step.sleep("bad", "invalid");
-            return "should-not-reach";
-        });
-        const worker = client.newWorker();
-        const handle = await workflow.run();
-        await worker.tick();
-        await sleep(100);
-        const failed = await backend.getWorkflowRun({
-            workflowRunId: handle.workflowRun.id
-        });
-        expect(failed?.status).toBe("pending"); // should be retrying
-        expect(failed?.error).toBeDefined();
-        expect(failed?.error?.message).toContain("Invalid duration format");
-    });
-    test("step.sleep handles multiple sequential sleeps (known slow test)", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        let executionCount = 0;
-        const workflow = client.defineWorkflow({
-            name: "sequential-sleeps"
-        }, async ({ step })=>{
-            executionCount++;
-            await step.run({
-                name: "step-1"
-            }, ()=>"one");
-            await step.sleep("sleep-1", "50ms");
-            await step.run({
-                name: "step-2"
-            }, ()=>"two");
-            await step.sleep("sleep-2", "50ms");
-            await step.run({
-                name: "step-3"
-            }, ()=>"three");
-            return "done";
-        });
-        const worker = client.newWorker();
-        const handle = await workflow.run();
-        // first execution: step-1, then sleep-1
-        await worker.tick();
-        await sleep(50);
-        expect(executionCount).toBe(1);
-        // verify first sleep is running
-        const attempts1 = await backend.listStepAttempts({
-            workflowRunId: handle.workflowRun.id
-        });
-        expect(attempts1.data.find((a)=>a.stepName === "sleep-1")?.status).toBe("running");
-        // wait for first sleep
-        await sleep(100);
-        // second execution: sleep-1 completed, step-2, then sleep-2
-        await worker.tick();
-        await sleep(50);
-        expect(executionCount).toBe(2);
-        // verify second sleep is running
-        const attempts2 = await backend.listStepAttempts({
-            workflowRunId: handle.workflowRun.id
-        });
-        expect(attempts2.data.find((a)=>a.stepName === "sleep-1")?.status).toBe("completed");
-        expect(attempts2.data.find((a)=>a.stepName === "sleep-2")?.status).toBe("running");
-        // wait for second sleep
-        await sleep(100);
-        // third execution: sleep-2 completed, step-3, complete
-        await worker.tick();
-        await sleep(50);
-        expect(executionCount).toBe(3);
-        const result = await handle.result();
-        expect(result).toBe("done");
-        // verify all steps completed
-        const finalAttempts = await backend.listStepAttempts({
-            workflowRunId: handle.workflowRun.id
-        });
-        expect(finalAttempts.data.length).toBe(5); // 3 regular steps + 2 sleeps
-        expect(finalAttempts.data.every((a)=>a.status === "completed")).toBe(true);
-    });
-    test("sleeping workflows can be claimed after availableAt", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "sleeping-claim-test"
-        }, async ({ step })=>{
-            await step.run({
-                name: "before"
-            }, ()=>"before");
-            await step.sleep("wait", "100ms");
-            await step.run({
-                name: "after"
-            }, ()=>"after");
-            return "done";
-        });
-        const worker = client.newWorker();
-        const handle = await workflow.run();
-        // first execution - sleep
-        await worker.tick();
-        await sleep(50);
-        // verify workflow is in sleeping state
-        const sleeping = await backend.getWorkflowRun({
-            workflowRunId: handle.workflowRun.id
-        });
-        expect(sleeping?.status).toBe("sleeping");
-        expect(sleeping?.workerId).toBeNull();
-        // wait for sleep duration
-        await sleep(100);
-        // verify workflow can be claimed again
-        const claimed = await backend.claimWorkflowRun({
-            workerId: "test-worker",
-            leaseDurationMs: 30_000
-        });
-        expect(claimed?.id).toBe(handle.workflowRun.id);
-        expect(claimed?.status).toBe("running");
-        expect(claimed?.workerId).toBe("test-worker");
-    });
-    test("sleep is not skipped when worker crashes after creating sleep step but before marking workflow as sleeping (known slow test)", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        let executionCount = 0;
-        let beforeSleepCount = 0;
-        let afterSleepCount = 0;
-        const workflow = client.defineWorkflow({
-            name: "crash-during-sleep"
-        }, async ({ step })=>{
-            executionCount++;
-            await step.run({
-                name: "before-sleep"
-            }, ()=>{
-                beforeSleepCount++;
-                return "before";
-            });
-            // this sleep should NOT be skipped even if crash happens
-            await step.sleep("critical-pause", "200ms");
-            await step.run({
-                name: "after-sleep"
-            }, ()=>{
-                afterSleepCount++;
-                return "after";
-            });
-            return {
-                executionCount,
-                beforeSleepCount,
-                afterSleepCount
-            };
-        });
-        const handle = await workflow.run();
-        // first worker processes the workflow until sleep
-        const worker1 = client.newWorker();
-        await worker1.tick();
-        await sleep(100);
-        const workflowAfterFirst = await backend.getWorkflowRun({
-            workflowRunId: handle.workflowRun.id
-        });
-        expect(workflowAfterFirst?.status).toBe("sleeping");
-        const attemptsAfterFirst = await backend.listStepAttempts({
-            workflowRunId: handle.workflowRun.id
-        });
-        const sleepStep = attemptsAfterFirst.data.find((a)=>a.stepName === "critical-pause");
-        expect(sleepStep).toBeDefined();
-        expect(sleepStep?.kind).toBe("sleep");
-        expect(sleepStep?.status).toBe("running");
-        await sleep(50); // only 50ms of the 200ms sleep
-        // if there's a running sleep step, the workflow should be properly
-        // transitioned to sleeping
-        const worker2 = client.newWorker();
-        await worker2.tick();
-        // after-sleep step should NOT have executed yet
-        expect(afterSleepCount).toBe(0);
-        // wait for the full sleep duration to elapse then check to make sure
-        // workflow is claimable and resume
-        await sleep(200);
-        await worker2.tick();
-        await sleep(100);
-        expect(afterSleepCount).toBe(1);
-        const result = await handle.result();
-        expect(result.afterSleepCount).toBe(1);
-    });
-    test("version enables conditional code paths (known slow test)", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "conditional-workflow",
-            version: "v2"
-        }, async ({ version, step })=>{
-            return version === "v1" ? await step.run({
-                name: "old-step"
-            }, ()=>"old-logic") : await step.run({
-                name: "new-step"
-            }, ()=>"new-logic");
-        });
-        const worker = client.newWorker();
-        const handle = await workflow.run();
-        await worker.tick();
-        const result = await handle.result();
-        expect(result).toBe("new-logic");
-    });
-    test("workflow version is null when not specified", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "unversioned-workflow"
-        }, async ({ version, step })=>{
-            const result = await step.run({
-                name: "check-version"
-            }, ()=>{
-                return {
-                    version
-                };
-            });
-            return result;
-        });
-        const worker = client.newWorker();
-        const handle = await workflow.run();
-        await worker.tick();
-        const result = await handle.result();
-        expect(result.version).toBeNull();
-    });
-    test("cancels a pending workflow", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "cancel-pending"
-        }, async ({ step })=>{
-            await step.run({
-                name: "step-1"
-            }, ()=>"result");
-            return {
-                completed: true
-            };
-        });
-        const handle = await workflow.run();
-        // cancel before worker processes it
-        await handle.cancel();
-        const workflowRun = await backend.getWorkflowRun({
-            workflowRunId: handle.workflowRun.id
-        });
-        expect(workflowRun?.status).toBe("canceled");
-        expect(workflowRun?.finishedAt).not.toBeNull();
-        expect(workflowRun?.availableAt).toBeNull();
-        expect(workflowRun?.workerId).toBeNull();
-    });
-    test("cancels a sleeping workflow", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "cancel-sleeping"
-        }, async ({ step })=>{
-            await step.sleep("sleep-1", "1h");
-            return {
-                completed: true
-            };
-        });
-        const worker = client.newWorker();
-        const handle = await workflow.run();
-        await worker.tick();
-        // cancel while sleeping
-        await handle.cancel();
-        const canceled = await backend.getWorkflowRun({
-            workflowRunId: handle.workflowRun.id
-        });
-        expect(canceled?.status).toBe("canceled");
-        expect(canceled?.finishedAt).not.toBeNull();
-        expect(canceled?.availableAt).toBeNull();
-        expect(canceled?.workerId).toBeNull();
-    });
-    test("cannot cancel a completed workflow", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "cancel-completed"
-        }, ()=>({
-                completed: true
-            }));
-        const worker = client.newWorker();
-        const handle = await workflow.run();
-        await worker.tick();
-        const result = await handle.result();
-        expect(result.completed).toBe(true);
-        // try to cancel after success
-        await expect(handle.cancel()).rejects.toThrow(/Cannot cancel workflow run .* with status completed/);
-    });
-    test("cannot cancel a failed workflow", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "cancel-failed"
-        }, ()=>{
-            throw new Error("intentional failure");
-        });
-        const worker = client.newWorker();
-        const handle = await workflow.run({
-            value: 1
-        }, {
-            deadlineAt: new Date()
-        });
-        await worker.tick();
-        // wait for it to fail due to deadline
-        await sleep(100);
-        const failed = await backend.getWorkflowRun({
-            workflowRunId: handle.workflowRun.id
-        });
-        expect(failed?.status).toBe("failed");
-        // try to cancel after failure
-        await expect(handle.cancel()).rejects.toThrow(/Cannot cancel workflow run .* with status failed/);
-    });
-    test("cannot cancel non-existent workflow", async ()=>{
-        await expect(backend.cancelWorkflowRun({
-            workflowRunId: "non-existent-id"
-        })).rejects.toThrow(/Workflow run non-existent-id does not exist/);
-    });
-    test("worker handles when canceled workflow during execution", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        let stepExecuted = false;
-        const workflow = client.defineWorkflow({
-            name: "cancel-during-execution"
-        }, async ({ step })=>{
-            await step.run({
-                name: "step-1"
-            }, async ()=>{
-                stepExecuted = true;
-                // simulate some work
-                await sleep(50);
-                return "result";
-            });
-            return {
-                completed: true
-            };
-        });
-        const worker = client.newWorker();
-        const handle = await workflow.run();
-        // start processing in the background
-        const tickPromise = worker.tick();
-        await sleep(25);
-        // cancel while step is executing
-        await handle.cancel();
-        // wait for tick to complete
-        await tickPromise;
-        // step should have been executed but workflow should be canceled
-        expect(stepExecuted).toBe(true);
-        const canceled = await backend.getWorkflowRun({
-            workflowRunId: handle.workflowRun.id
-        });
-        expect(canceled?.status).toBe("canceled");
-    });
-    test("result() rejects for canceled workflows", async ()=>{
-        const client = new OpenWorkflow({
-            backend
-        });
-        const workflow = client.defineWorkflow({
-            name: "cancel-result"
-        }, async ({ step })=>{
-            await step.sleep("sleep-1", "1h");
-            return {
-                completed: true
-            };
-        });
-        const handle = await workflow.run();
-        await handle.cancel();
-        await expect(handle.result()).rejects.toThrow(/Workflow cancel-result was canceled/);
-    });
-    describe("version matching", ()=>{
-        test("worker matches workflow runs by version", async ()=>{
-            const client = new OpenWorkflow({
-                backend
-            });
-            client.defineWorkflow({
-                name: "versioned-workflow",
-                version: "v1"
-            }, async ({ step })=>{
-                return await step.run({
-                    name: "compute"
-                }, ()=>"v1-result");
-            });
-            client.defineWorkflow({
-                name: "versioned-workflow",
-                version: "v2"
-            }, async ({ step })=>{
-                return await step.run({
-                    name: "compute"
-                }, ()=>"v2-result");
-            });
-            const worker = client.newWorker({
-                concurrency: 2
-            });
-            const v1Spec = declareWorkflow({
-                name: "versioned-workflow",
-                version: "v1"
-            });
-            const v2Spec = declareWorkflow({
-                name: "versioned-workflow",
-                version: "v2"
-            });
-            const handleV1 = await client.runWorkflow(v1Spec);
-            const handleV2 = await client.runWorkflow(v2Spec);
-            await worker.tick();
-            await sleep(100); // wait for background execution
-            const resultV1 = await handleV1.result();
-            const resultV2 = await handleV2.result();
-            expect(resultV1).toBe("v1-result");
-            expect(resultV2).toBe("v2-result");
-        });
-        test("worker fails workflow run when version is not registered", async ()=>{
-            const client = new OpenWorkflow({
-                backend
-            });
-            client.defineWorkflow({
-                name: "version-check",
-                version: "v1"
-            }, ()=>"v1-result");
-            const worker = client.newWorker();
-            const workflowRun = await backend.createWorkflowRun({
-                workflowName: "version-check",
-                version: "v2",
-                idempotencyKey: null,
-                config: {},
-                context: null,
-                input: null,
-                availableAt: null,
-                deadlineAt: null
-            });
-            await worker.tick();
-            const updated = await backend.getWorkflowRun({
-                workflowRunId: workflowRun.id
-            });
-            expect(updated?.status).toBe("pending");
-            expect(updated?.error).toEqual({
-                message: 'Workflow "version-check" (version: v2) is not registered'
-            });
-        });
-        test("unversioned workflow does not match versioned run", async ()=>{
-            const client = new OpenWorkflow({
-                backend
-            });
-            client.defineWorkflow({
-                name: "version-mismatch"
-            }, ()=>"unversioned-result");
-            const worker = client.newWorker();
-            const workflowRun = await backend.createWorkflowRun({
-                workflowName: "version-mismatch",
-                version: "v1",
-                idempotencyKey: null,
-                config: {},
-                context: null,
-                input: null,
-                availableAt: null,
-                deadlineAt: null
-            });
-            await worker.tick();
-            const updated = await backend.getWorkflowRun({
-                workflowRunId: workflowRun.id
-            });
-            expect(updated?.status).toBe("pending");
-            expect(updated?.error).toEqual({
-                message: 'Workflow "version-mismatch" (version: v1) is not registered'
-            });
-        });
-        test("versioned workflow does not match unversioned run", async ()=>{
-            const client = new OpenWorkflow({
-                backend
-            });
-            client.defineWorkflow({
-                name: "version-required",
-                version: "v1"
-            }, ()=>"v1-result");
-            const worker = client.newWorker();
-            const workflowRun = await backend.createWorkflowRun({
-                workflowName: "version-required",
-                version: null,
-                idempotencyKey: null,
-                config: {},
-                context: null,
-                input: null,
-                availableAt: null,
-                deadlineAt: null
-            });
-            await worker.tick();
-            const updated = await backend.getWorkflowRun({
-                workflowRunId: workflowRun.id
-            });
-            expect(updated?.status).toBe("pending");
-            expect(updated?.error).toEqual({
-                message: 'Workflow "version-required" is not registered'
-            });
-        });
-        test("workflow receives run's version, not registered version", async ()=>{
-            // this test verifies that the version passed to the workflow function
-            // is the one from the workflow run, not the registered workflow
-            const client = new OpenWorkflow({
-                backend
-            });
-            const workflow = client.defineWorkflow({
-                name: "version-in-handler",
-                version: "v1"
-            }, async ({ version, step })=>{
-                return await step.run({
-                    name: "get-version"
-                }, ()=>version);
-            });
-            const worker = client.newWorker();
-            const handle = await workflow.run();
-            await worker.tick();
-            const result = await handle.result();
-            expect(result).toBe("v1");
-        });
-    });
-});
-function sleep(ms) {
-    return new Promise((resolve)=>setTimeout(resolve, ms));
-}
-
-//# sourceMappingURL=worker.test.js.map