@onlineapps/service-wrapper 2.0.20 → 2.0.22

package/tests/mocks/connectors.js

@@ -1,304 +0,0 @@
-'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/tests/monitoring-integration.test.js

@@ -1,150 +0,0 @@
-/**
- * Test monitoring integration in service-wrapper
- */
-
-describe('ServiceWrapper Monitoring Integration @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();
-  });
-});

package/tests/run-tests.js

@@ -1,135 +0,0 @@
-#!/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/tests/setup.js

@@ -1,31 +0,0 @@
-'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();
-}