@onlineapps/conn-orch-validator 2.0.0

package/src/ServiceTestHarness.js

@@ -0,0 +1,256 @@
+'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://localhost:${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

@@ -0,0 +1,387 @@
+'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: {},
+      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) {
+          Object.entries(schema.properties).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);
+            }
+          });
+        }
+        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;