@onlineapps/conn-orch-validator 2.0.6 → 2.0.9

package/tests/unit/WorkflowTestRunner.test.js

@@ -1,546 +0,0 @@
-'use strict';
-
-const WorkflowTestRunner = require('../../src/WorkflowTestRunner');
-const MockMQClient = require('../../src/mocks/MockMQClient');
-const MockRegistry = require('../../src/mocks/MockRegistry');
-const MockStorage = require('../../src/mocks/MockStorage');
-
-describe('WorkflowTestRunner @unit', () => {
-  let runner;
-  let mqClient;
-  let registry;
-  let storage;
-
-  beforeEach(async () => {
-    mqClient = new MockMQClient();
-    registry = new MockRegistry();
-    storage = new MockStorage();
-    
-    await mqClient.connect();
-    await registry.register({ 
-      name: 'test-service',
-      openapi: {
-        paths: {
-          '/test': {
-            get: { operationId: 'testOp' }
-          }
-        }
-      }
-    });
-
-    runner = new WorkflowTestRunner({
-      mqClient,
-      registry,
-      storage,
-      timeout: 1000,
-      debug: false
-    });
-  });
-
-  describe('Workflow Execution', () => {
-    it('should run simple workflow', async () => {
-      const cookbook = {
-        steps: [
-          {
-            id: 'step1',
-            type: 'task',
-            service: 'test-service',
-            operation: 'testOp',
-            input: { test: 'data' }
-          }
-        ]
-      };
-
-      const workflow = await runner.runWorkflow(cookbook);
-      
-      expect(workflow.status).toBe('completed');
-      expect(workflow.results).toHaveLength(1);
-      expect(workflow.results[0].success).toBe(true);
-      expect(workflow.results[0].stepId).toBe('step1');
-    });
-
-    it('should generate workflow ID', async () => {
-      const workflow = await runner.runWorkflow({ steps: [] });
-      expect(workflow.id).toMatch(/^test-workflow-\d+$/);
-    });
-
-    it('should track workflow state', async () => {
-      const cookbook = {
-        steps: [
-          { id: 'step1', type: 'task', service: 'test-service' },
-          { id: 'step2', type: 'task', service: 'test-service' }
-        ]
-      };
-
-      const workflow = await runner.runWorkflow(cookbook);
-      
-      expect(workflow.currentStep).toBe(1); // Last executed step index
-      expect(workflow.startedAt).toBeDefined();
-      expect(workflow.completedAt).toBeDefined();
-    });
-
-    it('should pass initial context', async () => {
-      const initialContext = { userId: '123', data: 'test' };
-      const workflow = await runner.runWorkflow(
-        { steps: [] },
-        initialContext
-      );
-      
-      expect(workflow.context.api_input).toEqual(initialContext);
-    });
-
-    it('should update context with step results', async () => {
-      const cookbook = {
-        steps: [
-          {
-            id: 'step1',
-            type: 'task',
-            service: 'test-service',
-            operation: 'testOp'
-          }
-        ]
-      };
-
-      const workflow = await runner.runWorkflow(cookbook);
-      expect(workflow.context.steps['step1']).toBeDefined();
-    });
-  });
-
-  describe('Step Execution', () => {
-    it('should execute task step', async () => {
-      const step = {
-        id: 'task1',
-        type: 'task',
-        service: 'test-service',
-        operation: 'testOp',
-        input: { data: 'test' }
-      };
-
-      const workflow = { 
-        id: 'wf-1',
-        context: { api_input: {}, steps: {} }
-      };
-
-      const result = await runner.executeStep(step, workflow);
-      
-      expect(result.stepId).toBe('task1');
-      expect(result.type).toBe('task');
-      expect(result.success).toBe(true);
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should handle step errors', async () => {
-      const step = {
-        id: 'task1',
-        type: 'task',
-        service: 'unknown-service'
-      };
-
-      const workflow = { 
-        id: 'wf-1',
-        context: { api_input: {}, steps: {} }
-      };
-
-      const result = await runner.executeStep(step, workflow);
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Service not found');
-    });
-
-    it('should handle unknown step type', async () => {
-      const step = {
-        id: 'unknown1',
-        type: 'unknown-type'
-      };
-
-      const workflow = { 
-        id: 'wf-1',
-        context: { api_input: {}, steps: {} }
-      };
-
-      const result = await runner.executeStep(step, workflow);
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Unknown step type');
-    });
-  });
-
-  describe('Foreach Step', () => {
-    it('should execute foreach over array', async () => {
-      const step = {
-        id: 'foreach1',
-        type: 'foreach',
-        items: '$api_input.items',
-        body: {
-          id: 'process',
-          type: 'task',
-          service: 'test-service',
-          operation: 'testOp'
-        }
-      };
-
-      const workflow = {
-        id: 'wf-1',
-        context: {
-          api_input: { items: ['a', 'b', 'c'] },
-          steps: {}
-        }
-      };
-
-      const result = await runner.executeForeachStep(step, workflow);
-      
-      expect(result.items).toBe(3);
-      expect(result.results).toHaveLength(3);
-      expect(result.results.every(r => r.success)).toBe(true);
-    });
-
-    it('should error if items not an array', async () => {
-      const step = {
-        id: 'foreach1',
-        type: 'foreach',
-        items: '$api_input.notArray',
-        body: { id: 'process', type: 'task' }
-      };
-
-      const workflow = {
-        id: 'wf-1',
-        context: {
-          api_input: { notArray: 'string' },
-          steps: {}
-        }
-      };
-
-      await expect(runner.executeForeachStep(step, workflow))
-        .rejects.toThrow('Foreach items must resolve to an array');
-    });
-
-    it('should provide current_item in context', async () => {
-      let capturedContexts = [];
-      
-      const originalExecuteStep = runner.executeStep.bind(runner);
-      runner.executeStep = jest.fn(async (step, workflow) => {
-        capturedContexts.push({ ...workflow.context });
-        return originalExecuteStep(step, workflow);
-      });
-
-      const step = {
-        id: 'foreach1',
-        type: 'foreach',
-        items: '$api_input.items',
-        body: { id: 'process', type: 'task', service: 'test-service' }
-      };
-
-      const workflow = {
-        id: 'wf-1',
-        context: {
-          api_input: { items: ['first', 'second'] },
-          steps: {}
-        }
-      };
-
-      await runner.executeForeachStep(step, workflow);
-      
-      expect(capturedContexts).toHaveLength(2);
-      expect(capturedContexts[0].current_item).toBe('first');
-      expect(capturedContexts[1].current_item).toBe('second');
-    });
-  });
-
-  describe('Switch Step', () => {
-    it('should execute matching case', async () => {
-      const step = {
-        id: 'switch1',
-        type: 'switch',
-        condition: '$api_input.type',
-        cases: [
-          {
-            value: 'typeA',
-            step: { id: 'caseA', type: 'task', service: 'test-service' }
-          },
-          {
-            value: 'typeB',
-            step: { id: 'caseB', type: 'task', service: 'test-service' }
-          }
-        ]
-      };
-
-      const workflow = {
-        id: 'wf-1',
-        context: {
-          api_input: { type: 'typeB' },
-          steps: {}
-        }
-      };
-
-      const result = await runner.executeSwitchStep(step, workflow);
-      
-      expect(result.condition).toBe('typeB');
-      expect(result.executed).toBe('caseB');
-      expect(result.result.success).toBe(true);
-    });
-
-    it('should execute default case', async () => {
-      const step = {
-        id: 'switch1',
-        type: 'switch',
-        condition: '$api_input.type',
-        cases: [
-          {
-            value: 'typeA',
-            step: { id: 'caseA', type: 'task', service: 'test-service' }
-          }
-        ],
-        default: { id: 'defaultCase', type: 'task', service: 'test-service' }
-      };
-
-      const workflow = {
-        id: 'wf-1',
-        context: {
-          api_input: { type: 'typeC' },
-          steps: {}
-        }
-      };
-
-      const result = await runner.executeSwitchStep(step, workflow);
-      
-      expect(result.executed).toBe('defaultCase');
-    });
-
-    it('should error if no matching case and no default', async () => {
-      const step = {
-        id: 'switch1',
-        type: 'switch',
-        condition: '$api_input.type',
-        cases: [
-          {
-            value: 'typeA',
-            step: { id: 'caseA', type: 'task' }
-          }
-        ]
-      };
-
-      const workflow = {
-        id: 'wf-1',
-        context: {
-          api_input: { type: 'typeB' },
-          steps: {}
-        }
-      };
-
-      await expect(runner.executeSwitchStep(step, workflow))
-        .rejects.toThrow('No matching case for condition value: typeB');
-    });
-  });
-
-  describe('Fork-Join Step', () => {
-    it('should execute branches in parallel', async () => {
-      const step = {
-        id: 'fork1',
-        type: 'fork_join',
-        branches: [
-          { id: 'branch1', type: 'task', service: 'test-service' },
-          { id: 'branch2', type: 'task', service: 'test-service' },
-          { id: 'branch3', type: 'task', service: 'test-service' }
-        ],
-        join: { strategy: 'all' }
-      };
-
-      const workflow = {
-        id: 'wf-1',
-        context: { api_input: {}, steps: {} }
-      };
-
-      const result = await runner.executeForkJoinStep(step, workflow);
-      
-      expect(result.branches).toBe(3);
-      expect(result.strategy).toBe('all');
-      expect(result.result).toHaveLength(3);
-    });
-
-    it('should merge results', async () => {
-      // Mock executeStep to return specific data
-      runner.executeStep = jest.fn()
-        .mockResolvedValueOnce({ success: true, data: { a: 1 } })
-        .mockResolvedValueOnce({ success: true, data: { b: 2 } });
-
-      const step = {
-        id: 'fork1',
-        type: 'fork_join',
-        branches: [
-          { id: 'branch1', type: 'task' },
-          { id: 'branch2', type: 'task' }
-        ],
-        join: { strategy: 'merge' }
-      };
-
-      const workflow = {
-        id: 'wf-1',
-        context: { api_input: {}, steps: {} }
-      };
-
-      const result = await runner.executeForkJoinStep(step, workflow);
-      
-      expect(result.result).toEqual({ a: 1, b: 2 });
-    });
-
-    it('should use first strategy', async () => {
-      runner.executeStep = jest.fn()
-        .mockResolvedValueOnce({ success: true, data: 'first' })
-        .mockResolvedValueOnce({ success: true, data: 'second' });
-
-      const step = {
-        id: 'fork1',
-        type: 'fork_join',
-        branches: [
-          { id: 'branch1', type: 'task' },
-          { id: 'branch2', type: 'task' }
-        ],
-        join: { strategy: 'first' }
-      };
-
-      const workflow = {
-        id: 'wf-1',
-        context: { api_input: {}, steps: {} }
-      };
-
-      const result = await runner.executeForkJoinStep(step, workflow);
-      
-      expect(result.result).toEqual({ success: true, data: 'first' });
-    });
-  });
-
-  describe('Input Resolution', () => {
-    it('should resolve JSONPath', () => {
-      const context = {
-        api_input: { user: { name: 'John' } },
-        steps: { step1: { result: 'data' } }
-      };
-
-      expect(runner.resolveInput('$api_input.user.name', context)).toBe('John');
-      expect(runner.resolveInput('$steps.step1.result', context)).toBe('data');
-    });
-
-    it('should return null for invalid path', () => {
-      const context = { api_input: {} };
-      expect(runner.resolveInput('$api_input.nonexistent.path', context)).toBeNull();
-    });
-
-    it('should resolve nested objects', () => {
-      const context = {
-        api_input: { data: 'test' }
-      };
-
-      const input = {
-        field1: '$api_input.data',
-        field2: 'literal',
-        nested: {
-          field3: '$api_input.data'
-        }
-      };
-
-      const resolved = runner.resolveInput(input, context);
-      
-      expect(resolved).toEqual({
-        field1: 'test',
-        field2: 'literal',
-        nested: {
-          field3: 'test'
-        }
-      });
-    });
-
-    it('should return literals unchanged', () => {
-      const context = {};
-      expect(runner.resolveInput('literal', context)).toBe('literal');
-      expect(runner.resolveInput(123, context)).toBe(123);
-      expect(runner.resolveInput(true, context)).toBe(true);
-      expect(runner.resolveInput(null, context)).toBeNull();
-    });
-  });
-
-  describe('Event Emitting', () => {
-    it('should emit workflow events', async () => {
-      const events = [];
-      
-      runner.on('workflow:started', (e) => events.push({ type: 'started', ...e }));
-      runner.on('workflow:completed', (e) => events.push({ type: 'completed', ...e }));
-      
-      await runner.runWorkflow({ steps: [] });
-      
-      expect(events).toHaveLength(2);
-      expect(events[0].type).toBe('started');
-      expect(events[1].type).toBe('completed');
-    });
-
-    it('should emit step events', async () => {
-      const events = [];
-      
-      runner.on('step:started', (e) => events.push({ type: 'started', ...e }));
-      runner.on('step:completed', (e) => events.push({ type: 'completed', ...e }));
-      
-      const cookbook = {
-        steps: [
-          { id: 'step1', type: 'task', service: 'test-service' }
-        ]
-      };
-      
-      await runner.runWorkflow(cookbook);
-      
-      expect(events).toHaveLength(2);
-      expect(events[0].stepId).toBe('step1');
-      expect(events[1].stepId).toBe('step1');
-    });
-
-    it('should emit error events', async () => {
-      const events = [];
-      
-      runner.on('workflow:failed', (e) => events.push(e));
-      runner.on('step:failed', (e) => events.push(e));
-      
-      const cookbook = {
-        steps: [
-          { id: 'step1', type: 'task', service: 'unknown' }
-        ]
-      };
-      
-      await runner.runWorkflow(cookbook);
-      
-      expect(events.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('Workflow Management', () => {
-    it('should track running workflows', async () => {
-      const cookbook = { steps: [] };
-      const workflow = await runner.runWorkflow(cookbook);
-      
-      const status = runner.getWorkflowStatus(workflow.id);
-      expect(status).toBeDefined();
-      expect(status.id).toBe(workflow.id);
-    });
-
-    it('should stop workflow', async () => {
-      const events = [];
-      runner.on('workflow:stopped', (e) => events.push(e));
-      
-      const cookbook = { steps: [] };
-      const workflow = await runner.runWorkflow(cookbook);
-      
-      runner.stopWorkflow(workflow.id);
-      
-      expect(events).toHaveLength(1);
-      expect(events[0].workflowId).toBe(workflow.id);
-    });
-
-    it('should clear completed workflows', async () => {
-      const cookbook = { steps: [] };
-      const wf1 = await runner.runWorkflow(cookbook);
-      const wf2 = await runner.runWorkflow(cookbook);
-      
-      runner.clearCompleted();
-      
-      expect(runner.getWorkflowStatus(wf1.id)).toBeUndefined();
-      expect(runner.getWorkflowStatus(wf2.id)).toBeUndefined();
-    });
-  });
-});