stock-bot/libs/core/handlers/test/auto-register.test.ts

import { beforeEach, describe, expect, it, mock } from 'bun:test';
import type { IServiceContainer } from '@stock-bot/types';
import { BaseHandler } from '../src/base/BaseHandler';
import { autoRegisterHandlers, createAutoHandlerRegistry } from '../src/registry/auto-register';

describe('Auto Registration', () => {
  describe('autoRegisterHandlers', () => {
    it('should auto-register handlers', async () => {
      const mockServices = {} as IServiceContainer;
      // Using a directory that doesn't exist - the function handles this gracefully
      const result = await autoRegisterHandlers('./non-existent', mockServices);

      expect(result).toHaveProperty('registered');
      expect(result).toHaveProperty('failed');
      expect(result.registered).toEqual([]);
      expect(result.failed).toEqual([]);
    });

    it('should use default options when not provided', async () => {
      const mockServices = {} as IServiceContainer;
      const result = await autoRegisterHandlers('./test', mockServices);

      expect(result).toBeDefined();
      expect(result.registered).toBeInstanceOf(Array);
      expect(result.failed).toBeInstanceOf(Array);
    });

    it('should handle directory not found gracefully', async () => {
      const mockServices = {} as IServiceContainer;

      // Should not throw for non-existent directory
      const result = await autoRegisterHandlers('./non-existent-directory', mockServices);
      expect(result.registered).toEqual([]);
      expect(result.failed).toEqual([]);
    });
  });

  describe('createAutoHandlerRegistry', () => {
    it('should create a registry with registerDirectory method', () => {
      const mockServices = {} as IServiceContainer;
      const registry = createAutoHandlerRegistry(mockServices);

      expect(registry).toHaveProperty('registerDirectory');
      expect(typeof registry.registerDirectory).toBe('function');
    });

    it('should register from a directory', async () => {
      const mockServices = {} as IServiceContainer;
      const registry = createAutoHandlerRegistry(mockServices);

      const result = await registry.registerDirectory('./non-existent-dir');
      expect(result).toHaveProperty('registered');
      expect(result).toHaveProperty('failed');
    });

    it('should register from multiple directories', async () => {
      const mockServices = {} as IServiceContainer;
      const registry = createAutoHandlerRegistry(mockServices);

      const result = await registry.registerDirectories(['./dir1', './dir2']);
      expect(result).toHaveProperty('registered');
      expect(result).toHaveProperty('failed');
      expect(result.registered).toBeInstanceOf(Array);
      expect(result.failed).toBeInstanceOf(Array);
    });
  });

  describe('Edge Cases', () => {
    it('should handle non-existent directories gracefully', async () => {
      const mockServices = {} as any;

      // Should not throw, just return empty results
      const result = await autoRegisterHandlers('./definitely-does-not-exist-12345', mockServices);
      expect(result.registered).toEqual([]);
      expect(result.failed).toEqual([]);
    });

    it('should handle empty options', async () => {
      const mockServices = {} as any;

      // Should use default options
      const result = await autoRegisterHandlers('./test', mockServices, {});
      expect(result).toBeDefined();
      expect(result.registered).toBeInstanceOf(Array);
      expect(result.failed).toBeInstanceOf(Array);
    });

    it('should support service name in options', async () => {
      const mockServices = {} as any;

      const result = await autoRegisterHandlers('./test', mockServices, {
        serviceName: 'test-service',
      });

      expect(result).toBeDefined();
    });

    it('should handle dry run mode', async () => {
      const mockServices = {} as any;
      const result = await autoRegisterHandlers('./test', mockServices, { dryRun: true });

      expect(result).toBeDefined();
      expect(result.registered).toBeInstanceOf(Array);
      expect(result.failed).toBeInstanceOf(Array);
    });

    it('should handle excluded files', async () => {
      const mockServices = {} as any;
      const result = await autoRegisterHandlers('./test', mockServices, {
        exclude: ['test'],
      });

      expect(result).toBeDefined();
      expect(result.registered).toBeInstanceOf(Array);
      expect(result.failed).toBeInstanceOf(Array);
    });

    it('should handle custom pattern', async () => {
      const mockServices = {} as any;
      const result = await autoRegisterHandlers('./test', mockServices, { pattern: '.custom.' });

      expect(result).toBeDefined();
      expect(result.registered).toBeInstanceOf(Array);
      expect(result.failed).toBeInstanceOf(Array);
    });

    it('should handle errors gracefully', async () => {
      const mockServices = {} as any;

      // Even with a protected directory, it should handle gracefully
      const result = await autoRegisterHandlers('./protected-dir', mockServices);

      expect(result).toBeDefined();
      expect(result.registered).toBeInstanceOf(Array);
      expect(result.failed).toBeInstanceOf(Array);
    });
  });
});