created lots of tests

libs/core/di/test/registration.test.ts

@@ -0,0 +1,293 @@
+import { describe, expect, it, mock } from 'bun:test';
+import { createContainer, asClass, asFunction, asValue } from 'awilix';
+import {
+  registerCacheServices,
+  registerDatabaseServices,
+  registerServiceDependencies,
+} from '../src/registrations';
+
+describe('DI Registrations', () => {
+  describe('registerCacheServices', () => {
+    it('should register null cache when no redis config', () => {
+      const container = createContainer();
+      const config = {
+        service: {
+          name: 'test-service',
+          type: 'WORKER' as const,
+        },
+        // No redis config
+      };
+
+      registerCacheServices(container, config);
+
+      const cache = container.resolve('cache');
+      expect(cache).toBeDefined();
+      expect(cache.type).toBe('null'); // NullCache type
+    });
+
+    it('should register redis cache when redis config exists', () => {
+      const container = createContainer();
+      
+      // Register logger first as it's a dependency
+      container.register({
+        logger: asValue({
+          info: () => {},
+          error: () => {},
+          warn: () => {},
+          debug: () => {},
+        }),
+      });
+
+      const config = {
+        service: {
+          name: 'test-service',
+          type: 'WORKER' as const,
+        },
+        redis: {
+          host: 'localhost',
+          port: 6379,
+          db: 1,
+        },
+      };
+
+      registerCacheServices(container, config);
+
+      const cache = container.resolve('cache');
+      expect(cache).toBeDefined();
+    });
+
+    it('should register service cache', () => {
+      const container = createContainer();
+      
+      // Register dependencies
+      container.register({
+        cache: asValue({ type: 'null' }),
+        config: asValue({
+          service: { name: 'test-service' },
+          redis: { host: 'localhost', port: 6379 },
+        }),
+        logger: asValue({ info: () => {} }),
+      });
+
+      const config = {
+        service: {
+          name: 'test-service',
+          type: 'WORKER' as const,
+        },
+      };
+
+      registerCacheServices(container, config);
+
+      const serviceCache = container.resolve('serviceCache');
+      expect(serviceCache).toBeDefined();
+    });
+  });
+
+  describe('registerDatabaseServices', () => {
+    it('should register MongoDB when config exists', () => {
+      const container = createContainer();
+      const mockLogger = {
+        info: () => {},
+        error: () => {},
+        warn: () => {},
+        debug: () => {},
+      };
+
+      container.register({
+        logger: asValue(mockLogger),
+      });
+
+      const config = {
+        service: {
+          name: 'test-service',
+          type: 'WORKER' as const,
+        },
+        mongodb: {
+          uri: 'mongodb://localhost:27017',
+          database: 'test-db',
+        },
+      };
+
+      registerDatabaseServices(container, config);
+
+      // Check that mongodb is registered
+      const registrations = container.registrations;
+      expect(registrations.mongodb).toBeDefined();
+    });
+
+    it('should register Postgres when config exists', () => {
+      const container = createContainer();
+      const mockLogger = { info: () => {}, error: () => {} };
+
+      container.register({
+        logger: asValue(mockLogger),
+      });
+
+      const config = {
+        service: {
+          name: 'test-service',
+          type: 'WORKER' as const,
+        },
+        postgres: {
+          host: 'localhost',
+          port: 5432,
+          database: 'test-db',
+          username: 'user',
+          password: 'pass',
+        },
+      };
+
+      registerDatabaseServices(container, config);
+
+      const registrations = container.registrations;
+      expect(registrations.postgres).toBeDefined();
+    });
+
+    it('should register QuestDB when config exists', () => {
+      const container = createContainer();
+      const mockLogger = { info: () => {}, error: () => {} };
+
+      container.register({
+        logger: asValue(mockLogger),
+      });
+
+      const config = {
+        service: {
+          name: 'test-service',
+          type: 'WORKER' as const,
+        },
+        questdb: {
+          host: 'localhost',
+          httpPort: 9000,
+          pgPort: 8812,
+        },
+      };
+
+      registerDatabaseServices(container, config);
+
+      const registrations = container.registrations;
+      expect(registrations.questdb).toBeDefined();
+    });
+
+    it('should not register databases without config', () => {
+      const container = createContainer();
+      const config = {
+        service: {
+          name: 'test-service',
+          type: 'WORKER' as const,
+        },
+        // No database configs
+      };
+
+      registerDatabaseServices(container, config);
+
+      const registrations = container.registrations;
+      expect(registrations.mongodb).toBeUndefined();
+      expect(registrations.postgres).toBeUndefined();
+      expect(registrations.questdb).toBeUndefined();
+    });
+  });
+
+  describe('registerServiceDependencies', () => {
+    it('should register browser service when config exists', () => {
+      const container = createContainer();
+      const mockLogger = { info: () => {}, error: () => {} };
+
+      container.register({
+        logger: asValue(mockLogger),
+        config: asValue({
+          browser: { headless: true },
+        }),
+      });
+
+      const config = {
+        service: {
+          name: 'test-service',
+          type: 'WORKER' as const,
+        },
+        browser: {
+          headless: true,
+          timeout: 30000,
+        },
+      };
+
+      registerServiceDependencies(container, config);
+
+      const registrations = container.registrations;
+      expect(registrations.browser).toBeDefined();
+    });
+
+    it('should register proxy service when config exists', () => {
+      const container = createContainer();
+      const mockLogger = { info: () => {}, error: () => {} };
+
+      container.register({
+        logger: asValue(mockLogger),
+      });
+
+      const config = {
+        service: {
+          name: 'test-service',
+          type: 'WORKER' as const,
+        },
+        proxy: {
+          enabled: true,
+          rotateOnError: true,
+        },
+      };
+
+      registerServiceDependencies(container, config);
+
+      const registrations = container.registrations;
+      expect(registrations.proxyManager).toBeDefined();
+    });
+
+    it('should register queue services for worker type', () => {
+      const container = createContainer();
+      const mockLogger = { info: () => {}, error: () => {} };
+
+      container.register({
+        logger: asValue(mockLogger),
+        config: asValue({
+          service: { name: 'test-service', type: 'WORKER' },
+          redis: { host: 'localhost', port: 6379 },
+        }),
+      });
+
+      const config = {
+        service: {
+          name: 'test-service',
+          type: 'WORKER' as const,
+        },
+        redis: {
+          host: 'localhost',
+          port: 6379,
+        },
+      };
+
+      registerServiceDependencies(container, config);
+
+      const registrations = container.registrations;
+      expect(registrations.queueManager).toBeDefined();
+    });
+
+    it('should not register queue for API type', () => {
+      const container = createContainer();
+      const config = {
+        service: {
+          name: 'test-api',
+          type: 'API' as const,
+        },
+        redis: {
+          host: 'localhost',
+          port: 6379,
+        },
+      };
+
+      registerServiceDependencies(container, config);
+
+      const registrations = container.registrations;
+      expect(registrations.queueManager).toBeUndefined();
+    });
+  });
+})