@onlineapps/conn-orch-validator 2.0.0

package/tests/monitoring-e2e.test.js

@@ -0,0 +1,315 @@
+/**
+ * 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');
+      }
+    });
+  });
+});

package/tests/run-example.js

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