@onlineapps/conn-orch-validator 2.0.5 → 2.0.7

package/tests/unit/MockMQClient.test.js

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

package/tests/unit/MockRegistry.test.js

@@ -1,233 +0,0 @@
-'use strict';
-
-const MockRegistry = require('../../src/mocks/MockRegistry');
-
-describe('MockRegistry @unit', () => {
-  let registry;
-
-  beforeEach(() => {
-    registry = new MockRegistry();
-  });
-
-  describe('Service Registration', () => {
-    it('should register service successfully', async () => {
-      const serviceData = {
-        name: 'test-service',
-        version: '1.0.0',
-        url: 'http://localhost:3000',
-        healthCheck: '/health',
-        openapi: { paths: {} }
-      };
-
-      const result = await registry.register(serviceData);
-      
-      expect(result.success).toBe(true);
-      expect(result.certificate).toBeDefined();
-      expect(result.certificate.serviceId).toBe('test-service');
-      
-      const service = registry.getService('test-service');
-      expect(service).toBeDefined();
-      expect(service.name).toBe('test-service');
-      expect(service.version).toBe('1.0.0');
-      expect(service.status).toBe('active');
-    });
-
-    it('should use defaults for optional fields', async () => {
-      const result = await registry.register({ name: 'minimal-service' });
-      
-      const service = registry.getService('minimal-service');
-      expect(service.version).toBe('1.0.0');
-      expect(service.url).toBe('http://localhost:3000');
-      expect(service.healthCheck).toBe('/health');
-      expect(service.openapi).toEqual({});
-    });
-
-    it('should throw error if name not provided', async () => {
-      await expect(registry.register({})).rejects.toThrow('Service name is required');
-    });
-
-    it('should issue certificate on registration', async () => {
-      await registry.register({ name: 'cert-service' });
-      
-      const cert = registry.getCertificate('cert-service');
-      expect(cert).toBeDefined();
-      expect(cert.serviceId).toBe('cert-service');
-      expect(cert.fingerprint).toContain('mock-cert-cert-service');
-      expect(cert.expiresAt).toBeGreaterThan(Date.now());
-    });
-  });
-
-  describe('Service Unregistration', () => {
-    beforeEach(async () => {
-      await registry.register({ name: 'test-service' });
-    });
-
-    it('should unregister service', async () => {
-      const result = await registry.unregister('test-service');
-      
-      expect(result.success).toBe(true);
-      expect(registry.getService('test-service')).toBeNull();
-      expect(registry.getCertificate('test-service')).toBeNull();
-    });
-
-    it('should remove heartbeats on unregister', async () => {
-      await registry.heartbeat('test-service');
-      await registry.unregister('test-service');
-      
-      expect(registry.heartbeats['test-service']).toBeUndefined();
-    });
-  });
-
-  describe('Heartbeat Management', () => {
-    beforeEach(async () => {
-      await registry.register({ name: 'test-service' });
-    });
-
-    it('should send heartbeat successfully', async () => {
-      const result = await registry.heartbeat('test-service');
-      
-      expect(result.success).toBe(true);
-      expect(registry.heartbeats['test-service']).toBeDefined();
-      expect(registry.heartbeats['test-service'].status).toBe('healthy');
-    });
-
-    it('should throw error for unregistered service', async () => {
-      await expect(registry.heartbeat('unknown-service'))
-        .rejects.toThrow('Service unknown-service not registered');
-    });
-
-    it('should update heartbeat timestamp', async () => {
-      await registry.heartbeat('test-service');
-      const firstTimestamp = registry.heartbeats['test-service'].timestamp;
-      
-      await new Promise(resolve => setTimeout(resolve, 10));
-      
-      await registry.heartbeat('test-service');
-      const secondTimestamp = registry.heartbeats['test-service'].timestamp;
-      
-      expect(secondTimestamp).toBeGreaterThan(firstTimestamp);
-    });
-  });
-
-  describe('Service Discovery', () => {
-    beforeEach(async () => {
-      await registry.register({ 
-        name: 'service-v1', 
-        version: '1.0.0', 
-        status: 'active' 
-      });
-      await registry.register({ 
-        name: 'service-v2', 
-        version: '2.0.0', 
-        status: 'active' 
-      });
-      await registry.register({ 
-        name: 'inactive-service', 
-        version: '1.0.0' 
-      });
-      registry.services['inactive-service'].status = 'inactive';
-    });
-
-    it('should get all services', () => {
-      const services = registry.getServices();
-      expect(services).toHaveLength(3);
-    });
-
-    it('should discover by name', () => {
-      const results = registry.discover({ name: 'service' });
-      expect(results).toHaveLength(3);
-    });
-
-    it('should discover by version', () => {
-      const results = registry.discover({ version: '1.0.0' });
-      expect(results).toHaveLength(2);
-    });
-
-    it('should discover by status', () => {
-      const results = registry.discover({ status: 'active' });
-      expect(results).toHaveLength(2);
-    });
-
-    it('should combine discovery filters', () => {
-      const results = registry.discover({ 
-        version: '1.0.0', 
-        status: 'active' 
-      });
-      expect(results).toHaveLength(1);
-      expect(results[0].name).toBe('service-v1');
-    });
-  });
-
-  describe('Validation', () => {
-    beforeEach(async () => {
-      await registry.register({ name: 'test-service' });
-    });
-
-    it('should validate service', async () => {
-      const validationData = {
-        cookbook: { version: '1.0.0' },
-        testResults: { passed: 10, failed: 0 }
-      };
-      
-      const result = await registry.validate('test-service', validationData);
-      
-      expect(result.success).toBe(true);
-      expect(result.token).toContain('validation-token-test-service');
-      
-      const validationResults = registry.getValidationResults('test-service');
-      expect(validationResults).toBeDefined();
-      expect(validationResults.passed).toBe(true);
-      expect(validationResults.cookbook).toEqual(validationData.cookbook);
-    });
-
-    it('should return null for non-validated service', () => {
-      const results = registry.getValidationResults('non-validated');
-      expect(results).toBeNull();
-    });
-  });
-
-  describe('Statistics', () => {
-    beforeEach(async () => {
-      await registry.register({ name: 'service1' });
-      await registry.register({ name: 'service2' });
-      await registry.heartbeat('service1');
-    });
-
-    it('should return registry statistics', () => {
-      const stats = registry.getStats();
-      
-      expect(stats.serviceCount).toBe(2);
-      expect(stats.activeServices).toBe(2);
-      expect(stats.certificates).toBe(2);
-      expect(stats.recentHeartbeats).toBe(1);
-    });
-
-    it('should count only recent heartbeats', async () => {
-      // Add old heartbeat
-      registry.heartbeats['service2'] = {
-        timestamp: Date.now() - 120000, // 2 minutes ago
-        status: 'healthy'
-      };
-      
-      const stats = registry.getStats();
-      expect(stats.recentHeartbeats).toBe(1); // Only service1 is recent
-    });
-  });
-
-  describe('Clear Data', () => {
-    beforeEach(async () => {
-      await registry.register({ name: 'test-service' });
-      await registry.heartbeat('test-service');
-      await registry.validate('test-service', { test: 'data' });
-    });
-
-    it('should clear all data', () => {
-      registry.clear();
-      
-      expect(Object.keys(registry.services)).toHaveLength(0);
-      expect(Object.keys(registry.certificates)).toHaveLength(0);
-      expect(Object.keys(registry.heartbeats)).toHaveLength(0);
-      expect(Object.keys(registry.validationResults)).toHaveLength(0);
-    });
-  });
-});

