@onlineapps/conn-orch-validator 2.0.0

package/jest.config.js

@@ -0,0 +1,23 @@
+'use strict';
+
+module.exports = {
+  testEnvironment: 'node',
+  coverageDirectory: 'coverage',
+  collectCoverageFrom: [
+    'src/**/*.js',
+    '!src/index.js'
+  ],
+  testMatch: [
+    '**/tests/**/*.test.js'
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80
+    }
+  },
+  verbose: true,
+  testTimeout: 10000
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@onlineapps/conn-orch-validator",
+  "version": "2.0.0",
+  "description": "Validation orchestrator for OA Drive microservices - coordinates validation across all layers (base, infra, orch, business)",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "jest",
+    "test:unit": "jest tests/unit",
+    "test:component": "jest tests/component",
+    "test:integration": "jest tests/integration",
+    "test:coverage": "jest --coverage"
+  },
+  "keywords": [
+    "validation",
+    "orchestration",
+    "microservices",
+    "production-validation",
+    "tier1",
+    "pre-validation"
+  ],
+  "author": "OnlineApps",
+  "license": "PROPRIETARY",
+  "dependencies": {
+    "@onlineapps/service-validator-core": "^1.0.4",
+    "ajv": "^8.12.0",
+    "ajv-formats": "^2.1.1",
+    "amqplib": "^0.10.9",
+    "axios": "^1.4.0",
+    "joi": "^17.9.0"
+  },
+  "devDependencies": {
+    "express": "^4.18.0",
+    "jest": "^29.5.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "directories": {
+    "doc": "docs",
+    "example": "examples",
+    "test": "test"
+  }
+}

package/src/CookbookTestRunner.js

