@allternit/workflow-engine 0.1.0 → 0.1.1

package/src/engine/workflow-engine.test.ts.bak

@@ -1,852 +0,0 @@
-/**
- * Workflow Engine Tests
- *
- * Comprehensive tests for the WorkflowEngine class covering graph validation,
- * node execution, parallel execution, variable resolution, retry logic,
- * HTTP requests, and event system.
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { createWorkflowEngine, globalWorkflowEngine } from './workflow-engine';
-import type { Workflow, WorkflowNode, Connection, NodeType } from '../types';
-
-// Mock fetch for HTTP request tests
-global.fetch = vi.fn();
-
-describe('WorkflowEngine', () => {
-  let engine: ReturnType<typeof createWorkflowEngine>;
-
-  beforeEach(() => {
-    engine = createWorkflowEngine();
-    vi.clearAllMocks();
-  });
-
-  describe('workflow management', () => {
-    it('should register and retrieve a workflow', () => {
-      const workflow: Workflow = {
-        id: 'wf-1',
-        name: 'Test Workflow',
-        version: '1.0.0',
-        nodes: [],
-        connections: [],
-      };
-
-      engine.registerWorkflow(workflow);
-      const retrieved = engine.getWorkflow('wf-1');
-
-      expect(retrieved).toEqual(workflow);
-    });
-
-    it('should list all registered workflows', () => {
-      const wf1: Workflow = {
-        id: 'wf-1',
-        name: 'Workflow 1',
-        version: '1.0.0',
-        nodes: [],
-        connections: [],
-      };
-      const wf2: Workflow = {
-        id: 'wf-2',
-        name: 'Workflow 2',
-        version: '1.0.0',
-        nodes: [],
-        connections: [],
-      };
-
-      engine.registerWorkflow(wf1);
-      engine.registerWorkflow(wf2);
-      const list = engine.listWorkflows();
-
-      expect(list).toHaveLength(2);
-      expect(list.map(w => w.id)).toContain('wf-1');
-      expect(list.map(w => w.id)).toContain('wf-2');
-    });
-
-    it('should delete a workflow', () => {
-      const workflow: Workflow = {
-        id: 'wf-1',
-        name: 'Test Workflow',
-        version: '1.0.0',
-        nodes: [],
-        connections: [],
-      };
-
-      engine.registerWorkflow(workflow);
-      expect(engine.getWorkflow('wf-1')).toBeDefined();
-
-      const deleted = engine.deleteWorkflow('wf-1');
-      expect(deleted).toBe(true);
-      expect(engine.getWorkflow('wf-1')).toBeUndefined();
-    });
-
-    it('should return undefined for non-existent workflow', () => {
-      expect(engine.getWorkflow('non-existent')).toBeUndefined();
-    });
-  });
-
-  describe('node execution', () => {
-    it('should execute a simple linear workflow', async () => {
-      const nodes: WorkflowNode[] = [
-        { id: 'node-1', type: 'trigger:manual', name: 'Trigger' },
-        { id: 'node-2', type: 'transform:map', name: 'Transform', config: { expression: 'data.value * 2' } },
-        { id: 'node-3', type: 'output:result', name: 'Output' },
-      ];
-      const connections: Connection[] = [
-        { id: 'conn-1', source: 'node-1', target: 'node-2' },
-        { id: 'conn-2', source: 'node-2', target: 'node-3' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-linear',
-        name: 'Linear Workflow',
-        version: '1.0.0',
-        nodes,
-        connections,
-      };
-
-      engine.registerWorkflow(workflow);
-      const execution = await engine.execute('wf-linear', { value: 5 });
-
-      expect(execution.status).toBe('completed');
-      expect(execution.context?.state.completedNodes).toContain('node-1');
-      expect(execution.context?.state.completedNodes).toContain('node-2');
-      expect(execution.context?.state.completedNodes).toContain('node-3');
-    });
-
-    it('should execute nodes in topological order', async () => {
-      const executionOrder: string[] = [];
-      
-      const customNodeType: NodeType = {
-        type: 'custom:tracker',
-        category: 'custom',
-        displayName: 'Tracker',
-        executor: async (node) => {
-          executionOrder.push(node.id);
-          return { tracked: true };
-        },
-      };
-
-      engine.registerNodeType(customNodeType);
-
-      // Create a diamond-shaped workflow
-      //     A
-      //    / \
-      //   B   C
-      //    \ /
-      //     D
-      const nodes: WorkflowNode[] = [
-        { id: 'A', type: 'custom:tracker', name: 'Node A' },
-        { id: 'B', type: 'custom:tracker', name: 'Node B' },
-        { id: 'C', type: 'custom:tracker', name: 'Node C' },
-        { id: 'D', type: 'custom:tracker', name: 'Node D' },
-      ];
-      const connections: Connection[] = [
-        { id: 'c1', source: 'A', target: 'B' },
-        { id: 'c2', source: 'A', target: 'C' },
-        { id: 'c3', source: 'B', target: 'D' },
-        { id: 'c4', source: 'C', target: 'D' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-diamond',
-        name: 'Diamond Workflow',
-        version: '1.0.0',
-        nodes,
-        connections,
-      };
-
-      engine.registerWorkflow(workflow);
-      await engine.execute('wf-diamond');
-
-      // A must come before B and C
-      expect(executionOrder.indexOf('A')).toBeLessThan(executionOrder.indexOf('B'));
-      expect(executionOrder.indexOf('A')).toBeLessThan(executionOrder.indexOf('C'));
-      // B and C must come before D
-      expect(executionOrder.indexOf('B')).toBeLessThan(executionOrder.indexOf('D'));
-      expect(executionOrder.indexOf('C')).toBeLessThan(executionOrder.indexOf('D'));
-    });
-
-    it('should handle unknown node types', async () => {
-      const nodes: WorkflowNode[] = [
-        { id: 'node-1', type: 'trigger:manual', name: 'Trigger' },
-        { id: 'node-2', type: 'unknown:type', name: 'Unknown' },
-      ];
-      const connections: Connection[] = [
-        { id: 'conn-1', source: 'node-1', target: 'node-2' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-unknown',
-        name: 'Unknown Type Workflow',
-        version: '1.0.0',
-        nodes,
-        connections,
-      };
-
-      engine.registerWorkflow(workflow);
-      
-      // Execution fails when trying to execute the unknown node type
-      const execution = await engine.execute('wf-unknown');
-      expect(execution.status).toBe('failed');
-      expect(execution.error?.message).toContain('Unknown node type');
-    });
-  });
-
-  describe('parallel execution', () => {
-    it('should respect maxConcurrentExecutions limit', async () => {
-      const limitedEngine = createWorkflowEngine({ maxConcurrentExecutions: 1 });
-      
-      const slowNodeType: NodeType = {
-        type: 'custom:slow',
-        category: 'custom',
-        displayName: 'Slow Node',
-        executor: async () => {
-          await new Promise(resolve => setTimeout(resolve, 100));
-          return { done: true };
-        },
-      };
-      limitedEngine.registerNodeType(slowNodeType);
-
-      const nodes: WorkflowNode[] = [
-        { id: 'trigger', type: 'trigger:manual', name: 'Trigger' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-limit',
-        name: 'Limit Test',
-        version: '1.0.0',
-        nodes,
-        connections: [],
-      };
-
-      limitedEngine.registerWorkflow(workflow);
-
-      // First execution should succeed
-      const exec1 = limitedEngine.execute('wf-limit');
-      
-      // Second execution should fail due to limit
-      await expect(limitedEngine.execute('wf-limit')).rejects.toThrow('Max concurrent executions reached');
-      
-      // Wait for first to complete
-      await exec1;
-    });
-  });
-
-  describe('variable resolution', () => {
-    it('should resolve variables with ${} interpolation', async () => {
-      const customNodeType: NodeType = {
-        type: 'custom:input-test',
-        category: 'custom',
-        displayName: 'Input Test',
-        inputs: [{ name: 'data', type: 'any' }],
-        executor: async (node, context, inputs) => {
-          return { received: inputs.data };
-        },
-      };
-      engine.registerNodeType(customNodeType);
-
-      const nodes: WorkflowNode[] = [
-        { id: 'trigger', type: 'trigger:manual', name: 'Trigger' },
-        { 
-          id: 'test', 
-          type: 'custom:input-test', 
-          name: 'Test Node',
-          inputs: [{ target: 'data', source: '${user.name}' }],
-        },
-      ];
-      const connections: Connection[] = [
-        { id: 'c1', source: 'trigger', target: 'test' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-vars',
-        name: 'Variable Test',
-        version: '1.0.0',
-        nodes,
-        connections,
-      };
-
-      engine.registerWorkflow(workflow);
-      const execution = await engine.execute('wf-vars', { user: { name: 'John' } });
-
-      expect(execution.status).toBe('completed');
-      expect(execution.context?.state.nodeResults['test']).toEqual({ received: 'John' });
-    });
-
-    it('should use default values for undefined variables', async () => {
-      const customNodeType: NodeType = {
-        type: 'custom:input-test',
-        category: 'custom',
-        displayName: 'Input Test',
-        executor: async (node, context, inputs) => {
-          return { received: inputs.data };
-        },
-      };
-      engine.registerNodeType(customNodeType);
-
-      const nodes: WorkflowNode[] = [
-        { id: 'trigger', type: 'trigger:manual', name: 'Trigger' },
-        { 
-          id: 'test', 
-          type: 'custom:input-test', 
-          name: 'Test Node',
-          inputs: [{ target: 'data', source: '${missing.path}', default: 'default-value' }],
-        },
-      ];
-      const connections: Connection[] = [
-        { id: 'c1', source: 'trigger', target: 'test' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-default',
-        name: 'Default Test',
-        version: '1.0.0',
-        nodes,
-        connections,
-      };
-
-      engine.registerWorkflow(workflow);
-      const execution = await engine.execute('wf-default');
-
-      expect(execution.status).toBe('completed');
-      expect(execution.context?.state.nodeResults['test']).toEqual({ received: 'default-value' });
-    });
-
-    it('should handle nested path resolution', async () => {
-      const customNodeType: NodeType = {
-        type: 'custom:input-test',
-        category: 'custom',
-        displayName: 'Input Test',
-        executor: async (node, context, inputs) => {
-          return { received: inputs.data };
-        },
-      };
-      engine.registerNodeType(customNodeType);
-
-      const nodes: WorkflowNode[] = [
-        { id: 'trigger', type: 'trigger:manual', name: 'Trigger' },
-        { 
-          id: 'test', 
-          type: 'custom:input-test', 
-          name: 'Test Node',
-          inputs: [{ target: 'data', source: '${deeply.nested.value}' }],
-        },
-      ];
-      const connections: Connection[] = [
-        { id: 'c1', source: 'trigger', target: 'test' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-nested',
-        name: 'Nested Test',
-        version: '1.0.0',
-        nodes,
-        connections,
-      };
-
-      engine.registerWorkflow(workflow);
-      const execution = await engine.execute('wf-nested', { 
-        deeply: { nested: { value: 'found' } } 
-      });
-
-      expect(execution.status).toBe('completed');
-      expect(execution.context?.state.nodeResults['test']).toEqual({ received: 'found' });
-    });
-  });
-
-  describe('retry logic', () => {
-    it('should retry failed nodes with retry configuration', async () => {
-      let attempts = 0;
-      const flakyNodeType: NodeType = {
-        type: 'custom:flaky',
-        category: 'custom',
-        displayName: 'Flaky Node',
-        executor: async () => {
-          attempts++;
-          if (attempts < 3) {
-            throw new Error('Temporary failure');
-          }
-          return { success: true };
-        },
-      };
-      engine.registerNodeType(flakyNodeType);
-
-      const nodes: WorkflowNode[] = [
-        { id: 'trigger', type: 'trigger:manual', name: 'Trigger' },
-        { id: 'flaky', type: 'custom:flaky', name: 'Flaky Node' },
-      ];
-      const connections: Connection[] = [
-        { id: 'c1', source: 'trigger', target: 'flaky' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-retry',
-        name: 'Retry Test',
-        version: '1.0.0',
-        nodes,
-        connections,
-      };
-
-      engine.registerWorkflow(workflow);
-      
-      // Currently the engine doesn't have built-in retry, 
-      // but we can test that the error is captured
-      const execution = await engine.execute('wf-retry');
-      
-      // The workflow fails on first error
-      expect(execution.status).toBe('failed');
-      expect(execution.error).toBeDefined();
-    });
-  });
-
-  describe('HTTP request node', () => {
-    it('should execute HTTP GET request', async () => {
-      const mockResponse = {
-        json: vi.fn().mockResolvedValue({ data: 'test' }),
-        headers: new Map([['content-type', 'application/json']]),
-        status: 200,
-      };
-      (global.fetch as ReturnType<typeof vi.fn>).mockResolvedValue(mockResponse);
-
-      const httpNodeType = engine.getNodeType('http:request');
-      expect(httpNodeType?.executor).toBeDefined();
-
-      const mockNode: WorkflowNode = {
-        id: 'test-http',
-        type: 'http:request',
-        name: 'HTTP Request',
-        config: { method: 'GET', headers: {} },
-      };
-
-      const mockContext = {
-        variables: {},
-        state: {
-          activeNodes: [],
-          completedNodes: [],
-          failedNodes: [],
-          nodeResults: {},
-          executionPath: [],
-        },
-      };
-
-      const result = await httpNodeType?.executor!(mockNode, mockContext, { url: 'https://api.example.com/data' });
-
-      expect(global.fetch).toHaveBeenCalled();
-      const fetchCall = (global.fetch as ReturnType<typeof vi.fn>).mock.calls[0];
-      expect(fetchCall[0]).toBe('https://api.example.com/data');
-      expect(fetchCall[1]).toMatchObject({
-        method: 'GET',
-        headers: {},
-      });
-      expect(result).toHaveProperty('response');
-      expect(result).toHaveProperty('status', 200);
-    });
-
-    it('should handle HTTP errors', async () => {
-      (global.fetch as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('Network error'));
-
-      const nodes: WorkflowNode[] = [
-        { id: 'trigger', type: 'trigger:manual', name: 'Trigger' },
-        { 
-          id: 'http', 
-          type: 'http:request', 
-          name: 'HTTP Request',
-        },
-      ];
-      const connections: Connection[] = [
-        { id: 'c1', source: 'trigger', target: 'http', sourcePort: 'url' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-http-error',
-        name: 'HTTP Error Test',
-        version: '1.0.0',
-        nodes,
-        connections,
-      };
-
-      engine.registerWorkflow(workflow);
-      const execution = await engine.execute('wf-http-error', { url: 'https://api.example.com/data' });
-
-      expect(execution.status).toBe('failed');
-      expect(execution.error?.code).toBe('EXECUTION_ERROR');
-    });
-
-    it('should respect HTTP timeout', async () => {
-      const mockResponse = {
-        json: vi.fn().mockResolvedValue({ data: 'test' }),
-        headers: new Map(),
-        status: 200,
-      };
-      (global.fetch as ReturnType<typeof vi.fn>).mockImplementation(async (_, options) => {
-        // Check that signal is passed
-        expect(options?.signal).toBeDefined();
-        return mockResponse;
-      });
-
-      const nodes: WorkflowNode[] = [
-        { id: 'trigger', type: 'trigger:manual', name: 'Trigger' },
-        { 
-          id: 'http', 
-          type: 'http:request', 
-          name: 'HTTP Request',
-          config: { timeout: 5000 },
-        },
-      ];
-      const connections: Connection[] = [
-        { id: 'c1', source: 'trigger', target: 'http', sourcePort: 'url' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-http-timeout',
-        name: 'HTTP Timeout Test',
-        version: '1.0.0',
-        nodes,
-        connections,
-      };
-
-      engine.registerWorkflow(workflow);
-      await engine.execute('wf-http-timeout', { url: 'https://api.example.com/data' });
-
-      expect(global.fetch).toHaveBeenCalled();
-    });
-  });
-
-  describe('condition nodes', () => {
-    it('should evaluate if condition and route accordingly', async () => {
-      const nodes: WorkflowNode[] = [
-        { id: 'trigger', type: 'trigger:manual', name: 'Trigger' },
-        { 
-          id: 'condition', 
-          type: 'condition:if', 
-          name: 'Condition',
-          config: { condition: 'data.value > 10' },
-        },
-        { id: 'true-branch', type: 'output:result', name: 'True Branch' },
-        { id: 'false-branch', type: 'output:result', name: 'False Branch' },
-      ];
-      const connections: Connection[] = [
-        { id: 'c1', source: 'trigger', target: 'condition' },
-        { id: 'c2', source: 'condition', target: 'true-branch', condition: 'result.true' },
-        { id: 'c3', source: 'condition', target: 'false-branch', condition: 'result.false' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-condition',
-        name: 'Condition Test',
-        version: '1.0.0',
-        nodes,
-        connections,
-      };
-
-      engine.registerWorkflow(workflow);
-      
-      // Test true condition
-      const execTrue = await engine.execute('wf-condition', { value: 15 });
-      expect(execTrue.status).toBe('completed');
-
-      // Test false condition
-      const execFalse = await engine.execute('wf-condition', { value: 5 });
-      expect(execFalse.status).toBe('completed');
-    });
-  });
-
-  describe('transform nodes', () => {
-    it('should have transform:map node type registered', () => {
-      const nodeType = engine.getNodeType('transform:map');
-      expect(nodeType).toBeDefined();
-      expect(nodeType?.category).toBe('transform');
-      expect(nodeType?.displayName).toBe('Map');
-    });
-
-    it('should have transform:filter node type registered', () => {
-      const nodeType = engine.getNodeType('transform:filter');
-      expect(nodeType).toBeDefined();
-      expect(nodeType?.category).toBe('transform');
-      expect(nodeType?.displayName).toBe('Filter');
-    });
-
-    it('should execute map transform executor directly', async () => {
-      const mapNodeType = engine.getNodeType('transform:map');
-      expect(mapNodeType?.executor).toBeDefined();
-
-      const mockNode: WorkflowNode = {
-        id: 'test-map',
-        type: 'transform:map',
-        name: 'Test Map',
-        config: { expression: 'data.value * 2' },
-      };
-
-      const mockContext = {
-        variables: {},
-        state: {
-          activeNodes: [],
-          completedNodes: [],
-          failedNodes: [],
-          nodeResults: {},
-          executionPath: [],
-        },
-      };
-
-      const result = await mapNodeType?.executor!(mockNode, mockContext, { data: { value: 5 } });
-      expect(result).toEqual({ result: 10 });
-    });
-
-    it('should execute filter transform executor directly', async () => {
-      const filterNodeType = engine.getNodeType('transform:filter');
-      expect(filterNodeType?.executor).toBeDefined();
-
-      const mockNode: WorkflowNode = {
-        id: 'test-filter',
-        type: 'transform:filter',
-        name: 'Test Filter',
-        config: { condition: 'item > 5' },
-      };
-
-      const mockContext = {
-        variables: {},
-        state: {
-          activeNodes: [],
-          completedNodes: [],
-          failedNodes: [],
-          nodeResults: {},
-          executionPath: [],
-        },
-      };
-
-      const result = await filterNodeType?.executor!(mockNode, mockContext, { array: [3, 7, 1, 9, 2, 8] });
-      expect(result).toEqual({ filtered: [7, 9, 8] });
-    });
-
-    it('should require expression for map transform', async () => {
-      const mapNodeType = engine.getNodeType('transform:map');
-      
-      const mockNode: WorkflowNode = {
-        id: 'test-map',
-        type: 'transform:map',
-        name: 'Test Map',
-        config: {}, // No expression
-      };
-
-      const mockContext = {
-        variables: {},
-        state: {
-          activeNodes: [],
-          completedNodes: [],
-          failedNodes: [],
-          nodeResults: {},
-          executionPath: [],
-        },
-      };
-
-      await expect(mapNodeType?.executor!(mockNode, mockContext, { data: {} }))
-        .rejects.toThrow('Expression required');
-    });
-  });
-
-  describe('delay nodes', () => {
-    it('should execute wait delay', async () => {
-      const startTime = Date.now();
-      
-      const nodes: WorkflowNode[] = [
-        { id: 'trigger', type: 'trigger:manual', name: 'Trigger' },
-        { 
-          id: 'delay', 
-          type: 'delay:wait', 
-          name: 'Wait',
-          config: { delay: 50 },
-        },
-      ];
-      const connections: Connection[] = [
-        { id: 'c1', source: 'trigger', target: 'delay' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-delay',
-        name: 'Delay Test',
-        version: '1.0.0',
-        nodes,
-        connections,
-      };
-
-      engine.registerWorkflow(workflow);
-      const execution = await engine.execute('wf-delay', { data: 'test' });
-
-      const endTime = Date.now();
-      expect(execution.status).toBe('completed');
-      expect(endTime - startTime).toBeGreaterThanOrEqual(50);
-    });
-  });
-
-  describe('execution lifecycle', () => {
-    it('should cancel a running execution', async () => {
-      const nodes: WorkflowNode[] = [
-        { id: 'trigger', type: 'trigger:manual', name: 'Trigger' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-cancel',
-        name: 'Cancel Test',
-        version: '1.0.0',
-        nodes,
-        connections: [],
-      };
-
-      engine.registerWorkflow(workflow);
-      const execution = await engine.execute('wf-cancel');
-      
-      // Cancel after execution starts
-      const cancelled = engine.cancelExecution(execution.id);
-      
-      // Since execution completes quickly, it might already be done
-      // But the cancel function should handle it gracefully
-      expect(typeof cancelled).toBe('boolean');
-    });
-
-    it('should pause and resume execution', async () => {
-      const nodes: WorkflowNode[] = [
-        { id: 'trigger', type: 'trigger:manual', name: 'Trigger' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-pause',
-        name: 'Pause Test',
-        version: '1.0.0',
-        nodes,
-        connections: [],
-      };
-
-      engine.registerWorkflow(workflow);
-      const execution = await engine.execute('wf-pause');
-      
-      // These operations return boolean success
-      const paused = engine.pauseExecution(execution.id);
-      expect(typeof paused).toBe('boolean');
-      
-      const resumed = engine.resumeExecution(execution.id);
-      expect(typeof resumed).toBe('boolean');
-    });
-
-    it('should retrieve execution by ID', async () => {
-      const nodes: WorkflowNode[] = [
-        { id: 'trigger', type: 'trigger:manual', name: 'Trigger' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-get',
-        name: 'Get Test',
-        version: '1.0.0',
-        nodes,
-        connections: [],
-      };
-
-      engine.registerWorkflow(workflow);
-      const execution = await engine.execute('wf-get');
-      
-      const retrieved = engine.getExecution(execution.id);
-      expect(retrieved).toBeDefined();
-      expect(retrieved?.id).toBe(execution.id);
-    });
-  });
-
-  describe('hooks', () => {
-    it('should call lifecycle hooks', async () => {
-      const beforeExecute = vi.fn();
-      const afterExecute = vi.fn();
-      const beforeNodeExecute = vi.fn();
-      const afterNodeExecute = vi.fn();
-
-      const hookedEngine = createWorkflowEngine({
-        hooks: {
-          beforeExecute,
-          afterExecute,
-          beforeNodeExecute,
-          afterNodeExecute,
-        },
-      });
-
-      const nodes: WorkflowNode[] = [
-        { id: 'trigger', type: 'trigger:manual', name: 'Trigger' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-hooks',
-        name: 'Hooks Test',
-        version: '1.0.0',
-        nodes,
-        connections: [],
-      };
-
-      hookedEngine.registerWorkflow(workflow);
-      await hookedEngine.execute('wf-hooks');
-
-      expect(beforeExecute).toHaveBeenCalled();
-      expect(afterExecute).toHaveBeenCalled();
-      expect(beforeNodeExecute).toHaveBeenCalled();
-      expect(afterNodeExecute).toHaveBeenCalled();
-    });
-
-    it('should call onError hook on failure', async () => {
-      const onError = vi.fn();
-
-      const errorEngine = createWorkflowEngine({
-        hooks: {
-          onError,
-        },
-      });
-
-      const failingNodeType: NodeType = {
-        type: 'custom:failing',
-        category: 'custom',
-        displayName: 'Failing Node',
-        executor: async () => {
-          throw new Error('Intentional failure');
-        },
-      };
-      errorEngine.registerNodeType(failingNodeType);
-
-      const nodes: WorkflowNode[] = [
-        { id: 'trigger', type: 'trigger:manual', name: 'Trigger' },
-        { id: 'fail', type: 'custom:failing', name: 'Failing Node' },
-      ];
-      const connections: Connection[] = [
-        { id: 'c1', source: 'trigger', target: 'fail' },
-      ];
-      const workflow: Workflow = {
-        id: 'wf-error-hook',
-        name: 'Error Hook Test',
-        version: '1.0.0',
-        nodes,
-        connections,
-      };
-
-      errorEngine.registerWorkflow(workflow);
-      await errorEngine.execute('wf-error-hook');
-
-      expect(onError).toHaveBeenCalled();
-    });
-  });
-
-  describe('node type registration', () => {
-    it('should register custom node types', () => {
-      const customType: NodeType = {
-        type: 'custom:test',
-        category: 'custom',
-        displayName: 'Test Node',
-        description: 'A test node',
-        executor: async () => ({ test: true }),
-      };
-
-      engine.registerNodeType(customType);
-      const retrieved = engine.getNodeType('custom:test');
-
-      expect(retrieved).toEqual(customType);
-    });
-
-    it('should have built-in node types registered', () => {
-      expect(engine.getNodeType('trigger:manual')).toBeDefined();
-      expect(engine.getNodeType('trigger:schedule')).toBeDefined();
-      expect(engine.getNodeType('trigger:webhook')).toBeDefined();
-      expect(engine.getNodeType('transform:map')).toBeDefined();
-      expect(engine.getNodeType('transform:filter')).toBeDefined();
-      expect(engine.getNodeType('condition:if')).toBeDefined();
-      expect(engine.getNodeType('loop:for-each')).toBeDefined();
-      expect(engine.getNodeType('delay:wait')).toBeDefined();
-      expect(engine.getNodeType('http:request')).toBeDefined();
-      expect(engine.getNodeType('output:result')).toBeDefined();
-      expect(engine.getNodeType('output:log')).toBeDefined();
-    });
-  });
-
-  describe('global engine instance', () => {
-    it('should have a global workflow engine instance', () => {
-      expect(globalWorkflowEngine).toBeDefined();
-      expect(typeof globalWorkflowEngine.registerWorkflow).toBe('function');
-      expect(typeof globalWorkflowEngine.execute).toBe('function');
-    });
-  });
-});