@hazeljs/core 0.2.0-beta.1

package/dist/__tests__/shutdown.test.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shutdown_1 = require("../shutdown");
+describe('ShutdownManager', () => {
+    let shutdownManager;
+    let processExitSpy;
+    beforeEach(() => {
+        shutdownManager = new shutdown_1.ShutdownManager(5000);
+        // Mock process.exit to prevent tests from terminating
+        processExitSpy = jest.spyOn(process, 'exit').mockImplementation((() => { }));
+    });
+    afterEach(() => {
+        // Clean up any handlers
+        jest.clearAllMocks();
+        processExitSpy.mockRestore();
+    });
+    describe('registerHandler', () => {
+        it('should register a shutdown handler', () => {
+            const handler = {
+                name: 'test-handler',
+                handler: jest.fn(async () => { }),
+                timeout: 1000,
+            };
+            shutdownManager.registerHandler(handler);
+            expect(shutdownManager).toBeDefined();
+        });
+        it('should register multiple handlers', () => {
+            const handler1 = {
+                name: 'handler-1',
+                handler: jest.fn(async () => { }),
+            };
+            const handler2 = {
+                name: 'handler-2',
+                handler: jest.fn(async () => { }),
+            };
+            shutdownManager.registerHandler(handler1);
+            shutdownManager.registerHandler(handler2);
+            expect(shutdownManager).toBeDefined();
+        });
+    });
+    describe('shutdown', () => {
+        it('should execute all registered handlers', async () => {
+            const handler1 = jest.fn(async () => { });
+            const handler2 = jest.fn(async () => { });
+            shutdownManager.registerHandler({
+                name: 'handler-1',
+                handler: handler1,
+            });
+            shutdownManager.registerHandler({
+                name: 'handler-2',
+                handler: handler2,
+            });
+            await shutdownManager.shutdown('TEST');
+            expect(handler1).toHaveBeenCalled();
+            expect(handler2).toHaveBeenCalled();
+        });
+        it('should execute handlers in order', async () => {
+            const executionOrder = [];
+            shutdownManager.registerHandler({
+                name: 'first',
+                handler: async () => {
+                    executionOrder.push('first');
+                },
+            });
+            shutdownManager.registerHandler({
+                name: 'second',
+                handler: async () => {
+                    executionOrder.push('second');
+                },
+            });
+            await shutdownManager.shutdown('TEST');
+            expect(executionOrder).toEqual(['first', 'second']);
+        });
+        it('should handle handler errors gracefully', async () => {
+            const errorHandler = jest.fn(async () => {
+                throw new Error('Handler error');
+            });
+            const successHandler = jest.fn(async () => { });
+            shutdownManager.registerHandler({
+                name: 'error-handler',
+                handler: errorHandler,
+            });
+            shutdownManager.registerHandler({
+                name: 'success-handler',
+                handler: successHandler,
+            });
+            await shutdownManager.shutdown('TEST');
+            expect(errorHandler).toHaveBeenCalled();
+            expect(successHandler).toHaveBeenCalled();
+        });
+        it('should not execute shutdown twice', async () => {
+            const handler = jest.fn(async () => { });
+            shutdownManager.registerHandler({
+                name: 'test',
+                handler,
+            });
+            await shutdownManager.shutdown('TEST');
+            await shutdownManager.shutdown('TEST');
+            expect(handler).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('isShutdown', () => {
+        it('should return false initially', () => {
+            expect(shutdownManager.isShutdown()).toBe(false);
+        });
+        it('should return true after shutdown', async () => {
+            await shutdownManager.shutdown('TEST');
+            expect(shutdownManager.isShutdown()).toBe(true);
+        });
+    });
+    describe('signal handling', () => {
+        it('should handle SIGTERM signal', () => {
+            const shutdownSpy = jest.spyOn(shutdownManager, 'shutdown').mockResolvedValue();
+            // Simulate SIGTERM
+            process.emit('SIGTERM');
+            // Note: The actual signal handling is set up in constructor
+            expect(shutdownManager).toBeDefined();
+            shutdownSpy.mockRestore();
+        });
+        it('should handle SIGINT signal', () => {
+            const shutdownSpy = jest.spyOn(shutdownManager, 'shutdown').mockResolvedValue();
+            // Simulate SIGINT
+            process.emit('SIGINT');
+            expect(shutdownManager).toBeDefined();
+            shutdownSpy.mockRestore();
+        });
+    });
+    describe('timeout handling', () => {
+        it('should use default timeout', async () => {
+            const manager = new shutdown_1.ShutdownManager();
+            const slowHandler = {
+                name: 'slow-handler',
+                handler: jest.fn(async () => {
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                }),
+            };
+            manager.registerHandler(slowHandler);
+            await manager.shutdown('TEST');
+            expect(slowHandler.handler).toHaveBeenCalled();
+        });
+        it('should respect handler timeout', async () => {
+            const handler = {
+                name: 'timed-handler',
+                handler: jest.fn(async () => {
+                    await new Promise(resolve => setTimeout(resolve, 50));
+                }),
+                timeout: 100,
+            };
+            shutdownManager.registerHandler(handler);
+            await shutdownManager.shutdown('TEST');
+            expect(handler.handler).toHaveBeenCalled();
+        });
+        it('should handle handler without timeout', async () => {
+            const handler = {
+                name: 'no-timeout-handler',
+                handler: jest.fn(async () => { }),
+            };
+            shutdownManager.registerHandler(handler);
+            await shutdownManager.shutdown('TEST');
+            expect(handler.handler).toHaveBeenCalled();
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle empty handlers list', async () => {
+            await expect(shutdownManager.shutdown('TEST')).resolves.not.toThrow();
+        });
+        it('should handle handler that returns void', async () => {
+            const handler = {
+                name: 'void-handler',
+                handler: jest.fn(async () => { }),
+            };
+            shutdownManager.registerHandler(handler);
+            await shutdownManager.shutdown('TEST');
+            expect(handler.handler).toHaveBeenCalled();
+        });
+        it('should handle multiple shutdown calls gracefully', async () => {
+            const handler = jest.fn(async () => { });
+            shutdownManager.registerHandler({
+                name: 'test',
+                handler,
+            });
+            await shutdownManager.shutdown('TEST');
+            await shutdownManager.shutdown('TEST');
+            // Handler should only be called once
+            expect(handler).toHaveBeenCalledTimes(1);
+        });
+        it('should handle handler errors gracefully', async () => {
+            const errorHandler = jest.fn(async () => {
+                throw new Error('Handler error');
+            });
+            const successHandler = jest.fn(async () => { });
+            shutdownManager.registerHandler({
+                name: 'error-handler',
+                handler: errorHandler,
+            });
+            shutdownManager.registerHandler({
+                name: 'success-handler',
+                handler: successHandler,
+            });
+            // Mock process.exit to prevent actual exit
+            const exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+            await shutdownManager.shutdown('TEST');
+            expect(errorHandler).toHaveBeenCalled();
+            expect(successHandler).toHaveBeenCalled();
+            exitSpy.mockRestore();
+        });
+        it('should handle handler timeout', async () => {
+            const slowHandler = jest.fn(async () => {
+                await new Promise(resolve => setTimeout(resolve, 200));
+            });
+            shutdownManager.registerHandler({
+                name: 'slow-handler',
+                handler: slowHandler,
+                timeout: 50,
+            });
+            const exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+            await shutdownManager.shutdown('TEST');
+            expect(slowHandler).toHaveBeenCalled();
+            exitSpy.mockRestore();
+        });
+    });
+    describe('setupSignalHandlers', () => {
+        it('should setup signal handlers', () => {
+            shutdownManager.setupSignalHandlers();
+            // Verify the manager is still functional
+            expect(shutdownManager).toBeDefined();
+        });
+        it('should handle uncaught exceptions', async () => {
+            const exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+            shutdownManager.setupSignalHandlers();
+            // Simulate uncaught exception
+            const error = new Error('Test error');
+            process.emit('uncaughtException', error);
+            // Give time for async shutdown
+            await new Promise(resolve => setTimeout(resolve, 100));
+            exitSpy.mockRestore();
+        });
+        it('should handle unhandled rejections', async () => {
+            const exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+            shutdownManager.setupSignalHandlers();
+            // Simulate unhandled rejection - catch it to prevent test failure
+            const reason = 'Test rejection';
+            const promise = Promise.reject(reason).catch(() => { });
+            process.emit('unhandledRejection', reason, promise);
+            // Give time for async shutdown
+            await new Promise(resolve => setTimeout(resolve, 100));
+            exitSpy.mockRestore();
+        });
+    });
+});

package/dist/__tests__/testing/testing.module.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=testing.module.test.d.ts.map

package/dist/__tests__/testing/testing.module.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.module.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/testing/testing.module.test.ts"],"names":[],"mappings":"AACA,OAAO,kBAAkB,CAAC"}

package/dist/__tests__/testing/testing.module.test.js

@@ -0,0 +1,370 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const testing_module_1 = require("../../testing/testing.module");
+require("reflect-metadata");
+// Mock logger
+jest.mock('../../logger', () => ({
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    isDebugEnabled: jest.fn().mockReturnValue(false),
+}));
+describe('Testing Module', () => {
+    describe('Test.createTestingModule', () => {
+        it('should create testing module builder', () => {
+            const builder = testing_module_1.Test.createTestingModule({
+                controllers: [],
+                providers: [],
+            });
+            expect(builder).toBeInstanceOf(testing_module_1.TestingModuleBuilder);
+        });
+        it('should accept controllers', () => {
+            class TestController {
+            }
+            const builder = testing_module_1.Test.createTestingModule({
+                controllers: [TestController],
+            });
+            expect(builder).toBeDefined();
+        });
+        it('should accept providers', () => {
+            class TestService {
+            }
+            const builder = testing_module_1.Test.createTestingModule({
+                providers: [TestService],
+            });
+            expect(builder).toBeDefined();
+        });
+        it('should accept imports', () => {
+            class TestModule {
+            }
+            const builder = testing_module_1.Test.createTestingModule({
+                imports: [TestModule],
+            });
+            expect(builder).toBeDefined();
+        });
+    });
+    describe('TestingModuleBuilder', () => {
+        describe('compile', () => {
+            it('should compile testing module', async () => {
+                const builder = testing_module_1.Test.createTestingModule({});
+                const module = await builder.compile();
+                expect(module).toBeInstanceOf(testing_module_1.TestingModule);
+            });
+            it('should register providers', async () => {
+                class TestService {
+                    getValue() {
+                        return 'test';
+                    }
+                }
+                const builder = testing_module_1.Test.createTestingModule({
+                    providers: [TestService],
+                });
+                const module = await builder.compile();
+                const service = module.get(TestService);
+                expect(service).toBeInstanceOf(TestService);
+                expect(service.getValue()).toBe('test');
+            });
+            it('should register controllers', async () => {
+                class TestController {
+                    getStatus() {
+                        return 'ok';
+                    }
+                }
+                const builder = testing_module_1.Test.createTestingModule({
+                    controllers: [TestController],
+                });
+                const module = await builder.compile();
+                const controller = module.get(TestController);
+                expect(controller).toBeInstanceOf(TestController);
+                expect(controller.getStatus()).toBe('ok');
+            });
+            it('should register provider with useValue', async () => {
+                const mockValue = { data: 'mock' };
+                const builder = testing_module_1.Test.createTestingModule({
+                    providers: [
+                        {
+                            token: 'TEST_TOKEN',
+                            useValue: mockValue,
+                        },
+                    ],
+                });
+                const module = await builder.compile();
+                const value = module.get('TEST_TOKEN');
+                expect(value).toBe(mockValue);
+            });
+            it('should register provider with useClass', async () => {
+                class TestService {
+                    getValue() {
+                        return 'test';
+                    }
+                }
+                const builder = testing_module_1.Test.createTestingModule({
+                    providers: [
+                        {
+                            token: 'SERVICE',
+                            useClass: TestService,
+                        },
+                    ],
+                });
+                const module = await builder.compile();
+                const service = module.get('SERVICE');
+                expect(service).toBeInstanceOf(TestService);
+                expect(service.getValue()).toBe('test');
+            });
+            it('should register provider with useFactory', async () => {
+                const factory = () => ({ data: 'factory' });
+                const builder = testing_module_1.Test.createTestingModule({
+                    providers: [
+                        {
+                            token: 'FACTORY',
+                            useFactory: factory,
+                        },
+                    ],
+                });
+                const module = await builder.compile();
+                const value = module.get('FACTORY');
+                expect(value).toEqual({ data: 'factory' });
+            });
+        });
+        describe('overrideProvider', () => {
+            it('should override provider with useValue', async () => {
+                class OriginalService {
+                    getValue() {
+                        return 'original';
+                    }
+                }
+                const mockService = {
+                    getValue: () => 'mocked',
+                };
+                const builder = testing_module_1.Test.createTestingModule({
+                    providers: [OriginalService],
+                })
+                    .overrideProvider(OriginalService)
+                    .useValue(mockService);
+                const module = await builder.compile();
+                const service = module.get(OriginalService);
+                expect(service.getValue()).toBe('mocked');
+            });
+            it('should override provider with useClass', async () => {
+                class OriginalService {
+                    getValue() {
+                        return 'original';
+                    }
+                }
+                class MockService {
+                    getValue() {
+                        return 'mock';
+                    }
+                }
+                const builder = testing_module_1.Test.createTestingModule({
+                    providers: [OriginalService],
+                })
+                    .overrideProvider(OriginalService)
+                    .useClass(MockService);
+                const module = await builder.compile();
+                const service = module.get(OriginalService);
+                expect(service.getValue()).toBe('mock');
+            });
+            it('should override provider with useFactory', async () => {
+                class OriginalService {
+                    getValue() {
+                        return 'original';
+                    }
+                }
+                const factory = () => ({
+                    getValue: () => 'factory',
+                });
+                const builder = testing_module_1.Test.createTestingModule({
+                    providers: [OriginalService],
+                })
+                    .overrideProvider(OriginalService)
+                    .useFactory(factory);
+                const module = await builder.compile();
+                const service = module.get(OriginalService);
+                expect(service.getValue()).toBe('factory');
+            });
+            it('should override provider with factory and dependencies', async () => {
+                class Dependency {
+                    getValue() {
+                        return 'dep';
+                    }
+                }
+                class OriginalService {
+                    getValue() {
+                        return 'original';
+                    }
+                }
+                const factory = (...args) => {
+                    const dep = args[0];
+                    return {
+                        getValue: () => `factory-${dep.getValue()}`,
+                    };
+                };
+                const builder = testing_module_1.Test.createTestingModule({
+                    providers: [Dependency, OriginalService],
+                })
+                    .overrideProvider(OriginalService)
+                    .useFactory(factory, [Dependency]);
+                const module = await builder.compile();
+                const service = module.get(OriginalService);
+                expect(service.getValue()).toBe('factory-dep');
+            });
+            it('should add provider if not exists', async () => {
+                const mockValue = { data: 'new' };
+                const builder = testing_module_1.Test.createTestingModule({
+                    providers: [],
+                })
+                    .overrideProvider('NEW_TOKEN')
+                    .useValue(mockValue);
+                const module = await builder.compile();
+                const value = module.get('NEW_TOKEN');
+                expect(value).toBe(mockValue);
+            });
+        });
+    });
+    describe('TestingModule', () => {
+        describe('get', () => {
+            it('should get provider from container', async () => {
+                class TestService {
+                    getValue() {
+                        return 'test';
+                    }
+                }
+                const module = await testing_module_1.Test.createTestingModule({
+                    providers: [TestService],
+                }).compile();
+                const service = module.get(TestService);
+                expect(service).toBeInstanceOf(TestService);
+            });
+            it('should get value provider', async () => {
+                const mockValue = { data: 'test' };
+                const module = await testing_module_1.Test.createTestingModule({
+                    providers: [
+                        {
+                            token: 'TOKEN',
+                            useValue: mockValue,
+                        },
+                    ],
+                }).compile();
+                const value = module.get('TOKEN');
+                expect(value).toBe(mockValue);
+            });
+            it('should return undefined for non-existent provider', async () => {
+                const module = await testing_module_1.Test.createTestingModule({}).compile();
+                const value = module.get('NON_EXISTENT');
+                expect(value).toBeUndefined();
+            });
+        });
+        describe('select', () => {
+            it('should select module context', async () => {
+                class TestModule {
+                }
+                const module = await testing_module_1.Test.createTestingModule({}).compile();
+                const selected = module.select(TestModule);
+                expect(selected).toBeInstanceOf(testing_module_1.TestingModule);
+            });
+            it('should return same module for now', async () => {
+                class TestModule {
+                }
+                const module = await testing_module_1.Test.createTestingModule({}).compile();
+                const selected = module.select(TestModule);
+                expect(selected).toBe(module);
+            });
+        });
+        describe('close', () => {
+            it('should close testing module', async () => {
+                const module = await testing_module_1.Test.createTestingModule({}).compile();
+                await expect(module.close()).resolves.not.toThrow();
+            });
+            it('should cleanup container', async () => {
+                class TestService {
+                }
+                const module = await testing_module_1.Test.createTestingModule({
+                    providers: [TestService],
+                }).compile();
+                const serviceBefore = module.get(TestService);
+                expect(serviceBefore).toBeInstanceOf(TestService);
+                await module.close();
+                // After close, container is cleared
+                // Note: The actual behavior may vary based on implementation
+                expect(true).toBe(true);
+            });
+        });
+    });
+    describe('integration tests', () => {
+        it('should handle complex testing scenario', async () => {
+            class DatabaseService {
+                query() {
+                    return 'real-db';
+                }
+            }
+            class UserService {
+                constructor(db) {
+                    this.db = db;
+                }
+                getUsers() {
+                    return this.db.query();
+                }
+            }
+            class UserController {
+                constructor(userService) {
+                    this.userService = userService;
+                }
+                getAll() {
+                    return this.userService.getUsers();
+                }
+            }
+            // Set up dependency injection metadata
+            Reflect.defineMetadata('design:paramtypes', [DatabaseService], UserService);
+            Reflect.defineMetadata('design:paramtypes', [UserService], UserController);
+            const mockDb = {
+                query: () => 'mock-db',
+            };
+            const module = await testing_module_1.Test.createTestingModule({
+                controllers: [UserController],
+                providers: [UserService, DatabaseService],
+            })
+                .overrideProvider(DatabaseService)
+                .useValue(mockDb)
+                .compile();
+            const controller = module.get(UserController);
+            const service = module.get(UserService);
+            // Verify the mock is registered
+            const db = module.get(DatabaseService);
+            expect(db.query()).toBe('mock-db');
+            // The controller may still use the original service instance
+            // This tests the actual behavior
+            expect(controller).toBeInstanceOf(UserController);
+            expect(service).toBeInstanceOf(UserService);
+            await module.close();
+        });
+        it('should support multiple overrides', async () => {
+            class ServiceA {
+                getValue() {
+                    return 'A';
+                }
+            }
+            class ServiceB {
+                getValue() {
+                    return 'B';
+                }
+            }
+            const mockA = { getValue: () => 'MockA' };
+            const mockB = { getValue: () => 'MockB' };
+            const module = await testing_module_1.Test.createTestingModule({
+                providers: [ServiceA, ServiceB],
+            })
+                .overrideProvider(ServiceA)
+                .useValue(mockA)
+                .overrideProvider(ServiceB)
+                .useValue(mockB)
+                .compile();
+            const serviceA = module.get(ServiceA);
+            const serviceB = module.get(ServiceB);
+            expect(serviceA.getValue()).toBe('MockA');
+            expect(serviceB.getValue()).toBe('MockB');
+            await module.close();
+        });
+    });
+});

package/dist/__tests__/upload/file-upload.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=file-upload.test.d.ts.map

package/dist/__tests__/upload/file-upload.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-upload.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/upload/file-upload.test.ts"],"names":[],"mappings":"AAOA,OAAO,kBAAkB,CAAC"}