@onlineapps/conn-orch-validator 2.0.0

package/src/TestOrchestrator.js

@@ -0,0 +1,727 @@
+'use strict';
+
+const ServiceValidator = require('./ServiceValidator');
+const WorkflowTestRunner = require('./WorkflowTestRunner');
+const ServiceTestHarness = require('./ServiceTestHarness');
+const ServiceReadinessValidator = require('./ServiceReadinessValidator');
+
+/**
+ * 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;
+    this.logger = options.logger || console;
+
+    // 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();
+      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
+    return {
+      serviceUrl: process.env.TEST_SERVICE_URL || `http://localhost:${process.env.PORT || 3000}`,
+      mqUrl: process.env.TEST_MQ_URL || process.env.RABBITMQ_URL,
+      registryUrl: process.env.TEST_REGISTRY_URL || 'http://localhost:8080',
+      storageUrl: process.env.TEST_STORAGE_URL || process.env.MINIO_URL,
+      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;