@onlineapps/conn-orch-validator 2.0.6 → 2.0.9

package/tests/integration/ServiceReadiness.test.js

@@ -1,265 +0,0 @@
-'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();
-    });
-  });
-});

package/tests/monitoring-e2e.test.js

@@ -1,315 +0,0 @@
-/**
- * End-to-End tests for monitoring infrastructure
- * Tests the complete flow from service through monitoring to telemetry
- */
-
-const amqp = require('amqplib');
-const axios = require('axios');
-
-describe('Monitoring E2E Tests @e2e', () => {
-  let connection;
-  let channel;
-  const RABBITMQ_URL = process.env.AMQP_URL || 'amqp://localhost:5672';
-  const HELLO_SERVICE_URL = 'http://localhost:33199';
-
-  beforeAll(async () => {
-    try {
-      connection = await amqp.connect(RABBITMQ_URL);
-      channel = await connection.createChannel();
-
-      // Setup test exchange and queue
-      await channel.assertExchange('test.exchange', 'topic', { durable: false });
-      await channel.assertQueue('test.monitoring', { durable: false });
-      await channel.bindQueue('test.monitoring', 'test.exchange', 'monitoring.#');
-    } catch (error) {
-      console.error('Failed to connect to RabbitMQ:', error);
-    }
-  });
-
-  afterAll(async () => {
-    if (channel) await channel.close();
-    if (connection) await connection.close();
-  });
-
-  describe('Service to Monitoring Flow', () => {
-    test('should generate monitoring data from service call', async () => {
-      // Skip if services not available
-      if (!connection) {
-        console.log('Skipping - RabbitMQ not available');
-        return;
-      }
-
-      // Send cookbook message to service
-      const cookbook = {
-        id: 'e2e-test-1',
-        type: 'hello',
-        name: 'good-day',
-        version: '1.0.0',
-        metadata: {
-          workflowId: 'e2e-wf-1',
-          timestamp: new Date().toISOString()
-        }
-      };
-
-      // Send to service via MQ
-      const replyQueue = await channel.assertQueue('', { exclusive: true });
-      const correlationId = 'e2e-corr-1';
-
-      await channel.sendToQueue(
-        'hello-service',
-        Buffer.from(JSON.stringify(cookbook)),
-        {
-          correlationId,
-          replyTo: replyQueue.queue
-        }
-      );
-
-      // Wait for response
-      const response = await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          reject(new Error('Timeout waiting for response'));
-        }, 5000);
-
-        channel.consume(replyQueue.queue, (msg) => {
-          if (msg.properties.correlationId === correlationId) {
-            clearTimeout(timeout);
-            resolve(JSON.parse(msg.content.toString()));
-          }
-        }, { noAck: true });
-      });
-
-      expect(response).toBeDefined();
-      expect(response.status).toBeDefined();
-    });
-
-    test('should track workflow through monitoring', async () => {
-      // Direct HTTP call to service
-      try {
-        const response = await axios.post(`${HELLO_SERVICE_URL}/api/workflow`, {
-          workflowId: 'e2e-wf-2',
-          operation: 'good-day',
-          data: {
-            message: 'E2E test'
-          }
-        });
-
-        expect(response.status).toBe(200);
-        expect(response.data).toBeDefined();
-      } catch (error) {
-        // Service might not be running
-        console.log('Service not available, skipping HTTP test');
-      }
-    });
-  });
-
-  describe('Monitoring Data Collection', () => {
-    test('should collect logs from monitoring', async () => {
-      if (!channel) {
-        console.log('Skipping - no channel available');
-        return;
-      }
-
-      // Setup consumer for monitoring messages
-      const messages = [];
-
-      await channel.consume('test.monitoring', (msg) => {
-        if (msg) {
-          messages.push(JSON.parse(msg.content.toString()));
-          channel.ack(msg);
-        }
-      });
-
-      // Trigger some monitoring events
-      const testCookbook = {
-        id: 'monitor-test-1',
-        type: 'hello',
-        name: 'test-monitoring',
-        version: '1.0.0'
-      };
-
-      await channel.sendToQueue(
-        'hello-service',
-        Buffer.from(JSON.stringify(testCookbook))
-      );
-
-      // Wait for messages
-      await new Promise(resolve => setTimeout(resolve, 1000));
-
-      // Check if we received monitoring data
-      if (messages.length > 0) {
-        expect(messages[0]).toHaveProperty('timestamp');
-        expect(messages[0]).toHaveProperty('level');
-      }
-    });
-
-    test('should collect metrics from monitoring', async () => {
-      // This would connect to metrics endpoint if available
-      // For now, we just verify the structure
-
-      const metricsData = {
-        timestamp: new Date().toISOString(),
-        metric: 'requests.total',
-        value: 1,
-        labels: {
-          service: 'hello-service',
-          endpoint: '/good-day',
-          status: 'success'
-        }
-      };
-
-      expect(metricsData).toHaveProperty('timestamp');
-      expect(metricsData).toHaveProperty('metric');
-      expect(metricsData).toHaveProperty('value');
-      expect(metricsData.labels).toHaveProperty('service');
-    });
-  });
-
-  describe('Error Tracking E2E', () => {
-    test('should track errors through monitoring system', async () => {
-      if (!channel) {
-        console.log('Skipping - no channel available');
-        return;
-      }
-
-      // Send invalid cookbook to trigger error
-      const invalidCookbook = {
-        // Missing required fields
-        type: 'invalid'
-      };
-
-      const errorQueue = await channel.assertQueue('', { exclusive: true });
-      const correlationId = 'error-test-1';
-
-      await channel.sendToQueue(
-        'hello-service',
-        Buffer.from(JSON.stringify(invalidCookbook)),
-        {
-          correlationId,
-          replyTo: errorQueue.queue
-        }
-      );
-
-      // Wait for error response
-      const errorResponse = await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-          resolve({ error: 'timeout' });
-        }, 2000);
-
-        channel.consume(errorQueue.queue, (msg) => {
-          if (msg && msg.properties.correlationId === correlationId) {
-            clearTimeout(timeout);
-            resolve(JSON.parse(msg.content.toString()));
-          }
-        }, { noAck: true });
-      });
-
-      // Should receive error response or timeout
-      expect(errorResponse).toBeDefined();
-    });
-  });
-
-  describe('Performance Monitoring E2E', () => {
-    test('should measure end-to-end latency', async () => {
-      if (!channel) {
-        console.log('Skipping - no channel available');
-        return;
-      }
-
-      const startTime = Date.now();
-
-      const cookbook = {
-        id: 'perf-test-1',
-        type: 'hello',
-        name: 'good-day',
-        version: '1.0.0'
-      };
-
-      const perfQueue = await channel.assertQueue('', { exclusive: true });
-      const correlationId = 'perf-corr-1';
-
-      await channel.sendToQueue(
-        'hello-service',
-        Buffer.from(JSON.stringify(cookbook)),
-        {
-          correlationId,
-          replyTo: perfQueue.queue
-        }
-      );
-
-      await new Promise((resolve) => {
-        const timeout = setTimeout(resolve, 2000);
-
-        channel.consume(perfQueue.queue, (msg) => {
-          if (msg && msg.properties.correlationId === correlationId) {
-            clearTimeout(timeout);
-            resolve();
-          }
-        }, { noAck: true });
-      });
-
-      const latency = Date.now() - startTime;
-
-      // E2E latency should be reasonable
-      expect(latency).toBeLessThan(5000);
-
-      console.log(`E2E latency: ${latency}ms`);
-    });
-
-    test('should handle concurrent requests', async () => {
-      if (!channel) {
-        console.log('Skipping - no channel available');
-        return;
-      }
-
-      const concurrentCount = 10;
-      const promises = [];
-
-      for (let i = 0; i < concurrentCount; i++) {
-        const cookbook = {
-          id: `concurrent-${i}`,
-          type: 'hello',
-          name: 'good-day',
-          version: '1.0.0'
-        };
-
-        const promise = channel.sendToQueue(
-          'hello-service',
-          Buffer.from(JSON.stringify(cookbook))
-        );
-
-        promises.push(promise);
-      }
-
-      await Promise.all(promises);
-
-      // All messages should be sent successfully
-      expect(promises.length).toBe(concurrentCount);
-    });
-  });
-
-  describe('Monitoring Health Check', () => {
-    test('should verify monitoring infrastructure is healthy', async () => {
-      // Check RabbitMQ connection
-      expect(connection).toBeDefined();
-
-      // Check if monitoring exchanges exist
-      if (channel) {
-        try {
-          await channel.checkExchange('telemetry.exchange');
-          console.log('Telemetry exchange exists');
-        } catch (error) {
-          console.log('Telemetry exchange not found (expected in test env)');
-        }
-      }
-
-      // Check service health endpoint if available
-      try {
-        const health = await axios.get(`${HELLO_SERVICE_URL}/health`);
-        expect(health.status).toBe(200);
-        expect(health.data.status).toBe('ok');
-      } catch (error) {
-        console.log('Service health check not available');
-      }
-    });
-  });
-});