@onlineapps/conn-orch-validator 2.0.33 → 3.0.0

package/src/TestOrchestrator.js

@@ -1,736 +0,0 @@
-'use strict';
-
-const ServiceValidator = require('./ServiceValidator');
-const WorkflowTestRunner = require('./WorkflowTestRunner');
-const ServiceTestHarness = require('./ServiceTestHarness');
-const ServiceReadinessValidator = require('./ServiceReadinessValidator');
-const runtimeCfg = require('./config');
-
-/**
- * TestOrchestrator - Three-tier testing strategy
- * Level 1: Unit tests with full mocks
- * Level 2: Component tests with partial mocks
- * Level 3: Integration tests with real services
- */
-class TestOrchestrator {
-  constructor(options = {}) {
-    this.service = options.service;
-    this.serviceName = options.serviceName;
-    this.openApiSpec = options.openApiSpec;
-    if (!options.logger || typeof options.logger.warn !== 'function') {
-      throw new Error('[TestOrchestrator] Logger is required — Expected object with warn() method');
-    }
-    this.logger = options.logger;
-    if (!options.integrationConfig) {
-      throw new Error('[TestOrchestrator] integrationConfig is required');
-    }
-    this.integrationConfig = options.integrationConfig;
-
-    // Test configuration
-    this.testLevels = {
-      unit: {
-        useMocks: true,
-        useTestQueues: false,
-        useRealServices: false
-      },
-      component: {
-        useMocks: true,
-        useTestQueues: true,
-        useRealServices: false
-      },
-      integration: {
-        useMocks: false,
-        useTestQueues: true,
-        useRealServices: true
-      }
-    };
-
-    // Test suites
-    this.testSuites = {
-      unit: [],
-      component: [],
-      integration: []
-    };
-
-    // Results
-    this.results = {
-      unit: null,
-      component: null,
-      integration: null
-    };
-  }
-
-  /**
-   * Run all test levels
-   */
-  async runAllTests() {
-    const results = {
-      timestamp: Date.now(),
-      service: this.serviceName,
-      levels: {}
-    };
-
-    // Level 1: Unit Tests
-    this.logger.info('Starting Level 1: Unit Tests (full mocks)...');
-    results.levels.unit = await this.runUnitTests();
-
-    if (!results.levels.unit.passed) {
-      results.recommendation = 'Failed at unit test level - fix basic functionality';
-      return results;
-    }
-
-    // Level 2: Component Tests
-    this.logger.info('Starting Level 2: Component Tests (partial mocks + test queues)...');
-    results.levels.component = await this.runComponentTests();
-
-    if (!results.levels.component.passed) {
-      results.recommendation = 'Failed at component test level - fix integration issues';
-      return results;
-    }
-
-    // Level 3: Integration Tests
-    this.logger.info('Starting Level 3: Integration Tests (real services + test queues)...');
-    results.levels.integration = await this.runIntegrationTests();
-
-    if (!results.levels.integration.passed) {
-      results.recommendation = 'Failed at integration level - service not production ready';
-      return results;
-    }
-
-    results.passed = true;
-    results.recommendation = 'All test levels passed - service is production ready';
-    return results;
-  }
-
-  /**
-   * Level 1: Unit Tests with full mocks
-   */
-  async runUnitTests() {
-    const results = {
-      level: 'unit',
-      passed: true,
-      tests: [],
-      coverage: 0
-    };
-
-    try {
-      // Create test harness with full mocks
-      const harness = new ServiceTestHarness({
-        service: this.service,
-        serviceName: this.serviceName,
-        openApiSpec: this.openApiSpec,
-        mockInfrastructure: true
-      });
-
-      await harness.start();
-
-      // Test 1: Service starts and responds
-      const startTest = await this.testServiceStart(harness);
-      results.tests.push(startTest);
-      if (!startTest.passed) results.passed = false;
-
-      // Test 2: API endpoints exist
-      const endpointTest = await this.testEndpointsExist(harness);
-      results.tests.push(endpointTest);
-      if (!endpointTest.passed) results.passed = false;
-
-      // Test 3: Health check works
-      const healthTest = await this.testHealthCheck(harness);
-      results.tests.push(healthTest);
-      if (!healthTest.passed) results.passed = false;
-
-      // Test 4: Can handle mock messages
-      const messageTest = await this.testMockMessageHandling(harness);
-      results.tests.push(messageTest);
-      if (!messageTest.passed) results.passed = false;
-
-      await harness.stop();
-
-      // Calculate coverage
-      const passedTests = results.tests.filter(t => t.passed).length;
-      results.coverage = (passedTests / results.tests.length) * 100;
-
-    } catch (error) {
-      results.passed = false;
-      results.error = error.message;
-    }
-
-    return results;
-  }
-
-  /**
-   * Level 2: Component Tests with test queues
-   */
-  async runComponentTests() {
-    const results = {
-      level: 'component',
-      passed: true,
-      tests: [],
-      coverage: 0
-    };
-
-    try {
-      // Create test harness with test queues
-      const harness = new ServiceTestHarness({
-        service: this.service,
-        serviceName: this.serviceName,
-        openApiSpec: this.openApiSpec,
-        mockInfrastructure: true // Still use mocks but with test queue names
-      });
-
-      // Configure test queues
-      this.configureTestQueues(harness);
-
-      await harness.start();
-
-      // Test 1: OpenAPI compliance
-      const openApiTest = await this.testOpenApiCompliance(harness);
-      results.tests.push(openApiTest);
-      if (!openApiTest.passed) results.passed = false;
-
-      // Test 2: Workflow execution
-      const workflowTest = await this.testWorkflowExecution(harness);
-      results.tests.push(workflowTest);
-      if (!workflowTest.passed) results.passed = false;
-
-      // Test 3: Message routing
-      const routingTest = await this.testMessageRouting(harness);
-      results.tests.push(routingTest);
-      if (!routingTest.passed) results.passed = false;
-
-      // Test 4: Error handling
-      const errorTest = await this.testErrorHandling(harness);
-      results.tests.push(errorTest);
-      if (!errorTest.passed) results.passed = false;
-
-      await harness.stop();
-
-      // Calculate coverage
-      const passedTests = results.tests.filter(t => t.passed).length;
-      results.coverage = (passedTests / results.tests.length) * 100;
-
-    } catch (error) {
-      results.passed = false;
-      results.error = error.message;
-    }
-
-    return results;
-  }
-
-  /**
-   * Level 3: Integration Tests with real services
-   */
-  async runIntegrationTests() {
-    const results = {
-      level: 'integration',
-      passed: true,
-      tests: [],
-      coverage: 0
-    };
-
-    try {
-      // Use real infrastructure with test configuration
-      const config = this.getIntegrationTestConfig();
-
-      // Run readiness validator (uses real endpoints)
-      const validator = new ServiceReadinessValidator({ logger: this.logger });
-      const readinessTest = await validator.validateReadiness({
-        name: this.serviceName,
-        url: config.serviceUrl,
-        openApiSpec: this.openApiSpec,
-        registry: config.registry,
-        testCookbook: this.getTestCookbook(),
-        healthEndpoint: '/health'
-      });
-
-      results.tests.push({
-        name: 'Service Readiness',
-        passed: readinessTest.ready,
-        score: readinessTest.score,
-        details: readinessTest
-      });
-
-      if (!readinessTest.ready) {
-        results.passed = false;
-      }
-
-      // Test with real message queue (test exchange)
-      if (config.mqUrl) {
-        const mqTest = await this.testRealMessageQueue(config);
-        results.tests.push(mqTest);
-        if (!mqTest.passed) results.passed = false;
-      }
-
-      // Test with real registry (test environment)
-      if (config.registryUrl) {
-        const registryTest = await this.testRealRegistry(config);
-        results.tests.push(registryTest);
-        if (!registryTest.passed) results.passed = false;
-      }
-
-      // Test end-to-end workflow
-      const e2eTest = await this.testEndToEndWorkflow(config);
-      results.tests.push(e2eTest);
-      if (!e2eTest.passed) results.passed = false;
-
-      // Calculate coverage
-      const passedTests = results.tests.filter(t => t.passed).length;
-      results.coverage = (passedTests / results.tests.length) * 100;
-
-    } catch (error) {
-      results.passed = false;
-      results.error = error.message;
-    }
-
-    return results;
-  }
-
-  // === Unit Test Methods ===
-
-  async testServiceStart(harness) {
-    try {
-      const isRunning = harness.isRunning;
-      return {
-        name: 'Service Start',
-        passed: isRunning,
-        message: isRunning ? 'Service started successfully' : 'Service failed to start'
-      };
-    } catch (error) {
-      return {
-        name: 'Service Start',
-        passed: false,
-        error: error.message
-      };
-    }
-  }
-
-  async testEndpointsExist(harness) {
-    try {
-      const endpoints = this.extractEndpoints(this.openApiSpec);
-      const tested = [];
-
-      for (const endpoint of endpoints.slice(0, 3)) { // Test first 3
-        try {
-          await harness.callApi(endpoint.method, endpoint.path);
-          tested.push({ path: endpoint.path, exists: true });
-        } catch {
-          tested.push({ path: endpoint.path, exists: false });
-        }
-      }
-
-      const passed = tested.every(t => t.exists);
-      return {
-        name: 'Endpoints Exist',
-        passed,
-        tested,
-        message: `${tested.filter(t => t.exists).length}/${tested.length} endpoints exist`
-      };
-    } catch (error) {
-      return {
-        name: 'Endpoints Exist',
-        passed: false,
-        error: error.message
-      };
-    }
-  }
-
-  async testHealthCheck(harness) {
-    try {
-      const response = await harness.callApi('GET', '/health');
-      const passed = response && response.status === 'healthy';
-      return {
-        name: 'Health Check',
-        passed,
-        response,
-        message: passed ? 'Health check passed' : 'Health check failed'
-      };
-    } catch (error) {
-      return {
-        name: 'Health Check',
-        passed: false,
-        error: error.message
-      };
-    }
-  }
-
-  async testMockMessageHandling(harness) {
-    try {
-      const message = {
-        workflow_id: 'test-123',
-        step: 'test-step',
-        data: { test: true }
-      };
-
-      await harness.mqClient.publish('test-queue', message);
-      const published = harness.getPublishedMessages('test-queue');
-
-      const passed = published.length > 0;
-      return {
-        name: 'Mock Message Handling',
-        passed,
-        messagesHandled: published.length,
-        message: `Handled ${published.length} messages`
-      };
-    } catch (error) {
-      return {
-        name: 'Mock Message Handling',
-        passed: false,
-        error: error.message
-      };
-    }
-  }
-
-  // === Component Test Methods ===
-
-  async testOpenApiCompliance(harness) {
-    try {
-      const validator = new ServiceValidator();
-      const result = await validator.validateService(
-        harness.baseUrl,
-        this.openApiSpec
-      );
-
-      return {
-        name: 'OpenAPI Compliance',
-        passed: result.valid,
-        coverage: result.coverage,
-        errors: result.errors,
-        message: `${result.coverage}% endpoint coverage`
-      };
-    } catch (error) {
-      return {
-        name: 'OpenAPI Compliance',
-        passed: false,
-        error: error.message
-      };
-    }
-  }
-
-  async testWorkflowExecution(harness) {
-    try {
-      const cookbook = this.getTestCookbook();
-      const result = await harness.simulateWorkflow(cookbook);
-
-      return {
-        name: 'Workflow Execution',
-        passed: result.completed,
-        stepsExecuted: result.results.length,
-        message: `Executed ${result.results.length} workflow steps`
-      };
-    } catch (error) {
-      return {
-        name: 'Workflow Execution',
-        passed: false,
-        error: error.message
-      };
-    }
-  }
-
-  async testMessageRouting(harness) {
-    try {
-      // Publish to different queues
-      await harness.mqClient.publish('test.service.request', { type: 'request' });
-      await harness.mqClient.publish('test.service.response', { type: 'response' });
-      await harness.mqClient.publish('test.workflow.event', { type: 'event' });
-
-      const requests = harness.getPublishedMessages('test.service.request');
-      const responses = harness.getPublishedMessages('test.service.response');
-      const events = harness.getPublishedMessages('test.workflow.event');
-
-      const passed = requests.length > 0 && responses.length > 0 && events.length > 0;
-
-      return {
-        name: 'Message Routing',
-        passed,
-        queues: {
-          requests: requests.length,
-          responses: responses.length,
-          events: events.length
-        },
-        message: 'Message routing working correctly'
-      };
-    } catch (error) {
-      return {
-        name: 'Message Routing',
-        passed: false,
-        error: error.message
-      };
-    }
-  }
-
-  async testErrorHandling(harness) {
-    try {
-      // Test various error scenarios
-      const errors = [];
-
-      // Invalid endpoint
-      try {
-        await harness.callApi('GET', '/non-existent');
-      } catch (e) {
-        errors.push('Handled 404 correctly');
-      }
-
-      // Invalid payload
-      try {
-        await harness.callApi('POST', '/api/endpoint', 'invalid-json');
-      } catch (e) {
-        errors.push('Handled invalid JSON');
-      }
-
-      const passed = errors.length >= 1;
-
-      return {
-        name: 'Error Handling',
-        passed,
-        errorsHandled: errors.length,
-        details: errors,
-        message: `Handled ${errors.length} error scenarios`
-      };
-    } catch (error) {
-      return {
-        name: 'Error Handling',
-        passed: false,
-        error: error.message
-      };
-    }
-  }
-
-  // === Integration Test Methods ===
-
-  async testRealMessageQueue(config) {
-    try {
-      const MQClient = require('@onlineapps/connector-mq-client');
-      const mqClient = new MQClient({
-        url: config.mqUrl,
-        queue: `test.${this.serviceName}`,
-        exchange: 'test.exchange'
-      });
-
-      await mqClient.connect();
-
-      const testMessage = {
-        test: true,
-        timestamp: Date.now(),
-        service: this.serviceName
-      };
-
-      await mqClient.publish(`test.${this.serviceName}`, testMessage);
-
-      // Set up consumer to verify
-      let received = false;
-      await mqClient.consume(`test.${this.serviceName}`, (msg) => {
-        const content = JSON.parse(msg.content.toString());
-        if (content.test && content.service === this.serviceName) {
-          received = true;
-        }
-        mqClient.ack(msg);
-      });
-
-      // Wait for message
-      await new Promise(resolve => setTimeout(resolve, 1000));
-
-      await mqClient.disconnect();
-
-      return {
-        name: 'Real Message Queue',
-        passed: received,
-        message: received ? 'Successfully sent and received test message' : 'Message not received'
-      };
-    } catch (error) {
-      return {
-        name: 'Real Message Queue',
-        passed: false,
-        error: error.message
-      };
-    }
-  }
-
-  async testRealRegistry(config) {
-    try {
-      // Test registration with real registry
-      const response = await require('axios').post(
-        `${config.registryUrl}/register`,
-        {
-          name: `test-${this.serviceName}`,
-          version: '1.0.0-test',
-          url: config.serviceUrl,
-          openapi: this.openApiSpec
-        }
-      );
-
-      const passed = response.status === 200;
-
-      // Clean up test registration
-      if (passed) {
-        await require('axios').delete(
-          `${config.registryUrl}/unregister/test-${this.serviceName}`
-        );
-      }
-
-      return {
-        name: 'Real Registry',
-        passed,
-        message: 'Successfully registered and unregistered with real registry'
-      };
-    } catch (error) {
-      return {
-        name: 'Real Registry',
-        passed: false,
-        error: error.message
-      };
-    }
-  }
-
-  async testEndToEndWorkflow(config) {
-    try {
-      // Create real workflow runner
-      const runner = new WorkflowTestRunner({
-        mqClient: config.mqClient,
-        registry: config.registry,
-        timeout: 30000
-      });
-
-      const cookbook = this.getTestCookbook();
-      const workflow = await runner.runWorkflow(cookbook, {
-        test: true,
-        service: this.serviceName
-      });
-
-      const passed = workflow.status === 'completed';
-
-      return {
-        name: 'End-to-End Workflow',
-        passed,
-        workflowId: workflow.id,
-        status: workflow.status,
-        steps: workflow.results.length,
-        message: `Workflow ${workflow.status} with ${workflow.results.length} steps`
-      };
-    } catch (error) {
-      return {
-        name: 'End-to-End Workflow',
-        passed: false,
-        error: error.message
-      };
-    }
-  }
-
-  // === Helper Methods ===
-
-  configureTestQueues(harness) {
-    // Configure test queue names
-    const testQueues = {
-      request: `test.${this.serviceName}.request`,
-      response: `test.${this.serviceName}.response`,
-      workflow: `test.workflow.${this.serviceName}`,
-      dlq: `test.${this.serviceName}.dlq`
-    };
-
-    // Apply to mock MQ client
-    if (harness.mqClient) {
-      harness.mqClient.testQueues = testQueues;
-    }
-
-    return testQueues;
-  }
-
-  getIntegrationTestConfig() {
-    // Get configuration for integration tests
-    const resolved = runtimeCfg.resolve(this.integrationConfig);
-    return {
-      serviceUrl: resolved.serviceUrl,
-      mqUrl: resolved.mqUrl,
-      registryUrl: resolved.registryUrl,
-      storageUrl: resolved.storageUrl,
-      registry: null, // Would be real registry instance
-      mqClient: null  // Would be real MQ client instance
-    };
-  }
-
-  getTestCookbook() {
-    // Generate test cookbook based on service OpenAPI
-    const steps = [];
-
-    if (this.openApiSpec?.paths) {
-      const endpoints = this.extractEndpoints(this.openApiSpec);
-
-      // Add first few endpoints as test steps
-      endpoints.slice(0, 3).forEach((endpoint, index) => {
-        steps.push({
-          id: `test-step-${index}`,
-          type: 'task',
-          service: this.serviceName,
-          operation: endpoint.operation?.operationId || endpoint.path,
-          input: {}
-        });
-      });
-    }
-
-    return {
-      version: '1.0.0',
-      steps: steps.length > 0 ? steps : [
-        {
-          id: 'default-step',
-          type: 'task',
-          service: this.serviceName,
-          operation: 'health',
-          input: {}
-        }
-      ]
-    };
-  }
-
-  extractEndpoints(openApiSpec) {
-    const endpoints = [];
-    if (!openApiSpec?.paths) return endpoints;
-
-    for (const [path, pathItem] of Object.entries(openApiSpec.paths)) {
-      for (const [method, operation] of Object.entries(pathItem)) {
-        if (method !== 'parameters' && !method.startsWith('x-')) {
-          endpoints.push({ path, method, operation });
-        }
-      }
-    }
-
-    return endpoints;
-  }
-
-  /**
-   * Generate test report
-   */
-  generateReport(results) {
-    const report = [];
-
-    report.push('=== Test Orchestration Report ===');
-    report.push(`Service: ${results.service}`);
-    report.push(`Timestamp: ${new Date(results.timestamp).toISOString()}`);
-    report.push('');
-
-    // Level results
-    for (const [level, levelResults] of Object.entries(results.levels)) {
-      report.push(`Level: ${level.toUpperCase()}`);
-      report.push(`  Passed: ${levelResults.passed ? 'YES' : 'NO'}`);
-      report.push(`  Coverage: ${levelResults.coverage}%`);
-      report.push(`  Tests: ${levelResults.tests.length}`);
-
-      if (levelResults.tests) {
-        levelResults.tests.forEach(test => {
-          const status = test.passed ? '✓' : '✗';
-          report.push(`    ${status} ${test.name}`);
-        });
-      }
-
-      if (levelResults.error) {
-        report.push(`  Error: ${levelResults.error}`);
-      }
-      report.push('');
-    }
-
-    report.push(`Overall: ${results.passed ? 'PASSED' : 'FAILED'}`);
-    report.push(`Recommendation: ${results.recommendation}`);
-
-    return report.join('\n');
-  }
-}
-
-module.exports = TestOrchestrator;