@onlineapps/conn-base-hub 1.0.0

package/test/component/hub-integration.test.js

@@ -0,0 +1,413 @@
+'use strict';
+
+// Mock all external dependencies before requiring the module
+jest.mock('@onlineapps/connector-mq-client', () => {
+  return jest.fn().mockImplementation(() => ({
+    connect: jest.fn().mockResolvedValue(),
+    publish: jest.fn().mockResolvedValue(),
+    subscribe: jest.fn().mockResolvedValue(),
+    close: jest.fn().mockResolvedValue()
+  }));
+}, { virtual: true });
+
+jest.mock('@onlineapps/connector-registry-client', () => ({
+  ServiceRegistryClient: jest.fn().mockImplementation(() => ({
+    register: jest.fn().mockResolvedValue(),
+    deregister: jest.fn().mockResolvedValue(),
+    discover: jest.fn().mockResolvedValue([]),
+    emit: jest.fn()
+  }))
+}), { virtual: true });
+
+jest.mock('@onlineapps/connector-cookbook', () => ({
+  validateCookbook: jest.fn(),
+  parseCookbook: jest.fn(),
+  executeCookbook: jest.fn()
+}), { virtual: true });
+
+jest.mock('@onlineapps/connector-storage', () => {
+  return jest.fn().mockImplementation(() => ({
+    upload: jest.fn().mockResolvedValue({ etag: '123' }),
+    download: jest.fn().mockResolvedValue(Buffer.from('test')),
+    delete: jest.fn().mockResolvedValue(),
+    list: jest.fn().mockResolvedValue([])
+  }));
+}, { virtual: true });
+
+jest.mock('@onlineapps/connector-logger', () => {
+  return 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()
+  }));
+}, { virtual: true });
+
+describe('Hub Connector Component Tests', () => {
+  let hub;
+  let mockConfig;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Clear require cache to get fresh module
+    delete require.cache[require.resolve('../../src/index.js')];
+
+    // Now require the hub
+    hub = require('../../src/index.js');
+
+    mockConfig = {
+      serviceName: 'test-service',
+      version: '1.0.0',
+      amqpUrl: 'amqp://localhost',
+      registry: {
+        registryUrl: 'http://registry:3000'
+      },
+      mq: {
+        queue: 'test-queue'
+      },
+      storage: {
+        endpoint: 'http://minio:9000',
+        accessKey: 'test',
+        secretKey: 'test'
+      },
+      logger: {
+        level: 'info'
+      }
+    };
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('Module Exports', () => {
+    it('should export all required connectors', () => {
+      expect(hub.MQClient).toBeDefined();
+      expect(hub.ServiceRegistryClient).toBeDefined();
+      expect(hub.StorageConnector).toBeDefined();
+      expect(hub.createLogger).toBeDefined();
+      expect(hub.createMicroservice).toBeDefined();
+    });
+
+    it('should export cookbook functions', () => {
+      expect(hub.validateCookbook).toBeDefined();
+      expect(hub.parseCookbook).toBeDefined();
+      expect(hub.executeCookbook).toBeDefined();
+    });
+  });
+
+  describe('createMicroservice Factory', () => {
+    it('should create microservice with all components', () => {
+      const microservice = hub.createMicroservice(mockConfig);
+
+      expect(microservice).toHaveProperty('logger');
+      expect(microservice).toHaveProperty('registry');
+      expect(microservice).toHaveProperty('mq');
+      expect(microservice).toHaveProperty('storage');
+      // Note: cookbook is not a property on microservice, it's exported separately
+    });
+
+    it('should create microservice with partial config', () => {
+      const partialConfig = {
+        serviceName: 'partial-service',
+        version: '1.0.0',
+        mq: {
+          queue: 'partial-queue'
+        }
+      };
+
+      const microservice = hub.createMicroservice(partialConfig);
+
+      expect(microservice.logger).toBeDefined();
+      expect(microservice.mq).toBeDefined();
+      expect(microservice.registry).toBeNull();
+      expect(microservice.storage).toBeNull();
+    });
+
+    it('should use environment variables as fallback', () => {
+      process.env.RABBITMQ_URL = 'amqp://env-rabbit';
+      process.env.MINIO_ENDPOINT = 'http://env-minio:9000';
+      process.env.MINIO_ACCESS_KEY = 'env-access';
+      process.env.MINIO_SECRET_KEY = 'env-secret';
+
+      const microservice = hub.createMicroservice({
+        serviceName: 'env-service',
+        version: '1.0.0',
+        mq: {},
+        storage: {}
+      });
+
+      expect(microservice.mq).toBeDefined();
+      expect(microservice.storage).toBeDefined();
+
+      delete process.env.RABBITMQ_URL;
+      delete process.env.MINIO_ENDPOINT;
+      delete process.env.MINIO_ACCESS_KEY;
+      delete process.env.MINIO_SECRET_KEY;
+    });
+
+    it('should handle initialization errors gracefully', () => {
+      const invalidConfig = {
+        serviceName: null,
+        version: undefined
+      };
+
+      expect(() => {
+        hub.createMicroservice(invalidConfig);
+      }).not.toThrow();
+    });
+  });
+
+  describe('Logger Integration', () => {
+    it('should create logger with correct configuration', () => {
+      const microservice = hub.createMicroservice(mockConfig);
+
+      expect(microservice.logger).toBeDefined();
+      expect(microservice.logger.info).toBeDefined();
+      expect(microservice.logger.error).toBeDefined();
+      expect(microservice.logger.warn).toBeDefined();
+      expect(microservice.logger.debug).toBeDefined();
+    });
+
+    it('should handle logger operations', () => {
+      const microservice = hub.createMicroservice(mockConfig);
+
+      expect(() => {
+        microservice.logger.info('Test info');
+        microservice.logger.error('Test error');
+        microservice.logger.warn('Test warning');
+        microservice.logger.debug('Test debug');
+      }).not.toThrow();
+    });
+  });
+
+  describe('MQ Client Integration', () => {
+    it('should initialize MQ client with correct config', () => {
+      const microservice = hub.createMicroservice(mockConfig);
+
+      expect(microservice.mq).toBeDefined();
+      expect(microservice.mq.connect).toBeDefined();
+      expect(microservice.mq.publish).toBeDefined();
+      expect(microservice.mq.subscribe).toBeDefined();
+    });
+
+    it('should handle MQ operations', async () => {
+      const microservice = hub.createMicroservice(mockConfig);
+
+      await expect(microservice.mq.connect()).resolves.not.toThrow();
+      await expect(microservice.mq.publish('test-queue', { test: 'message' })).resolves.not.toThrow();
+
+      const handler = jest.fn();
+      await expect(microservice.mq.subscribe('test-queue', handler)).resolves.not.toThrow();
+      await expect(microservice.mq.close()).resolves.not.toThrow();
+    });
+  });
+
+  describe('Service Registry Integration', () => {
+    it('should initialize registry client with correct config', () => {
+      const microservice = hub.createMicroservice(mockConfig);
+
+      expect(microservice.registry).toBeDefined();
+      expect(microservice.registry.register).toBeDefined();
+      expect(microservice.registry.discover).toBeDefined();
+      expect(microservice.registry.deregister).toBeDefined();
+    });
+
+    it('should handle service registration', async () => {
+      const microservice = hub.createMicroservice(mockConfig);
+
+      await expect(
+        microservice.registry.register({
+          name: 'test-service',
+          version: '1.0.0',
+          endpoints: ['http://localhost:3000']
+        })
+      ).resolves.not.toThrow();
+
+      const services = await microservice.registry.discover('test-service');
+      expect(services).toBeDefined();
+      expect(Array.isArray(services)).toBe(true);
+
+      await expect(microservice.registry.deregister()).resolves.not.toThrow();
+    });
+  });
+
+  describe('Storage Integration', () => {
+    it('should initialize storage connector with correct config', () => {
+      const microservice = hub.createMicroservice(mockConfig);
+
+      expect(microservice.storage).toBeDefined();
+      expect(microservice.storage.upload).toBeDefined();
+      expect(microservice.storage.download).toBeDefined();
+      expect(microservice.storage.delete).toBeDefined();
+      expect(microservice.storage.list).toBeDefined();
+    });
+
+    it('should handle storage operations', async () => {
+      const microservice = hub.createMicroservice(mockConfig);
+
+      const buffer = Buffer.from('test data');
+      const result = await microservice.storage.upload('test-bucket', 'test-file', buffer);
+      expect(result).toBeDefined();
+      expect(result.etag).toBe('123');
+
+      const downloaded = await microservice.storage.download('test-bucket', 'test-file');
+      expect(downloaded).toBeDefined();
+      expect(Buffer.isBuffer(downloaded)).toBe(true);
+
+      await expect(microservice.storage.delete('test-bucket', 'test-file')).resolves.not.toThrow();
+
+      const list = await microservice.storage.list('test-bucket');
+      expect(Array.isArray(list)).toBe(true);
+    });
+  });
+
+  describe('Cookbook Integration', () => {
+    it('should provide cookbook functions', () => {
+      expect(hub.validateCookbook).toBeDefined();
+      expect(hub.parseCookbook).toBeDefined();
+      expect(hub.executeCookbook).toBeDefined();
+    });
+
+    it('should handle cookbook operations', () => {
+      const cookbook = {
+        version: '1.0',
+        name: 'test-cookbook',
+        steps: []
+      };
+
+      expect(() => hub.validateCookbook(cookbook)).not.toThrow();
+      expect(() => hub.parseCookbook('yaml content')).not.toThrow();
+      expect(() => hub.executeCookbook(cookbook, {})).not.toThrow();
+    });
+  });
+
+  describe('Complete Microservice Lifecycle', () => {
+    it('should initialize, operate and cleanup microservice', async () => {
+      const microservice = hub.createMicroservice(mockConfig);
+
+      // Initialize
+      await microservice.mq.connect();
+      await microservice.registry.register({
+        name: mockConfig.serviceName,
+        version: mockConfig.version
+      });
+
+      // Operate
+      microservice.logger.info('Service started');
+      await microservice.mq.publish('events', { type: 'started' });
+
+      // Cleanup
+      await microservice.registry.deregister();
+      await microservice.mq.close();
+
+      if (microservice.logger.close) {
+        await microservice.logger.close();
+      }
+
+      expect(true).toBe(true); // Test completed without errors
+    });
+
+    it('should handle errors during lifecycle', async () => {
+      const microservice = hub.createMicroservice(mockConfig);
+
+      // Simulate connection error
+      microservice.mq.connect = jest.fn().mockRejectedValue(new Error('Connection failed'));
+
+      await expect(microservice.mq.connect()).rejects.toThrow('Connection failed');
+
+      // Should still be able to use logger
+      expect(() => {
+        microservice.logger.error('Connection failed');
+      }).not.toThrow();
+    });
+  });
+
+  describe('Environment-specific Configuration', () => {
+    it('should adapt to development environment', () => {
+      const devConfig = {
+        ...mockConfig,
+        environment: 'development',
+        logger: {
+          level: 'debug',
+          pretty: true
+        }
+      };
+
+      const microservice = hub.createMicroservice(devConfig);
+
+      expect(microservice.logger).toBeDefined();
+      expect(microservice.logger.debug).toBeDefined();
+    });
+
+    it('should adapt to production environment', () => {
+      const prodConfig = {
+        ...mockConfig,
+        environment: 'production',
+        logger: {
+          level: 'error',
+          json: true
+        }
+      };
+
+      const microservice = hub.createMicroservice(prodConfig);
+
+      expect(microservice.logger).toBeDefined();
+      expect(microservice.logger.error).toBeDefined();
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle missing configuration gracefully', () => {
+      const invalidConfig = {
+        // Missing serviceName
+        version: '1.0.0'
+      };
+
+      const microservice = hub.createMicroservice(invalidConfig);
+
+      // Should still create microservice but with limited functionality
+      expect(microservice).toBeDefined();
+      expect(microservice.logger).toBeDefined();
+    });
+
+    it('should handle null configuration sections', () => {
+      const configWithNulls = {
+        serviceName: 'test',
+        version: '1.0.0',
+        registry: null,
+        mq: null,
+        storage: null
+      };
+
+      const microservice = hub.createMicroservice(configWithNulls);
+
+      expect(microservice.logger).toBeDefined();
+      expect(microservice.registry).toBeNull();
+      expect(microservice.mq).toBeNull();
+      expect(microservice.storage).toBeNull();
+    });
+  });
+
+  describe('Utility Functions', () => {
+    it('should provide convenience methods', async () => {
+      const microservice = hub.createMicroservice(mockConfig);
+
+      // Test start method if available
+      if (microservice.start) {
+        await expect(microservice.start()).resolves.not.toThrow();
+      }
+
+      // Test stop method if available
+      if (microservice.stop) {
+        await expect(microservice.stop()).resolves.not.toThrow();
+      }
+    });
+  });
+});