@onlineapps/service-wrapper 2.0.21 → 2.0.22

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

@@ -1,293 +0,0 @@
-'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 @e2e', () => {
-  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/tests/integration/orchestrator-integration.test.js

@@ -1,170 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Integration test for ServiceWrapper with OrchestratorConnector
- * Tests that the thin orchestration layer properly delegates to orchestrator
- */
-
-const path = require('path');
-
-// Mock setup
-const Module = require('module');
-const originalRequire = Module.prototype.require;
-
-// Create test doubles
-const testDoubles = {
-  processWorkflowMessage: null,
-  lastMessage: null,
-  lastServiceName: null
-};
-
-Module.prototype.require = function(id) {
-  switch(id) {
-    case '@onlineapps/conn-infra-mq':
-      return class MockMQ {
-        constructor() { this.connected = false; }
-        async connect() { this.connected = true; }
-        async disconnect() { this.connected = false; }
-        async consume(handler) { this.handler = handler; }
-        isConnected() { return this.connected; }
-      };
-
-    case '@onlineapps/conn-orch-registry':
-      return {
-        ServiceRegistryClient: class {
-          async register() { return true; }
-          async unregister() { return true; }
-          async sendHeartbeat() { return true; }
-          isConnected() { return true; }
-        }
-      };
-
-    case '@onlineapps/conn-base-logger':
-      return {
-        create: () => ({
-          info: () => {},
-          error: () => {},
-          warn: () => {},
-          debug: () => {}
-        })
-      };
-
-    case '@onlineapps/conn-orch-orchestrator':
-      return {
-        create: (options) => ({
-          processWorkflowMessage: async (message, serviceName) => {
-            testDoubles.lastMessage = message;
-            testDoubles.lastServiceName = serviceName;
-            testDoubles.processWorkflowMessage = true;
-            return { processed: true };
-          }
-        })
-      };
-
-    case '@onlineapps/conn-orch-api-mapper':
-      return { create: () => ({ map: () => {} }) };
-
-    case '@onlineapps/conn-orch-cookbook':
-      return { validateCookbook: () => true };
-
-    case '@onlineapps/conn-base-cache':
-      return class {
-        async connect() {}
-        async disconnect() {}
-      };
-
-    case '@onlineapps/conn-infra-error-handler':
-      return class {
-        constructor() {}
-      };
-
-    default:
-      return originalRequire.apply(this, arguments);
-  }
-};
-
-// Run test
-async function testOrchestratorIntegration() {
-  console.log('=== Orchestrator Integration Test ===\n');
-
-  try {
-    // Load ServiceWrapper with mocked dependencies
-    const ServiceWrapper = require('../../src/ServiceWrapper');
-
-    // Create instance
-    const wrapper = new ServiceWrapper({
-      service: function expressApp() {},
-      serviceName: 'test-service',
-      openApiSpec: {
-        openapi: '3.0.0',
-        info: { version: '1.0.0' },
-        paths: {}
-      },
-      config: {}
-    });
-
-    // Start wrapper
-    await wrapper.start();
-    console.log('✓ ServiceWrapper started');
-
-    // Get MQ client handler
-    const mqClient = wrapper.mqClient;
-    if (!mqClient.handler) {
-      throw new Error('No message handler registered');
-    }
-
-    // Simulate workflow message
-    const testMessage = {
-      workflow_id: 'wf-123',
-      current_step: {
-        id: 'step-1',
-        service: 'test-service',
-        operation: 'testOp',
-        input: { data: 'test' }
-      },
-      context: {
-        variables: {},
-        results: {}
-      }
-    };
-
-    // Process message through the handler
-    console.log('Sending test message to handler...');
-    await mqClient.handler(testMessage);
-
-    // Verify orchestrator was called
-    if (testDoubles.processWorkflowMessage) {
-      console.log('✓ Orchestrator.processWorkflowMessage was called');
-      console.log('✓ Message passed:', JSON.stringify(testDoubles.lastMessage, null, 2));
-      console.log('✓ Service name passed:', testDoubles.lastServiceName);
-
-      // Verify correct delegation
-      if (testDoubles.lastMessage === testMessage &&
-          testDoubles.lastServiceName === 'test-service') {
-        console.log('✓ Message and service name correctly delegated');
-      } else {
-        console.log('✗ Incorrect delegation parameters');
-      }
-    } else {
-      console.log('✗ Orchestrator.processWorkflowMessage was NOT called');
-    }
-
-    // Stop wrapper
-    await wrapper.stop();
-    console.log('✓ ServiceWrapper stopped');
-
-    console.log('\n=== Test Result ===');
-    console.log('✅ Orchestrator integration working correctly!');
-    console.log('ServiceWrapper properly delegates workflow messages to orchestrator.');
-
-  } catch (error) {
-    console.error('\n=== Test Failed ===');
-    console.error('✗ Error:', error.message);
-    console.error('Stack:', error.stack);
-    process.exit(1);
-  }
-}
-
-// Run the test
-testOrchestratorIntegration();