@onlineapps/conn-orch-validator 2.0.6 → 2.0.9

package/tests/run-example.js

@@ -1,257 +0,0 @@
-'use strict';
-
-/**
- * Simple test runner to demonstrate connector-testing functionality
- */
-
-const { TestOrchestrator, ServiceTestHarness, ServiceReadinessValidator } = require('../src');
-const express = require('express');
-const path = require('path');
-
-// Create a minimal test service
-function createTestService() {
-  const app = express();
-  app.use(express.json());
-
-  app.get('/health', (req, res) => {
-    res.json({
-      status: 'healthy',
-      service: 'test-service',
-      timestamp: new Date().toISOString()
-    });
-  });
-
-  app.get('/good-day', (req, res) => {
-    const name = req.query.name || 'World';
-    res.json({
-      message: `Good day, ${name}!`,
-      timestamp: new Date().toISOString()
-    });
-  });
-
-  app.post('/process', (req, res) => {
-    res.json({
-      processed: true,
-      input: req.body,
-      output: { transformed: true }
-    });
-  });
-
-  return app;
-}
-
-// Create OpenAPI spec
-function createOpenApiSpec() {
-  return {
-    openapi: '3.0.0',
-    info: {
-      title: 'Test Service',
-      version: '1.0.0',
-      description: 'Service for testing connector-testing'
-    },
-    paths: {
-      '/health': {
-        get: {
-          operationId: 'healthCheck',
-          summary: 'Health check endpoint',
-          responses: {
-            '200': {
-              description: 'Service is healthy',
-              content: {
-                'application/json': {
-                  schema: {
-                    type: 'object',
-                    properties: {
-                      status: { type: 'string' },
-                      service: { type: 'string' },
-                      timestamp: { type: 'string' }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      },
-      '/good-day': {
-        get: {
-          operationId: 'goodDay',
-          summary: 'Greeting endpoint',
-          parameters: [
-            {
-              name: 'name',
-              in: 'query',
-              required: false,
-              schema: { type: 'string' }
-            }
-          ],
-          responses: {
-            '200': {
-              description: 'Greeting response',
-              content: {
-                'application/json': {
-                  schema: {
-                    type: 'object',
-                    properties: {
-                      message: { type: 'string' },
-                      timestamp: { type: 'string' }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      },
-      '/process': {
-        post: {
-          operationId: 'processData',
-          summary: 'Process data',
-          requestBody: {
-            content: {
-              'application/json': {
-                schema: {
-                  type: 'object'
-                }
-              }
-            }
-          },
-          responses: {
-            '200': {
-              description: 'Processing result',
-              content: {
-                'application/json': {
-                  schema: {
-                    type: 'object',
-                    properties: {
-                      processed: { type: 'boolean' },
-                      input: { type: 'object' },
-                      output: { type: 'object' }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-}
-
-async function runTests() {
-  console.log('=== Connector-Testing Demo ===\n');
-
-  const app = createTestService();
-  const openApiSpec = createOpenApiSpec();
-
-  // Test 1: Service Test Harness
-  console.log('1. Testing with ServiceTestHarness (with mocks)...\n');
-
-  const harness = new ServiceTestHarness({
-    service: app,
-    serviceName: 'test-service',
-    openApiSpec,
-    mockInfrastructure: true
-  });
-
-  await harness.start();
-  console.log(`   ✓ Service started at: ${harness.baseUrl}`);
-
-  // Test API calls
-  const healthResponse = await harness.callApi('GET', '/health');
-  console.log(`   ✓ Health check: ${healthResponse.status}`);
-
-  const greetingResponse = await harness.callApi('GET', '/good-day', null, {});
-  console.log(`   ✓ Greeting: ${greetingResponse.message}`);
-
-  // Test workflow simulation
-  const workflow = await harness.simulateWorkflow({
-    steps: [
-      {
-        id: 'step1',
-        type: 'task',
-        service: 'test-service',
-        operation: 'healthCheck'
-      },
-      {
-        id: 'step2',
-        type: 'task',
-        service: 'test-service',
-        operation: 'processData',
-        input: { test: 'data' }
-      }
-    ]
-  });
-  console.log(`   ✓ Workflow completed: ${workflow.completed}`);
-
-  // Check mock infrastructure
-  const messages = harness.getPublishedMessages();
-  console.log(`   ✓ Messages published: ${messages.length}`);
-
-  const registration = harness.getServiceRegistration();
-  console.log(`   ✓ Service registered: ${registration.name}`);
-
-  await harness.stop();
-  console.log('   ✓ Harness stopped\n');
-
-  // Test 2: Service Readiness Validator
-  console.log('2. Testing with ServiceReadinessValidator...\n');
-
-  // Start service for validation
-  const server = app.listen(4444);
-
-  const validator = new ServiceReadinessValidator();
-  const readiness = await validator.validateReadiness({
-    name: 'test-service',
-    url: 'http://localhost:4444',
-    openApiSpec,
-    healthEndpoint: '/health'
-  });
-
-  console.log(`   ✓ Readiness score: ${readiness.score}/${readiness.maxScore}`);
-  console.log(`   ✓ Service ready: ${readiness.ready}`);
-  console.log(`   ✓ Recommendation: ${readiness.recommendation}`);
-
-  // Show check results
-  console.log('\n   Check results:');
-  for (const [name, check] of Object.entries(readiness.checks)) {
-    const status = check.passed ? '✓' : '✗';
-    console.log(`     ${status} ${name}: ${check.passed ? 'Passed' : 'Failed'}`);
-  }
-
-  server.close();
-  console.log('\n   ✓ Validator test completed\n');
-
-  // Test 3: Test Orchestrator (Three-tier testing)
-  console.log('3. Testing with TestOrchestrator (three-tier)...\n');
-
-  const orchestrator = new TestOrchestrator({
-    service: app,
-    serviceName: 'test-service',
-    openApiSpec
-  });
-
-  // Run only unit tests for speed
-  console.log('   Running unit tests with full mocks...');
-  const unitResults = await orchestrator.runUnitTests();
-
-  console.log(`   ✓ Unit tests passed: ${unitResults.passed}`);
-  console.log(`   ✓ Coverage: ${unitResults.coverage}%`);
-  console.log(`   ✓ Tests run: ${unitResults.tests.length}`);
-
-  // Show individual test results
-  console.log('\n   Test results:');
-  unitResults.tests.forEach(test => {
-    const status = test.passed ? '✓' : '✗';
-    console.log(`     ${status} ${test.name}`);
-  });
-
-  console.log('\n=== All tests completed successfully! ===\n');
-}
-
-// Run the tests
-runTests().catch(error => {
-  console.error('Test failed:', error);
-  process.exit(1);
-});

package/tests/unit/CookbookTestRunner.test.js

@@ -1,353 +0,0 @@
-'use strict';
-
-const CookbookTestRunner = require('../../src/CookbookTestRunner');
-const fs = require('fs');
-const path = require('path');
-
-describe('CookbookTestRunner @unit', () => {
-  let runner;
-  const testServicePath = path.join(__dirname, '../fixtures/test-service');
-
-  beforeEach(() => {
-    runner = new CookbookTestRunner({
-      serviceName: 'test-service',
-      serviceUrl: 'http://localhost:3000',
-      servicePath: testServicePath,
-      mockInfrastructure: true
-    });
-  });
-
-  describe('constructor', () => {
-    test('should initialize with default options', () => {
-      const defaultRunner = new CookbookTestRunner({
-        serviceName: 'test'
-      });
-
-      expect(defaultRunner.serviceName).toBe('test');
-      expect(defaultRunner.serviceUrl).toBe('http://localhost:3000');
-      expect(defaultRunner.mockInfrastructure).toBe(true);
-      expect(defaultRunner.timeout).toBe(30000);
-    });
-
-    test('should accept custom options', () => {
-      const customRunner = new CookbookTestRunner({
-        serviceName: 'custom',
-        serviceUrl: 'http://localhost:5000',
-        mockInfrastructure: false,
-        timeout: 60000
-      });
-
-      expect(customRunner.serviceName).toBe('custom');
-      expect(customRunner.serviceUrl).toBe('http://localhost:5000');
-      expect(customRunner.mockInfrastructure).toBe(false);
-      expect(customRunner.timeout).toBe(60000);
-    });
-  });
-
-  describe('validateCookbook()', () => {
-    test('should validate valid cookbook', () => {
-      const validCookbook = {
-        version: '1.0.0',
-        steps: [{
-          id: 'test-1',
-          service: 'test-service',
-          operation: 'test-op',
-          input: {}
-        }]
-      };
-
-      expect(() => runner.validateCookbook(validCookbook)).not.toThrow();
-    });
-
-    test('should reject cookbook without steps', () => {
-      const invalidCookbook = {
-        version: '1.0.0'
-      };
-
-      expect(() => runner.validateCookbook(invalidCookbook))
-        .toThrow('Cookbook must have steps array');
-    });
-
-    test('should reject cookbook with empty steps', () => {
-      const invalidCookbook = {
-        version: '1.0.0',
-        steps: []
-      };
-
-      expect(() => runner.validateCookbook(invalidCookbook))
-        .toThrow('Cookbook must have at least one step');
-    });
-
-    test('should reject step without service', () => {
-      const invalidCookbook = {
-        version: '1.0.0',
-        steps: [{
-          operation: 'test-op'
-        }]
-      };
-
-      expect(() => runner.validateCookbook(invalidCookbook))
-        .toThrow('Step must have service');
-    });
-
-    test('should reject step without operation', () => {
-      const invalidCookbook = {
-        version: '1.0.0',
-        steps: [{
-          service: 'test-service'
-        }]
-      };
-
-      expect(() => runner.validateCookbook(invalidCookbook))
-        .toThrow('Step must have operation');
-    });
-  });
-
-  describe('hasExpectClauses()', () => {
-    test('should detect cookbook with expect clauses', () => {
-      const cookbook = {
-        steps: [{
-          service: 'test',
-          operation: 'op',
-          expect: { status: 'success' }
-        }]
-      };
-
-      expect(runner.hasExpectClauses(cookbook)).toBe(true);
-    });
-
-    test('should detect cookbook without expect clauses', () => {
-      const cookbook = {
-        steps: [{
-          service: 'test',
-          operation: 'op'
-        }]
-      };
-
-      expect(runner.hasExpectClauses(cookbook)).toBe(false);
-    });
-  });
-
-  describe('validateOutput()', () => {
-    test('should pass valid type check', () => {
-      const expected = {
-        message: { type: 'string' }
-      };
-
-      const actual = {
-        message: 'Hello'
-      };
-
-      const errors = runner.validateOutput(expected, actual);
-
-      expect(errors).toHaveLength(0);
-    });
-
-    test('should fail invalid type check', () => {
-      const expected = {
-        count: { type: 'number' }
-      };
-
-      const actual = {
-        count: 'not a number'
-      };
-
-      const errors = runner.validateOutput(expected, actual);
-
-      expect(errors.length).toBeGreaterThan(0);
-      expect(errors[0]).toContain('expected type number');
-    });
-
-    test('should pass contains check', () => {
-      const expected = {
-        message: { contains: 'Hello' }
-      };
-
-      const actual = {
-        message: 'Hello World'
-      };
-
-      const errors = runner.validateOutput(expected, actual);
-
-      expect(errors).toHaveLength(0);
-    });
-
-    test('should fail contains check', () => {
-      const expected = {
-        message: { contains: 'Goodbye' }
-      };
-
-      const actual = {
-        message: 'Hello World'
-      };
-
-      const errors = runner.validateOutput(expected, actual);
-
-      expect(errors.length).toBeGreaterThan(0);
-      expect(errors[0]).toContain('expected to contain');
-    });
-
-    test('should pass pattern check', () => {
-      const expected = {
-        timestamp: { pattern: '^\\d{4}-\\d{2}-\\d{2}T' }
-      };
-
-      const actual = {
-        timestamp: '2025-09-30T12:00:00Z'
-      };
-
-      const errors = runner.validateOutput(expected, actual);
-
-      expect(errors).toHaveLength(0);
-    });
-
-    test('should fail pattern check', () => {
-      const expected = {
-        code: { pattern: '^[A-Z]{3}$' }
-      };
-
-      const actual = {
-        code: 'invalid'
-      };
-
-      const errors = runner.validateOutput(expected, actual);
-
-      expect(errors.length).toBeGreaterThan(0);
-      expect(errors[0]).toContain('does not match pattern');
-    });
-
-    test('should pass equals check', () => {
-      const expected = {
-        status: { equals: 'active' }
-      };
-
-      const actual = {
-        status: 'active'
-      };
-
-      const errors = runner.validateOutput(expected, actual);
-
-      expect(errors).toHaveLength(0);
-    });
-
-    test('should fail equals check', () => {
-      const expected = {
-        status: { equals: 'active' }
-      };
-
-      const actual = {
-        status: 'inactive'
-      };
-
-      const errors = runner.validateOutput(expected, actual);
-
-      expect(errors.length).toBeGreaterThan(0);
-      expect(errors[0]).toContain('expected active');
-    });
-
-    test('should pass range check', () => {
-      const expected = {
-        count: { min: 0, max: 100 }
-      };
-
-      const actual = {
-        count: 50
-      };
-
-      const errors = runner.validateOutput(expected, actual);
-
-      expect(errors).toHaveLength(0);
-    });
-
-    test('should fail min check', () => {
-      const expected = {
-        count: { min: 10 }
-      };
-
-      const actual = {
-        count: 5
-      };
-
-      const errors = runner.validateOutput(expected, actual);
-
-      expect(errors.length).toBeGreaterThan(0);
-      expect(errors[0]).toContain('less than min');
-    });
-
-    test('should fail max check', () => {
-      const expected = {
-        count: { max: 100 }
-      };
-
-      const actual = {
-        count: 150
-      };
-
-      const errors = runner.validateOutput(expected, actual);
-
-      expect(errors.length).toBeGreaterThan(0);
-      expect(errors[0]).toContain('exceeds max');
-    });
-
-    test('should check field existence', () => {
-      const expected = {
-        optional: { exists: false },
-        required: { exists: true }
-      };
-
-      const actual = {
-        required: 'value'
-      };
-
-      const errors = runner.validateOutput(expected, actual);
-
-      expect(errors).toHaveLength(0);
-    });
-
-    test('should detect missing required field', () => {
-      const expected = {
-        required: { exists: true }
-      };
-
-      const actual = {};
-
-      const errors = runner.validateOutput(expected, actual);
-
-      expect(errors.length).toBeGreaterThan(0);
-      expect(errors[0]).toContain('expected to exist');
-    });
-  });
-
-  describe('getResults()', () => {
-    test('should return initialized results', () => {
-      const results = runner.getResults();
-
-      expect(results).toEqual({
-        total: 0,
-        passed: 0,
-        failed: 0,
-        duration: 0,
-        steps: []
-      });
-    });
-  });
-
-  describe('resetResults()', () => {
-    test('should reset results', () => {
-      // Simulate some test runs
-      runner.results.total = 5;
-      runner.results.passed = 3;
-      runner.results.failed = 2;
-
-      runner.resetResults();
-
-      expect(runner.results).toEqual({
-        total: 0,
-        passed: 0,
-        failed: 0,
-        duration: 0,
-        steps: []
-      });
-    });
-  });
-});