@allternit/workflow-engine 0.1.0 → 0.1.1

package/src/scheduler/scheduler.test.ts.bak

@@ -1,521 +0,0 @@
-/**
- * Workflow Scheduler Tests
- *
- * Comprehensive tests for the WorkflowScheduler class covering priority queue,
- * resource limits, cron-based scheduling, task cancellation, and queue statistics.
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { createScheduler, globalScheduler } from './index';
-import type { Task, WorkflowNode, WorkflowExecution } from '../types';
-
-describe('WorkflowScheduler', () => {
-  let scheduler: ReturnType<typeof createScheduler>;
-
-  beforeEach(() => {
-    scheduler = createScheduler();
-  });
-
-  describe('basic task submission', () => {
-    it('should submit a single task', async () => {
-      const task: Task = {
-        id: 'task-1',
-        node: { id: 'node-1', type: 'test', name: 'Test Node' },
-        execution: {
-          id: 'exec-1',
-          workflowId: 'wf-1',
-          status: 'running',
-        } as WorkflowExecution,
-      };
-
-      // Submit returns a promise that resolves when task completes
-      const resultPromise = scheduler.submit(task);
-      expect(resultPromise).toBeInstanceOf(Promise);
-      
-      const result = await resultPromise;
-      // Result may be undefined if task completes without returning value
-      expect(result !== undefined || result === undefined).toBe(true);
-    });
-
-    it('should submit multiple tasks', async () => {
-      const tasks: Task[] = [
-        {
-          id: 'task-1',
-          node: { id: 'node-1', type: 'test', name: 'Test Node 1' },
-          execution: { id: 'exec-1', workflowId: 'wf-1', status: 'running' } as WorkflowExecution,
-        },
-        {
-          id: 'task-2',
-          node: { id: 'node-2', type: 'test', name: 'Test Node 2' },
-          execution: { id: 'exec-2', workflowId: 'wf-1', status: 'running' } as WorkflowExecution,
-        },
-      ];
-
-      const results = await scheduler.submitAll(tasks);
-      expect(results).toHaveLength(2);
-    });
-  });
-
-  describe('priority queue', () => {
-    it('should respect priority when enabled', async () => {
-      const priorityScheduler = createScheduler({ enablePriority: true });
-      const executionOrder: string[] = [];
-
-      // Create custom scheduler that tracks execution order
-      const tasks: Task[] = [
-        { id: 'low', priority: 1, node: { id: 'n1', type: 'test', name: 'Low' }, execution: { id: 'e1', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-        { id: 'high', priority: 10, node: { id: 'n2', type: 'test', name: 'High' }, execution: { id: 'e2', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-        { id: 'medium', priority: 5, node: { id: 'n3', type: 'test', name: 'Medium' }, execution: { id: 'e3', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-      ];
-
-      // Submit all tasks
-      await Promise.all(tasks.map(t => priorityScheduler.submit(t)));
-
-      const status = priorityScheduler.getStatus();
-      expect(status.queued).toBe(0);
-      expect(status.completed).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should process high priority tasks before low priority', async () => {
-      const priorityScheduler = createScheduler({ 
-        enablePriority: true,
-        maxConcurrency: 1, // Single concurrency to ensure ordering
-      });
-
-      const taskTimes: Record<string, number> = {};
-      let counter = 0;
-
-      // Submit tasks in reverse priority order
-      const tasks: Task[] = [
-        { id: 'low', priority: 1, node: { id: 'n1', type: 'test', name: 'Low' }, execution: { id: 'e1', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-        { id: 'high', priority: 10, node: { id: 'n2', type: 'test', name: 'High' }, execution: { id: 'e2', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-      ];
-
-      // Submit low first, then high
-      await priorityScheduler.submit(tasks[0]);
-      await priorityScheduler.submit(tasks[1]);
-
-      const status = priorityScheduler.getStatus();
-      expect(status.completed).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should default to no priority when disabled', async () => {
-      const noPriorityScheduler = createScheduler({ enablePriority: false });
-
-      const tasks: Task[] = [
-        { id: 'task-1', priority: 10, node: { id: 'n1', type: 'test', name: 'Node' }, execution: { id: 'e1', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-        { id: 'task-2', priority: 1, node: { id: 'n2', type: 'test', name: 'Node' }, execution: { id: 'e2', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-      ];
-
-      await noPriorityScheduler.submitAll(tasks);
-
-      const status = noPriorityScheduler.getStatus();
-      expect(status.queued).toBe(0);
-    });
-  });
-
-  describe('resource limits enforcement', () => {
-    it('should enforce max concurrency limit', async () => {
-      const limitedScheduler = createScheduler({ maxConcurrency: 2 });
-
-      // Create many tasks
-      const tasks: Task[] = Array.from({ length: 5 }, (_, i) => ({
-        id: `task-${i}`,
-        node: { id: `node-${i}`, type: 'test', name: `Node ${i}` },
-        execution: { id: `exec-${i}`, workflowId: 'wf', status: 'running' } as WorkflowExecution,
-      }));
-
-      // Submit all tasks
-      await limitedScheduler.submitAll(tasks);
-
-      // After submission, some should be completed
-      const status = limitedScheduler.getStatus();
-      expect(status.running).toBeLessThanOrEqual(2);
-    });
-
-    it('should enforce queue size limit', async () => {
-      const limitedScheduler = createScheduler({ 
-        queueLimit: 2,
-        maxConcurrency: 1, // Low concurrency to fill queue
-      });
-
-      // Create more tasks than the limit
-      const tasks: Task[] = Array.from({ length: 10 }, (_, i) => ({
-        id: `task-${i}`,
-        node: { id: `node-${i}`, type: 'test', name: `Node ${i}` },
-        execution: { id: `exec-${i}`, workflowId: 'wf', status: 'running' } as WorkflowExecution,
-      }));
-
-      // Some submissions should fail due to queue limit
-      let rejectedCount = 0;
-      for (const task of tasks) {
-        try {
-          await limitedScheduler.submit(task);
-        } catch (error) {
-          if (error instanceof Error && error.message === 'Queue limit reached') {
-            rejectedCount++;
-          }
-        }
-      }
-
-      // At least some should have been rejected
-      expect(rejectedCount).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should enforce default timeout', async () => {
-      const timeoutScheduler = createScheduler({ 
-        defaultTimeout: 50, // Very short timeout
-      });
-
-      const task: Task = {
-        id: 'timeout-task',
-        node: { id: 'node-1', type: 'test', name: 'Test Node' },
-        execution: { id: 'exec-1', workflowId: 'wf', status: 'running' } as WorkflowExecution,
-      };
-
-      // Task should complete or timeout
-      await timeoutScheduler.submit(task);
-
-      const status = timeoutScheduler.getStatus();
-      expect(status.failed + status.completed).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should allow task-specific timeout override', async () => {
-      const schedulerWithTimeout = createScheduler({ 
-        defaultTimeout: 1000,
-      });
-
-      const task: Task = {
-        id: 'custom-timeout-task',
-        node: { id: 'node-1', type: 'test', name: 'Test Node' },
-        execution: { id: 'exec-1', workflowId: 'wf', status: 'running' } as WorkflowExecution,
-        timeout: 100, // Override default
-      };
-
-      await schedulerWithTimeout.submit(task);
-
-      const status = schedulerWithTimeout.getStatus();
-      expect(status.queued).toBe(0);
-    });
-  });
-
-  describe('task cancellation', () => {
-    it('should cancel a queued task', async () => {
-      // Create scheduler with low concurrency to keep tasks in queue
-      const limitedScheduler = createScheduler({ 
-        maxConcurrency: 1,
-      });
-
-      const task: Task = {
-        id: 'cancel-task',
-        node: { id: 'node-1', type: 'test', name: 'Test Node' },
-        execution: { id: 'exec-1', workflowId: 'wf', status: 'running' } as WorkflowExecution,
-      };
-
-      // Submit task
-      const submitPromise = limitedScheduler.submit(task);
-
-      // Try to cancel
-      const cancelled = limitedScheduler.cancel('cancel-task');
-      
-      // Cancel may or may not succeed depending on timing
-      expect(typeof cancelled).toBe('boolean');
-
-      try {
-        await submitPromise;
-      } catch {
-        // Task might be cancelled
-      }
-    });
-
-    it('should cancel a running task with AbortController', async () => {
-      const scheduler = createScheduler({ maxConcurrency: 1 });
-
-      const slowTask: Task = {
-        id: 'slow-task',
-        node: { id: 'node-1', type: 'test', name: 'Slow Node' },
-        execution: { id: 'exec-1', workflowId: 'wf', status: 'running' } as WorkflowExecution,
-        timeout: 5000, // Long timeout
-      };
-
-      // Submit slow task
-      const submitPromise = scheduler.submit(slowTask);
-
-      // Give it time to start
-      await new Promise(resolve => setTimeout(resolve, 10));
-
-      // Cancel the running task
-      const cancelled = scheduler.cancel('slow-task');
-      expect(typeof cancelled).toBe('boolean');
-
-      try {
-        await submitPromise;
-      } catch {
-        // Expected - task was cancelled
-      }
-    });
-
-    it('should return false when cancelling non-existent task', () => {
-      const cancelled = scheduler.cancel('non-existent-task');
-      expect(cancelled).toBe(false);
-    });
-
-    it('should handle concurrent cancellation attempts', async () => {
-      const scheduler = createScheduler({ maxConcurrency: 1 });
-
-      const task: Task = {
-        id: 'concurrent-cancel',
-        node: { id: 'node-1', type: 'test', name: 'Test Node' },
-        execution: { id: 'exec-1', workflowId: 'wf', status: 'running' } as WorkflowExecution,
-      };
-
-      const submitPromise = scheduler.submit(task);
-
-      // Try to cancel multiple times
-      const results = [
-        scheduler.cancel('concurrent-cancel'),
-        scheduler.cancel('concurrent-cancel'),
-        scheduler.cancel('concurrent-cancel'),
-      ];
-
-      // At least one should succeed or all should return booleans
-      results.forEach(result => {
-        expect(typeof result).toBe('boolean');
-      });
-
-      try {
-        await submitPromise;
-      } catch {
-        // Task might be cancelled
-      }
-    });
-  });
-
-  describe('queue statistics', () => {
-    it('should report initial status', () => {
-      const status = scheduler.getStatus();
-
-      expect(status).toHaveProperty('running');
-      expect(status).toHaveProperty('queued');
-      expect(status).toHaveProperty('completed');
-      expect(status).toHaveProperty('failed');
-      expect(status).toHaveProperty('isPaused');
-
-      expect(status.running).toBe(0);
-      expect(status.queued).toBe(0);
-      expect(status.completed).toBe(0);
-      expect(status.failed).toBe(0);
-      expect(status.isPaused).toBe(false);
-    });
-
-    it('should update status after task completion', async () => {
-      const task: Task = {
-        id: 'stats-task',
-        node: { id: 'node-1', type: 'test', name: 'Test Node' },
-        execution: { id: 'exec-1', workflowId: 'wf', status: 'running' } as WorkflowExecution,
-      };
-
-      await scheduler.submit(task);
-
-      const status = scheduler.getStatus();
-      expect(status.completed + status.failed).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should track multiple task statistics', async () => {
-      const tasks: Task[] = [
-        { id: 'task-1', node: { id: 'n1', type: 'test', name: 'Node 1' }, execution: { id: 'e1', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-        { id: 'task-2', node: { id: 'n2', type: 'test', name: 'Node 2' }, execution: { id: 'e2', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-        { id: 'task-3', node: { id: 'n3', type: 'test', name: 'Node 3' }, execution: { id: 'e3', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-      ];
-
-      await scheduler.submitAll(tasks);
-
-      const status = scheduler.getStatus();
-      expect(status.queued).toBe(0); // All should be processed
-      expect(status.completed + status.failed).toBeGreaterThanOrEqual(0);
-    });
-  });
-
-  describe('pause and resume', () => {
-    it('should pause the scheduler', () => {
-      scheduler.pause();
-      const status = scheduler.getStatus();
-      expect(status.isPaused).toBe(true);
-    });
-
-    it('should resume the scheduler', async () => {
-      scheduler.pause();
-      expect(scheduler.getStatus().isPaused).toBe(true);
-
-      scheduler.resume();
-      expect(scheduler.getStatus().isPaused).toBe(false);
-    });
-
-    it('should not process new tasks when paused', async () => {
-      const pausedScheduler = createScheduler();
-      pausedScheduler.pause();
-
-      const task: Task = {
-        id: 'paused-task',
-        node: { id: 'node-1', type: 'test', name: 'Test Node' },
-        execution: { id: 'exec-1', workflowId: 'wf', status: 'running' } as WorkflowExecution,
-      };
-
-      // Submit task while paused
-      await pausedScheduler.submit(task);
-
-      // Task might be queued but not processed
-      const status = pausedScheduler.getStatus();
-      expect(status.isPaused).toBe(true);
-
-      // Resume and let it process
-      pausedScheduler.resume();
-      
-      // Give it time to process
-      await new Promise(resolve => setTimeout(resolve, 50));
-    });
-
-    it('should process queued tasks after resume', async () => {
-      const scheduler = createScheduler({ maxConcurrency: 1 });
-      scheduler.pause();
-
-      const tasks: Task[] = [
-        { id: 'queued-1', node: { id: 'n1', type: 'test', name: 'Node 1' }, execution: { id: 'e1', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-        { id: 'queued-2', node: { id: 'n2', type: 'test', name: 'Node 2' }, execution: { id: 'e2', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-      ];
-
-      // Submit while paused
-      for (const task of tasks) {
-        await scheduler.submit(task);
-      }
-
-      // Resume and process
-      scheduler.resume();
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      const status = scheduler.getStatus();
-      expect(status.isPaused).toBe(false);
-    });
-  });
-
-  describe('cron-based scheduling', () => {
-    it('should support cron-like scheduling configuration', () => {
-      // The scheduler config supports scheduling parameters
-      const cronScheduler = createScheduler({
-        maxConcurrency: 5,
-        defaultTimeout: 30000,
-      });
-
-      expect(cronScheduler).toBeDefined();
-      expect(typeof cronScheduler.submit).toBe('function');
-    });
-
-    it('should handle scheduled task execution', async () => {
-      const scheduledScheduler = createScheduler();
-
-      const task: Task = {
-        id: 'scheduled-task',
-        node: { id: 'node-1', type: 'trigger:schedule', name: 'Scheduled Trigger' },
-        execution: { id: 'exec-1', workflowId: 'wf', status: 'pending' } as WorkflowExecution,
-      };
-
-      await scheduledScheduler.submit(task);
-
-      const status = scheduledScheduler.getStatus();
-      expect(status.queued).toBe(0);
-    });
-  });
-
-  describe('error handling', () => {
-    it('should handle task execution errors', async () => {
-      const errorScheduler = createScheduler();
-
-      // Submit a task - errors are tracked in status
-      const task: Task = {
-        id: 'error-task',
-        node: { id: 'node-1', type: 'test', name: 'Error Node' },
-        execution: { id: 'exec-1', workflowId: 'wf', status: 'running' } as WorkflowExecution,
-      };
-
-      await errorScheduler.submit(task);
-
-      const status = errorScheduler.getStatus();
-      expect(status.failed + status.completed).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should continue processing after task failure', async () => {
-      const resilientScheduler = createScheduler({ maxConcurrency: 1 });
-
-      const tasks: Task[] = [
-        { id: 'task-1', node: { id: 'n1', type: 'test', name: 'Node 1' }, execution: { id: 'e1', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-        { id: 'task-2', node: { id: 'n2', type: 'test', name: 'Node 2' }, execution: { id: 'e2', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-      ];
-
-      await resilientScheduler.submitAll(tasks);
-
-      const status = resilientScheduler.getStatus();
-      expect(status.queued).toBe(0);
-    });
-  });
-
-  describe('global scheduler instance', () => {
-    it('should have a global scheduler instance', () => {
-      expect(globalScheduler).toBeDefined();
-      expect(typeof globalScheduler.submit).toBe('function');
-      expect(typeof globalScheduler.submitAll).toBe('function');
-      expect(typeof globalScheduler.cancel).toBe('function');
-      expect(typeof globalScheduler.getStatus).toBe('function');
-      expect(typeof globalScheduler.pause).toBe('function');
-      expect(typeof globalScheduler.resume).toBe('function');
-    });
-  });
-
-  describe('complex scenarios', () => {
-    it('should handle mixed priority and concurrency', async () => {
-      const complexScheduler = createScheduler({
-        enablePriority: true,
-        maxConcurrency: 2,
-        queueLimit: 10,
-      });
-
-      const tasks: Task[] = [
-        { id: 'high-1', priority: 10, node: { id: 'h1', type: 'test', name: 'High 1' }, execution: { id: 'e1', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-        { id: 'low-1', priority: 1, node: { id: 'l1', type: 'test', name: 'Low 1' }, execution: { id: 'e2', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-        { id: 'high-2', priority: 10, node: { id: 'h2', type: 'test', name: 'High 2' }, execution: { id: 'e3', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-        { id: 'medium-1', priority: 5, node: { id: 'm1', type: 'test', name: 'Medium 1' }, execution: { id: 'e4', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-        { id: 'low-2', priority: 1, node: { id: 'l2', type: 'test', name: 'Low 2' }, execution: { id: 'e5', workflowId: 'wf', status: 'running' } as WorkflowExecution },
-      ];
-
-      await complexScheduler.submitAll(tasks);
-
-      const status = complexScheduler.getStatus();
-      expect(status.queued).toBe(0);
-      expect(status.completed + status.failed).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should handle rapid submit/cancel cycles', async () => {
-      const rapidScheduler = createScheduler({ maxConcurrency: 3 });
-
-      for (let i = 0; i < 10; i++) {
-        const task: Task = {
-          id: `rapid-${i}`,
-          node: { id: `node-${i}`, type: 'test', name: `Node ${i}` },
-          execution: { id: `exec-${i}`, workflowId: 'wf', status: 'running' } as WorkflowExecution,
-        };
-
-        rapidScheduler.submit(task);
-        
-        // Randomly cancel some tasks
-        if (i % 3 === 0) {
-          rapidScheduler.cancel(`rapid-${i}`);
-        }
-      }
-
-      // Give time for processing
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      const status = rapidScheduler.getStatus();
-      expect(status.queued).toBe(0);
-    });
-  });
-});