@onlineapps/conn-orch-orchestrator 1.0.63 → 1.0.64

package/tests/component/orchestrator.component.test.js

@@ -1,125 +1,47 @@
 'use strict';
 
 /**
- * Component tests for Orchestrator
- * Tests orchestrator with real internal components but mocked external services
+ * Component tests for WorkflowOrchestrator (V2.1 unified cookbook message format)
+ *
+ * Goal: verify orchestration behavior (task execution + routing) without external MQ/registry.
  */
 
+jest.mock('@onlineapps/mq-client-core', () => ({
+  monitoring: {
+    publishToMonitoringWorkflow: jest.fn(async () => true)
+  }
+}));
+
 const WorkflowOrchestrator = require('../../src/WorkflowOrchestrator');
 
-describe('Orchestrator - Component Tests @component', () => {
+describe('WorkflowOrchestrator - Component Tests @component', () => {
   let orchestrator;
   let mqClientStub;
   let registryClientStub;
   let apiMapperStub;
 
   beforeEach(() => {
-    // Create stubbed versions of external dependencies
-    // that simulate real behavior
     mqClientStub = {
-      connected: true,
-      queues: new Map(),
-
-      publish: jest.fn(async (message, options) => {
-        // Simulate message publishing
-        const queueName = options.queue || 'default';
-        if (!mqClientStub.queues.has(queueName)) {
-          mqClientStub.queues.set(queueName, []);
-        }
-        mqClientStub.queues.get(queueName).push(message);
-        return { published: true };
-      }),
-
-      consume: jest.fn(async (handler, options) => {
-        // Store handler for later invocation
-        mqClientStub.handler = handler;
-        return { consuming: true };
-      }),
-
-      isConnected: () => mqClientStub.connected
+      publish: jest.fn(async () => true)
     };
 
     registryClientStub = {
-      services: new Map([
-        ['test-service', {
-          name: 'test-service',
-          url: 'http://localhost:3000',
-          openapi: {
-            openapi: '3.0.0',
-            paths: {
-              '/test': {
-                post: {
-                  operationId: 'testOp',
-                  requestBody: {
-                    content: {
-                      'application/json': {
-                        schema: { type: 'object' }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }],
-        ['invoice-service', {
-          name: 'invoice-service',
-          url: 'http://localhost:3001',
-          openapi: {}
-        }]
-      ]),
-
-      getService: jest.fn(async (serviceName) => {
-        return registryClientStub.services.get(serviceName);
-      }),
-
-      getAllServices: jest.fn(async () => {
-        return Array.from(registryClientStub.services.values());
-      })
+      getService: jest.fn(async () => null),
+      getAllServices: jest.fn(async () => [])
     };
 
     apiMapperStub = {
-      operations: new Map(),
-
-      callOperation: jest.fn(async (operationId, input, context) => {
-        // Simulate successful API call
-        return {
-          status: 200,
-          data: {
-            operationId,
-            input,
-            result: `Processed ${operationId}`
-          }
-        };
-      }),
-
-      parseOpenApi: jest.fn((spec) => {
-        // Extract operations from OpenAPI spec
-        const operations = {};
-        if (spec.paths) {
-          Object.entries(spec.paths).forEach(([path, methods]) => {
-            Object.entries(methods).forEach(([method, op]) => {
-              if (op.operationId) {
-                operations[op.operationId] = { path, method, ...op };
-              }
-            });
-          });
-        }
-        return operations;
-      })
+      callOperation: jest.fn(async (operationId, input) => ({ operationId, input }))
     };
 
-    // Create orchestrator with component stubs
     orchestrator = new WorkflowOrchestrator({
       mqClient: mqClientStub,
       registryClient: registryClientStub,
       apiMapper: apiMapperStub,
       cookbook: {
         validateCookbook: jest.fn(),
-        CookbookExecutor: class {
-          execute() {
-            return Promise.resolve({ results: {} });
-          }
+        templateHelpers: {
+          normalizeString: (v) => String(v || '').trim()
         }
       },
       logger: {
@@ -131,248 +53,68 @@ describe('Orchestrator - Component Tests @component', () => {
     });
   });
 
-  describe('Workflow Processing', () => {
-    it('should process a complete workflow with multiple steps', async () => {
-      const workflow = {
-        workflow_id: 'wf-test-123',
-        current_step: {
-          id: 'step1',
-          service: 'test-service',
-          operation: 'testOp',
-          input: { value: 100 },
-          output: 'step1Result'
-        },
-        next_steps: [
-          {
-            id: 'step2',
-            service: 'invoice-service',
-            operation: 'createInvoice',
-            input: {
-              amount: '{{step1Result.value}}'
-            }
-          }
-        ],
-        context: {
-          variables: { customerId: 'cust-123' },
-          results: {}
-        }
-      };
-
-      // Process first step
-      const result = await orchestrator.processWorkflowMessage(workflow, 'test-service');
-
-      expect(result).toBeDefined();
-      expect(apiMapperStub.callOperation).toHaveBeenCalledWith(
-        'testOp',
-        { value: 100 },
-        expect.any(Object)
-      );
-
-      // Verify message was routed to next service
-      if (workflow.next_steps && workflow.next_steps.length > 0) {
-        expect(mqClientStub.publish).toHaveBeenCalledWith(
-          expect.objectContaining({
-            workflow_id: 'wf-test-123',
-            current_step: expect.objectContaining({
-              service: 'invoice-service'
-            })
-          }),
-          expect.objectContaining({
-            queue: 'invoice-service.workflow'
-          })
-        );
-      }
-    });
-
-    it('should handle parallel step execution', async () => {
-      const workflow = {
-        workflow_id: 'wf-parallel-123',
-        current_step: {
-          id: 'fork',
-          type: 'parallel',
-          steps: [
-            {
-              id: 'parallel1',
-              service: 'test-service',
-              operation: 'op1'
-            },
-            {
-              id: 'parallel2',
-              service: 'test-service',
-              operation: 'op2'
-            }
-          ]
-        },
-        context: {}
-      };
-
-      await orchestrator.processWorkflowMessage(workflow, 'test-service');
-
-      // Both operations should be called
-      expect(apiMapperStub.callOperation).toHaveBeenCalledTimes(2);
-    });
-
-    it('should handle conditional routing', async () => {
-      const workflow = {
-        workflow_id: 'wf-conditional-123',
-        current_step: {
-          id: 'decision',
-          service: 'test-service',
-          operation: 'checkCondition',
-          input: { threshold: 50 },
-          output: 'decision'
-        },
-        next_steps: [
-          {
-            id: 'highPath',
-            condition: '{{decision.value}} > 50',
-            service: 'invoice-service',
-            operation: 'highValue'
-          },
-          {
-            id: 'lowPath',
-            condition: '{{decision.value}} <= 50',
-            service: 'invoice-service',
-            operation: 'lowValue'
-          }
-        ],
-        context: {}
-      };
-
-      // Mock API response
-      apiMapperStub.callOperation.mockResolvedValueOnce({
-        status: 200,
-        data: { value: 75 }
-      });
-
-      await orchestrator.processWorkflowMessage(workflow, 'test-service');
+  it('executes task and routes next task to next service queue', async () => {
+    const cookbook = {
+      version: '2.1.0',
+      api_input: { x: 1 },
+      steps: [
+        { step_id: 's1', type: 'task', service: 'svc-a', operation: 'op1', input: { x: '{{api_input.x}}' } },
+        { step_id: 's2', type: 'task', service: 'svc-b', operation: 'op2', input: { y: 2 } }
+      ],
+      delivery: { handler: 'none' }
+    };
 
-      // Should route to high value path
-      expect(mqClientStub.publish).toHaveBeenCalledWith(
-        expect.objectContaining({
-          current_step: expect.objectContaining({
-            operation: 'highValue'
-          })
-        }),
-        expect.any(Object)
-      );
-    });
+    const msg = { workflow_id: 'wf-1', cookbook, current_step: 's1' };
+    await orchestrator.processWorkflowMessage(msg, 'svc-a');
+
+    expect(apiMapperStub.callOperation).toHaveBeenCalledWith(
+      'op1',
+      { x: 1 },
+      expect.any(Object)
+    );
+
+    expect(mqClientStub.publish).toHaveBeenCalledWith(
+      'svc-b.workflow',
+      expect.objectContaining({
+        workflow_id: 'wf-1',
+        current_step: 's2',
+        cookbook: expect.objectContaining({
+          _pointer: { next: 's2' }
+        })
+      })
+    );
   });
 
-  describe('Error Handling', () => {
-    it('should handle service unavailable gracefully', async () => {
-      registryClientStub.getService.mockResolvedValueOnce(null);
-
-      const workflow = {
-        workflow_id: 'wf-error-123',
-        current_step: {
-          service: 'unknown-service',
-          operation: 'test'
-        }
-      };
-
-      await expect(
-        orchestrator.processWorkflowMessage(workflow, 'unknown-service')
-      ).rejects.toThrow();
-    });
-
-    it('should handle API call failures', async () => {
-      apiMapperStub.callOperation.mockRejectedValueOnce(
-        new Error('Connection refused')
-      );
-
-      const workflow = {
-        workflow_id: 'wf-api-error-123',
-        current_step: {
-          service: 'test-service',
-          operation: 'failingOp'
+  it('routes next pinned control-flow step to pinned service queue (not workflow.init)', async () => {
+    const cookbook = {
+      version: '2.1.0',
+      api_input: { items: ['a'] },
+      steps: [
+        { step_id: 's1', type: 'task', service: 'svc-a', operation: 'op1', input: { x: 1 } },
+        {
+          step_id: 'loop',
+          type: 'foreach',
+          service: 'hello-service',
+          iterator: '{{api_input.items}}',
+          body: [
+            { step_id: 'inner', type: 'task', service: 'hello-service', operation: 'good-day', input: { name: '{{current}}' } }
+          ]
         }
-      };
-
-      await expect(
-        orchestrator.processWorkflowMessage(workflow, 'test-service')
-      ).rejects.toThrow('Connection refused');
-    });
+      ],
+      delivery: { handler: 'none' }
+    };
 
-    it('should handle malformed workflows', async () => {
-      const malformedWorkflow = {
-        // Missing required fields
-        workflow_id: 'wf-malformed-123'
-      };
+    const msg = { workflow_id: 'wf-2', cookbook, current_step: 's1' };
+    await orchestrator.processWorkflowMessage(msg, 'svc-a');
 
-      await expect(
-        orchestrator.processWorkflowMessage(malformedWorkflow, 'test-service')
-      ).rejects.toThrow();
-    });
+    expect(mqClientStub.publish).toHaveBeenCalledWith(
+      'hello-service.workflow',
+      expect.objectContaining({
+        workflow_id: 'wf-2',
+        current_step: 'loop'
+      })
+    );
   });
+});
 
-  describe('Context Management', () => {
-    it('should maintain context across steps', async () => {
-      const workflow = {
-        workflow_id: 'wf-context-123',
-        current_step: {
-          id: 'step1',
-          service: 'test-service',
-          operation: 'addContext',
-          input: { newData: 'test' },
-          output: 'contextData'
-        },
-        context: {
-          variables: { existing: 'data' },
-          results: {}
-        }
-      };
-
-      await orchestrator.processWorkflowMessage(workflow, 'test-service');
-
-      // Context should be preserved in routed message
-      expect(mqClientStub.publish).toHaveBeenCalledWith(
-        expect.objectContaining({
-          context: expect.objectContaining({
-            variables: expect.objectContaining({
-              existing: 'data'
-            })
-          })
-        }),
-        expect.any(Object)
-      );
-    });
-
-    it('should accumulate results in context', async () => {
-      const workflow = {
-        workflow_id: 'wf-results-123',
-        current_step: {
-          id: 'step2',
-          service: 'test-service',
-          operation: 'process',
-          output: 'step2Result'
-        },
-        context: {
-          results: {
-            step1Result: { previous: 'data' }
-          }
-        }
-      };
-
-      apiMapperStub.callOperation.mockResolvedValueOnce({
-        status: 200,
-        data: { new: 'result' }
-      });
 
-      await orchestrator.processWorkflowMessage(workflow, 'test-service');
-
-      // Results should accumulate
-      expect(mqClientStub.publish).toHaveBeenCalledWith(
-        expect.objectContaining({
-          context: expect.objectContaining({
-            results: expect.objectContaining({
-              step1Result: { previous: 'data' },
-              step2Result: { new: 'result' }
-            })
-          })
-        }),
-        expect.any(Object)
-      );
-    });
-  });
-});

package/tests/integration/orchestrator.integration.test.js

@@ -13,14 +13,18 @@ const CookbookConnector = require('@onlineapps/conn-orch-cookbook');
 
 // Skip integration tests if external services are not available
 const SKIP_INTEGRATION = process.env.SKIP_INTEGRATION === 'true';
-const { requireEnv } = require('../../../../../tests/_helpers/test-config');
-const RABBITMQ_URL = requireEnv('RABBITMQ_URL', 'RabbitMQ connection URL');
-const REGISTRY_URL = requireEnv('REGISTRY_URL', 'Registry service URL');
+const RABBITMQ_URL = process.env.RABBITMQ_URL || null;
+const REGISTRY_URL = process.env.REGISTRY_URL || null;
+const HAS_ENV = !!(RABBITMQ_URL && REGISTRY_URL);
 
-describe('Orchestrator - Integration Tests @integration', () => {
+const describeMaybe = (!SKIP_INTEGRATION && HAS_ENV) ? describe : describe.skip;
+
+describeMaybe('Orchestrator - Integration Tests @integration', () => {
   if (SKIP_INTEGRATION) {
-    it.skip('Skipping integration tests (SKIP_INTEGRATION=true)', () => {});
-    return;
+    it('Skipping integration tests (SKIP_INTEGRATION=true)', () => {});
+  }
+  if (!HAS_ENV) {
+    it('Skipping integration tests (missing RABBITMQ_URL/REGISTRY_URL)', () => {});
   }
 
   let orchestrator;