@@ -0,0 +1,434 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+const MockMQClient = require('./mocks/MockMQClient');
+const MockRegistry = require('./mocks/MockRegistry');
+
+/**
+ * CookbookTestRunner - Executes cookbook tests offline with mocked infrastructure
+ *
+ * Supports unified cookbook format for both testing (with expect) and production (without expect)
+ */
+class CookbookTestRunner {
+  constructor(options = {}) {
+    this.serviceName = options.serviceName;
+    this.serviceUrl = options.serviceUrl || 'http://localhost:3000';
+    this.servicePath = options.servicePath;
+    this.mockInfrastructure = options.mockInfrastructure !== false; // default true
+    this.timeout = options.timeout || 30000;
+    this.logger = options.logger || console;
+
+    // Initialize mocked infrastructure
+    if (this.mockInfrastructure) {
+      this.mqClient = new MockMQClient();
+      this.registry = new MockRegistry();
+    }
+
+    // Test results
+    this.results = {
+      total: 0,
+      passed: 0,
+      failed: 0,
+      duration: 0,
+      steps: []
+    };
+  }
+
+  /**
+   * Run single cookbook test
+   *
+   * @param {string|Object} cookbook - Path to cookbook file or cookbook object
+   * @returns {Object} Test results
+   */
+  async runCookbook(cookbook) {
+    const startTime = Date.now();
+
+    // Load cookbook
+    const cookbookData = typeof cookbook === 'string'
+      ? this.loadCookbook(cookbook)
+      : cookbook;
+
+    // Validate cookbook format
+    this.validateCookbook(cookbookData);
+
+    // Get test configuration
+    const testConfig = cookbookData.test || { mode: 'production' };
+
+    // Check if this is a test cookbook (has expect clauses)
+    const isTestMode = testConfig.mode === 'offline' || this.hasExpectClauses(cookbookData);
+
+    this.logger.info(`Running cookbook: ${cookbookData.description || 'Unnamed'}`);
+    this.logger.info(`Mode: ${testConfig.mode || 'production'}, Test: ${isTestMode}`);
+
+    // Execute steps
+    const stepResults = [];
+    for (const step of cookbookData.steps) {
+      const stepResult = await this.executeStep(step, testConfig);
+      stepResults.push(stepResult);
+
+      // If step failed and has expect, fail immediately
+      if (!stepResult.passed && step.expect) {
+        break;
+      }
+    }
+
+    // Calculate results
+    const duration = Date.now() - startTime;
+    const passed = stepResults.every(r => r.passed);
+    const failed = stepResults.filter(r => !r.passed).length;
+
+    const results = {
+      cookbook: cookbookData.description || 'Unnamed',
+      passed,
+      total: stepResults.length,
+      passed: stepResults.filter(r => r.passed).length,
+      failed,
+      duration,
+      steps: stepResults
+    };
+
+    // Update aggregate results
+    this.results.total += results.total;
+    this.results.passed += results.passed;
+    this.results.failed += results.failed;
+    this.results.duration += results.duration;
+    this.results.steps.push(...results.steps);
+
+    return results;
+  }
+
+  /**
+   * Run all cookbooks in a directory
+   *
+   * @param {string} cookbooksDir - Path to cookbooks directory
+   * @returns {Object} Aggregate results
+   */
+  async runCookbooks(cookbooksDir) {
+    const files = fs.readdirSync(cookbooksDir).filter(f => f.endsWith('.json'));
+
+    this.logger.info(`Found ${files.length} cookbook(s) in ${cookbooksDir}`);
+
+    for (const file of files) {
+      const cookbookPath = path.join(cookbooksDir, file);
+      try {
+        await this.runCookbook(cookbookPath);
+      } catch (error) {
+        this.logger.error(`Failed to run cookbook ${file}:`, error.message);
+        this.results.failed++;
+        this.results.steps.push({
+          cookbook: file,
+          passed: false,
+          error: error.message
+        });
+      }
+    }
+
+    return this.results;
+  }
+
+  /**
+   * Execute single step
+   */
+  async executeStep(step, testConfig) {
+    const startTime = Date.now();
+
+    this.logger.info(`Executing step: ${step.id || 'unnamed'} (${step.operation})`);
+
+    const result = {
+      id: step.id,
+      operation: step.operation,
+      passed: false,
+      duration: 0,
+      request: null,
+      response: null,
+      expected: step.expect || null,
+      actual: null,
+      error: null,
+      validationErrors: []
+    };
+
+    try {
+      // Resolve operation endpoint from operations.json
+      const endpoint = await this.resolveOperation(step.service, step.operation);
+
+      // Build request
+      const request = {
+        method: endpoint.method,
+        url: `${this.serviceUrl}${endpoint.path}`,
+        data: step.input,
+        timeout: testConfig.timeout || this.timeout
+      };
+
+      result.request = request;
+
+      // Execute request
+      const response = await axios(request);
+
+      result.response = {
+        status: response.status,
+        statusText: response.statusText,
+        data: response.data
+      };
+
+      result.actual = response.data;
+      result.duration = Date.now() - startTime;
+
+      // Validate expectations
+      if (step.expect) {
+        const validation = this.validateExpectations(step.expect, result);
+        result.passed = validation.passed;
+        result.validationErrors = validation.errors;
+      } else {
+        // No expectations = just check if request succeeded
+        result.passed = response.status >= 200 && response.status < 300;
+      }
+
+      this.logger.info(`Step ${step.id}: ${result.passed ? 'PASSED' : 'FAILED'} (${result.duration}ms)`);
+
+    } catch (error) {
+      result.error = error.message;
+      result.duration = Date.now() - startTime;
+      result.passed = false;
+
+      this.logger.error(`Step ${step.id}: ERROR - ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Validate expectations against actual results
+   */
+  validateExpectations(expect, result) {
+    const errors = [];
+
+    // Validate status
+    if (expect.status) {
+      const expectedSuccess = expect.status === 'success';
+      const actualSuccess = result.response && result.response.status >= 200 && result.response.status < 300;
+
+      if (expectedSuccess !== actualSuccess) {
+        errors.push(`Expected status: ${expect.status}, got: ${actualSuccess ? 'success' : 'error'}`);
+      }
+    }
+
+    // Validate status code
+    if (expect.statusCode && result.response) {
+      if (result.response.status !== expect.statusCode) {
+        errors.push(`Expected status code: ${expect.statusCode}, got: ${result.response.status}`);
+      }
+    }
+
+    // Validate duration
+    if (expect.duration && expect.duration.max) {
+      if (result.duration > expect.duration.max) {
+        errors.push(`Duration ${result.duration}ms exceeds max ${expect.duration.max}ms`);
+      }
+    }
+
+    // Validate output
+    if (expect.output && result.actual) {
+      const outputErrors = this.validateOutput(expect.output, result.actual);
+      errors.push(...outputErrors);
+    }
+
+    // Validate error
+    if (expect.error && result.error) {
+      const errorErrors = this.validateError(expect.error, result.error);
+      errors.push(...errorErrors);
+    }
+
+    return {
+      passed: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Validate output fields
+   */
+  validateOutput(expected, actual) {
+    const errors = [];
+
+    for (const [field, expectation] of Object.entries(expected)) {
+      const actualValue = actual[field];
+
+      // Check existence
+      if (expectation.exists !== undefined) {
+        const exists = actualValue !== undefined && actualValue !== null;
+        if (expectation.exists !== exists) {
+          errors.push(`Field ${field}: expected to ${expectation.exists ? 'exist' : 'not exist'}`);
+        }
+        // If we're only checking existence, skip other validations
+        if (!exists) {
+          continue;
+        }
+      }
+
+      // If field doesn't exist and we're not explicitly checking existence, error
+      if (actualValue === undefined || actualValue === null) {
+        if (expectation.exists === undefined) {
+          errors.push(`Field ${field}: missing in output`);
+        }
+        continue;
+      }
+
+      // Type check
+      if (expectation.type) {
+        const actualType = typeof actualValue;
+        if (actualType !== expectation.type) {
+          errors.push(`Field ${field}: expected type ${expectation.type}, got ${actualType}`);
+        }
+      }
+
+      // Equals check
+      if (expectation.equals !== undefined) {
+        if (actualValue !== expectation.equals) {
+          errors.push(`Field ${field}: expected ${expectation.equals}, got ${actualValue}`);
+        }
+      }
+
+      // Contains check (for strings)
+      if (expectation.contains) {
+        if (typeof actualValue !== 'string' || !actualValue.includes(expectation.contains)) {
+          errors.push(`Field ${field}: expected to contain "${expectation.contains}"`);
+        }
+      }
+
+      // Pattern check (regex)
+      if (expectation.pattern) {
+        const regex = new RegExp(expectation.pattern);
+        if (!regex.test(String(actualValue))) {
+          errors.push(`Field ${field}: does not match pattern ${expectation.pattern}`);
+        }
+      }
+
+      // Range checks
+      if (expectation.min !== undefined && actualValue < expectation.min) {
+        errors.push(`Field ${field}: ${actualValue} is less than min ${expectation.min}`);
+      }
+
+      if (expectation.max !== undefined && actualValue > expectation.max) {
+        errors.push(`Field ${field}: ${actualValue} exceeds max ${expectation.max}`);
+      }
+
+      // Length check
+      if (expectation.length !== undefined) {
+        const length = Array.isArray(actualValue) ? actualValue.length : String(actualValue).length;
+        if (length !== expectation.length) {
+          errors.push(`Field ${field}: expected length ${expectation.length}, got ${length}`);
+        }
+      }
+    }
+
+    return errors;
+  }
+
+  /**
+   * Validate error expectations
+   */
+  validateError(expected, actual) {
+    const errors = [];
+
+    if (expected.code && actual.code !== expected.code) {
+      errors.push(`Expected error code: ${expected.code}, got: ${actual.code}`);
+    }
+
+    if (expected.message) {
+      if (expected.message.contains && !actual.message.includes(expected.message.contains)) {
+        errors.push(`Expected error message to contain: "${expected.message.contains}"`);
+      }
+    }
+
+    return errors;
+  }
+
+  /**
+   * Resolve operation to HTTP endpoint
+   */
+  async resolveOperation(serviceName, operationName) {
+    // Load operations.json from service path
+    const operationsPath = this.servicePath
+      ? path.join(this.servicePath, 'conn-config', 'operations.json')
+      : null;
+
+    if (!operationsPath || !fs.existsSync(operationsPath)) {
+      throw new Error(`Operations file not found for service: ${serviceName}`);
+    }
+
+    const operations = JSON.parse(fs.readFileSync(operationsPath, 'utf8'));
+    const operation = operations.operations[operationName];
+
+    if (!operation) {
+      throw new Error(`Operation not found: ${operationName}`);
+    }
+
+    return {
+      path: operation.endpoint,
+      method: operation.method
+    };
+  }
+
+  /**
+   * Load cookbook from file
+   */
+  loadCookbook(cookbookPath) {
+    if (!fs.existsSync(cookbookPath)) {
+      throw new Error(`Cookbook not found: ${cookbookPath}`);
+    }
+
+    const content = fs.readFileSync(cookbookPath, 'utf8');
+    return JSON.parse(content);
+  }
+
+  /**
+   * Validate cookbook format
+   */
+  validateCookbook(cookbook) {
+    if (!cookbook.steps || !Array.isArray(cookbook.steps)) {
+      throw new Error('Cookbook must have steps array');
+    }
+
+    if (cookbook.steps.length === 0) {
+      throw new Error('Cookbook must have at least one step');
+    }
+
+    for (const step of cookbook.steps) {
+      if (!step.service) throw new Error('Step must have service');
+      if (!step.operation) throw new Error('Step must have operation');
+    }
+
+    return true;
+  }
+
+  /**
+   * Check if cookbook has expect clauses
+   */
+  hasExpectClauses(cookbook) {
+    return cookbook.steps.some(step => step.expect !== undefined);
+  }
+
+  /**
+   * Get aggregate results
+   */
+  getResults() {
+    return this.results;
+  }
+
+  /**
+   * Reset results
+   */
+  resetResults() {
+    this.results = {
+      total: 0,
+      passed: 0,
+      failed: 0,
+      duration: 0,
+      steps: []
+    };
+  }
+}
+
+module.exports = CookbookTestRunner;