@multiplier-labs/stepflow 0.3.1 → 0.3.3

package/src/scheduler/cron.test.ts

@@ -1,16 +1,12 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import {
-  CronScheduler,
-  type CronSchedulerConfig,
-  type SchedulePersistence,
-} from "./cron";
-import { WorkflowEngine } from "../core/engine";
-import { MemoryStorageAdapter } from "../storage/memory";
-import { MemoryEventTransport } from "../events/memory";
-import { SilentLogger } from "../utils/logger";
-import type { WorkflowSchedule } from "./types";
-
-describe("CronScheduler", () => {
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { CronScheduler, type CronSchedulerConfig, type SchedulePersistence } from './cron';
+import { WorkflowEngine } from '../core/engine';
+import { MemoryStorageAdapter } from '../storage/memory';
+import { MemoryEventTransport } from '../events/memory';
+import { SilentLogger } from '../utils/logger';
+import type { WorkflowSchedule } from './types';
+
+describe('CronScheduler', () => {
   let engine: WorkflowEngine;
   let scheduler: CronScheduler;
 
@@ -24,13 +20,13 @@ describe("CronScheduler", () => {
 
     // Register a test workflow
     engine.registerWorkflow({
-      kind: "test.workflow",
-      name: "Test Workflow",
+      kind: 'test.workflow',
+      name: 'Test Workflow',
       steps: [
         {
-          key: "step1",
-          name: "Step 1",
-          handler: async (ctx) => ({ value: ctx.input.value ?? "default" }),
+          key: 'step1',
+          name: 'Step 1',
+          handler: async (ctx) => ({ value: ctx.input.value ?? 'default' }),
         },
       ],
     });
@@ -48,64 +44,64 @@ describe("CronScheduler", () => {
     await engine.shutdown();
   });
 
-  describe("addSchedule", () => {
-    it("should add a cron schedule", async () => {
+  describe('addSchedule', () => {
+    it('should add a cron schedule', async () => {
       const schedule = await scheduler.addSchedule({
-        workflowKind: "test.workflow",
-        triggerType: "cron",
-        cronExpression: "0 * * * *", // Every hour
+        workflowKind: 'test.workflow',
+        triggerType: 'cron',
+        cronExpression: '0 * * * *', // Every hour
         enabled: true,
       });
 
       expect(schedule.id).toBeDefined();
-      expect(schedule.workflowKind).toBe("test.workflow");
-      expect(schedule.triggerType).toBe("cron");
-      expect(schedule.cronExpression).toBe("0 * * * *");
+      expect(schedule.workflowKind).toBe('test.workflow');
+      expect(schedule.triggerType).toBe('cron');
+      expect(schedule.cronExpression).toBe('0 * * * *');
       expect(schedule.nextRunAt).toBeInstanceOf(Date);
     });
 
-    it("should add a workflow completion trigger", async () => {
+    it('should add a workflow completion trigger', async () => {
       const schedule = await scheduler.addSchedule({
-        workflowKind: "notification.send",
-        triggerType: "workflow_completed",
-        triggerOnWorkflowKind: "order.process",
-        triggerOnStatus: ["succeeded"],
+        workflowKind: 'notification.send',
+        triggerType: 'workflow_completed',
+        triggerOnWorkflowKind: 'order.process',
+        triggerOnStatus: ['succeeded'],
         enabled: true,
       });
 
       expect(schedule.id).toBeDefined();
-      expect(schedule.triggerType).toBe("workflow_completed");
-      expect(schedule.triggerOnWorkflowKind).toBe("order.process");
+      expect(schedule.triggerType).toBe('workflow_completed');
+      expect(schedule.triggerOnWorkflowKind).toBe('order.process');
     });
 
-    it("should reject invalid cron expression", async () => {
+    it('should reject invalid cron expression', async () => {
       await expect(
         scheduler.addSchedule({
-          workflowKind: "test.workflow",
-          triggerType: "cron",
-          cronExpression: "invalid cron",
+          workflowKind: 'test.workflow',
+          triggerType: 'cron',
+          cronExpression: 'invalid cron',
           enabled: true,
-        }),
-      ).rejects.toThrow("Invalid cron expression");
+        })
+      ).rejects.toThrow('Invalid cron expression');
     });
 
-    it("should require triggerOnWorkflowKind for workflow_completed triggers", async () => {
+    it('should require triggerOnWorkflowKind for workflow_completed triggers', async () => {
       await expect(
         scheduler.addSchedule({
-          workflowKind: "test.workflow",
-          triggerType: "workflow_completed",
+          workflowKind: 'test.workflow',
+          triggerType: 'workflow_completed',
           enabled: true,
-        }),
-      ).rejects.toThrow("triggerOnWorkflowKind is required");
+        })
+      ).rejects.toThrow('triggerOnWorkflowKind is required');
     });
   });
 
-  describe("removeSchedule", () => {
-    it("should remove a schedule", async () => {
+  describe('removeSchedule', () => {
+    it('should remove a schedule', async () => {
       const schedule = await scheduler.addSchedule({
-        workflowKind: "test.workflow",
-        triggerType: "cron",
-        cronExpression: "0 * * * *",
+        workflowKind: 'test.workflow',
+        triggerType: 'cron',
+        cronExpression: '0 * * * *',
         enabled: true,
       });
 
@@ -115,19 +111,19 @@ describe("CronScheduler", () => {
       expect(schedules).toHaveLength(0);
     });
 
-    it("should throw for non-existent schedule", async () => {
-      await expect(scheduler.removeSchedule("nonexistent")).rejects.toThrow(
-        "Schedule not found",
+    it('should throw for non-existent schedule', async () => {
+      await expect(scheduler.removeSchedule('nonexistent')).rejects.toThrow(
+        'Schedule not found'
       );
     });
   });
 
-  describe("updateSchedule", () => {
-    it("should update schedule properties", async () => {
+  describe('updateSchedule', () => {
+    it('should update schedule properties', async () => {
       const schedule = await scheduler.addSchedule({
-        workflowKind: "test.workflow",
-        triggerType: "cron",
-        cronExpression: "0 * * * *",
+        workflowKind: 'test.workflow',
+        triggerType: 'cron',
+        cronExpression: '0 * * * *',
         enabled: true,
       });
 
@@ -137,38 +133,38 @@ describe("CronScheduler", () => {
       expect(updated?.enabled).toBe(false);
     });
 
-    it("should update cron expression and recalculate next run", async () => {
+    it('should update cron expression and recalculate next run', async () => {
       const schedule = await scheduler.addSchedule({
-        workflowKind: "test.workflow",
-        triggerType: "cron",
-        cronExpression: "0 * * * *",
+        workflowKind: 'test.workflow',
+        triggerType: 'cron',
+        cronExpression: '0 * * * *',
         enabled: true,
       });
 
       const originalNextRun = schedule.nextRunAt;
 
       await scheduler.updateSchedule(schedule.id, {
-        cronExpression: "30 * * * *",
+        cronExpression: '30 * * * *',
       });
 
       const updated = scheduler.getSchedule(schedule.id);
-      expect(updated?.cronExpression).toBe("30 * * * *");
+      expect(updated?.cronExpression).toBe('30 * * * *');
       expect(updated?.nextRunAt).not.toEqual(originalNextRun);
     });
   });
 
-  describe("getSchedules", () => {
-    it("should return all schedules", async () => {
+  describe('getSchedules', () => {
+    it('should return all schedules', async () => {
       await scheduler.addSchedule({
-        workflowKind: "test.workflow",
-        triggerType: "cron",
-        cronExpression: "0 * * * *",
+        workflowKind: 'test.workflow',
+        triggerType: 'cron',
+        cronExpression: '0 * * * *',
         enabled: true,
       });
 
       await scheduler.addSchedule({
-        workflowKind: "test.workflow",
-        triggerType: "manual",
+        workflowKind: 'test.workflow',
+        triggerType: 'manual',
         enabled: true,
       });
 
@@ -177,13 +173,13 @@ describe("CronScheduler", () => {
     });
   });
 
-  describe("triggerNow", () => {
-    it("should manually trigger a schedule", async () => {
+  describe('triggerNow', () => {
+    it('should manually trigger a schedule', async () => {
       const schedule = await scheduler.addSchedule({
-        workflowKind: "test.workflow",
-        triggerType: "cron",
-        cronExpression: "0 0 1 1 *", // Once a year (won't trigger naturally)
-        input: { value: "manual" },
+        workflowKind: 'test.workflow',
+        triggerType: 'cron',
+        cronExpression: '0 0 1 1 *', // Once a year (won't trigger naturally)
+        input: { value: 'manual' },
         enabled: true,
       });
 
@@ -193,27 +189,27 @@ describe("CronScheduler", () => {
 
       // Wait for workflow to complete
       const run = await engine.waitForRun(runId);
-      expect(run.status).toBe("succeeded");
+      expect(run.status).toBe('succeeded');
     });
 
-    it("should throw for non-existent schedule", async () => {
-      await expect(scheduler.triggerNow("nonexistent")).rejects.toThrow(
-        "Schedule not found",
+    it('should throw for non-existent schedule', async () => {
+      await expect(scheduler.triggerNow('nonexistent')).rejects.toThrow(
+        'Schedule not found'
       );
     });
   });
 
-  describe("cron execution", () => {
-    it("should execute scheduled workflow when cron time is reached", async () => {
+  describe('cron execution', () => {
+    it('should execute scheduled workflow when cron time is reached', async () => {
       // Use fake timers
       vi.useFakeTimers();
 
       // Create a schedule that runs every minute
       await scheduler.addSchedule({
-        workflowKind: "test.workflow",
-        triggerType: "cron",
-        cronExpression: "* * * * *", // Every minute
-        input: { value: "scheduled" },
+        workflowKind: 'test.workflow',
+        triggerType: 'cron',
+        cronExpression: '* * * * *', // Every minute
+        input: { value: 'scheduled' },
         enabled: true,
       });
 
@@ -234,16 +230,16 @@ describe("CronScheduler", () => {
     });
   });
 
-  describe("workflow completion triggers", () => {
-    it("should trigger workflow on completion of another workflow", async () => {
+  describe('workflow completion triggers', () => {
+    it('should trigger workflow on completion of another workflow', async () => {
       // Register a trigger workflow
       engine.registerWorkflow({
-        kind: "trigger.workflow",
-        name: "Trigger Workflow",
+        kind: 'trigger.workflow',
+        name: 'Trigger Workflow',
         steps: [
           {
-            key: "trigger",
-            name: "Trigger",
+            key: 'trigger',
+            name: 'Trigger',
             handler: async () => ({ triggered: true }),
           },
         ],
@@ -251,14 +247,14 @@ describe("CronScheduler", () => {
 
       // Register a dependent workflow
       engine.registerWorkflow({
-        kind: "dependent.workflow",
-        name: "Dependent Workflow",
+        kind: 'dependent.workflow',
+        name: 'Dependent Workflow',
         steps: [
           {
-            key: "dependent",
-            name: "Dependent",
+            key: 'dependent',
+            name: 'Dependent',
             handler: async (ctx) => ({
-              parentRunId: ctx.metadata.triggerRunId,
+              parentRunId: ctx.metadata.triggerRunId
             }),
           },
         ],
@@ -266,42 +262,42 @@ describe("CronScheduler", () => {
 
       // Add a completion trigger
       await scheduler.addSchedule({
-        workflowKind: "dependent.workflow",
-        triggerType: "workflow_completed",
-        triggerOnWorkflowKind: "trigger.workflow",
-        triggerOnStatus: ["succeeded"],
+        workflowKind: 'dependent.workflow',
+        triggerType: 'workflow_completed',
+        triggerOnWorkflowKind: 'trigger.workflow',
+        triggerOnStatus: ['succeeded'],
         enabled: true,
       });
 
       await scheduler.start();
 
       // Start the trigger workflow
-      const triggerRunId = await engine.startRun({ kind: "trigger.workflow" });
+      const triggerRunId = await engine.startRun({ kind: 'trigger.workflow' });
 
       // Wait for trigger workflow to complete
       await engine.waitForRun(triggerRunId);
 
       // Give time for the completion trigger to fire and dependent workflow to start
-      await new Promise((resolve) => setTimeout(resolve, 200));
+      await new Promise(resolve => setTimeout(resolve, 200));
 
       // Check that the dependent workflow was started
       const storage = engine.getStorage();
-      const { items } = await storage.listRuns({ kind: "dependent.workflow" });
+      const { items } = await storage.listRuns({ kind: 'dependent.workflow' });
 
       expect(items.length).toBeGreaterThanOrEqual(1);
     });
 
-    it("should not trigger on non-matching status", async () => {
+    it('should not trigger on non-matching status', async () => {
       // Register a failing trigger workflow
       engine.registerWorkflow({
-        kind: "failing.workflow",
-        name: "Failing Workflow",
+        kind: 'failing.workflow',
+        name: 'Failing Workflow',
         steps: [
           {
-            key: "fail",
-            name: "Fail",
+            key: 'fail',
+            name: 'Fail',
             handler: async () => {
-              throw new Error("Intentional failure");
+              throw new Error('Intentional failure');
             },
           },
         ],
@@ -309,56 +305,56 @@ describe("CronScheduler", () => {
 
       // Add a completion trigger for success only
       await scheduler.addSchedule({
-        workflowKind: "test.workflow",
-        triggerType: "workflow_completed",
-        triggerOnWorkflowKind: "failing.workflow",
-        triggerOnStatus: ["succeeded"], // Only on success
+        workflowKind: 'test.workflow',
+        triggerType: 'workflow_completed',
+        triggerOnWorkflowKind: 'failing.workflow',
+        triggerOnStatus: ['succeeded'], // Only on success
         enabled: true,
       });
 
       await scheduler.start();
 
       // Start the failing workflow
-      const runId = await engine.startRun({ kind: "failing.workflow" });
+      const runId = await engine.startRun({ kind: 'failing.workflow' });
 
       // Wait for it to fail
       await engine.waitForRun(runId);
 
       // Give time for any triggers
-      await new Promise((resolve) => setTimeout(resolve, 200));
+      await new Promise(resolve => setTimeout(resolve, 200));
 
       // Check that test.workflow was NOT started
       const storage = engine.getStorage();
-      const { items } = await storage.listRuns({ kind: "test.workflow" });
+      const { items } = await storage.listRuns({ kind: 'test.workflow' });
 
       expect(items).toHaveLength(0);
     });
   });
 
-  describe("start/stop", () => {
-    it("should start and stop without error", async () => {
+  describe('start/stop', () => {
+    it('should start and stop without error', async () => {
       await scheduler.start();
       await scheduler.stop();
     });
 
-    it("should warn when starting twice", async () => {
+    it('should warn when starting twice', async () => {
       await scheduler.start();
       await scheduler.start(); // Should just warn
       await scheduler.stop();
     });
 
-    it("should handle stopping when not started", async () => {
+    it('should handle stopping when not started', async () => {
       await scheduler.stop(); // Should do nothing
     });
   });
 
-  describe("persistence", () => {
-    it("should load schedules from persistence on start", async () => {
+  describe('persistence', () => {
+    it('should load schedules from persistence on start', async () => {
       const mockSchedule: WorkflowSchedule = {
-        id: "persisted-1",
-        workflowKind: "test.workflow",
-        triggerType: "cron",
-        cronExpression: "0 * * * *",
+        id: 'persisted-1',
+        workflowKind: 'test.workflow',
+        triggerType: 'cron',
+        cronExpression: '0 * * * *',
         enabled: true,
       };
 
@@ -381,12 +377,12 @@ describe("CronScheduler", () => {
 
       const schedules = await schedulerWithPersistence.getSchedules();
       expect(schedules).toHaveLength(1);
-      expect(schedules[0].id).toBe("persisted-1");
+      expect(schedules[0].id).toBe('persisted-1');
 
       await schedulerWithPersistence.stop();
     });
 
-    it("should save schedule to persistence when added", async () => {
+    it('should save schedule to persistence when added', async () => {
       const mockPersistence: SchedulePersistence = {
         loadSchedules: vi.fn().mockResolvedValue([]),
         saveSchedule: vi.fn().mockResolvedValue(undefined),
@@ -401,9 +397,9 @@ describe("CronScheduler", () => {
       });
 
       await schedulerWithPersistence.addSchedule({
-        workflowKind: "test.workflow",
-        triggerType: "cron",
-        cronExpression: "0 * * * *",
+        workflowKind: 'test.workflow',
+        triggerType: 'cron',
+        cronExpression: '0 * * * *',
         enabled: true,
       });
 
@@ -411,14 +407,9 @@ describe("CronScheduler", () => {
     });
   });
 
-  describe("updateNextRunTime parse-error path", () => {
-    it("should set nextRunAt to undefined and log error for malformed cron expression update", async () => {
-      const logger = {
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-      };
+  describe('updateNextRunTime parse-error path', () => {
+    it('should set nextRunAt to undefined and log error for malformed cron expression update', async () => {
+      const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
       const errorScheduler = new CronScheduler({
         engine,
         logger,
@@ -427,9 +418,9 @@ describe("CronScheduler", () => {
 
       // Add a valid schedule first
       const schedule = await errorScheduler.addSchedule({
-        workflowKind: "test.workflow",
-        triggerType: "cron",
-        cronExpression: "0 * * * *",
+        workflowKind: 'test.workflow',
+        triggerType: 'cron',
+        cronExpression: '0 * * * *',
         enabled: true,
       });
 
@@ -443,10 +434,10 @@ describe("CronScheduler", () => {
       const mockPersistence: SchedulePersistence = {
         loadSchedules: vi.fn().mockResolvedValue([
           {
-            id: "bad-cron",
-            workflowKind: "test.workflow",
-            triggerType: "cron" as const,
-            cronExpression: "99 99 99 99 99",
+            id: 'bad-cron',
+            workflowKind: 'test.workflow',
+            triggerType: 'cron' as const,
+            cronExpression: '99 99 99 99 99',
             enabled: true,
           },
         ]),
@@ -465,12 +456,12 @@ describe("CronScheduler", () => {
       await badScheduler.start();
 
       // The schedule should have been loaded with nextRunAt = undefined due to parse error
-      const loaded = badScheduler.getSchedule("bad-cron");
+      const loaded = badScheduler.getSchedule('bad-cron');
       expect(loaded).toBeDefined();
       expect(loaded!.nextRunAt).toBeUndefined();
       expect(logger.error).toHaveBeenCalledWith(
-        expect.stringContaining("Failed to parse cron expression"),
-        expect.anything(),
+        expect.stringContaining('Failed to parse cron expression'),
+        expect.anything()
       );
 
       await badScheduler.stop();