@onlineapps/conn-orch-orchestrator 1.0.63 → 1.0.65

package/tests/unit/WorkflowOrchestrator.test.js

@@ -5,6 +5,12 @@
  * Tests individual methods in isolation with mocked dependencies
  */
 
+jest.mock('@onlineapps/mq-client-core', () => ({
+  monitoring: {
+    publishToMonitoringWorkflow: jest.fn(async () => true)
+  }
+}));
+
 const WorkflowOrchestrator = require('../../src/WorkflowOrchestrator');
 
 describe('WorkflowOrchestrator - Unit Tests @unit', () => {
@@ -33,19 +39,21 @@ describe('WorkflowOrchestrator - Unit Tests @unit', () => {
     };
 
     mockApiMapper = {
-      callOperation: jest.fn().mockResolvedValue({
-        status: 200,
-        data: { result: 'success' }
-      })
+      callOperation: jest.fn(async (operationId, input, ctx) => ({
+        operationId,
+        input,
+        ctx
+      }))
     };
 
     mockCookbook = {
       validateCookbook: jest.fn(),
-      CookbookExecutor: jest.fn().mockImplementation(() => ({
-        execute: jest.fn().mockResolvedValue({
-          results: { step1: { data: 'test' } }
-        })
-      }))
+      templateHelpers: {
+        normalizeString: jest.fn((value) => String(value || '').replace(/\s+/g, ' ').trim()),
+        webalizeString: jest.fn((value) => String(value || '').toLowerCase().replace(/\s+/g, '-')),
+        string2file: jest.fn(async (value) => ({ _descriptor: true, type: 'file', storage_ref: `minio://mock/${String(value).length}` })),
+        file2string: jest.fn(async (descriptor) => (descriptor && descriptor.storage_ref ? `from:${descriptor.storage_ref}` : String(descriptor)))
+      }
     };
 
     mockLogger = {
@@ -95,159 +103,152 @@ describe('WorkflowOrchestrator - Unit Tests @unit', () => {
   });
 
   describe('processWorkflowMessage', () => {
-    const testMessage = {
-      workflow_id: 'wf-123',
-      current_step: {
-        id: 'step1',
-        service: 'test-service',
-        operation: 'testOp',
-        input: { data: 'test' }
-      },
-      context: {
-        variables: {},
-        results: {}
-      }
-    };
-
-    it('should process a valid workflow message', async () => {
-      const result = await orchestrator.processWorkflowMessage(testMessage, 'test-service');
-
-      expect(mockLogger.info).toHaveBeenCalledWith(
-        expect.stringContaining('Processing workflow message'),
-        expect.any(Object)
-      );
-      expect(result).toBeDefined();
-    });
-
-    it('should use cache when available', async () => {
-      mockCache.get.mockResolvedValueOnce({ cached: 'data' });
-
-      await orchestrator.processWorkflowMessage(testMessage, 'test-service');
-
-      expect(mockCache.get).toHaveBeenCalled();
-    });
-
-    it('should handle errors appropriately', async () => {
-      mockApiMapper.callOperation.mockRejectedValueOnce(new Error('API Error'));
-
-      await expect(
-        orchestrator.processWorkflowMessage(testMessage, 'test-service')
-      ).rejects.toThrow('API Error');
-
-      expect(mockLogger.error).toHaveBeenCalled();
-    });
-  });
-
-  describe('validateMessage', () => {
-    it('should validate a correct message', () => {
-      const message = {
-        workflow_id: 'wf-123',
-        current_step: {
-          id: 'step1',
-          service: 'test',
-          operation: 'op1'
-        }
+    it('executes task step for the current service and calls ApiMapper', async () => {
+      const cookbook = {
+        version: '2.1.0',
+        api_input: { text: 'hello' },
+        steps: [
+          {
+            step_id: 's1',
+            type: 'task',
+            service: 'hello-service',
+            operation: 'test-echo',
+            input: { text: '{{api_input.text}}' }
+          }
+        ],
+        delivery: { handler: 'none' }
       };
 
-      expect(() => orchestrator.validateMessage(message)).not.toThrow();
-    });
-
-    it('should throw for invalid message structure', () => {
-      const invalidMessage = {
-        workflow_id: 'wf-123'
-        // missing current_step
-      };
-
-      expect(() => orchestrator.validateMessage(invalidMessage)).toThrow();
-    });
-  });
-
-  describe('executeStep', () => {
-    const step = {
-      id: 'step1',
-      service: 'test-service',
-      operation: 'testOp',
-      input: { data: 'test' }
-    };
-
-    it('should execute a step successfully', async () => {
-      const result = await orchestrator.executeStep(step, {});
+      const message = { workflow_id: 'wf-123', cookbook, current_step: 's1' };
+      const result = await orchestrator.processWorkflowMessage(message, 'hello-service');
 
       expect(mockApiMapper.callOperation).toHaveBeenCalledWith(
-        'testOp',
-        { data: 'test' },
-        {}
+        'test-echo',
+        { text: 'hello' },
+        expect.objectContaining({ workflow_id: 'wf-123', step_id: 's1' })
       );
-      expect(result).toEqual({
-        status: 200,
-        data: { result: 'success' }
-      });
+      expect(result.success).toBe(true);
     });
 
-    it('should retry on transient errors', async () => {
-      mockErrorHandler.isRetryableError.mockReturnValue(true);
-      mockApiMapper.callOperation
-        .mockRejectedValueOnce(new Error('Transient error'))
-        .mockResolvedValueOnce({ status: 200, data: 'success' });
+    it('routes task step to correct service queue when service does not match', async () => {
+      const cookbook = {
+        version: '2.1.0',
+        api_input: { text: 'hello' },
+        steps: [
+          {
+            step_id: 's1',
+            type: 'task',
+            service: 'other-service',
+            operation: 'test-echo',
+            input: { text: '{{api_input.text}}' }
+          }
+        ],
+        delivery: { handler: 'none' }
+      };
 
-      const result = await orchestrator.executeStep(step, {});
+      const message = { workflow_id: 'wf-123', cookbook, current_step: 's1' };
+      const res = await orchestrator.processWorkflowMessage(message, 'hello-service');
 
-      expect(mockErrorHandler.executeWithRetry).toHaveBeenCalled();
+      expect(res).toEqual({ skipped: true, reason: 'wrong_service' });
+      expect(mockMqClient.publish).toHaveBeenCalledWith('other-service.workflow', message);
+      expect(mockApiMapper.callOperation).not.toHaveBeenCalled();
     });
-  });
 
-  describe('routeToNextStep', () => {
-    it('should route to next service via MQ', async () => {
-      const nextStep = {
-        service: 'next-service',
-        operation: 'nextOp'
+    it('routes pinned control-flow step to pinned service when current service does not match', async () => {
+      const cookbook = {
+        version: '2.1.0',
+        api_input: { items: ['A', 'B'] },
+        steps: [
+          {
+            step_id: 'loop',
+            type: 'foreach',
+            service: 'hello-service', // pin
+            iterator: '{{api_input.items}}',
+            body: [
+              {
+                step_id: 'inner',
+                type: 'task',
+                service: 'hello-service',
+                operation: 'good-day',
+                input: { name: '{{current}}' }
+              }
+            ]
+          }
+        ],
+        delivery: { handler: 'none' }
       };
 
-      await orchestrator.routeToNextStep('wf-123', nextStep, {});
-
-      expect(mockMqClient.publish).toHaveBeenCalledWith(
-        expect.objectContaining({
-          workflow_id: 'wf-123',
-          current_step: nextStep
-        }),
-        expect.objectContaining({
-          queue: 'next-service.workflow'
-        })
-      );
-    });
-
-    it('should handle routing errors', async () => {
-      mockMqClient.publish.mockRejectedValueOnce(new Error('MQ Error'));
+      const message = { workflow_id: 'wf-123', cookbook, current_step: 'loop' };
+      const res = await orchestrator.processWorkflowMessage(message, 'pdfgen-service');
 
-      await expect(
-        orchestrator.routeToNextStep('wf-123', {}, {})
-      ).rejects.toThrow('MQ Error');
+      expect(res).toEqual({ skipped: true, reason: 'wrong_service_control_flow' });
+      expect(mockMqClient.publish).toHaveBeenCalledWith('hello-service.workflow', message);
+      expect(mockApiMapper.callOperation).not.toHaveBeenCalled();
     });
-  });
 
-  describe('caching', () => {
-    it('should cache successful results when cache is available', async () => {
-      const step = {
-        id: 'step1',
-        cache: { ttl: 300 }
+    it('executes foreach control-flow step when pinned to this service', async () => {
+      const cookbook = {
+        version: '2.1.0',
+        api_input: { items: ['A', 'B'] },
+        steps: [
+          {
+            step_id: 'loop',
+            type: 'foreach',
+            service: 'hello-service', // pin to ensure deterministic executor
+            iterator: '{{api_input.items}}',
+            body: [
+              {
+                step_id: 'inner',
+                type: 'task',
+                service: 'hello-service',
+                operation: 'good-day',
+                input: { name: '{{current}}' }
+              }
+            ]
+          }
+        ],
+        delivery: { handler: 'none' }
       };
-      const result = { data: 'test' };
-
-      await orchestrator.cacheResult(step, result);
 
-      expect(mockCache.set).toHaveBeenCalledWith(
-        expect.any(String),
-        result,
-        300
+      const message = { workflow_id: 'wf-123', cookbook, current_step: 'loop' };
+      const res = await orchestrator.processWorkflowMessage(message, 'hello-service');
+
+      expect(res.success).toBe(true);
+      expect(res.result).toEqual(expect.objectContaining({ type: 'foreach', count: 2 }));
+      expect(mockApiMapper.callOperation).toHaveBeenCalledTimes(2);
+      expect(mockApiMapper.callOperation).toHaveBeenNthCalledWith(
+        1,
+        'good-day',
+        { name: 'A' },
+        expect.objectContaining({ workflow_id: 'wf-123', step_id: 'inner' })
       );
     });
 
-    it('should skip caching when cache is not configured', async () => {
-      orchestrator.cache = null;
+    it('resolves helper call in templates', async () => {
+      const cookbook = {
+        version: '2.1.0',
+        api_input: { text: '  Hello   World  ' },
+        steps: [
+          {
+            step_id: 's1',
+            type: 'task',
+            service: 'hello-service',
+            operation: 'test-echo',
+            input: { text: '{{normalizeString(api_input.text)}}' }
+          }
+        ],
+        delivery: { handler: 'none' }
+      };
 
-      await orchestrator.cacheResult({}, {});
+      const message = { workflow_id: 'wf-123', cookbook, current_step: 's1' };
+      await orchestrator.processWorkflowMessage(message, 'hello-service');
 
-      expect(mockCache.set).not.toHaveBeenCalled();
+      expect(mockCookbook.templateHelpers.normalizeString).toHaveBeenCalled();
+      expect(mockApiMapper.callOperation).toHaveBeenCalledWith(
+        'test-echo',
+        { text: 'Hello World' },
+        expect.objectContaining({ workflow_id: 'wf-123', step_id: 's1' })
+      );
     });
   });
 });