stock-bot/libs/core/di/test/registration.test.ts

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();
    });
  });
})