@onlineapps/conn-orch-orchestrator 1.0.0

package/test/unit/WorkflowOrchestrator.test.js

@@ -0,0 +1,253 @@
+'use strict';
+
+/**
+ * Unit tests for WorkflowOrchestrator
+ * Tests individual methods in isolation with mocked dependencies
+ */
+
+const WorkflowOrchestrator = require('../../src/WorkflowOrchestrator');
+
+describe('WorkflowOrchestrator - Unit Tests', () => {
+  let orchestrator;
+  let mockMqClient;
+  let mockRegistryClient;
+  let mockApiMapper;
+  let mockCookbook;
+  let mockLogger;
+  let mockCache;
+  let mockErrorHandler;
+
+  beforeEach(() => {
+    // Setup mocked dependencies
+    mockMqClient = {
+      publish: jest.fn().mockResolvedValue(true),
+      subscribe: jest.fn().mockResolvedValue(true)
+    };
+
+    mockRegistryClient = {
+      getService: jest.fn().mockResolvedValue({
+        name: 'test-service',
+        url: 'http://localhost:3000',
+        openapi: {}
+      })
+    };
+
+    mockApiMapper = {
+      callOperation: jest.fn().mockResolvedValue({
+        status: 200,
+        data: { result: 'success' }
+      })
+    };
+
+    mockCookbook = {
+      validateCookbook: jest.fn(),
+      CookbookExecutor: jest.fn().mockImplementation(() => ({
+        execute: jest.fn().mockResolvedValue({
+          results: { step1: { data: 'test' } }
+        })
+      }))
+    };
+
+    mockLogger = {
+      info: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+      debug: jest.fn()
+    };
+
+    mockCache = {
+      get: jest.fn().mockResolvedValue(null),
+      set: jest.fn().mockResolvedValue('OK'),
+      del: jest.fn().mockResolvedValue(1)
+    };
+
+    mockErrorHandler = {
+      executeWithRetry: jest.fn((fn) => fn()),
+      handleError: jest.fn(),
+      isRetryableError: jest.fn().mockReturnValue(false)
+    };
+
+    orchestrator = new WorkflowOrchestrator({
+      mqClient: mockMqClient,
+      registryClient: mockRegistryClient,
+      apiMapper: mockApiMapper,
+      cookbook: mockCookbook,
+      logger: mockLogger,
+      cache: mockCache,
+      errorHandler: mockErrorHandler
+    });
+  });
+
+  describe('constructor', () => {
+    it('should initialize with all required dependencies', () => {
+      expect(orchestrator.mqClient).toBe(mockMqClient);
+      expect(orchestrator.registryClient).toBe(mockRegistryClient);
+      expect(orchestrator.apiMapper).toBe(mockApiMapper);
+      expect(orchestrator.cookbook).toBe(mockCookbook);
+      expect(orchestrator.logger).toBe(mockLogger);
+      expect(orchestrator.cache).toBe(mockCache);
+      expect(orchestrator.errorHandler).toBe(mockErrorHandler);
+    });
+
+    it('should throw if required dependencies are missing', () => {
+      expect(() => new WorkflowOrchestrator({})).toThrow();
+    });
+  });
+
+  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'
+        }
+      };
+
+      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, {});
+
+      expect(mockApiMapper.callOperation).toHaveBeenCalledWith(
+        'testOp',
+        { data: 'test' },
+        {}
+      );
+      expect(result).toEqual({
+        status: 200,
+        data: { result: 'success' }
+      });
+    });
+
+    it('should retry on transient errors', async () => {
+      mockErrorHandler.isRetryableError.mockReturnValue(true);
+      mockApiMapper.callOperation
+        .mockRejectedValueOnce(new Error('Transient error'))
+        .mockResolvedValueOnce({ status: 200, data: 'success' });
+
+      const result = await orchestrator.executeStep(step, {});
+
+      expect(mockErrorHandler.executeWithRetry).toHaveBeenCalled();
+    });
+  });
+
+  describe('routeToNextStep', () => {
+    it('should route to next service via MQ', async () => {
+      const nextStep = {
+        service: 'next-service',
+        operation: 'nextOp'
+      };
+
+      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'));
+
+      await expect(
+        orchestrator.routeToNextStep('wf-123', {}, {})
+      ).rejects.toThrow('MQ Error');
+    });
+  });
+
+  describe('caching', () => {
+    it('should cache successful results when cache is available', async () => {
+      const step = {
+        id: 'step1',
+        cache: { ttl: 300 }
+      };
+      const result = { data: 'test' };
+
+      await orchestrator.cacheResult(step, result);
+
+      expect(mockCache.set).toHaveBeenCalledWith(
+        expect.any(String),
+        result,
+        300
+      );
+    });
+
+    it('should skip caching when cache is not configured', async () => {
+      orchestrator.cache = null;
+
+      await orchestrator.cacheResult({}, {});
+
+      expect(mockCache.set).not.toHaveBeenCalled();
+    });
+  });
+});