@onlineapps/conn-orch-validator 2.0.0

package/src/CookbookTestUtils.js

@@ -0,0 +1,237 @@
+'use strict';
+
+/**
+ * CookbookTestUtils - Utilities for cookbook testing
+ */
+class CookbookTestUtils {
+  /**
+   * Create a mock workflow message
+   */
+  static createWorkflowMessage(options = {}) {
+    return {
+      workflow_id: options.workflow_id || `test-workflow-${Date.now()}`,
+      cookbook: options.cookbook || {
+        version: '1.0.0',
+        steps: options.steps || [
+          {
+            id: 'step1',
+            type: 'task',
+            service: options.serviceName || 'test-service',
+            operation: 'testOperation',
+            input: options.input || {},
+            output: options.output || {}
+          }
+        ]
+      },
+      current_step: options.current_step || 'step1',
+      context: options.context || {
+        api_input: options.api_input || {},
+        steps: options.previous_steps || {}
+      }
+    };
+  }
+
+  /**
+   * Generate test cookbook with multiple steps
+   */
+  static generateTestCookbook(options = {}) {
+    const stepCount = options.steps || 3;
+    const services = options.services || ['service1', 'service2'];
+    const steps = [];
+
+    for (let i = 1; i <= stepCount; i++) {
+      steps.push({
+        id: `step${i}`,
+        type: 'task',
+        service: services[i % services.length],
+        operation: `operation${i}`,
+        input: { data: `input${i}` },
+        output: { result: `$.result${i}` }
+      });
+    }
+
+    return {
+      version: '1.0.0',
+      api_input: options.api_input || { test: 'data' },
+      steps
+    };
+  }
+
+  /**
+   * Validate cookbook structure (basic validation)
+   */
+  static validateCookbook(cookbook) {
+    const errors = [];
+
+    if (!cookbook) {
+      errors.push('Cookbook is required');
+      return { valid: false, errors };
+    }
+
+    if (!cookbook.version) {
+      errors.push('Version is required');
+    }
+
+    if (!cookbook.steps || !Array.isArray(cookbook.steps)) {
+      errors.push('Steps array is required');
+    } else {
+      cookbook.steps.forEach((step, index) => {
+        if (!step.id) {
+          errors.push(`Step ${index}: id is required`);
+        }
+        if (!step.type) {
+          errors.push(`Step ${index}: type is required`);
+        }
+        if (step.type === 'task' && !step.service) {
+          errors.push(`Step ${index}: service is required for task steps`);
+        }
+      });
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Compare two cookbooks and find differences
+   */
+  static compareCookbooks(cookbook1, cookbook2) {
+    const differences = [];
+
+    // Compare basic properties
+    if (cookbook1.version !== cookbook2.version) {
+      differences.push({
+        field: 'version',
+        cookbook1: cookbook1.version,
+        cookbook2: cookbook2.version
+      });
+    }
+
+    // Compare steps
+    const steps1 = cookbook1.steps || [];
+    const steps2 = cookbook2.steps || [];
+
+    if (steps1.length !== steps2.length) {
+      differences.push({
+        field: 'steps.length',
+        cookbook1: steps1.length,
+        cookbook2: steps2.length
+      });
+    }
+
+    // Compare individual steps
+    const minLength = Math.min(steps1.length, steps2.length);
+    for (let i = 0; i < minLength; i++) {
+      const step1 = steps1[i];
+      const step2 = steps2[i];
+
+      if (step1.id !== step2.id) {
+        differences.push({
+          field: `steps[${i}].id`,
+          cookbook1: step1.id,
+          cookbook2: step2.id
+        });
+      }
+
+      if (step1.type !== step2.type) {
+        differences.push({
+          field: `steps[${i}].type`,
+          cookbook1: step1.type,
+          cookbook2: step2.type
+        });
+      }
+
+      if (step1.service !== step2.service) {
+        differences.push({
+          field: `steps[${i}].service`,
+          cookbook1: step1.service,
+          cookbook2: step2.service
+        });
+      }
+    }
+
+    return differences;
+  }
+
+  /**
+   * Create test context with previous step results
+   */
+  static createContext(previousSteps = {}) {
+    return {
+      api_input: {
+        test_data: 'test',
+        timestamp: Date.now()
+      },
+      steps: previousSteps,
+      metadata: {
+        workflow_id: `test-${Date.now()}`,
+        started_at: new Date().toISOString()
+      }
+    };
+  }
+
+  /**
+   * Simulate step execution result
+   */
+  static createStepResult(stepId, success = true, data = {}) {
+    return {
+      stepId,
+      success,
+      data: data || { processed: true },
+      timestamp: Date.now(),
+      duration: Math.floor(Math.random() * 1000)
+    };
+  }
+
+  /**
+   * Generate control flow step (foreach, switch, etc.)
+   */
+  static createControlFlowStep(type, options = {}) {
+    const baseStep = {
+      id: options.id || `${type}-step-${Date.now()}`,
+      type
+    };
+
+    switch (type) {
+      case 'foreach':
+        return {
+          ...baseStep,
+          items: options.items || '$api_input.items',
+          body: options.body || {
+            id: 'foreach-body',
+            type: 'task',
+            service: 'test-service',
+            operation: 'processItem'
+          }
+        };
+
+      case 'switch':
+        return {
+          ...baseStep,
+          condition: options.condition || '$api_input.type',
+          cases: options.cases || [
+            { value: 'type1', step: { id: 'case1', type: 'task', service: 'service1' } },
+            { value: 'type2', step: { id: 'case2', type: 'task', service: 'service2' } }
+          ],
+          default: options.default || { id: 'default', type: 'task', service: 'default-service' }
+        };
+
+      case 'fork_join':
+        return {
+          ...baseStep,
+          branches: options.branches || [
+            { id: 'branch1', type: 'task', service: 'service1' },
+            { id: 'branch2', type: 'task', service: 'service2' }
+          ],
+          join: options.join || { strategy: 'merge' }
+        };
+
+      default:
+        return baseStep;
+    }
+  }
+}
+
+module.exports = CookbookTestUtils;

package/src/ServiceReadinessValidator.js

@@ -0,0 +1,430 @@
+'use strict';
+
+const ServiceValidator = require('./ServiceValidator');
+const CookbookTestUtils = require('./CookbookTestUtils');
+
+/**
+ * ServiceReadinessValidator - Orchestrates complete service validation
+ * Used by service-wrapper to verify service is ready for production
+ *
+ * IMPORTANT: Only supports operations.json format. OpenAPI is deprecated.
+ */
+class ServiceReadinessValidator {
+  constructor(options = {}) {
+    this.validator = new ServiceValidator(options);
+    this.logger = options.logger || console;
+
+    // Readiness checks: core (80 points) + optional (20 points) = 100 points max
+    // Core checks ALWAYS run, optional checks run if testCookbook/registry provided
+    // See: /shared/connector/conn-orch-validator/README.md for usage pattern
+    this.checks = {
+      operations: { weight: 30, required: true },   // operations.json structure valid
+      endpoints: { weight: 30, required: true },    // all endpoints respond correctly
+      health: { weight: 20, required: true },       // health check works
+      cookbook: { weight: 15, required: false },    // OPTIONAL - cookbook valid (with mocks)
+      registry: { weight: 5, required: false }      // OPTIONAL - registry compatible (MockRegistry)
+    };
+  }
+
+  /**
+   * Perform complete readiness check
+   * @param {Object} service - Service configuration
+   * @returns {Object} Validation results with score
+   */
+  async validateReadiness(service) {
+    const {
+      url,
+      operations,
+      registry,
+      testCookbook,
+      healthEndpoint = '/health'
+    } = service;
+
+    const results = {
+      timestamp: Date.now(),
+      serviceName: service.name,
+      serviceUrl: url,
+      checks: {},
+      score: 0,
+      maxScore: 100,
+      ready: false,
+      errors: [],
+      warnings: []
+    };
+
+    // 1. Validate operations.json structure
+    if (operations) {
+      results.checks.operations = await this.checkOperationsCompliance(operations);
+      if (results.checks.operations.passed) {
+        results.score += this.checks.operations.weight;
+      } else if (this.checks.operations.required) {
+        results.errors.push('Operations validation failed');
+      }
+    } else {
+      results.errors.push('No operations.json provided - required for all services');
+      results.checks.operations = { passed: false, error: 'Missing operations.json' };
+    }
+
+    // 2. Test all declared operations endpoints
+    if (operations && results.checks.operations?.passed) {
+      results.checks.endpoints = await this.checkOperationsEndpoints(url, operations);
+      if (results.checks.endpoints.passed) {
+        results.score += this.checks.endpoints.weight;
+      } else if (this.checks.endpoints.required) {
+        results.errors.push('Endpoint validation failed');
+      }
+    }
+
+    // 3. Verify health check
+    results.checks.health = await this.checkHealth(url + healthEndpoint);
+    if (results.checks.health.passed) {
+      results.score += this.checks.health.weight;
+    } else if (this.checks.health.required) {
+      results.errors.push('Health check failed');
+    }
+
+    // 4. Test cookbook execution (if provided)
+    if (testCookbook) {
+      results.checks.cookbook = await this.checkCookbookExecution(
+        testCookbook
+      );
+      if (results.checks.cookbook.passed) {
+        results.score += this.checks.cookbook.weight;
+      } else if (this.checks.cookbook.required) {
+        results.errors.push('Cookbook validation failed');
+      }
+    }
+
+    // 5. Verify registry compatibility
+    if (registry) {
+      results.checks.registry = await this.checkRegistryCompatibility(
+        service,
+        registry
+      );
+      if (results.checks.registry.passed) {
+        results.score += this.checks.registry.weight;
+      } else if (this.checks.registry.required) {
+        results.errors.push('Registry compatibility check failed');
+      }
+    }
+
+    // Calculate readiness
+    const requiredChecks = Object.entries(this.checks)
+      .filter(([_, config]) => config.required)
+      .map(([name, _]) => name);
+
+    const requiredPassed = requiredChecks.every(
+      check => !results.checks[check] || results.checks[check].passed
+    );
+
+    results.ready = requiredPassed && results.score >= 60;
+    results.recommendation = this.getRecommendation(results);
+
+    return results;
+  }
+
+  /**
+   * Check operations.json compliance
+   */
+  async checkOperationsCompliance(operations) {
+    try {
+      const errors = [];
+      const warnings = [];
+
+      // Validate operations structure
+      if (!operations || typeof operations !== 'object') {
+        return {
+          passed: false,
+          error: 'Operations must be an object'
+        };
+      }
+
+      const operationCount = Object.keys(operations).length;
+      if (operationCount === 0) {
+        return {
+          passed: false,
+          error: 'No operations defined'
+        };
+      }
+
+      // Validate each operation
+      for (const [name, operation] of Object.entries(operations)) {
+        // Required fields
+        if (!operation.description) {
+          errors.push(`Operation '${name}' missing description`);
+        }
+        if (!operation.endpoint) {
+          errors.push(`Operation '${name}' missing endpoint`);
+        }
+        if (!operation.method) {
+          errors.push(`Operation '${name}' missing method`);
+        }
+        if (!operation.input) {
+          errors.push(`Operation '${name}' missing input schema`);
+        }
+        if (!operation.output) {
+          errors.push(`Operation '${name}' missing output schema`);
+        }
+
+        // Validate method
+        const validMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'];
+        if (operation.method && !validMethods.includes(operation.method)) {
+          errors.push(`Operation '${name}' has invalid method: ${operation.method}`);
+        }
+
+        // Validate endpoint format
+        if (operation.endpoint && !operation.endpoint.startsWith('/')) {
+          warnings.push(`Operation '${name}' endpoint should start with /`);
+        }
+      }
+
+      return {
+        passed: errors.length === 0,
+        operationCount,
+        errors,
+        warnings
+      };
+    } catch (error) {
+      return {
+        passed: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Check all operations endpoints respond correctly
+   */
+  async checkOperationsEndpoints(serviceUrl, operations) {
+    const axios = require('axios');
+    const results = {
+      passed: true,
+      total: Object.keys(operations).length,
+      successful: 0,
+      failed: 0,
+      details: []
+    };
+
+    for (const [operationName, operation] of Object.entries(operations)) {
+      try {
+        const endpoint = operation.endpoint;
+        const method = operation.method.toLowerCase();
+        const url = `${serviceUrl}${endpoint}`;
+
+        // Generate test input based on schema
+        const testInput = this.generateTestInput(operation.input);
+
+        // Make request
+        const response = await axios({
+          method,
+          url,
+          data: method !== 'get' ? testInput : undefined,
+          params: method === 'get' ? testInput : undefined,
+          timeout: 5000,
+          validateStatus: () => true // Accept any status for validation
+        });
+
+        // Check response
+        const isValid = response.status >= 200 && response.status < 300;
+
+        if (isValid) {
+          results.successful++;
+        } else {
+          results.failed++;
+          results.passed = false;
+        }
+
+        results.details.push({
+          operation: operationName,
+          endpoint,
+          method: method.toUpperCase(),
+          status: response.status,
+          valid: isValid
+        });
+      } catch (error) {
+        results.failed++;
+        results.passed = false;
+        results.details.push({
+          operation: operationName,
+          endpoint: operation.endpoint,
+          method: operation.method,
+          valid: false,
+          error: error.message
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Check health endpoint
+   */
+  async checkHealth(healthUrl) {
+    try {
+      const axios = require('axios');
+      const response = await axios.get(healthUrl, { timeout: 5000 });
+
+      return {
+        passed: response.status === 200,
+        status: response.status,
+        data: response.data
+      };
+    } catch (error) {
+      return {
+        passed: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Check cookbook structure validity
+   * Simple structural validation - checks cookbook has required fields and valid structure
+   */
+  async checkCookbookExecution(cookbook) {
+    try {
+      // Validate cookbook structure using CookbookTestUtils
+      const structureValidation = CookbookTestUtils.validateCookbook(cookbook);
+
+      return {
+        passed: structureValidation.valid,
+        errors: structureValidation.errors || [],
+        stepsValidated: cookbook.steps ? cookbook.steps.length : 0
+      };
+    } catch (error) {
+      return {
+        passed: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Check registry compatibility
+   */
+  async checkRegistryCompatibility(service, registry) {
+    try {
+      // Check if service can be registered
+      const canRegister = !!(
+        service.name &&
+        service.version &&
+        service.operations
+      );
+
+      // Check if service operations match registry expectations
+      const registeredService = registry.getService(service.name);
+      const compatible = !registeredService ||
+        registeredService.version === service.version;
+
+      return {
+        passed: canRegister && compatible,
+        canRegister,
+        compatible,
+        existingVersion: registeredService?.version
+      };
+    } catch (error) {
+      return {
+        passed: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Generate test input based on operation input schema
+   */
+  generateTestInput(inputSchema) {
+    const testData = {};
+
+    for (const [fieldName, fieldSpec] of Object.entries(inputSchema)) {
+      if (fieldSpec.required) {
+        // Generate appropriate test value based on type
+        switch (fieldSpec.type) {
+          case 'string':
+            testData[fieldName] = fieldSpec.default || 'Test';
+            break;
+          case 'number':
+            testData[fieldName] = fieldSpec.default || 0;
+            break;
+          case 'boolean':
+            testData[fieldName] = fieldSpec.default || false;
+            break;
+          case 'array':
+            testData[fieldName] = fieldSpec.default || [];
+            break;
+          case 'object':
+            testData[fieldName] = fieldSpec.default || {};
+            break;
+          default:
+            testData[fieldName] = null;
+        }
+      }
+    }
+
+    return testData;
+  }
+
+  /**
+   * Get recommendation based on results
+   */
+  getRecommendation(results) {
+    if (results.ready) {
+      if (results.score >= 90) {
+        return 'Service is fully ready for production deployment';
+      } else if (results.score >= 75) {
+        return 'Service is ready but consider addressing warnings';
+      } else {
+        return 'Service meets minimum requirements but needs improvement';
+      }
+    } else {
+      if (results.errors.length > 0) {
+        return `Service is not ready: ${results.errors.join(', ')}`;
+      } else {
+        return 'Service does not meet minimum readiness requirements';
+      }
+    }
+  }
+
+  /**
+   * Generate readiness report
+   */
+  generateReport(results) {
+    const report = [];
+
+    report.push('=== Service Readiness Report ===');
+    report.push(`Service: ${results.serviceName}`);
+    report.push(`URL: ${results.serviceUrl}`);
+    report.push(`Score: ${results.score}/${results.maxScore}`);
+    report.push(`Status: ${results.ready ? 'READY' : 'NOT READY'}`);
+    report.push('');
+
+    report.push('Checks:');
+    for (const [name, check] of Object.entries(results.checks)) {
+      const status = check.passed ? '✓' : '✗';
+      report.push(`  ${status} ${name}: ${check.passed ? 'Passed' : 'Failed'}`);
+      if (check.error) {
+        report.push(`    Error: ${check.error}`);
+      }
+    }
+
+    report.push('');
+    report.push(`Recommendation: ${results.recommendation}`);
+
+    if (results.errors.length > 0) {
+      report.push('');
+      report.push('Errors:');
+      results.errors.forEach(err => report.push(`  - ${err}`));
+    }
+
+    if (results.warnings.length > 0) {
+      report.push('');
+      report.push('Warnings:');
+      results.warnings.forEach(warn => report.push(`  - ${warn}`));
+    }
+
+    return report.join('\n');
+  }
+}
+
+module.exports = ServiceReadinessValidator;