@onlineapps/conn-orch-validator 2.0.0

package/tests/unit/CookbookTestRunner.test.js

@@ -0,0 +1,353 @@
+'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: []
+      });
+    });
+  });
+});

package/tests/unit/MockMQClient.test.js

@@ -0,0 +1,190 @@
+'use strict';
+
+const MockMQClient = require('../../src/mocks/MockMQClient');
+
+describe('MockMQClient @unit', () => {
+  let mqClient;
+
+  beforeEach(() => {
+    mqClient = new MockMQClient();
+  });
+
+  describe('Connection Management', () => {
+    it('should connect successfully', async () => {
+      expect(mqClient.isConnected).toBe(false);
+      await mqClient.connect();
+      expect(mqClient.isConnected).toBe(true);
+    });
+
+    it('should disconnect successfully', async () => {
+      await mqClient.connect();
+      expect(mqClient.isConnected).toBe(true);
+      await mqClient.disconnect();
+      expect(mqClient.isConnected).toBe(false);
+    });
+
+    it('should clear consumers on disconnect', async () => {
+      await mqClient.connect();
+      await mqClient.consume('test-queue', jest.fn());
+      expect(Object.keys(mqClient.consumers)).toHaveLength(1);
+      await mqClient.disconnect();
+      expect(Object.keys(mqClient.consumers)).toHaveLength(0);
+    });
+  });
+
+  describe('Publishing Messages', () => {
+    beforeEach(async () => {
+      await mqClient.connect();
+    });
+
+    it('should publish message to queue', async () => {
+      const message = { test: 'data' };
+      await mqClient.publish('test-queue', message);
+      
+      const messages = mqClient.getMessages('test-queue');
+      expect(messages).toHaveLength(1);
+      expect(messages[0]).toEqual(message);
+    });
+
+    it('should track published messages', async () => {
+      await mqClient.publish('queue1', { msg: 1 });
+      await mqClient.publish('queue2', { msg: 2 });
+      
+      const allPublished = mqClient.getPublishedMessages();
+      expect(allPublished).toHaveLength(2);
+      
+      const queue1Messages = mqClient.getPublishedMessages('queue1');
+      expect(queue1Messages).toHaveLength(1);
+      expect(queue1Messages[0].message).toEqual({ msg: 1 });
+    });
+
+    it('should throw error when not connected', async () => {
+      await mqClient.disconnect();
+      await expect(mqClient.publish('test', {})).rejects.toThrow('Not connected to MQ');
+    });
+
+    it('should include message options', async () => {
+      const options = { priority: 1, persistent: true };
+      await mqClient.publish('test-queue', { test: 'data' }, options);
+      
+      const published = mqClient.getPublishedMessages()[0];
+      expect(published.options).toEqual(options);
+    });
+  });
+
+  describe('Consuming Messages', () => {
+    let callback;
+
+    beforeEach(async () => {
+      callback = jest.fn();
+      await mqClient.connect();
+    });
+
+    it('should register consumer', async () => {
+      await mqClient.consume('test-queue', callback);
+      expect(mqClient.consumers['test-queue']).toBeDefined();
+      expect(mqClient.consumers['test-queue'].callback).toBe(callback);
+    });
+
+    it('should process existing messages when consuming', async () => {
+      await mqClient.publish('test-queue', { msg: 1 });
+      await mqClient.publish('test-queue', { msg: 2 });
+      
+      await mqClient.consume('test-queue', callback);
+      
+      // Wait for async processing
+      await new Promise(resolve => setTimeout(resolve, 10));
+      
+      expect(callback).toHaveBeenCalledTimes(2);
+    });
+
+    it('should trigger consumer on new message', async () => {
+      await mqClient.consume('test-queue', callback);
+      await mqClient.publish('test-queue', { test: 'data' });
+      
+      // Wait for async processing
+      await new Promise(resolve => setTimeout(resolve, 10));
+      
+      expect(callback).toHaveBeenCalledTimes(1);
+      const call = callback.mock.calls[0][0];
+      expect(JSON.parse(call.content.toString())).toEqual({ test: 'data' });
+    });
+
+    it('should throw error when not connected', async () => {
+      await mqClient.disconnect();
+      await expect(mqClient.consume('test', jest.fn())).rejects.toThrow('Not connected to MQ');
+    });
+  });
+
+  describe('Message Acknowledgement', () => {
+    let message;
+
+    beforeEach(async () => {
+      await mqClient.connect();
+      message = {
+        content: Buffer.from(JSON.stringify({ test: 'data' })),
+        fields: { routingKey: 'test-queue' }
+      };
+    });
+
+    it('should acknowledge message', async () => {
+      await mqClient.ack(message);
+      expect(mqClient.acknowledgedMessages).toHaveLength(1);
+      expect(mqClient.acknowledgedMessages[0].message).toBe(message);
+    });
+
+    it('should reject message without requeue', async () => {
+      await mqClient.nack(message, false, false);
+      expect(mqClient.rejectedMessages).toHaveLength(1);
+      expect(mqClient.rejectedMessages[0].requeue).toBe(false);
+    });
+
+    it('should reject and requeue message', async () => {
+      await mqClient.nack(message, false, true);
+      expect(mqClient.rejectedMessages).toHaveLength(1);
+      expect(mqClient.rejectedMessages[0].requeue).toBe(true);
+      
+      const messages = mqClient.getMessages('test-queue');
+      expect(messages).toHaveLength(1);
+    });
+  });
+
+  describe('Statistics and Clearing', () => {
+    beforeEach(async () => {
+      await mqClient.connect();
+    });
+
+    it('should return statistics', async () => {
+      await mqClient.publish('queue1', { msg: 1 });
+      await mqClient.publish('queue2', { msg: 2 });
+      await mqClient.consume('queue1', jest.fn());
+      
+      const stats = mqClient.getStats();
+      expect(stats.queues).toEqual(['queue1', 'queue2']);
+      expect(stats.messageCount).toBe(2);
+      expect(stats.published).toBe(2);
+      expect(stats.consumers).toEqual(['queue1']);
+    });
+
+    it('should clear all data', async () => {
+      await mqClient.publish('test', { msg: 1 });
+      await mqClient.ack({ test: 'message' });
+      
+      mqClient.clear();
+      
+      expect(mqClient.getMessages('test')).toHaveLength(0);
+      expect(mqClient.publishedMessages).toHaveLength(0);
+      expect(mqClient.acknowledgedMessages).toHaveLength(0);
+      expect(mqClient.rejectedMessages).toHaveLength(0);
+    });
+  });
+
+  describe('Delay Simulation', () => {
+    it('should simulate delay', async () => {
+      const start = Date.now();
+      await mqClient.simulateDelay(50);
+      const duration = Date.now() - start;
+      expect(duration).toBeGreaterThanOrEqual(50);
+    });
+  });
+});