@onlineapps/conn-base-hub 1.0.0

package/test/unit/hub.test.js

@@ -0,0 +1,351 @@
+/**
+ * Tests for @onlineapps/connector-hub
+ */
+
+const ConnectorHub = require('../../src/index');
+
+// Mock all dependencies
+jest.mock('@onlineapps/connector-registry-client', () => ({
+  ServiceRegistryClient: jest.fn().mockImplementation(() => ({
+    initialize: jest.fn().mockResolvedValue(true),
+    dispose: jest.fn().mockResolvedValue(true),
+    registerService: jest.fn().mockResolvedValue(true),
+    deregisterService: jest.fn().mockResolvedValue(true),
+    startHeartbeat: jest.fn(),
+    subscribeToChanges: jest.fn().mockResolvedValue(true)
+  }))
+}), { virtual: true });
+
+jest.mock('@onlineapps/connector-mq-client', () => jest.fn().mockImplementation(() => ({
+  connect: jest.fn().mockResolvedValue(true),
+  disconnect: jest.fn().mockResolvedValue(true),
+  publish: jest.fn().mockResolvedValue(true),
+  consume: jest.fn().mockResolvedValue(true)
+})), { virtual: true });
+
+jest.mock('@onlineapps/connector-storage', () => jest.fn().mockImplementation(() => ({
+  initialize: jest.fn().mockResolvedValue(true),
+  uploadWithFingerprint: jest.fn().mockResolvedValue({ fingerprint: 'abc123' }),
+  downloadWithVerification: jest.fn().mockResolvedValue({ data: 'test' })
+})), { virtual: true });
+
+jest.mock('@onlineapps/connector-logger', () => jest.fn().mockImplementation((config) => ({
+  info: jest.fn(),
+  error: jest.fn(),
+  warn: jest.fn(),
+  debug: jest.fn(),
+  api: { info: jest.fn(), error: jest.fn() },
+  mq: { info: jest.fn(), error: jest.fn() },
+  workflow: { info: jest.fn(), error: jest.fn() },
+  registry: { info: jest.fn(), error: jest.fn() },
+  close: jest.fn().mockResolvedValue(true)
+})), { virtual: true });
+
+jest.mock('@onlineapps/connector-cookbook', () => ({
+  validateCookbook: jest.fn(),
+  parseCookbook: jest.fn(),
+  executeCookbook: jest.fn()
+}), { virtual: true });
+
+describe('ConnectorHub', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('Module exports', () => {
+    test('should export all connectors', () => {
+      expect(ConnectorHub.ServiceRegistryClient).toBeDefined();
+      expect(ConnectorHub.MQClient).toBeDefined();
+      expect(ConnectorHub.StorageConnector).toBeDefined();
+      expect(ConnectorHub.createLogger).toBeDefined();
+      expect(ConnectorHub.validateCookbook).toBeDefined();
+      expect(ConnectorHub.parseCookbook).toBeDefined();
+      expect(ConnectorHub.executeCookbook).toBeDefined();
+    });
+
+    test('should export factory methods', () => {
+      expect(ConnectorHub.createMicroservice).toBeDefined();
+      expect(ConnectorHub.WorkflowHelper).toBeDefined();
+    });
+  });
+
+  describe('createMicroservice factory', () => {
+    test('should create microservice with all connectors', async () => {
+      const config = {
+        serviceName: 'test-service',
+        version: '1.0.0',
+        registry: {
+          url: 'amqp://localhost',
+          queue: 'registry'
+        },
+        mq: {
+          url: 'amqp://localhost',
+          queue: 'test-queue'
+        },
+        storage: {
+          endpoint: 'localhost',
+          port: 9000,
+          accessKey: 'minioadmin',
+          secretKey: 'minioadmin'
+        },
+        logger: {
+          level: 'info'
+        }
+      };
+
+      const microservice = ConnectorHub.createMicroservice(config);
+
+      expect(microservice.registry).toBeDefined();
+      expect(microservice.mq).toBeDefined();
+      expect(microservice.storage).toBeDefined();
+      expect(microservice.logger).toBeDefined();
+      expect(microservice.init).toBeDefined();
+      expect(microservice.shutdown).toBeDefined();
+    });
+
+    test('should create microservice with partial connectors', () => {
+      const config = {
+        serviceName: 'test-service',
+        version: '1.0.0',
+        registry: {
+          url: 'amqp://localhost',
+          queue: 'registry'
+        }
+        // Only registry, no mq or storage
+      };
+
+      const microservice = ConnectorHub.createMicroservice(config);
+
+      expect(microservice.registry).toBeDefined();
+      expect(microservice.mq).toBeNull();
+      expect(microservice.storage).toBeNull();
+      expect(microservice.logger).toBeDefined(); // Logger is always created
+    });
+
+    test('should initialize all connectors', async () => {
+      const config = {
+        serviceName: 'test-service',
+        version: '1.0.0',
+        registry: {
+          url: 'amqp://localhost',
+          queue: 'registry'
+        },
+        mq: {
+          url: 'amqp://localhost',
+          queue: 'test-queue'
+        },
+        storage: {
+          endpoint: 'localhost',
+          port: 9000,
+          accessKey: 'minioadmin',
+          secretKey: 'minioadmin'
+        }
+      };
+
+      const microservice = ConnectorHub.createMicroservice(config);
+      await microservice.init();
+
+      expect(microservice.registry.initialize).toHaveBeenCalled();
+      expect(microservice.mq.connect).toHaveBeenCalled();
+      expect(microservice.storage.initialize).toHaveBeenCalled();
+    });
+
+    test('should shutdown all connectors', async () => {
+      const config = {
+        serviceName: 'test-service',
+        version: '1.0.0',
+        registry: {
+          url: 'amqp://localhost',
+          queue: 'registry'
+        },
+        mq: {
+          url: 'amqp://localhost',
+          queue: 'test-queue'
+        },
+        storage: {
+          endpoint: 'localhost',
+          port: 9000,
+          accessKey: 'minioadmin',
+          secretKey: 'minioadmin'
+        }
+      };
+
+      const microservice = ConnectorHub.createMicroservice(config);
+      await microservice.init();
+      await microservice.shutdown();
+
+      expect(microservice.registry.dispose).toHaveBeenCalled();
+      expect(microservice.mq.disconnect).toHaveBeenCalled();
+      expect(microservice.logger.close).toHaveBeenCalled();
+    });
+
+    test('should handle initialization errors gracefully', async () => {
+      const config = {
+        serviceName: 'test-service',
+        version: '1.0.0',
+        registry: {
+          url: 'amqp://localhost',
+          queue: 'registry'
+        }
+      };
+
+      const microservice = ConnectorHub.createMicroservice(config);
+
+      // Mock initialization failure
+      microservice.registry.initialize.mockRejectedValueOnce(new Error('Connection failed'));
+
+      await expect(microservice.init()).rejects.toThrow('Connection failed');
+    });
+  });
+
+  describe('WorkflowHelper', () => {
+    test('should create workflow message', () => {
+      const message = ConnectorHub.WorkflowHelper.createMessage({
+        workflowId: 'wf-123',
+        cookbookName: 'test-cookbook',
+        step: 1,
+        data: { test: true }
+      });
+
+      expect(message.workflow_id).toBe('wf-123');
+      expect(message.cookbook_name).toBe('test-cookbook');
+      expect(message.step_index).toBe(1);
+      expect(message.data).toEqual({ test: true });
+      expect(message.timestamp).toBeDefined();
+    });
+
+    test('should parse workflow message', () => {
+      const rawMessage = {
+        workflow_id: 'wf-123',
+        cookbook_name: 'test-cookbook',
+        step_index: 1,
+        data: { test: true },
+        timestamp: new Date().toISOString()
+      };
+
+      const parsed = ConnectorHub.WorkflowHelper.parseMessage(rawMessage);
+
+      expect(parsed.workflowId).toBe('wf-123');
+      expect(parsed.cookbookName).toBe('test-cookbook');
+      expect(parsed.step).toBe(1);
+      expect(parsed.data).toEqual({ test: true });
+    });
+
+    test('should get next queue from cookbook step', () => {
+      const step = {
+        service: 'test-service',
+        queue: 'custom-queue'
+      };
+
+      const queue = ConnectorHub.WorkflowHelper.getNextQueue(step);
+      expect(queue).toBe('custom-queue');
+    });
+
+    test('should generate default queue name', () => {
+      const step = {
+        service: 'test-service'
+      };
+
+      const queue = ConnectorHub.WorkflowHelper.getNextQueue(step);
+      expect(queue).toBe('test-service.queue');
+    });
+
+    test('should validate workflow message', () => {
+      const validMessage = {
+        workflow_id: 'wf-123',
+        cookbook_name: 'test-cookbook',
+        step_index: 1,
+        data: { test: true }
+      };
+
+      const invalidMessage = {
+        workflow_id: 'wf-123'
+        // Missing required fields
+      };
+
+      expect(ConnectorHub.WorkflowHelper.isValidMessage(validMessage)).toBe(true);
+      expect(ConnectorHub.WorkflowHelper.isValidMessage(invalidMessage)).toBe(false);
+    });
+
+    test('should add result to workflow message', () => {
+      const message = {
+        workflow_id: 'wf-123',
+        cookbook_name: 'test-cookbook',
+        step_index: 1,
+        data: { test: true },
+        results: []
+      };
+
+      const result = {
+        service: 'test-service',
+        status: 'success',
+        data: { processed: true }
+      };
+
+      const updated = ConnectorHub.WorkflowHelper.addResult(message, result);
+
+      expect(updated.results).toHaveLength(1);
+      expect(updated.results[0]).toEqual(result);
+      expect(updated.last_result).toEqual(result);
+    });
+
+    test('should handle errors in workflow', () => {
+      const message = {
+        workflow_id: 'wf-123',
+        cookbook_name: 'test-cookbook',
+        step_index: 1,
+        data: { test: true }
+      };
+
+      const error = new Error('Processing failed');
+      const errorMessage = ConnectorHub.WorkflowHelper.createErrorMessage(message, error, 'test-service');
+
+      expect(errorMessage.workflow_id).toBe('wf-123');
+      expect(errorMessage.status).toBe('error');
+      expect(errorMessage.error.message).toBe('Processing failed');
+      expect(errorMessage.error.service).toBe('test-service');
+      expect(errorMessage.error.step).toBe(1);
+    });
+  });
+
+  describe('Integration helpers', () => {
+    test('should provide quick setup for common patterns', async () => {
+      // Test workflow consumer setup
+      const config = {
+        serviceName: 'workflow-service',
+        version: '1.0.0',
+        mq: {
+          url: 'amqp://localhost',
+          queue: 'workflow-queue'
+        }
+      };
+
+      const microservice = ConnectorHub.createMicroservice(config);
+
+      // Setup workflow consumer
+      const handler = jest.fn().mockResolvedValue({ status: 'success' });
+
+      await microservice.mq.consume('workflow-queue', async (msg) => {
+        const message = ConnectorHub.WorkflowHelper.parseMessage(JSON.parse(msg.content));
+        const result = await handler(message);
+        const nextMessage = ConnectorHub.WorkflowHelper.addResult(message, result);
+        await microservice.mq.publish('next-queue', nextMessage);
+      });
+
+      expect(microservice.mq.consume).toHaveBeenCalledWith('workflow-queue', expect.any(Function));
+    });
+  });
+
+  describe('Error handling', () => {
+    test('should handle missing dependencies gracefully', () => {
+      // Even if a dependency fails to load, others should work
+      const config = {
+        serviceName: 'test-service',
+        version: '1.0.0'
+      };
+
+      const microservice = ConnectorHub.createMicroservice(config);
+      expect(microservice.logger).toBeDefined();
+    });
+  });
+});