added cli-covarage tool and fixed more tests

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

@@ -1,55 +1,35 @@
-import { beforeEach, describe, expect, it, mock } from 'bun:test';
-import type { IServiceContainer } from '@stock-bot/types';
-import { Handler, Operation } from '../src/decorators/decorators';
+import { describe, it, expect, beforeEach, mock } from 'bun:test';
 import { autoRegisterHandlers, createAutoHandlerRegistry } from '../src/registry/auto-register';
+import { BaseHandler } from '../src/base/BaseHandler';
+import type { IServiceContainer } from '@stock-bot/types';
 
 describe('Auto Registration', () => {
-  const mockServices: IServiceContainer = {
-    getService: mock(() => null),
-    hasService: mock(() => false),
-    registerService: mock(() => {}),
-  } as any;
-
-  const mockLogger = {
-    info: mock(() => {}),
-    error: mock(() => {}),
-    warn: mock(() => {}),
-    debug: mock(() => {}),
-  };
-
-  beforeEach(() => {
-    // Reset all mocks
-    mockLogger.info = mock(() => {});
-    mockLogger.error = mock(() => {});
-    mockLogger.warn = mock(() => {});
-    mockLogger.debug = mock(() => {});
-  });
-
   describe('autoRegisterHandlers', () => {
     it('should auto-register handlers', async () => {
-      // Since this function reads from file system, we'll create a temporary directory
-      const result = await autoRegisterHandlers('./non-existent-dir', mockServices, {
-        pattern: '.handler.',
-        dryRun: true,
-      });
-
+      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(Array.isArray(result.registered)).toBe(true);
-      expect(Array.isArray(result.failed)).toBe(true);
+      expect(result.registered).toEqual([]);
+      expect(result.failed).toEqual([]);
     });
 
     it('should use default options when not provided', async () => {
-      const result = await autoRegisterHandlers('./non-existent-dir', mockServices);
-
-      expect(result).toHaveProperty('registered');
-      expect(result).toHaveProperty('failed');
+      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 () => {
-      // This should not throw but return empty results
+      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([]);
     });
@@ -57,36 +37,102 @@ describe('Auto Registration', () => {
 
   describe('createAutoHandlerRegistry', () => {
     it('should create a registry with registerDirectory method', () => {
+      const mockServices = {} as IServiceContainer;
       const registry = createAutoHandlerRegistry(mockServices);
-
+      
       expect(registry).toHaveProperty('registerDirectory');
-      expect(registry).toHaveProperty('registerDirectories');
       expect(typeof registry.registerDirectory).toBe('function');
-      expect(typeof registry.registerDirectories).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', {
-        dryRun: true,
-      });
-
+      
+      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'], {
-        dryRun: true,
-      });
-
+      
+      const result = await registry.registerDirectories(['./dir1', './dir2']);
       expect(result).toHaveProperty('registered');
       expect(result).toHaveProperty('failed');
-      expect(Array.isArray(result.registered)).toBe(true);
-      expect(Array.isArray(result.failed)).toBe(true);
+      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);
+    });
+  });
+});