@onlineapps/service-wrapper 2.0.21 → 2.0.23

package/tests/unit/ServiceWrapper.test.js

@@ -1,372 +0,0 @@
-'use strict';
-
-const ServiceWrapper = require('../../src/ServiceWrapper');
-const {
-  MockMQConnector,
-  MockServiceRegistryClient,
-  MockLogger,
-  MockOrchestratorConnector,
-  MockApiMapperConnector,
-  MockCookbookConnector
-} = require('../mocks/connectors');
-
-// Mock all connector dependencies
-jest.mock('@onlineapps/conn-infra-mq', () => MockMQConnector);
-jest.mock('@onlineapps/conn-orch-registry', () => ({
-  ServiceRegistryClient: MockServiceRegistryClient
-}));
-jest.mock('@onlineapps/conn-base-logger', () => MockLogger);
-jest.mock('@onlineapps/conn-orch-orchestrator', () => MockOrchestratorConnector);
-jest.mock('@onlineapps/conn-orch-api-mapper', () => MockApiMapperConnector);
-jest.mock('@onlineapps/conn-orch-cookbook', () => MockCookbookConnector);
-
-describe('ServiceWrapper Unit Tests @unit', () => {
-  let wrapper;
-  let mockExpressApp;
-  let mockOpenApiSpec;
-
-  beforeEach(() => {
-    // Mock Express app
-    mockExpressApp = jest.fn();
-
-    // Mock OpenAPI spec
-    mockOpenApiSpec = {
-      openapi: '3.0.0',
-      info: {
-        title: 'Test Service',
-        version: '1.0.0',
-        description: 'Test service for unit tests'
-      },
-      paths: {
-        '/test': {
-          get: {
-            operationId: 'getTest',
-            responses: { '200': { description: 'OK' } }
-          }
-        }
-      }
-    };
-
-    // Clear all mocks
-    jest.clearAllMocks();
-  });
-
-  afterEach(async () => {
-    if (wrapper && wrapper.isRunning) {
-      await wrapper.stop();
-    }
-  });
-
-  describe('Constructor', () => {
-    test('should create instance with valid options', () => {
-      wrapper = new ServiceWrapper({
-        service: mockExpressApp,
-        serviceName: 'test-service',
-        openApiSpec: mockOpenApiSpec
-      });
-
-      expect(wrapper).toBeInstanceOf(ServiceWrapper);
-      expect(wrapper.serviceName).toBe('test-service');
-      expect(wrapper.service).toBe(mockExpressApp);
-      expect(wrapper.openApiSpec).toBe(mockOpenApiSpec);
-    });
-
-    test('should throw error without service', () => {
-      expect(() => {
-        new ServiceWrapper({
-          serviceName: 'test-service',
-          openApiSpec: mockOpenApiSpec
-        });
-      }).toThrow('Service (Express app) is required');
-    });
-
-    test('should throw error without serviceName', () => {
-      expect(() => {
-        new ServiceWrapper({
-          service: mockExpressApp,
-          openApiSpec: mockOpenApiSpec
-        });
-      }).toThrow('Service name is required');
-    });
-
-    test('should throw error without openApiSpec', () => {
-      expect(() => {
-        new ServiceWrapper({
-          service: mockExpressApp,
-          serviceName: 'test-service'
-        });
-      }).toThrow('OpenAPI specification is required');
-    });
-
-    test('should accept optional config', () => {
-      wrapper = new ServiceWrapper({
-        service: mockExpressApp,
-        serviceName: 'test-service',
-        openApiSpec: mockOpenApiSpec,
-        config: {
-          port: 3001,
-          prefetch: 5,
-          heartbeatInterval: 10000
-        }
-      });
-
-      expect(wrapper.config.port).toBe(3001);
-      expect(wrapper.config.prefetch).toBe(5);
-      expect(wrapper.config.heartbeatInterval).toBe(10000);
-    });
-  });
-
-  describe('Start', () => {
-    beforeEach(() => {
-      wrapper = new ServiceWrapper({
-        service: mockExpressApp,
-        serviceName: 'test-service',
-        openApiSpec: mockOpenApiSpec
-      });
-    });
-
-    test('should start successfully', async () => {
-      await wrapper.start();
-
-      expect(wrapper.isRunning).toBe(true);
-      expect(wrapper.mqClient).toBeDefined();
-      expect(wrapper.mqClient.isConnected()).toBe(true);
-      expect(wrapper.registryClient).toBeDefined();
-      expect(wrapper.orchestrator).toBeDefined();
-    });
-
-    test('should register service with registry', async () => {
-      await wrapper.start();
-
-      const registeredServices = wrapper.registryClient.registeredServices;
-      expect(registeredServices.has('test-service')).toBe(true);
-
-      const serviceInfo = registeredServices.get('test-service');
-      expect(serviceInfo.name).toBe('test-service');
-      expect(serviceInfo.url).toBe('http://localhost:3000');
-      expect(serviceInfo.openapi).toBe(mockOpenApiSpec);
-    });
-
-    test('should subscribe to workflow queue', async () => {
-      await wrapper.start();
-
-      const consumers = wrapper.mqClient.consumers;
-      expect(consumers.has('test-service.workflow')).toBe(true);
-    });
-
-    test('should not start twice', async () => {
-      await wrapper.start();
-      const firstMqClient = wrapper.mqClient;
-
-      await wrapper.start(); // Second call
-
-      expect(wrapper.mqClient).toBe(firstMqClient); // Same instance
-      expect(wrapper.logger.logs.some(log =>
-        log.level === 'warn' && log.message.includes('already running')
-      )).toBe(true);
-    });
-
-    test('should handle start failure gracefully', async () => {
-      // Force connection to fail
-      MockMQConnector.prototype.connect = jest.fn()
-        .mockRejectedValue(new Error('Connection failed'));
-
-      wrapper = new ServiceWrapper({
-        service: mockExpressApp,
-        serviceName: 'test-service',
-        openApiSpec: mockOpenApiSpec
-      });
-
-      await expect(wrapper.start()).rejects.toThrow('Connection failed');
-      expect(wrapper.isRunning).toBe(false);
-
-      // Restore original
-      MockMQConnector.prototype.connect = jest.fn().mockResolvedValue();
-    });
-  });
-
-  describe('Stop', () => {
-    beforeEach(async () => {
-      wrapper = new ServiceWrapper({
-        service: mockExpressApp,
-        serviceName: 'test-service',
-        openApiSpec: mockOpenApiSpec
-      });
-      await wrapper.start();
-    });
-
-    test('should stop successfully', async () => {
-      expect(wrapper.isRunning).toBe(true);
-
-      await wrapper.stop();
-
-      expect(wrapper.isRunning).toBe(false);
-      expect(wrapper.mqClient.isConnected()).toBe(false);
-    });
-
-    test('should unregister from registry', async () => {
-      expect(wrapper.registryClient.registeredServices.has('test-service')).toBe(true);
-
-      await wrapper.stop();
-
-      expect(wrapper.registryClient.registeredServices.has('test-service')).toBe(false);
-    });
-
-    test('should stop heartbeat', async () => {
-      const intervalSpy = jest.spyOn(global, 'clearInterval');
-
-      await wrapper.stop();
-
-      expect(intervalSpy).toHaveBeenCalled();
-      intervalSpy.mockRestore();
-    });
-
-    test('should not stop if not running', async () => {
-      await wrapper.stop();
-      const logCount = wrapper.logger.logs.length;
-
-      await wrapper.stop(); // Second call
-
-      expect(wrapper.logger.logs.some((log, index) =>
-        index >= logCount &&
-        log.level === 'warn' &&
-        log.message.includes('not running')
-      )).toBe(true);
-    });
-  });
-
-  describe('Message Processing', () => {
-    beforeEach(async () => {
-      wrapper = new ServiceWrapper({
-        service: mockExpressApp,
-        serviceName: 'test-service',
-        openApiSpec: mockOpenApiSpec
-      });
-      await wrapper.start();
-    });
-
-    test('should process workflow message successfully', async () => {
-      const testMessage = {
-        workflow_id: 'wf-123',
-        cookbook: {
-          steps: [
-            { id: 'step1', type: 'task', service: 'test-service' }
-          ]
-        },
-        current_step: 'step1',
-        context: { test: true }
-      };
-
-      // Simulate message arrival
-      await wrapper.mqClient.simulateMessage('test-service.workflow', testMessage);
-
-      // Check orchestrator received the message
-      const processedMessages = wrapper.orchestrator.processedMessages;
-      expect(processedMessages).toHaveLength(1);
-      expect(processedMessages[0].message).toEqual(testMessage);
-      expect(processedMessages[0].serviceName).toBe('test-service');
-    });
-
-    test('should handle message processing error', async () => {
-      // Make orchestrator fail
-      wrapper.orchestrator.setNextProcessingToFail(true);
-
-      const testMessage = {
-        workflow_id: 'wf-123',
-        cookbook: { steps: [] },
-        current_step: 'step1',
-        context: {}
-      };
-
-      // Simulate message arrival
-      await wrapper.mqClient.simulateMessage('test-service.workflow', testMessage);
-
-      // Check error was logged
-      expect(wrapper.logger.logs.some(log =>
-        log.level === 'error' &&
-        log.message.includes('Message processing failed')
-      )).toBe(true);
-    });
-  });
-
-  describe('GetStatus', () => {
-    test('should return status when running', async () => {
-      wrapper = new ServiceWrapper({
-        service: mockExpressApp,
-        serviceName: 'test-service',
-        openApiSpec: mockOpenApiSpec,
-        config: { port: 3001 }
-      });
-
-      await wrapper.start();
-      const status = wrapper.getStatus();
-
-      expect(status).toEqual({
-        serviceName: 'test-service',
-        isRunning: true,
-        mqConnected: true,
-        registryConnected: true,
-        config: {
-          port: 3001,
-          prefetch: 10,
-          heartbeatInterval: 30000
-        }
-      });
-    });
-
-    test('should return status when not running', () => {
-      wrapper = new ServiceWrapper({
-        service: mockExpressApp,
-        serviceName: 'test-service',
-        openApiSpec: mockOpenApiSpec
-      });
-
-      const status = wrapper.getStatus();
-
-      expect(status).toEqual({
-        serviceName: 'test-service',
-        isRunning: false,
-        mqConnected: false,
-        registryConnected: false,
-        config: {
-          port: 3000,
-          prefetch: 10,
-          heartbeatInterval: 30000
-        }
-      });
-    });
-  });
-
-  describe('Heartbeat', () => {
-    beforeEach(() => {
-      jest.useFakeTimers();
-    });
-
-    afterEach(() => {
-      jest.useRealTimers();
-    });
-
-    test('should send heartbeats periodically', async () => {
-      wrapper = new ServiceWrapper({
-        service: mockExpressApp,
-        serviceName: 'test-service',
-        openApiSpec: mockOpenApiSpec,
-        config: { heartbeatInterval: 5000 }
-      });
-
-      await wrapper.start();
-
-      // Initially no heartbeats
-      expect(wrapper.registryClient.heartbeats).toHaveLength(0);
-
-      // Advance time
-      jest.advanceTimersByTime(5000);
-
-      // Wait for async heartbeat
-      await Promise.resolve();
-
-      expect(wrapper.registryClient.heartbeats.length).toBeGreaterThan(0);
-      expect(wrapper.registryClient.heartbeats[0].service).toBe('test-service');
-    });
-  });
-});