@onlineapps/conn-orch-validator 2.0.33 → 3.0.0

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;

package/src/ServiceValidator.js

@@ -1,399 +0,0 @@
-'use strict';
-
-const axios = require('axios');
-const Ajv = require('ajv');
-const addFormats = require('ajv-formats');
-
-/**
- * ServiceValidator - Validates service compliance with OpenAPI spec
- */
-class ServiceValidator {
-  constructor(options = {}) {
-    this.ajv = new Ajv({ allErrors: true, strict: false });
-    addFormats(this.ajv);
-    this.timeout = options.timeout || 5000;
-  }
-
-  /**
-   * Validate service against OpenAPI specification
-   */
-  async validateService(serviceUrl, openApiSpec) {
-    const results = {
-      valid: true,
-      errors: [],
-      warnings: [],
-      testedEndpoints: [],
-      coverage: 0
-    };
-
-    if (!openApiSpec.paths) {
-      results.valid = false;
-      results.errors.push('No paths defined in OpenAPI spec');
-      return results;
-    }
-
-    const totalEndpoints = this.countEndpoints(openApiSpec.paths);
-    let testedCount = 0;
-
-    // Test each endpoint
-    for (const [path, pathItem] of Object.entries(openApiSpec.paths)) {
-      for (const [method, operation] of Object.entries(pathItem)) {
-        if (method === 'parameters' || method.startsWith('x-')) continue;
-
-        const endpointResult = await this.testEndpoint(
-          serviceUrl,
-          path,
-          method,
-          operation
-        );
-
-        results.testedEndpoints.push(endpointResult);
-        if (!endpointResult.valid) {
-          results.valid = false;
-          results.errors.push(...endpointResult.errors);
-        }
-        if (endpointResult.warnings) {
-          results.warnings.push(...endpointResult.warnings);
-        }
-        testedCount++;
-      }
-    }
-
-    results.coverage = (testedCount / totalEndpoints) * 100;
-    return results;
-  }
-
-  /**
-   * Test individual endpoint
-   */
-  async testEndpoint(serviceUrl, path, method, operation) {
-    const result = {
-      path,
-      method: method.toUpperCase(),
-      operationId: operation.operationId,
-      valid: true,
-      errors: [],
-      warnings: [],
-      response: null
-    };
-
-    try {
-      // Build test request
-      const testRequest = this.buildTestRequest(path, method, operation);
-      const url = `${serviceUrl}${testRequest.path}`;
-
-      // Execute request
-      const response = await axios({
-        method: method.toUpperCase(),
-        url,
-        data: testRequest.body,
-        params: testRequest.query,
-        headers: testRequest.headers,
-        timeout: this.timeout,
-        validateStatus: () => true // Don't throw on any status
-      });
-
-      result.response = {
-        status: response.status,
-        headers: response.headers,
-        data: response.data
-      };
-
-      // Validate response
-      this.validateResponse(response, operation, result);
-
-    } catch (error) {
-      result.valid = false;
-      result.errors.push(`Failed to call endpoint: ${error.message}`);
-    }
-
-    return result;
-  }
-
-  /**
-   * Build test request from OpenAPI operation
-   */
-  buildTestRequest(path, method, operation) {
-    const request = {
-      path,
-      headers: {
-        // Validation context: ALWAYS add x-validation-request header to indicate this is a validation probe.
-        // This allows services to return deterministic responses without accessing external resources.
-        'x-validation-request': 'true'
-      },
-      query: {},
-      body: null
-    };
-
-    // Process parameters
-    if (operation.parameters) {
-      operation.parameters.forEach(param => {
-        const testValue = this.generateTestValue(param.schema);
-
-        switch (param.in) {
-          case 'path':
-            request.path = request.path.replace(`{${param.name}}`, testValue);
-            break;
-          case 'query':
-            if (!param.required && Math.random() > 0.5) break;
-            request.query[param.name] = testValue;
-            break;
-          case 'header':
-            if (!param.required && Math.random() > 0.5) break;
-            request.headers[param.name] = testValue;
-            break;
-        }
-      });
-    }
-
-    // Process request body
-    if (operation.requestBody && operation.requestBody.content) {
-      const contentType = Object.keys(operation.requestBody.content)[0];
-      const schema = operation.requestBody.content[contentType].schema;
-      request.headers['Content-Type'] = contentType;
-      request.body = this.generateTestValue(schema);
-    }
-
-    return request;
-  }
-
-  /**
-   * Generate test value based on schema
-   */
-  generateTestValue(schema) {
-    if (!schema) return null;
-
-    switch (schema.type) {
-      case 'string':
-        if (schema.enum) return schema.enum[0];
-        if (schema.format === 'email') return 'test@example.com';
-        if (schema.format === 'date') return '2024-01-01';
-        if (schema.format === 'date-time') return '2024-01-01T00:00:00Z';
-        if (schema.format === 'uuid') return '123e4567-e89b-12d3-a456-426614174000';
-        return schema.example || 'test';
-
-      case 'number':
-      case 'integer':
-        if (schema.minimum !== undefined) return schema.minimum;
-        if (schema.maximum !== undefined) return schema.maximum;
-        return schema.example || 1;
-
-      case 'boolean':
-        return schema.example !== undefined ? schema.example : true;
-
-      case 'array':
-        const itemValue = this.generateTestValue(schema.items);
-        return [itemValue];
-
-      case 'object':
-        const obj = {};
-        if (schema.properties) {
-          const entries = Object.entries(schema.properties);
-          entries.forEach(([key, prop]) => {
-            if (schema.required && schema.required.includes(key)) {
-              obj[key] = this.generateTestValue(prop);
-            } else if (Math.random() > 0.5) {
-              obj[key] = this.generateTestValue(prop);
-            }
-          });
-
-          // If schema has properties but nothing was picked (e.g., no required fields and randomness skipped),
-          // pick the first property to keep requests deterministic and non-empty.
-          if (Object.keys(obj).length === 0 && entries.length > 0) {
-            const [firstKey, firstSchema] = entries[0];
-            obj[firstKey] = this.generateTestValue(firstSchema);
-          }
-        }
-        return obj;
-
-      default:
-        return null;
-    }
-  }
-
-  /**
-   * Validate response against OpenAPI schema
-   */
-  validateResponse(response, operation, result) {
-    if (!operation.responses) {
-      result.warnings.push('No responses defined in OpenAPI spec');
-      return;
-    }
-
-    const statusCode = response.status.toString();
-    const responseSpec = operation.responses[statusCode] || operation.responses.default;
-
-    if (!responseSpec) {
-      result.valid = false;
-      result.errors.push(`Unexpected status code: ${statusCode}`);
-      return;
-    }
-
-    // Validate response body
-    if (responseSpec.content) {
-      const contentType = Object.keys(responseSpec.content)[0];
-      const schema = responseSpec.content[contentType].schema;
-
-      if (schema) {
-        const validate = this.ajv.compile(schema);
-        if (!validate(response.data)) {
-          result.valid = false;
-          result.errors.push(`Response validation failed: ${JSON.stringify(validate.errors)}`);
-        }
-      }
-    }
-
-    // Validate headers
-    if (responseSpec.headers) {
-      Object.entries(responseSpec.headers).forEach(([headerName, headerSpec]) => {
-        const headerValue = response.headers[headerName.toLowerCase()];
-        if (headerSpec.required && !headerValue) {
-          result.valid = false;
-          result.errors.push(`Required header missing: ${headerName}`);
-        }
-      });
-    }
-  }
-
-  /**
-   * Count total endpoints in paths
-   */
-  countEndpoints(paths) {
-    let count = 0;
-    Object.values(paths).forEach(pathItem => {
-      Object.keys(pathItem).forEach(method => {
-        if (method !== 'parameters' && !method.startsWith('x-')) {
-          count++;
-        }
-      });
-    });
-    return count;
-  }
-
-  /**
-   * Validate cookbook structure and operations
-   */
-  async validateCookbook(cookbook, serviceRegistry) {
-    const results = {
-      valid: true,
-      errors: [],
-      warnings: [],
-      validatedSteps: []
-    };
-
-    if (!cookbook.steps || !Array.isArray(cookbook.steps)) {
-      results.valid = false;
-      results.errors.push('Cookbook must have steps array');
-      return results;
-    }
-
-    // Validate each step
-    for (const step of cookbook.steps) {
-      const stepResult = await this.validateStep(step, serviceRegistry);
-      results.validatedSteps.push(stepResult);
-      
-      if (!stepResult.valid) {
-        results.valid = false;
-        results.errors.push(...stepResult.errors);
-      }
-      if (stepResult.warnings) {
-        results.warnings.push(...stepResult.warnings);
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * Validate individual cookbook step
-   */
-  async validateStep(step, serviceRegistry) {
-    const result = {
-      stepId: step.id,
-      valid: true,
-      errors: [],
-      warnings: []
-    };
-
-    // Basic validation
-    if (!step.id) {
-      result.valid = false;
-      result.errors.push('Step must have an id');
-    }
-
-    if (!step.type) {
-      result.valid = false;
-      result.errors.push('Step must have a type');
-    }
-
-    // Type-specific validation
-    switch (step.type) {
-      case 'task':
-        if (!step.service) {
-          result.valid = false;
-          result.errors.push('Task step must have a service');
-        } else {
-          // Check if service exists
-          const service = serviceRegistry.getService(step.service);
-          if (!service) {
-            result.valid = false;
-            result.errors.push(`Service not found: ${step.service}`);
-          } else if (step.operation) {
-            // Validate operation exists in service
-            const hasOperation = this.serviceHasOperation(
-              service.openapi,
-              step.operation
-            );
-            if (!hasOperation) {
-              result.valid = false;
-              result.errors.push(`Operation not found: ${step.operation}`);
-            }
-          }
-        }
-        break;
-
-      case 'foreach':
-        if (!step.items) {
-          result.valid = false;
-          result.errors.push('Foreach step must have items');
-        }
-        if (!step.body) {
-          result.valid = false;
-          result.errors.push('Foreach step must have body');
-        }
-        break;
-
-      case 'switch':
-        if (!step.condition) {
-          result.valid = false;
-          result.errors.push('Switch step must have condition');
-        }
-        if (!step.cases || !Array.isArray(step.cases)) {
-          result.valid = false;
-          result.errors.push('Switch step must have cases array');
-        }
-        break;
-    }
-
-    return result;
-  }
-
-  /**
-   * Check if service has operation
-   */
-  serviceHasOperation(openApiSpec, operationId) {
-    if (!openApiSpec || !openApiSpec.paths) return false;
-
-    for (const pathItem of Object.values(openApiSpec.paths)) {
-      for (const operation of Object.values(pathItem)) {
-        if (operation.operationId === operationId) {
-          return true;
-        }
-      }
-    }
-
-    return false;
-  }
-}
-
-module.exports = ServiceValidator;