package/tests/unit/MockStorage.test.js

@@ -1,257 +0,0 @@
-'use strict';
-
-const MockStorage = require('../../src/mocks/MockStorage');
-
-describe('MockStorage @unit', () => {
-  let storage;
-
-  beforeEach(() => {
-    storage = new MockStorage();
-  });
-
-  describe('Bucket Management', () => {
-    it('should create bucket', async () => {
-      const result = await storage.createBucket('test-bucket');
-      expect(result.success).toBe(true);
-      expect(storage.buckets['test-bucket']).toBeDefined();
-    });
-
-    it('should not error on duplicate bucket creation', async () => {
-      await storage.createBucket('test-bucket');
-      const result = await storage.createBucket('test-bucket');
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('Object Storage', () => {
-    it('should put object in bucket', async () => {
-      const content = { test: 'data' };
-      const result = await storage.put('test-bucket', 'test-key', content);
-      
-      expect(result.success).toBe(true);
-      expect(result.etag).toContain('mock-etag');
-      expect(result.location).toBe('test-bucket/test-key');
-    });
-
-    it('should auto-create bucket if not exists', async () => {
-      await storage.put('new-bucket', 'key', 'content');
-      expect(storage.buckets['new-bucket']).toBeDefined();
-    });
-
-    it('should store string content', async () => {
-      await storage.put('bucket', 'key', 'string content');
-      const obj = await storage.get('bucket', 'key');
-      expect(obj.content).toBe('string content');
-    });
-
-    it('should store object as JSON', async () => {
-      const data = { nested: { value: 123 } };
-      await storage.put('bucket', 'key', data);
-      const obj = await storage.get('bucket', 'key');
-      expect(obj.content).toEqual(data);
-    });
-
-    it('should store metadata', async () => {
-      const metadata = { author: 'test', version: '1.0' };
-      await storage.put('bucket', 'key', 'content', {
-        metadata,
-        contentType: 'text/plain'
-      });
-      
-      const obj = await storage.get('bucket', 'key');
-      expect(obj.metadata).toEqual(metadata);
-      expect(obj.contentType).toBe('text/plain');
-    });
-  });
-
-  describe('Object Retrieval', () => {
-    beforeEach(async () => {
-      await storage.put('bucket', 'key1', { data: 'test' });
-      await storage.put('bucket', 'key2', 'text content', {
-        contentType: 'text/plain'
-      });
-    });
-
-    it('should get object from bucket', async () => {
-      const obj = await storage.get('bucket', 'key1');
-      expect(obj.content).toEqual({ data: 'test' });
-      expect(obj.contentType).toBe('application/json');
-    });
-
-    it('should throw error for non-existent object', async () => {
-      await expect(storage.get('bucket', 'non-existent'))
-        .rejects.toThrow('Object not found: bucket/non-existent');
-    });
-
-    it('should check object existence', async () => {
-      expect(await storage.exists('bucket', 'key1')).toBe(true);
-      expect(await storage.exists('bucket', 'non-existent')).toBe(false);
-      expect(await storage.exists('non-bucket', 'key')).toBe(false);
-    });
-
-    it('should get object metadata', async () => {
-      const metadata = await storage.getMetadata('bucket', 'key1');
-      expect(metadata.size).toBeGreaterThan(0);
-      expect(metadata.lastModified).toBeDefined();
-      expect(metadata.contentType).toBe('application/json');
-    });
-
-    it('should throw error for non-existent metadata', async () => {
-      await expect(storage.getMetadata('bucket', 'non-existent'))
-        .rejects.toThrow('Metadata not found: bucket/non-existent');
-    });
-  });
-
-  describe('Object Deletion', () => {
-    beforeEach(async () => {
-      await storage.put('bucket', 'key', 'content');
-    });
-
-    it('should delete object', async () => {
-      expect(await storage.exists('bucket', 'key')).toBe(true);
-      
-      const result = await storage.delete('bucket', 'key');
-      expect(result.success).toBe(true);
-      
-      expect(await storage.exists('bucket', 'key')).toBe(false);
-    });
-
-    it('should not error on deleting non-existent object', async () => {
-      const result = await storage.delete('bucket', 'non-existent');
-      expect(result.success).toBe(true);
-    });
-
-    it('should remove metadata on delete', async () => {
-      await storage.delete('bucket', 'key');
-      await expect(storage.getMetadata('bucket', 'key'))
-        .rejects.toThrow('Metadata not found');
-    });
-  });
-
-  describe('Object Listing', () => {
-    beforeEach(async () => {
-      await storage.put('bucket', 'file1.txt', 'content1');
-      await storage.put('bucket', 'file2.txt', 'content2');
-      await storage.put('bucket', 'folder/file3.txt', 'content3');
-      await storage.put('bucket', 'folder/file4.txt', 'content4');
-      await storage.put('other-bucket', 'file5.txt', 'content5');
-    });
-
-    it('should list all objects in bucket', async () => {
-      const result = await storage.list('bucket');
-      expect(result.objects).toHaveLength(4);
-      expect(result.objects[0].key).toBe('file1.txt');
-    });
-
-    it('should list with prefix', async () => {
-      const result = await storage.list('bucket', 'folder/');
-      expect(result.objects).toHaveLength(2);
-      expect(result.objects.every(o => o.key.startsWith('folder/'))).toBe(true);
-    });
-
-    it('should respect limit', async () => {
-      const result = await storage.list('bucket', '', 2);
-      expect(result.objects).toHaveLength(2);
-    });
-
-    it('should return empty list for non-existent bucket', async () => {
-      const result = await storage.list('non-existent');
-      expect(result.objects).toHaveLength(0);
-    });
-
-    it('should include size and timestamp in listing', async () => {
-      const result = await storage.list('bucket');
-      const obj = result.objects[0];
-      expect(obj.size).toBeGreaterThan(0);
-      expect(obj.lastModified).toBeDefined();
-    });
-  });
-
-  describe('Object Copying', () => {
-    beforeEach(async () => {
-      await storage.put('source-bucket', 'source-key', { data: 'test' }, {
-        metadata: { original: true },
-        contentType: 'application/json'
-      });
-    });
-
-    it('should copy object to same bucket', async () => {
-      await storage.copy('source-bucket', 'source-key', 'source-bucket', 'copy-key');
-      
-      const copy = await storage.get('source-bucket', 'copy-key');
-      expect(copy.content).toEqual({ data: 'test' });
-      expect(copy.metadata).toEqual({ original: true });
-      expect(copy.contentType).toBe('application/json');
-    });
-
-    it('should copy object to different bucket', async () => {
-      await storage.copy('source-bucket', 'source-key', 'dest-bucket', 'dest-key');
-      
-      const copy = await storage.get('dest-bucket', 'dest-key');
-      expect(copy.content).toEqual({ data: 'test' });
-    });
-
-    it('should throw error copying non-existent object', async () => {
-      await expect(storage.copy('source-bucket', 'non-existent', 'dest', 'key'))
-        .rejects.toThrow('Object not found');
-    });
-  });
-
-  describe('Presigned URLs', () => {
-    it('should generate presigned URL', async () => {
-      const result = await storage.getPresignedUrl('bucket', 'key');
-      
-      expect(result.url).toContain('http://mock-storage/bucket/key');
-      expect(result.url).toContain('token=mock-token');
-      expect(result.expiresAt).toBeGreaterThan(Date.now());
-    });
-
-    it('should respect custom expiration', async () => {
-      const expiresIn = 7200; // 2 hours
-      const result = await storage.getPresignedUrl('bucket', 'key', expiresIn);
-      
-      const expectedExpiry = Date.now() + (expiresIn * 1000);
-      expect(result.expiresAt).toBeCloseTo(expectedExpiry, -3);
-    });
-  });
-
-  describe('Statistics', () => {
-    beforeEach(async () => {
-      await storage.put('bucket1', 'key1', 'content1');
-      await storage.put('bucket1', 'key2', 'content2');
-      await storage.put('bucket2', 'key3', 'content3');
-    });
-
-    it('should return storage statistics', () => {
-      const stats = storage.getStats();
-      
-      expect(stats.bucketCount).toBe(2);
-      expect(stats.totalObjects).toBe(3);
-      expect(stats.totalSize).toBeGreaterThan(0);
-    });
-
-    it('should calculate total size correctly', () => {
-      const stats = storage.getStats();
-      const expectedSize = 'content1'.length + 'content2'.length + 'content3'.length;
-      expect(stats.totalSize).toBe(expectedSize);
-    });
-  });
-
-  describe('Clear Data', () => {
-    beforeEach(async () => {
-      await storage.put('bucket1', 'key1', 'content');
-      await storage.put('bucket2', 'key2', 'content');
-    });
-
-    it('should clear all data', () => {
-      storage.clear();
-      
-      expect(Object.keys(storage.buckets)).toHaveLength(0);
-      expect(Object.keys(storage.metadata)).toHaveLength(0);
-      
-      const stats = storage.getStats();
-      expect(stats.bucketCount).toBe(0);
-      expect(stats.totalObjects).toBe(0);
-    });
-  });
-});