@onlineapps/conn-orch-validator 2.0.0

package/test-orchestrator.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Quick test of ValidationOrchestrator
+ *
+ * Usage: node test-orchestrator.js <serviceRoot>
+ * Example: node test-orchestrator.js /var/www/html/oa_drive/services/hello-service
+ *
+ * Loads service configuration from conn-config/config.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const ValidationOrchestrator = require('./src/ValidationOrchestrator');
+
+async function test() {
+  // Get service root from CLI or default to hello-service
+  const serviceRoot = process.argv[2] || path.resolve(__dirname, '../../../services/hello-service');
+
+  if (!fs.existsSync(serviceRoot)) {
+    console.error(`❌ Service root not found: ${serviceRoot}`);
+    console.error('Usage: node test-orchestrator.js <serviceRoot>');
+    process.exit(1);
+  }
+
+  // Load service configuration
+  const configPath = path.join(serviceRoot, 'conn-config', 'config.json');
+  if (!fs.existsSync(configPath)) {
+    console.error(`❌ Config not found: ${configPath}`);
+    console.error('Service must have conn-config/config.json');
+    process.exit(1);
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  const serviceName = config.service?.name;
+  const serviceVersion = config.service?.version;
+
+  if (!serviceName || !serviceVersion) {
+    console.error('❌ Config must contain service.name and service.version');
+    process.exit(1);
+  }
+
+  console.log(`🧪 Testing ValidationOrchestrator`);
+  console.log(`   Service: ${serviceName} v${serviceVersion}`);
+  console.log(`   Root: ${serviceRoot}\n`);
+
+  const orchestrator = new ValidationOrchestrator({
+    serviceRoot,
+    serviceName,
+    serviceVersion,
+    logger: console
+  });
+
+  try {
+    const result = await orchestrator.validate();
+
+    console.log('\n📊 Validation Results:');
+    console.log('Success:', result.success);
+    console.log('Duration:', result.durationMs, 'ms');
+
+    if (result.skipped) {
+      console.log('✓ Used existing proof (validation skipped)');
+      console.log('Fingerprint:', result.proof?.fingerprint);
+    } else {
+      console.log('Tests run:', result.totalTests);
+      console.log('Tests passed:', result.passedTests);
+      console.log('Tests failed:', result.failedTests);
+
+      if (result.errors && result.errors.length > 0) {
+        console.log('\n❌ Errors:');
+        result.errors.forEach(err => console.log('  -', err));
+      }
+
+      if (result.warnings && result.warnings.length > 0) {
+        console.log('\n⚠️  Warnings:');
+        result.warnings.forEach(warn => console.log('  -', warn));
+      }
+
+      if (result.proof) {
+        console.log('\n✅ Proof generated:');
+        console.log('  Fingerprint:', result.fingerprint);
+        console.log('  Location: conn-runtime/validation-proof.json');
+      }
+    }
+
+    process.exit(result.success ? 0 : 1);
+  } catch (error) {
+    console.error('\n❌ Test failed:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+test();

package/tests/component/testing-framework-integration.test.js

@@ -0,0 +1,313 @@
+'use strict';
+
+/**
+ * Component tests for E2E Testing Framework
+ * Tests the integration between different testing utilities
+ */
+
+describe('E2E Testing Framework Integration @component', () => {
+  let framework;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    delete require.cache[require.resolve('../../src/index.js')];
+    framework = require('../../src/index.js');
+  });
+
+  describe('Framework Exports', () => {
+    it('should export all mock components', () => {
+      expect(framework.MockMQClient).toBeDefined();
+      expect(framework.MockRegistry).toBeDefined();
+      expect(framework.MockStorage).toBeDefined();
+    });
+
+    it('should export all test utilities', () => {
+      expect(framework.ServiceTestHarness).toBeDefined();
+      expect(framework.ServiceValidator).toBeDefined();
+      expect(framework.WorkflowTestRunner).toBeDefined();
+      expect(framework.CookbookTestUtils).toBeDefined();
+      expect(framework.ServiceReadinessValidator).toBeDefined();
+      expect(framework.TestOrchestrator).toBeDefined();
+    });
+
+    it('should export factory functions', () => {
+      expect(typeof framework.createTestHarness).toBe('function');
+      expect(typeof framework.createValidator).toBe('function');
+      expect(typeof framework.createMockMQ).toBe('function');
+      expect(typeof framework.createMockRegistry).toBe('function');
+      expect(typeof framework.createMockStorage).toBe('function');
+    });
+  });
+
+  describe('Factory Functions', () => {
+    it('should create MockMQClient instance', () => {
+      const mq = framework.createMockMQ();
+      expect(mq.constructor.name).toBe('MockMQClient');
+      expect(typeof mq.connect).toBe('function');
+      expect(typeof mq.publish).toBe('function');
+    });
+
+    it('should create MockRegistry instance', () => {
+      const registry = framework.createMockRegistry();
+      expect(registry.constructor.name).toBe('MockRegistry');
+      expect(typeof registry.register).toBe('function');
+      expect(typeof registry.discover).toBe('function');
+    });
+
+    it('should create MockStorage instance', () => {
+      const storage = framework.createMockStorage();
+      expect(storage.constructor.name).toBe('MockStorage');
+      expect(typeof storage.upload).toBe('function');
+      expect(typeof storage.download).toBe('function');
+    });
+
+    it('should create ServiceTestHarness with options', () => {
+      const harness = framework.createTestHarness({
+        serviceName: 'test-service'
+      });
+      expect(harness.constructor.name).toBe('ServiceTestHarness');
+      expect(harness.serviceName).toBe('test-service');
+    });
+
+    it('should create ServiceValidator with options', () => {
+      const validator = framework.createValidator({
+        services: ['service1', 'service2']
+      });
+      expect(validator.constructor.name).toBe('ServiceValidator');
+      expect(validator.services).toEqual(['service1', 'service2']);
+    });
+  });
+
+  describe('Component Integration', () => {
+    it('should allow ServiceTestHarness to use mocks', async () => {
+      const harness = new framework.ServiceTestHarness({
+        serviceName: 'integration-test'
+      });
+
+      await harness.setup();
+
+      // Harness should have created mock instances
+      expect(harness.mq).toBeDefined();
+      expect(harness.registry).toBeDefined();
+      expect(harness.storage).toBeDefined();
+
+      await harness.cleanup();
+    });
+
+    it('should allow WorkflowTestRunner to use MockMQClient', async () => {
+      const mq = new framework.MockMQClient();
+      const runner = new framework.WorkflowTestRunner({
+        mq: mq
+      });
+
+      expect(runner.mq).toBe(mq);
+      expect(runner.state).toBeDefined();
+    });
+
+    it('should allow ServiceValidator to work with OpenAPI specs', () => {
+      const validator = new framework.ServiceValidator();
+
+      const spec = {
+        openapi: '3.0.0',
+        paths: {
+          '/test': {
+            get: {
+              responses: {
+                '200': { description: 'Success' }
+              }
+            }
+          }
+        }
+      };
+
+      const paths = validator.countEndpoints(spec.paths);
+      expect(paths).toBeGreaterThan(0);
+    });
+
+    it('should allow CookbookTestUtils to generate valid cookbooks', () => {
+      const utils = new framework.CookbookTestUtils();
+
+      const cookbook = utils.generateCookbook({
+        name: 'test-cookbook',
+        steps: 3
+      });
+
+      expect(cookbook.name).toBe('test-cookbook');
+      expect(cookbook.version).toBeDefined();
+      expect(cookbook.steps).toHaveLength(3);
+      expect(cookbook.steps[0]).toHaveProperty('service');
+      expect(cookbook.steps[0]).toHaveProperty('operation');
+    });
+
+    it('should allow TestOrchestrator to coordinate components', () => {
+      const harness = new framework.ServiceTestHarness({
+        serviceName: 'orchestrated-test'
+      });
+      const validator = new framework.ServiceValidator();
+      const runner = new framework.WorkflowTestRunner({
+        mq: new framework.MockMQClient()
+      });
+
+      const orchestrator = new framework.TestOrchestrator({
+        harness,
+        validator,
+        runner
+      });
+
+      expect(orchestrator.harness).toBe(harness);
+      expect(orchestrator.validator).toBe(validator);
+      expect(orchestrator.runner).toBe(runner);
+    });
+  });
+
+  describe('Mock Components Behavior', () => {
+    it('MockMQClient should handle basic operations', async () => {
+      const mq = new framework.MockMQClient();
+
+      // Should connect
+      await mq.connect();
+      expect(mq.isConnected).toBe(true);
+
+      // Should publish messages
+      await mq.publish('test-queue', { test: true });
+      const messages = mq.getMessages('test-queue');
+      expect(messages).toHaveLength(1);
+      expect(messages[0]).toEqual({ test: true });
+
+      // Should disconnect
+      await mq.disconnect();
+      expect(mq.isConnected).toBe(false);
+    });
+
+    it('MockRegistry should handle service registration', async () => {
+      const registry = new framework.MockRegistry();
+
+      // Should register service
+      await registry.register({
+        name: 'test-service',
+        version: '1.0.0'
+      });
+
+      // Should discover service
+      const services = await registry.discover('test-service');
+      expect(services).toHaveLength(1);
+      expect(services[0].name).toBe('test-service');
+    });
+
+    it('MockStorage should handle file operations', async () => {
+      const storage = new framework.MockStorage();
+
+      // Should upload file
+      const data = Buffer.from('test data');
+      await storage.upload('bucket', 'key', data);
+
+      // Should download file
+      const retrieved = await storage.download('bucket', 'key');
+      expect(retrieved.toString()).toBe('test data');
+
+      // Should list files
+      const files = await storage.list('bucket');
+      expect(files).toContain('key');
+    });
+  });
+
+  describe('Testing Utilities Behavior', () => {
+    it('ServiceReadinessValidator should check readiness', async () => {
+      const validator = new framework.ServiceReadinessValidator({
+        services: ['api', 'worker']
+      });
+
+      // Mock service readiness
+      validator.mockServiceReady('api');
+      validator.mockServiceReady('worker');
+
+      const allReady = await validator.checkAll();
+      expect(allReady).toBe(true);
+    });
+
+    it('CookbookTestUtils should validate cookbook structure', () => {
+      const utils = new framework.CookbookTestUtils();
+
+      const validCookbook = {
+        name: 'valid-cookbook',
+        version: '1.0.0',
+        steps: [
+          {
+            service: 'service1',
+            operation: 'process'
+          }
+        ]
+      };
+
+      const validation = utils.validate(validCookbook);
+      expect(validation.valid).toBe(true);
+
+      const invalidCookbook = { steps: [] };
+      const invalidValidation = utils.validate(invalidCookbook);
+      expect(invalidValidation.valid).toBe(false);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle missing configuration gracefully', () => {
+      expect(() => new framework.ServiceTestHarness()).not.toThrow();
+      expect(() => new framework.ServiceValidator()).not.toThrow();
+      expect(() => new framework.WorkflowTestRunner()).not.toThrow();
+    });
+
+    it('should handle invalid operations gracefully', async () => {
+      const mq = new framework.MockMQClient();
+
+      // Should fail when not connected
+      await expect(mq.publish('queue', {}))
+        .rejects.toThrow('Not connected');
+
+      // Storage should fail on non-existent files
+      const storage = new framework.MockStorage();
+      await expect(storage.download('bucket', 'nonexistent'))
+        .rejects.toThrow();
+    });
+  });
+
+  describe('Complete Testing Workflow', () => {
+    it('should support complete test workflow', async () => {
+      // 1. Setup test environment
+      const harness = new framework.ServiceTestHarness({
+        serviceName: 'complete-test'
+      });
+      await harness.setup();
+
+      // 2. Register mock services
+      await harness.registry.register({
+        name: 'service1',
+        version: '1.0.0'
+      });
+
+      // 3. Create test cookbook
+      const utils = new framework.CookbookTestUtils();
+      const cookbook = utils.generateCookbook({
+        name: 'test-workflow',
+        steps: 2
+      });
+
+      // 4. Run workflow
+      const runner = new framework.WorkflowTestRunner({
+        mq: harness.mq
+      });
+
+      // Mock step execution
+      runner.mockStepResponse('test-service-0', { success: true });
+      runner.mockStepResponse('test-service-1', { complete: true });
+
+      const result = await runner.runWorkflow(cookbook, { input: 'data' });
+      expect(result.status).toBe('completed');
+
+      // 5. Validate results
+      const validator = new framework.ServiceValidator();
+      expect(validator).toBeDefined();
+
+      // 6. Cleanup
+      await harness.cleanup();
+    });
+  });
+});

package/tests/integration/ServiceReadiness.test.js

@@ -0,0 +1,265 @@
+'use strict';
+
+/**
+ * Integration test for complete service readiness validation
+ * Uses existing connector tests, doesn't duplicate them
+ */
+
+const { ServiceTestHarness, ServiceValidator, WorkflowTestRunner } = require('../../src');
+const express = require('express');
+
+describe('Service Readiness Integration @integration', () => {
+  let harness;
+  let app;
+  let openApiSpec;
+
+  beforeEach(() => {
+    // Create minimal test service
+    app = express();
+    app.use(express.json());
+    
+    app.get('/health', (req, res) => {
+      res.json({ status: 'healthy' });
+    });
+    
+    app.post('/process', (req, res) => {
+      res.json({ processed: true, data: req.body });
+    });
+
+    openApiSpec = {
+      openapi: '3.0.0',
+      info: { title: 'Test Service', version: '1.0.0' },
+      paths: {
+        '/health': {
+          get: {
+            operationId: 'healthCheck',
+            responses: {
+              '200': {
+                content: {
+                  'application/json': {
+                    schema: {
+                      type: 'object',
+                      properties: {
+                        status: { type: 'string' }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        '/process': {
+          post: {
+            operationId: 'processData',
+            requestBody: {
+              content: {
+                'application/json': {
+                  schema: { type: 'object' }
+                }
+              }
+            },
+            responses: {
+              '200': {
+                content: {
+                  'application/json': {
+                    schema: { type: 'object' }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+  });
+
+  afterEach(async () => {
+    if (harness) {
+      await harness.stop();
+    }
+  });
+
+  describe('Complete Service Validation', () => {
+    it('should validate service is ready for production', async () => {
+      harness = new ServiceTestHarness({
+        service: app,
+        serviceName: 'test-service',
+        openApiSpec,
+        mockInfrastructure: true
+      });
+
+      await harness.start();
+
+      // 1. Verify service is registered
+      const registration = harness.getServiceRegistration();
+      expect(registration).toBeDefined();
+      expect(registration.name).toBe('test-service');
+      expect(registration.status).toBe('active');
+
+      // 2. Validate OpenAPI compliance
+      const validator = new ServiceValidator();
+      const validation = await validator.validateService(
+        harness.baseUrl,
+        openApiSpec
+      );
+      expect(validation.valid).toBe(true);
+      expect(validation.coverage).toBe(100);
+
+      // 3. Test workflow execution
+      const workflow = await harness.simulateWorkflow({
+        steps: [
+          {
+            id: 'step1',
+            type: 'task',
+            service: 'test-service',
+            operation: 'processData',
+            input: { test: 'data' }
+          }
+        ]
+      });
+      expect(workflow.completed).toBe(true);
+
+      // 4. Verify message queue integration
+      const messages = harness.getPublishedMessages('workflow.completed');
+      expect(messages.length).toBeGreaterThan(0);
+    });
+
+    it('should detect service not ready - missing endpoints', async () => {
+      // Remove an endpoint
+      delete openApiSpec.paths['/process'];
+
+      harness = new ServiceTestHarness({
+        service: app,
+        serviceName: 'test-service',
+        openApiSpec,
+        mockInfrastructure: true
+      });
+
+      await harness.start();
+
+      const validator = new ServiceValidator();
+      const validation = await validator.validateService(
+        harness.baseUrl,
+        openApiSpec
+      );
+      
+      // Service still works but coverage is reduced
+      expect(validation.valid).toBe(true);
+      expect(validation.coverage).toBeLessThan(100);
+    });
+  });
+
+  describe('Cookbook Validation for Production', () => {
+    it('should validate cookbook can execute in environment', async () => {
+      harness = new ServiceTestHarness({
+        service: app,
+        serviceName: 'test-service',
+        openApiSpec,
+        mockInfrastructure: true
+      });
+
+      await harness.start();
+
+      const cookbook = {
+        version: '1.0.0',
+        steps: [
+          {
+            id: 'validate',
+            type: 'task',
+            service: 'test-service',
+            operation: 'healthCheck'
+          },
+          {
+            id: 'process',
+            type: 'task',
+            service: 'test-service',
+            operation: 'processData',
+            input: { data: '$steps.validate' }
+          }
+        ]
+      };
+
+      // Validate cookbook structure
+      const validator = new ServiceValidator();
+      const cookbookValidation = await validator.validateCookbook(
+        cookbook,
+        harness.registry
+      );
+      expect(cookbookValidation.valid).toBe(true);
+
+      // Execute cookbook
+      const runner = new WorkflowTestRunner({
+        mqClient: harness.mqClient,
+        registry: harness.registry,
+        storage: harness.storage
+      });
+
+      const workflow = await runner.runWorkflow(cookbook);
+      expect(workflow.status).toBe('completed');
+      expect(workflow.results).toHaveLength(2);
+    });
+  });
+
+  describe('Production Deployment Readiness', () => {
+    it('should verify all production requirements', async () => {
+      harness = new ServiceTestHarness({
+        service: app,
+        serviceName: 'test-service',
+        openApiSpec,
+        mockInfrastructure: true
+      });
+
+      await harness.start();
+
+      const readinessChecks = {
+        serviceRunning: false,
+        apiAccessible: false,
+        registryConnected: false,
+        mqConnected: false,
+        openApiValid: false,
+        healthCheckPassing: false
+      };
+
+      // Check service is running
+      readinessChecks.serviceRunning = harness.isRunning;
+
+      // Check API is accessible
+      try {
+        const response = await harness.callApi('GET', '/health');
+        readinessChecks.apiAccessible = true;
+        readinessChecks.healthCheckPassing = response.status === 'healthy';
+      } catch (e) {
+        // API not accessible
+      }
+
+      // Check registry connection
+      readinessChecks.registryConnected = !!harness.getServiceRegistration();
+
+      // Check MQ connection
+      readinessChecks.mqConnected = harness.mqClient.isConnected;
+
+      // Validate OpenAPI
+      const validator = new ServiceValidator();
+      const validation = await validator.validateService(
+        harness.baseUrl,
+        openApiSpec
+      );
+      readinessChecks.openApiValid = validation.valid;
+
+      // All checks should pass
+      expect(readinessChecks).toEqual({
+        serviceRunning: true,
+        apiAccessible: true,
+        registryConnected: true,
+        mqConnected: true,
+        openApiValid: true,
+        healthCheckPassing: true
+      });
+
+      // Get statistics
+      const stats = harness.getStats();
+      expect(stats).toBeDefined();
+    });
+  });
+});