@onlineapps/conn-orch-validator 2.0.32 → 2.0.34

package/examples/service-wrapper-usage.js

@@ -1,250 +0,0 @@
-'use strict';
-
-/**
- * Example: How service-wrapper uses connector-testing
- * Shows the integration between service-wrapper and testing framework
- */
-
-const { ServiceReadinessValidator, TestOrchestrator } = require('../src');
-
-/**
- * Enhanced ServiceWrapper with integrated testing
- */
-class ServiceWrapperWithTesting {
-  constructor(options) {
-    this.service = options.service;
-    this.serviceName = options.serviceName;
-    this.openApiSpec = options.openApiSpec;
-    this.config = options.config;
-
-    // Testing configuration
-    this.testingEnabled = options.testingEnabled !== false;
-    this.testLevel = options.testLevel || 'component'; // unit, component, or integration
-    this.validator = new ServiceReadinessValidator();
-  }
-
-  /**
-   * Start service with validation
-   */
-  async start() {
-    console.log(`Starting ${this.serviceName}...`);
-
-    // Step 1: Pre-start validation
-    if (this.testingEnabled) {
-      const validation = await this.validateBeforeStart();
-
-      if (!validation.ready) {
-        throw new Error(`Service validation failed: ${validation.recommendation}`);
-      }
-
-      console.log(`Validation passed with score: ${validation.score}/100`);
-    }
-
-    // Step 2: Start the actual service
-    await this.startService();
-
-    // Step 3: Post-start verification
-    if (this.testingEnabled) {
-      await this.verifyAfterStart();
-    }
-
-    console.log(`${this.serviceName} started successfully`);
-  }
-
-  /**
-   * Validate service before starting
-   */
-  async validateBeforeStart() {
-    console.log('Running pre-start validation...');
-
-    // Use TestOrchestrator for comprehensive testing
-    const orchestrator = new TestOrchestrator({
-      service: this.service,
-      serviceName: this.serviceName,
-      openApiSpec: this.openApiSpec
-    });
-
-    // Run tests based on configured level
-    let testResults;
-    switch (this.testLevel) {
-      case 'unit':
-        testResults = await orchestrator.runUnitTests();
-        break;
-      case 'component':
-        testResults = await orchestrator.runComponentTests();
-        break;
-      case 'integration':
-        testResults = await orchestrator.runIntegrationTests();
-        break;
-      default:
-        testResults = await orchestrator.runComponentTests();
-    }
-
-    // Convert test results to readiness format
-    return {
-      ready: testResults.passed,
-      score: testResults.coverage || 0,
-      recommendation: testResults.passed
-        ? 'Service passed validation'
-        : 'Service failed validation tests',
-      details: testResults
-    };
-  }
-
-  /**
-   * Start the actual service
-   */
-  async startService() {
-    // This would contain the actual service startup logic
-    // - Start Express server
-    // - Connect to MQ
-    // - Register with registry
-    // - etc.
-
-    return new Promise((resolve) => {
-      const PORT = this.config.port || 3000;
-      this.server = this.service.listen(PORT, () => {
-        console.log(`Service listening on port ${PORT}`);
-        resolve();
-      });
-    });
-  }
-
-  /**
-   * Verify service after start
-   */
-  async verifyAfterStart() {
-    console.log('Running post-start verification...');
-
-    const serviceUrl = `http://localhost:${this.config.port || 3000}`;
-
-    // Quick readiness check
-    const readiness = await this.validator.validateReadiness({
-      name: this.serviceName,
-      url: serviceUrl,
-      openApiSpec: this.openApiSpec,
-      healthEndpoint: '/health'
-    });
-
-    if (!readiness.ready) {
-      console.warn('Post-start verification found issues:', readiness.errors);
-    }
-
-    return readiness;
-  }
-
-  /**
-   * Stop service
-   */
-  async stop() {
-    if (this.server) {
-      await new Promise((resolve) => {
-        this.server.close(resolve);
-      });
-    }
-  }
-}
-
-// === Example Usage ===
-
-async function demonstrateUsage() {
-  const express = require('express');
-
-  // Create a simple service
-  const app = express();
-  app.use(express.json());
-
-  app.get('/health', (req, res) => {
-    res.json({ status: 'healthy' });
-  });
-
-  app.post('/api/process', (req, res) => {
-    res.json({ processed: true, data: req.body });
-  });
-
-  // OpenAPI spec
-  const openApiSpec = {
-    openapi: '3.0.0',
-    info: { title: 'Demo Service', version: '1.0.0' },
-    paths: {
-      '/health': {
-        get: {
-          operationId: 'healthCheck',
-          responses: {
-            '200': {
-              content: {
-                'application/json': {
-                  schema: {
-                    type: 'object',
-                    properties: {
-                      status: { type: 'string' }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      },
-      '/api/process': {
-        post: {
-          operationId: 'processData',
-          requestBody: {
-            content: {
-              'application/json': {
-                schema: { type: 'object' }
-              }
-            }
-          },
-          responses: {
-            '200': {
-              content: {
-                'application/json': {
-                  schema: { type: 'object' }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-
-  // Create wrapper with testing
-  const wrapper = new ServiceWrapperWithTesting({
-    service: app,
-    serviceName: 'demo-service',
-    openApiSpec,
-    config: {
-      port: 3333
-    },
-    testingEnabled: true,
-    testLevel: 'unit' // Start with unit tests for speed
-  });
-
-  try {
-    // Start service (will run validation first)
-    await wrapper.start();
-
-    console.log('\nService is running with validation!');
-    console.log('Try: curl http://localhost:3333/health');
-
-    // Keep running for demo
-    await new Promise(resolve => setTimeout(resolve, 5000));
-
-    // Stop service
-    await wrapper.stop();
-    console.log('\nService stopped');
-
-  } catch (error) {
-    console.error('Failed to start service:', error.message);
-    process.exit(1);
-  }
-}
-
-// Run demonstration
-if (require.main === module) {
-  demonstrateUsage().catch(console.error);
-}
-
-module.exports = { ServiceWrapperWithTesting };

package/examples/three-tier-testing.js

@@ -1,144 +0,0 @@
-'use strict';
-
-/**
- * Example: Three-tier testing strategy
- * Shows how to use connector-testing for comprehensive service validation
- */
-
-const { TestOrchestrator } = require('../src');
-const express = require('express');
-
-// Example service
-const app = express();
-app.use(express.json());
-
-app.get('/health', (req, res) => {
-  res.json({ status: 'healthy', service: 'example-service' });
-});
-
-app.post('/process', (req, res) => {
-  res.json({
-    processed: true,
-    input: req.body,
-    timestamp: Date.now()
-  });
-});
-
-app.get('/status', (req, res) => {
-  res.json({
-    running: true,
-    uptime: process.uptime()
-  });
-});
-
-// OpenAPI specification
-const openApiSpec = {
-  openapi: '3.0.0',
-  info: {
-    title: 'Example Service',
-    version: '1.0.0'
-  },
-  paths: {
-    '/health': {
-      get: {
-        operationId: 'healthCheck',
-        responses: {
-          '200': {
-            content: {
-              'application/json': {
-                schema: {
-                  type: 'object',
-                  properties: {
-                    status: { type: 'string' },
-                    service: { type: 'string' }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    '/process': {
-      post: {
-        operationId: 'processData',
-        requestBody: {
-          content: {
-            'application/json': {
-              schema: { type: 'object' }
-            }
-          }
-        },
-        responses: {
-          '200': {
-            content: {
-              'application/json': {
-                schema: {
-                  type: 'object',
-                  properties: {
-                    processed: { type: 'boolean' },
-                    input: { type: 'object' },
-                    timestamp: { type: 'number' }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    '/status': {
-      get: {
-        operationId: 'getStatus',
-        responses: {
-          '200': {
-            content: {
-              'application/json': {
-                schema: {
-                  type: 'object',
-                  properties: {
-                    running: { type: 'boolean' },
-                    uptime: { type: 'number' }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-};
-
-async function runExample() {
-  console.log('=== Three-Tier Testing Example ===\n');
-
-  // Create test orchestrator
-  const orchestrator = new TestOrchestrator({
-    service: app,
-    serviceName: 'example-service',
-    openApiSpec,
-    logger: console
-  });
-
-  // Run all three levels of testing
-  console.log('Starting comprehensive test suite...\n');
-  const results = await orchestrator.runAllTests();
-
-  // Generate and display report
-  const report = orchestrator.generateReport(results);
-  console.log('\n' + report);
-
-  // Return exit code based on results
-  process.exit(results.passed ? 0 : 1);
-}
-
-// Run if executed directly
-if (require.main === module) {
-  runExample().catch(error => {
-    console.error('Test failed:', error);
-    process.exit(1);
-  });
-}
-
-module.exports = { app, openApiSpec, runExample };

package/src/ServiceTestHarness.js

@@ -1,256 +0,0 @@
-'use strict';
-
-const MockMQClient = require('./mocks/MockMQClient');
-const MockRegistry = require('./mocks/MockRegistry');
-const MockStorage = require('./mocks/MockStorage');
-const axios = require('axios');
-
-/**
- * ServiceTestHarness - Complete test environment for services
- */
-class ServiceTestHarness {
-  constructor(options = {}) {
-    this.service = options.service; // Express app
-    this.serviceName = options.serviceName || 'test-service';
-    this.openApiSpec = options.openApiSpec || {};
-    this.mockInfrastructure = options.mockInfrastructure !== false;
-
-    // Initialize mocks if requested
-    if (this.mockInfrastructure) {
-      this.mqClient = new MockMQClient();
-      this.registry = new MockRegistry();
-      this.storage = new MockStorage();
-    }
-
-    // Test state
-    this.server = null;
-    this.port = options.port || 0; // 0 = random port
-    this.baseUrl = null;
-    this.isRunning = false;
-  }
-
-  /**
-   * Start test harness
-   */
-  async start() {
-    if (this.isRunning) {
-      return;
-    }
-
-    // Start Express server if provided
-    if (this.service) {
-      await this.startServer();
-    }
-
-    // Connect mocks
-    if (this.mockInfrastructure) {
-      await this.mqClient.connect();
-      await this.registry.register({
-        name: this.serviceName,
-        url: this.baseUrl,
-        openapi: this.openApiSpec
-      });
-    }
-
-    this.isRunning = true;
-  }
-
-  /**
-   * Stop test harness
-   */
-  async stop() {
-    if (!this.isRunning) {
-      return;
-    }
-
-    // Stop server
-    if (this.server) {
-      await new Promise(resolve => {
-        this.server.close(resolve);
-      });
-    }
-
-    // Disconnect mocks
-    if (this.mockInfrastructure) {
-      await this.mqClient.disconnect();
-      await this.registry.unregister(this.serviceName);
-    }
-
-    this.isRunning = false;
-  }
-
-  /**
-   * Start Express server
-   * @private
-   */
-  async startServer() {
-    return new Promise((resolve) => {
-      this.server = this.service.listen(this.port, () => {
-        const actualPort = this.server.address().port;
-        this.baseUrl = `http://127.0.0.1:${actualPort}`;
-        resolve();
-      });
-    });
-  }
-
-  /**
-   * Call API endpoint
-   */
-  async callApi(method, path, data = null, headers = {}) {
-    if (!this.baseUrl) {
-      throw new Error('Service not started');
-    }
-
-    const config = {
-      method,
-      url: `${this.baseUrl}${path}`,
-      headers,
-      timeout: 5000
-    };
-
-    if (data) {
-      if (method === 'GET') {
-        config.params = data;
-      } else {
-        config.data = data;
-      }
-    }
-
-    const response = await axios(config);
-    return response.data;
-  }
-
-  /**
-   * Simulate workflow execution
-   */
-  async simulateWorkflow(workflow) {
-    const results = [];
-
-    for (const step of workflow.steps) {
-      if (step.type === 'task' && step.service === this.serviceName) {
-        // Execute task step
-        const result = await this.executeStep(step);
-        results.push(result);
-
-        // Simulate publishing result to queue
-        if (this.mockInfrastructure) {
-          await this.mqClient.publish('workflow.completed', {
-            step: step.id,
-            result
-          });
-        }
-      }
-    }
-
-    return {
-      workflow: workflow,
-      results,
-      completed: true
-    };
-  }
-
-  /**
-   * Execute a single workflow step
-   * @private
-   */
-  async executeStep(step) {
-    // Map step to API call based on operation
-    const operation = step.operation || step.id;
-    const endpoint = this.findEndpoint(operation);
-
-    if (!endpoint) {
-      throw new Error(`No endpoint found for operation: ${operation}`);
-    }
-
-    // Call the API
-    const response = await this.callApi(
-      endpoint.method,
-      endpoint.path,
-      step.input
-    );
-
-    return {
-      stepId: step.id,
-      operation,
-      response
-    };
-  }
-
-  /**
-   * Find endpoint in OpenAPI spec
-   * @private
-   */
-  findEndpoint(operationId) {
-    if (!this.openApiSpec.paths) {
-      return null;
-    }
-
-    for (const [path, pathItem] of Object.entries(this.openApiSpec.paths)) {
-      for (const [method, operation] of Object.entries(pathItem)) {
-        if (operation.operationId === operationId) {
-          return { method: method.toUpperCase(), path };
-        }
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Get published messages from mock MQ
-   */
-  getPublishedMessages(queue = null) {
-    if (!this.mockInfrastructure) {
-      throw new Error('Mock infrastructure not enabled');
-    }
-    return this.mqClient.getPublishedMessages(queue);
-  }
-
-  /**
-   * Get service registration from mock registry
-   */
-  getServiceRegistration() {
-    if (!this.mockInfrastructure) {
-      throw new Error('Mock infrastructure not enabled');
-    }
-    return this.registry.getService(this.serviceName);
-  }
-
-  /**
-   * Get storage contents from mock storage
-   */
-  async getStorageObject(bucket, key) {
-    if (!this.mockInfrastructure) {
-      throw new Error('Mock infrastructure not enabled');
-    }
-    return await this.storage.get(bucket, key);
-  }
-
-  /**
-   * Clear all test data
-   */
-  clear() {
-    if (this.mockInfrastructure) {
-      this.mqClient.clear();
-      this.registry.clear();
-      this.storage.clear();
-    }
-  }
-
-  /**
-   * Get test statistics
-   */
-  getStats() {
-    if (!this.mockInfrastructure) {
-      return { mocks: 'disabled' };
-    }
-
-    return {
-      mq: this.mqClient.getStats(),
-      registry: this.registry.getStats(),
-      storage: this.storage.getStats()
-    };
-  }
-}
-
-module.exports = ServiceTestHarness;