@onlineapps/service-wrapper 2.0.0

package/test/integration/orchestrator-integration.test.js

@@ -0,0 +1,170 @@
+#!/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();

package/test/mocks/connectors.js

@@ -0,0 +1,304 @@
+'use strict';
+
+/**
+ * Mock connectors for unit testing
+ * These mocks allow us to test ServiceWrapper in isolation
+ */
+
+// Mock MQ Connector
+class MockMQConnector {
+  constructor(config) {
+    this.config = config;
+    this.connected = false;
+    this.consumers = new Map();
+    this.publishedMessages = [];
+  }
+
+  async connect() {
+    this.connected = true;
+    return Promise.resolve();
+  }
+
+  async disconnect() {
+    this.connected = false;
+    return Promise.resolve();
+  }
+
+  isConnected() {
+    return this.connected;
+  }
+
+  async consume(handler, options) {
+    this.consumers.set(options.queue, handler);
+    return Promise.resolve();
+  }
+
+  async publish(queue, message) {
+    this.publishedMessages.push({ queue, message });
+    return Promise.resolve();
+  }
+
+  // Test helper - simulate message arrival
+  async simulateMessage(queue, message) {
+    const handler = this.consumers.get(queue);
+    if (handler) {
+      await handler(message);
+    }
+  }
+}
+
+// Mock Registry Connector
+class MockServiceRegistryClient {
+  constructor(config) {
+    this.config = config;
+    this.registeredServices = new Map();
+    this.heartbeats = [];
+    this.connected = true;
+  }
+
+  async register(serviceInfo) {
+    this.registeredServices.set(serviceInfo.name, serviceInfo);
+    return Promise.resolve();
+  }
+
+  async unregister(serviceName) {
+    this.registeredServices.delete(serviceName);
+    return Promise.resolve();
+  }
+
+  async sendHeartbeat(serviceName) {
+    this.heartbeats.push({ service: serviceName, timestamp: Date.now() });
+    return Promise.resolve();
+  }
+
+  isConnected() {
+    return this.connected;
+  }
+}
+
+// Mock Logger Connector
+class MockLogger {
+  constructor(serviceName) {
+    this.serviceName = serviceName;
+    this.logs = [];
+  }
+
+  _log(level, message, meta) {
+    this.logs.push({ level, message, meta, timestamp: Date.now() });
+  }
+
+  info(message, meta) {
+    this._log('info', message, meta);
+  }
+
+  warn(message, meta) {
+    this._log('warn', message, meta);
+  }
+
+  error(message, meta) {
+    this._log('error', message, meta);
+  }
+
+  debug(message, meta) {
+    this._log('debug', message, meta);
+  }
+
+  // Test helper
+  getLogsByLevel(level) {
+    return this.logs.filter(log => log.level === level);
+  }
+}
+
+// Add static create method to the class itself and as a property
+MockLogger.create = function(serviceName) {
+  return new MockLogger(serviceName);
+};
+
+// Mock Orchestrator Connector
+class MockWorkflowOrchestrator {
+  constructor(config) {
+    this.config = config;
+    this.processedMessages = [];
+    this.shouldFail = false;
+  }
+
+  async processWorkflowMessage(message, serviceName) {
+    this.processedMessages.push({ message, serviceName });
+
+    if (this.shouldFail) {
+      throw new Error('Mock processing failure');
+    }
+
+    return {
+      success: true,
+      workflow_id: message.workflow_id,
+      step_id: message.current_step,
+      result: { mocked: true }
+    };
+  }
+
+  // Test helper - make next processing fail
+  setNextProcessingToFail(shouldFail = true) {
+    this.shouldFail = shouldFail;
+  }
+}
+
+const MockOrchestratorConnector = {
+  create: (config) => new MockWorkflowOrchestrator(config)
+};
+
+// Mock API Mapper Connector
+class MockApiMapper {
+  constructor(config) {
+    this.config = config;
+    this.operations = new Map();
+  }
+
+  async callOperation(operationId, input, context) {
+    return {
+      operationId,
+      input,
+      context,
+      result: 'mocked'
+    };
+  }
+}
+
+const MockApiMapperConnector = {
+  create: (config) => new MockApiMapper(config)
+};
+
+// Mock Cookbook Connector
+const MockCookbookConnector = {
+  validateCookbook: (cookbook) => {
+    if (!cookbook || !cookbook.steps) {
+      throw new Error('Invalid cookbook');
+    }
+    return true;
+  },
+
+  createRouter: (mqClient, registryClient, options) => {
+    return {
+      routeToService: async (service, message) => {
+        return Promise.resolve();
+      },
+      routeToDLQ: async (cookbook, context, error, service) => {
+        return Promise.resolve();
+      }
+    };
+  },
+
+  CookbookExecutor: class {
+    constructor(cookbook, options) {
+      this.cookbook = cookbook;
+      this.options = options;
+      this.context = {
+        setInput: (input) => {},
+        data: { steps: {} }
+      };
+    }
+
+    async executeStep(step) {
+      return { executed: step.id };
+    }
+  },
+
+  CookbookGenerator: class {
+    constructor(options) {
+      this.options = options;
+    }
+
+    generate(openApiSpec) {
+      return { generated: true };
+    }
+  },
+
+  ResponseMapper: class {
+    mapResponse(response, mapping) {
+      return response;
+    }
+  }
+};
+
+/**
+ * MockCacheConnector - Simulates cache connector
+ */
+class MockCacheConnector {
+  constructor(options = {}) {
+    this.options = options;
+    this.connected = false;
+  }
+
+  async connect() {
+    this.connected = true;
+    return Promise.resolve();
+  }
+
+  async disconnect() {
+    this.connected = false;
+    return Promise.resolve();
+  }
+
+  async get(key) {
+    return null;
+  }
+
+  async set(key, value, ttl) {
+    return 'OK';
+  }
+
+  async del(key) {
+    return 1;
+  }
+
+  isConnected() {
+    return this.connected;
+  }
+}
+
+/**
+ * MockErrorHandlerConnector - Simulates error handler
+ */
+class MockErrorHandlerConnector {
+  constructor(options = {}) {
+    this.maxRetries = options.maxRetries || 3;
+    this.retryDelay = options.retryDelay || 1000;
+    this.logger = options.logger;
+  }
+
+  async executeWithRetry(fn, context = {}) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (this.logger) {
+        this.logger.error('Error in executeWithRetry', { error: error.message });
+      }
+      throw error;
+    }
+  }
+
+  handleError(error, context = {}) {
+    if (this.logger) {
+      this.logger.error('Handling error', { error: error.message, context });
+    }
+    return {
+      error: error.message,
+      retry: false
+    };
+  }
+
+  isRetryableError(error) {
+    return error.code === 'ECONNREFUSED' || error.code === 'ETIMEDOUT';
+  }
+}
+
+module.exports = {
+  MockMQConnector,
+  MockServiceRegistryClient,
+  MockLogger,
+  MockOrchestratorConnector,
+  MockApiMapperConnector,
+  MockCookbookConnector,
+  MockCacheConnector,
+  MockErrorHandlerConnector
+};

