@onlineapps/service-wrapper 2.0.6 → 2.0.8

package/test/e2e/full-flow.test.js

@@ -0,0 +1,293 @@
+'use strict';
+
+/**
+ * End-to-End Integration Tests for ServiceWrapper
+ * Tests the complete flow: MQ → ServiceWrapper → HTTP Service → Response
+ */
+
+const ServiceWrapper = require('../../src/ServiceWrapper');
+const MQConnector = require('@onlineapps/conn-infra-mq');
+const express = require('express');
+const http = require('http');
+
+describe('ServiceWrapper E2E Tests', () => {
+  let testService;
+  let testServer;
+  let serviceWrapper;
+  let mqClient;
+  let servicePort;
+  const serviceName = 'test-service';
+  const rabbitUrl = process.env.RABBITMQ_URL || 'amqp://guest:guest@localhost:33023';
+
+  beforeAll(async () => {
+    // 1. Create test HTTP service
+    testService = express();
+    testService.use(express.json());
+
+    // Add test endpoints
+    testService.post('/test/hello', (req, res) => {
+      res.json({
+        message: `Hello ${req.body.name}`,
+        timestamp: new Date().toISOString()
+      });
+    });
+
+    testService.post('/test/error', (req, res) => {
+      res.status(500).json({ error: 'Test error' });
+    });
+
+    testService.get('/health', (req, res) => {
+      res.json({ status: 'ok' });
+    });
+
+    // Start test service
+    servicePort = 40000 + Math.floor(Math.random() * 1000);
+    testServer = http.createServer(testService);
+    await new Promise(resolve => {
+      testServer.listen(servicePort, resolve);
+    });
+
+    // 2. Create OpenAPI spec
+    const openApiSpec = {
+      openapi: '3.0.0',
+      info: {
+        title: 'Test Service',
+        version: '1.0.0'
+      },
+      paths: {
+        '/test/hello': {
+          post: {
+            operationId: 'sayHello',
+            requestBody: {
+              content: {
+                'application/json': {
+                  schema: {
+                    type: 'object',
+                    properties: {
+                      name: { type: 'string' }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        '/test/error': {
+          post: {
+            operationId: 'triggerError'
+          }
+        }
+      }
+    };
+
+    // 3. Initialize ServiceWrapper
+    serviceWrapper = new ServiceWrapper({
+      serviceUrl: `http://localhost:${servicePort}`,
+      serviceName,
+      openApiSpec,
+      config: {
+        rabbitmq: rabbitUrl,
+        heartbeatInterval: 60000, // Long interval for tests
+        directCall: false // Force HTTP calls
+      }
+    });
+
+    // 4. Initialize MQ client for sending test messages
+    mqClient = new MQConnector({
+      type: 'rabbitmq',
+      host: rabbitUrl,
+      queue: `${serviceName}.workflow`,
+      durable: true
+    });
+    await mqClient.connect();
+
+    // 5. Start wrapper (with timeout for registration)
+    await serviceWrapper.start();
+  }, 60000); // 60s timeout for setup
+
+  afterAll(async () => {
+    // Cleanup
+    if (serviceWrapper) {
+      await serviceWrapper.stop();
+    }
+    if (mqClient) {
+      await mqClient.disconnect();
+    }
+    if (testServer) {
+      await new Promise(resolve => testServer.close(resolve));
+    }
+  });
+
+  describe('Basic Message Flow', () => {
+    test('should process simple workflow message', async () => {
+      const testMessage = {
+        workflow_id: 'test-workflow-1',
+        current_step: {
+          service: serviceName,
+          operation: 'sayHello',
+          input: {
+            name: 'World'
+          }
+        }
+      };
+
+      // Send message to queue
+      await mqClient.publish(testMessage);
+
+      // Wait for processing
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      // Verify by checking service logs or response queue
+      // Note: In real test, we'd capture response through response queue
+      expect(true).toBe(true); // Placeholder
+    });
+
+    test('should handle error responses', async () => {
+      const testMessage = {
+        workflow_id: 'test-workflow-2',
+        current_step: {
+          service: serviceName,
+          operation: 'triggerError',
+          input: {}
+        }
+      };
+
+      await mqClient.publish(testMessage);
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      // Verify error handling
+      expect(true).toBe(true); // Placeholder
+    });
+  });
+
+  describe('Workflow Orchestration', () => {
+    test('should process multi-step workflow', async () => {
+      const workflow = {
+        workflow_id: 'multi-step-1',
+        steps: [
+          {
+            service: serviceName,
+            operation: 'sayHello',
+            input: { name: 'Step1' }
+          },
+          {
+            service: serviceName,
+            operation: 'sayHello',
+            input: { name: 'Step2' }
+          }
+        ],
+        current_step: {
+          service: serviceName,
+          operation: 'sayHello',
+          input: { name: 'Step1' }
+        }
+      };
+
+      await mqClient.publish(workflow);
+      await new Promise(resolve => setTimeout(resolve, 3000));
+
+      expect(true).toBe(true); // Placeholder
+    });
+  });
+
+  describe('Error Handling & Recovery', () => {
+    test('should retry on transient failures', async () => {
+      // Test retry logic
+      const testMessage = {
+        workflow_id: 'retry-test-1',
+        current_step: {
+          service: serviceName,
+          operation: 'triggerError',
+          input: {},
+          retry_count: 0,
+          max_retries: 3
+        }
+      };
+
+      await mqClient.publish(testMessage);
+      await new Promise(resolve => setTimeout(resolve, 5000));
+
+      // Verify retries occurred
+      expect(true).toBe(true); // Placeholder
+    });
+
+    test('should handle circuit breaker', async () => {
+      // Send multiple failing requests to trigger circuit breaker
+      for (let i = 0; i < 5; i++) {
+        await mqClient.publish({
+          workflow_id: `circuit-test-${i}`,
+          current_step: {
+            service: serviceName,
+            operation: 'triggerError',
+            input: {}
+          }
+        });
+      }
+
+      await new Promise(resolve => setTimeout(resolve, 3000));
+
+      // Verify circuit breaker activated
+      expect(true).toBe(true); // Placeholder
+    });
+  });
+
+  describe('Performance & Load Testing', () => {
+    test('should handle concurrent messages', async () => {
+      const messages = [];
+      for (let i = 0; i < 10; i++) {
+        messages.push({
+          workflow_id: `concurrent-${i}`,
+          current_step: {
+            service: serviceName,
+            operation: 'sayHello',
+            input: { name: `User${i}` }
+          }
+        });
+      }
+
+      // Send all messages concurrently
+      await Promise.all(messages.map(msg => mqClient.publish(msg)));
+
+      // Wait for all to process
+      await new Promise(resolve => setTimeout(resolve, 5000));
+
+      expect(true).toBe(true); // Placeholder
+    });
+
+    test('should respect prefetch limit', async () => {
+      // Send more messages than prefetch limit
+      const messages = [];
+      for (let i = 0; i < 20; i++) {
+        messages.push({
+          workflow_id: `prefetch-${i}`,
+          current_step: {
+            service: serviceName,
+            operation: 'sayHello',
+            input: { name: `Batch${i}` }
+          }
+        });
+      }
+
+      await Promise.all(messages.map(msg => mqClient.publish(msg)));
+      await new Promise(resolve => setTimeout(resolve, 10000));
+
+      // Verify prefetch was respected
+      expect(true).toBe(true); // Placeholder
+    });
+  });
+
+  describe('Registry Integration', () => {
+    test('should register service on startup', () => {
+      // Verify service was registered
+      expect(serviceWrapper.isRunning).toBe(true);
+    });
+
+    test('should send heartbeats', async () => {
+      // Wait for at least one heartbeat
+      await new Promise(resolve => setTimeout(resolve, 5000));
+
+      // Verify heartbeat was sent (check logs or registry)
+      expect(true).toBe(true); // Placeholder
+    });
+  });
+});

package/test/monitoring-integration.test.js

@@ -0,0 +1,150 @@
+/**
+ * Test monitoring integration in service-wrapper
+ */
+
+describe('ServiceWrapper Monitoring Integration', () => {
+  let ServiceWrapper;
+  let express;
+
+  beforeEach(() => {
+    // Reset modules
+    jest.resetModules();
+
+    // Mock dependencies
+    jest.mock('@onlineapps/conn-infra-mq', () => {
+      return jest.fn().mockImplementation(() => ({
+        connect: jest.fn().mockResolvedValue(true),
+        disconnect: jest.fn().mockResolvedValue(true),
+        consume: jest.fn().mockResolvedValue(true),
+        isConnected: jest.fn().mockReturnValue(true)
+      }));
+    });
+
+    jest.mock('@onlineapps/conn-orch-registry', () => ({
+      ServiceRegistryClient: jest.fn().mockImplementation(() => ({
+        register: jest.fn().mockResolvedValue(true),
+        unregister: jest.fn().mockResolvedValue(true),
+        sendHeartbeat: jest.fn().mockResolvedValue(true),
+        isConnected: jest.fn().mockReturnValue(true)
+      }))
+    }));
+
+    jest.mock('@onlineapps/conn-base-monitoring', () => ({
+      init: jest.fn().mockResolvedValue({
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+        debug: jest.fn()
+      }),
+      info: jest.fn(),
+      warn: jest.fn(),
+      error: jest.fn(),
+      debug: jest.fn()
+    }));
+
+    jest.mock('@onlineapps/conn-orch-orchestrator', () => ({
+      create: jest.fn().mockReturnValue({
+        processWorkflowMessage: jest.fn().mockResolvedValue({ success: true })
+      })
+    }));
+
+    jest.mock('@onlineapps/conn-orch-api-mapper', () => ({
+      create: jest.fn().mockReturnValue({})
+    }));
+
+    jest.mock('@onlineapps/conn-orch-cookbook', () => ({}));
+    jest.mock('@onlineapps/conn-base-cache', () => jest.fn());
+    jest.mock('@onlineapps/conn-infra-error-handler', () => jest.fn());
+
+    ServiceWrapper = require('../src/ServiceWrapper');
+    express = require('express');
+  });
+
+  test('should initialize monitoring on start', async () => {
+    const app = express();
+    const monitoring = require('@onlineapps/conn-base-monitoring');
+
+    const wrapper = new ServiceWrapper({
+      service: app,
+      serviceName: 'test-service',
+      openApiSpec: { info: { version: '1.0.0' } },
+      config: {}
+    });
+
+    await wrapper.start();
+
+    expect(monitoring.init).toHaveBeenCalledWith({
+      serviceName: 'test-service'
+    });
+
+    expect(wrapper.logger).toBeDefined();
+    expect(wrapper.monitoring).toBeDefined();
+  });
+
+  test('should use monitoring for logging', async () => {
+    const app = express();
+    const wrapper = new ServiceWrapper({
+      service: app,
+      serviceName: 'test-service',
+      openApiSpec: { info: { version: '1.0.0' } },
+      config: {}
+    });
+
+    await wrapper.start();
+
+    // Test logger methods are available
+    expect(wrapper.logger.info).toBeDefined();
+    expect(wrapper.logger.error).toBeDefined();
+    expect(wrapper.logger.warn).toBeDefined();
+    expect(wrapper.logger.debug).toBeDefined();
+
+    // Test logger is used
+    wrapper.logger.info('Test message', { data: 'test' });
+    wrapper.logger.error('Error message', { error: 'test' });
+  });
+
+  test('should pass monitoring to orchestrator', async () => {
+    const app = express();
+    const OrchestratorConnector = require('@onlineapps/conn-orch-orchestrator');
+
+    const wrapper = new ServiceWrapper({
+      service: app,
+      serviceName: 'test-service',
+      openApiSpec: { info: { version: '1.0.0' } },
+      config: {}
+    });
+
+    await wrapper.start();
+
+    expect(OrchestratorConnector.create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        logger: expect.objectContaining({
+          info: expect.any(Function),
+          error: expect.any(Function),
+          warn: expect.any(Function),
+          debug: expect.any(Function)
+        })
+      })
+    );
+  });
+
+  test('should handle monitoring mode from config', async () => {
+    const app = express();
+    const monitoring = require('@onlineapps/conn-base-monitoring');
+
+    const wrapper = new ServiceWrapper({
+      service: app,
+      serviceName: 'test-service',
+      openApiSpec: { info: { version: '1.0.0' } },
+      config: {
+        monitoringMode: 'debug'
+      }
+    });
+
+    await wrapper.start();
+
+    // Monitoring should be initialized but mode is not passed
+    // because ServiceWrapper doesn't pass it through yet
+    expect(monitoring.init).toHaveBeenCalled();
+  });
+});