package/test/run-tests.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Test runner that uses mocked dependencies
+ * Allows us to test service-wrapper without actual connectors
+ */
+
+const path = require('path');
+
+// Setup module aliases for mocked connectors
+const mocks = require('./mocks/connectors');
+
+const Module = require('module');
+const originalRequire = Module.prototype.require;
+
+Module.prototype.require = function(id) {
+  // Intercept connector imports and return appropriate mocks
+  switch(id) {
+    case '@onlineapps/conn-infra-mq':
+      return mocks.MockMQConnector;
+    case '@onlineapps/conn-orch-registry':
+      return { ServiceRegistryClient: mocks.MockServiceRegistryClient };
+    case '@onlineapps/conn-base-logger':
+      return mocks.MockLogger;
+    case '@onlineapps/conn-orch-orchestrator':
+      return mocks.MockOrchestratorConnector;
+    case '@onlineapps/conn-orch-api-mapper':
+      return mocks.MockApiMapperConnector;
+    case '@onlineapps/conn-orch-cookbook':
+      return mocks.MockCookbookConnector;
+    case '@onlineapps/conn-base-cache':
+      return mocks.MockCacheConnector;
+    case '@onlineapps/conn-infra-error-handler':
+      return mocks.MockErrorHandlerConnector;
+    default:
+      return originalRequire.apply(this, arguments);
+  }
+};
+
+// Now we can test the ServiceWrapper with mocked dependencies
+console.log('Testing ServiceWrapper with mocked connectors...\n');
+
+// Test 1: Basic instantiation
+try {
+  const ServiceWrapper = require('../src/ServiceWrapper');
+  const wrapper = new ServiceWrapper({
+    service: function() {},
+    serviceName: 'test-service',
+    openApiSpec: { openapi: '3.0.0', paths: {} }
+  });
+  console.log('✓ ServiceWrapper instantiation works');
+} catch (error) {
+  console.log('✗ ServiceWrapper instantiation failed:', error.message);
+}
+
+// Test 2: Check what connectors are imported
+try {
+  const ServiceWrapper = require('../src/ServiceWrapper');
+  console.log('✓ All connector imports resolved');
+} catch (error) {
+  console.log('✗ Failed to import connectors:', error.message);
+}
+
+// Test 3: Test start/stop lifecycle
+async function testLifecycle() {
+  try {
+    const ServiceWrapper = require('../src/ServiceWrapper');
+    const wrapper = new ServiceWrapper({
+      service: function() {},
+      serviceName: 'test-service',
+      openApiSpec: { openapi: '3.0.0', paths: {} }
+    });
+
+    await wrapper.start();
+    console.log('✓ ServiceWrapper.start() works');
+
+    const status = wrapper.getStatus();
+    console.log('✓ ServiceWrapper.getStatus() returns:', status);
+
+    await wrapper.stop();
+    console.log('✓ ServiceWrapper.stop() works');
+  } catch (error) {
+    console.log('✗ Lifecycle test failed:', error.message);
+  }
+}
+
+// Test 4: Check for missing functionality
+function checkMissingFunctionality() {
+  console.log('\n=== Missing Functionality Check ===');
+
+  const missing = [];
+
+  // Check for cache connector
+  try {
+    require('@onlineapps/conn-base-cache');
+  } catch (e) {
+    missing.push('conn-base-cache');
+  }
+
+  // Check for error handler
+  try {
+    require('@onlineapps/conn-infra-error-handler');
+  } catch (e) {
+    missing.push('conn-infra-error-handler');
+  }
+
+  // Check cookbook connector exports
+  const cookbook = require('./mocks/connectors').MockCookbookConnector;
+  const requiredExports = ['validateCookbook', 'createRouter', 'CookbookExecutor', 'CookbookGenerator', 'ResponseMapper'];
+  const missingExports = requiredExports.filter(exp => !cookbook[exp]);
+
+  if (missingExports.length > 0) {
+    missing.push(`cookbook missing: ${missingExports.join(', ')}`);
+  }
+
+  if (missing.length > 0) {
+    console.log('Missing connectors/functionality:');
+    missing.forEach(m => console.log(`  - ${m}`));
+  } else {
+    console.log('All required functionality is available (mocked)');
+  }
+}
+
+// Run tests
+testLifecycle().then(() => {
+  checkMissingFunctionality();
+  console.log('\n=== Test Summary ===');
+  console.log('Service-wrapper is working as a thin orchestration layer!');
+  console.log('Next steps:');
+  console.log('1. Implement conn-base-cache connector');
+  console.log('2. Implement conn-infra-error-handler connector');
+  console.log('3. Fix cookbook connector exports');
+  console.log('4. Test with real connectors');
+});

package/test/setup.js

@@ -0,0 +1,31 @@
+'use strict';
+
+/**
+ * Jest setup file
+ * Configure test environment
+ */
+
+// Set test environment variables
+process.env.NODE_ENV = 'test';
+process.env.LOG_LEVEL = 'error'; // Reduce noise during tests
+
+// Global test timeout
+jest.setTimeout(10000);
+
+// Mock timers for tests that need them
+global.mockTimers = () => {
+  jest.useFakeTimers();
+};
+
+global.restoreTimers = () => {
+  jest.useRealTimers();
+};
+
+// Helper to wait for async operations
+global.waitForAsync = () => new Promise(resolve => setImmediate(resolve));
+
+// Suppress console errors in tests unless debugging
+if (!process.env.DEBUG_TESTS) {
+  global.console.error = jest.fn();
+  global.console.warn = jest.fn();
+}