@hz-9/a5-core 0.2.0-alpha.1

package/dist/test/unit/core/a5-application.unit.spec.js

@@ -0,0 +1,450 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../../const/index");
+const a5_application_1 = require("../../../core/a5-application");
+const a5_console_logger_1 = require("../../../core/a5-console-logger");
+const util_1 = require("../../../util");
+// Test helper class to access protected members
+class TestableA5Application extends a5_application_1.A5Application {
+    getInitTime() {
+        return this.initTime;
+    }
+    getLogger() {
+        return this.logger;
+    }
+    getExtraUrls() {
+        return this.extraUrls;
+    }
+}
+describe('A5Application Unit Test', () => {
+    const originalEnv = process.env;
+    // eslint-disable-next-line init-declarations
+    let processStdoutWriteSpy;
+    // eslint-disable-next-line init-declarations
+    let processStderrWriteSpy;
+    // eslint-disable-next-line init-declarations
+    let app;
+    // eslint-disable-next-line init-declarations
+    let mockNestApp;
+    beforeEach(() => {
+        jest.resetModules();
+        process.env = { ...originalEnv };
+        processStdoutWriteSpy = jest.spyOn(process.stdout, 'write').mockImplementation();
+        processStderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation();
+        jest.clearAllMocks();
+        // Mock the Date.now() to ensure consistent timing
+        const mockDateNow = 1642780800000; // 2022-01-21 12:00:00 UTC
+        jest.spyOn(Date, 'now').mockReturnValue(mockDateNow);
+        process.env.A5_INIT_TIME = String(mockDateNow - 1000); // 1 second earlier
+        // Create mock NestFastifyApplication
+        mockNestApp = {
+            useLogger: jest.fn().mockReturnValue(undefined),
+            init: jest.fn().mockResolvedValue(undefined),
+            flushLogs: jest.fn().mockResolvedValue(undefined),
+            listen: jest.fn().mockResolvedValue(undefined),
+            getUrl: jest.fn().mockResolvedValue('http://localhost:3000'),
+            close: jest.fn().mockResolvedValue(undefined),
+            getHttpServer: jest.fn().mockReturnValue({
+                address: jest.fn().mockReturnValue({ port: 3000 }),
+            }),
+            get: jest.fn().mockImplementation((token) => {
+                if (token.toString().includes('ModuleRef')) {
+                    return {
+                        get: jest.fn().mockImplementation(() => {
+                            throw new Error('Module not found');
+                        }),
+                    };
+                }
+                throw new Error('Unknown token');
+            }),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        };
+        app = new TestableA5Application(mockNestApp);
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+        processStdoutWriteSpy.mockRestore();
+        processStderrWriteSpy.mockRestore();
+        jest.restoreAllMocks();
+    });
+    describe('[[Constructor]]', () => {
+        describe('[[Constructor]]', () => {
+            describe('[[Default]]', () => {
+                it('should create instance with default options when no options provided', () => {
+                    const testApp = new TestableA5Application(mockNestApp);
+                    expect(testApp).toBeInstanceOf(a5_application_1.A5Application);
+                    expect(testApp.instanceId).toBeDefined();
+                    expect(testApp.instanceId).toHaveLength(21);
+                    expect(testApp.nestApp).toBe(mockNestApp);
+                    expect(testApp.options.logger).toBeDefined();
+                });
+                it('should create instance with empty options object', () => {
+                    const testApp = new TestableA5Application(mockNestApp, {});
+                    expect(testApp).toBeInstanceOf(a5_application_1.A5Application);
+                    expect(testApp.options.logger).toBeDefined();
+                });
+            });
+            describe('nestApp', () => {
+                it('should accept NestFastifyApplication instance', () => {
+                    const testApp = new TestableA5Application(mockNestApp);
+                    expect(testApp.nestApp).toBe(mockNestApp);
+                });
+                it('should preserve all methods of nested app', () => {
+                    const testApp = new TestableA5Application(mockNestApp);
+                    expect(testApp.nestApp.init).toBeDefined();
+                    expect(testApp.nestApp.listen).toBeDefined();
+                    expect(testApp.nestApp.close).toBeDefined();
+                });
+            });
+            describe('options', () => {
+                it('should use provided logger when specified', () => {
+                    const customLogger = new a5_console_logger_1.A5ConsoleLogger({ context: 'Custom' });
+                    const testApp = new TestableA5Application(mockNestApp, { logger: customLogger });
+                    expect(testApp.options.logger).toBe(customLogger);
+                });
+                it('should use default logger when logger not provided', () => {
+                    const testApp = new TestableA5Application(mockNestApp, {});
+                    expect(testApp.options.logger).toBeDefined();
+                    expect(testApp.options.logger).toBeInstanceOf(a5_console_logger_1.A5ConsoleLogger);
+                });
+                it('should handle undefined options', () => {
+                    const testApp = new TestableA5Application(mockNestApp, undefined);
+                    expect(testApp.options.logger).toBeDefined();
+                });
+            });
+        });
+    });
+    describe('[[Protected Properties]]', () => {
+        describe('[[Properties]]', () => {
+            describe('logger', () => {
+                it('should be initialized with A5Application name', () => {
+                    const logger = app.getLogger();
+                    expect(logger).toBeDefined();
+                    expect(logger.constructor.name).toBe('Logger');
+                });
+                it('should be accessible through test helper', () => {
+                    const logger = app.getLogger();
+                    expect(logger).toBeDefined();
+                });
+            });
+            describe('extraUrls', () => {
+                it('should be empty array initially', () => {
+                    const extraUrls = app.getExtraUrls();
+                    expect(extraUrls).toEqual([]);
+                    expect(Array.isArray(extraUrls)).toBe(true);
+                });
+                it('should be modifiable', () => {
+                    const extraUrls = app.getExtraUrls();
+                    extraUrls.push('test-url');
+                    expect(app.getExtraUrls()).toContain('test-url');
+                });
+            });
+        });
+    });
+    describe('[[Public Properties]]', () => {
+        describe('[[Properties]]', () => {
+            describe('instanceId', () => {
+                it('should be a 21-character string generated by nanoid', () => {
+                    expect(app.instanceId).toBeDefined();
+                    expect(typeof app.instanceId).toBe('string');
+                    expect(app.instanceId).toHaveLength(21);
+                });
+                it('should be unique for each instance', () => {
+                    const app1 = new TestableA5Application(mockNestApp);
+                    const app2 = new TestableA5Application(mockNestApp);
+                    expect(app1.instanceId).not.toBe(app2.instanceId);
+                });
+                it('should contain only valid nanoid characters', () => {
+                    expect(app.instanceId).toMatch(/^[A-Za-z0-9_-]+$/);
+                });
+            });
+            describe('nestApp', () => {
+                it('should be the same instance passed to constructor', () => {
+                    expect(app.nestApp).toBe(mockNestApp);
+                });
+                it('should be readonly property', () => {
+                    const originalNestApp = app.nestApp;
+                    expect(app.nestApp).toBe(originalNestApp);
+                });
+            });
+            describe('options', () => {
+                it('should contain logger property', () => {
+                    expect(app.options).toHaveProperty('logger');
+                    expect(app.options.logger).toBeDefined();
+                });
+                it('should be readonly property', () => {
+                    const originalOptions = app.options;
+                    expect(app.options).toBe(originalOptions);
+                });
+                it('should be A5AppOptions type with logger', () => {
+                    expect(app.options.logger).toBeDefined();
+                    expect(typeof app.options.logger.log).toBe('function');
+                });
+            });
+        });
+    });
+    describe('[[Public Methods]]', () => {
+        describe('init', () => {
+            describe('[[Default]]', () => {
+                it('should initialize nest application with logger', async () => {
+                    await app.init();
+                    expect(mockNestApp.useLogger).toHaveBeenCalledWith(app.options.logger);
+                    expect(mockNestApp.init).toHaveBeenCalled();
+                    expect(mockNestApp.flushLogs).toHaveBeenCalled();
+                });
+                it('should call methods in correct order', async () => {
+                    const callOrder = [];
+                    mockNestApp.useLogger.mockImplementation(() => {
+                        callOrder.push('useLogger');
+                        return undefined;
+                    });
+                    mockNestApp.init.mockImplementation(jest.fn());
+                    mockNestApp.flushLogs.mockImplementation(jest.fn());
+                    await app.init();
+                    expect(callOrder).toEqual(['useLogger']);
+                });
+                it('should handle init errors', async () => {
+                    const error = new Error('Init failed');
+                    mockNestApp.init.mockRejectedValue(error);
+                    await expect(app.init()).rejects.toThrow('Init failed');
+                });
+                it('should handle flushLogs errors', async () => {
+                    const error = new Error('FlushLogs failed');
+                    mockNestApp.flushLogs.mockRejectedValue(error);
+                    await expect(app.init()).rejects.toThrow('FlushLogs failed');
+                });
+            });
+        });
+        describe('listen', () => {
+            describe('[[Default]]', () => {
+                it('should listen on default port when no arguments provided', async () => {
+                    await app.listen();
+                    expect(mockNestApp.listen).toHaveBeenCalledWith(index_1.A5_APP_LISTEN_PORT_DEFAULT);
+                });
+                it('should use default options when no options provided', async () => {
+                    const listenSpy = jest.spyOn(mockNestApp, 'listen');
+                    await app.listen();
+                    expect(listenSpy).toHaveBeenCalledWith(index_1.A5_APP_LISTEN_PORT_DEFAULT);
+                });
+            });
+            describe('port', () => {
+                it('should listen on specified numeric port', async () => {
+                    await app.listen(8080);
+                    expect(mockNestApp.listen).toHaveBeenCalledWith(8080);
+                });
+                it('should listen on specified string port', async () => {
+                    await app.listen('8080');
+                    expect(mockNestApp.listen).toHaveBeenCalledWith(8080);
+                });
+                it('should handle invalid string port', async () => {
+                    await app.listen('invalid');
+                    expect(mockNestApp.listen).toHaveBeenCalledWith(NaN);
+                });
+            });
+            describe('options', () => {
+                it('should use provided listen options', async () => {
+                    const options = {
+                        tryTimes: 5,
+                        tryInterval: 2000,
+                        autoExit: false,
+                    };
+                    await app.listen(options);
+                    expect(mockNestApp.listen).toHaveBeenCalledWith(index_1.A5_APP_LISTEN_PORT_DEFAULT);
+                });
+                it('should merge port and options correctly', async () => {
+                    const options = {
+                        tryTimes: 3,
+                        autoExit: true,
+                    };
+                    await app.listen(9000, options);
+                    expect(mockNestApp.listen).toHaveBeenCalledWith(9000);
+                });
+                it('should use default values for undefined option properties', async () => {
+                    const options = {
+                        tryTimes: 2,
+                    };
+                    await app.listen(options);
+                    expect(mockNestApp.listen).toHaveBeenCalledWith(index_1.A5_APP_LISTEN_PORT_DEFAULT);
+                });
+            });
+            describe('retryLogic', () => {
+                it('should retry when port is in use', async () => {
+                    let callCount = 0;
+                    mockNestApp.listen.mockImplementation(async () => {
+                        callCount += 1;
+                        if (callCount === 1) {
+                            throw new Error('listen EADDRINUSE: address already in use');
+                        }
+                    });
+                    const sleepSpy = jest.spyOn(util_1.A5Util, 'sleep').mockResolvedValue();
+                    await app.listen({ tryTimes: 2, tryInterval: 100 });
+                    expect(mockNestApp.listen).toHaveBeenCalledTimes(2);
+                    expect(sleepSpy).toHaveBeenCalledWith(100);
+                    sleepSpy.mockRestore();
+                });
+                it('should throw error when max retry attempts exceeded and autoExit is false', async () => {
+                    // eslint-disable-next-line @typescript-eslint/no-extra-semi
+                    ;
+                    mockNestApp.listen.mockRejectedValue(new Error('listen EADDRINUSE: address already in use'));
+                    await expect(app.listen({ tryTimes: 1, autoExit: false })).rejects.toThrow('A5Application.listen error: port 16100 has be used');
+                });
+                it('should call close when max retry attempts exceeded and autoExit is true', async () => {
+                    // eslint-disable-next-line @typescript-eslint/no-extra-semi
+                    ;
+                    mockNestApp.listen.mockRejectedValue(new Error('listen EADDRINUSE: address already in use'));
+                    await app.listen({ tryTimes: 1, autoExit: true });
+                    expect(mockNestApp.close).toHaveBeenCalled();
+                });
+            });
+        });
+        describe('setExtraUrl', () => {
+            describe('[[Default]]', () => {
+                it('should add single URL to extraUrls array', async () => {
+                    await app.setExtraUrl('http://example.com');
+                    expect(app.getExtraUrls()).toContain('http://example.com');
+                });
+                it('should return undefined', async () => {
+                    const result = await app.setExtraUrl('http://example.com');
+                    expect(result).toBeUndefined();
+                });
+            });
+            describe('urlOrUrls', () => {
+                it('should add single string URL', async () => {
+                    await app.setExtraUrl('http://single.com');
+                    expect(app.getExtraUrls()).toEqual(['http://single.com']);
+                });
+                it('should add array of URLs', async () => {
+                    const urls = ['http://first.com', 'http://second.com'];
+                    await app.setExtraUrl(urls);
+                    expect(app.getExtraUrls()).toEqual(urls);
+                });
+                it('should append URLs to existing extraUrls', async () => {
+                    await app.setExtraUrl('http://first.com');
+                    await app.setExtraUrl(['http://second.com', 'http://third.com']);
+                    expect(app.getExtraUrls()).toEqual(['http://first.com', 'http://second.com', 'http://third.com']);
+                });
+                it('should handle empty array', async () => {
+                    await app.setExtraUrl([]);
+                    expect(app.getExtraUrls()).toEqual([]);
+                });
+                it('should handle empty string', async () => {
+                    await app.setExtraUrl('');
+                    expect(app.getExtraUrls()).toEqual(['']);
+                });
+            });
+        });
+        describe('getUrls', () => {
+            describe('[[Default]]', () => {
+                it('should return array containing nest app URL', async () => {
+                    const urls = await app.getUrls();
+                    expect(urls).toContain('http://localhost:3000');
+                    expect(urls).toHaveLength(1);
+                });
+                it('should call nestApp.getUrl', async () => {
+                    await app.getUrls();
+                    expect(mockNestApp.getUrl).toHaveBeenCalled();
+                });
+            });
+            describe('extraUrls', () => {
+                it('should include extra URLs when present', async () => {
+                    await app.setExtraUrl(['http://extra1.com', 'http://extra2.com']);
+                    const urls = await app.getUrls();
+                    expect(urls).toEqual(['http://localhost:3000', 'http://extra1.com', 'http://extra2.com']);
+                });
+                it('should maintain order with nest URL first', async () => {
+                    await app.setExtraUrl('http://extra.com');
+                    const urls = await app.getUrls();
+                    expect(urls[0]).toBe('http://localhost:3000');
+                    expect(urls[1]).toBe('http://extra.com');
+                });
+                it('should handle empty extra URLs', async () => {
+                    const urls = await app.getUrls();
+                    expect(urls).toEqual(['http://localhost:3000']);
+                });
+            });
+        });
+        describe('printAddress', () => {
+            describe('[[Default]]', () => {
+                it('should print application running message', async () => {
+                    const loggerSpy = jest.spyOn(app.getLogger(), 'log');
+                    await app.printAddress();
+                    expect(loggerSpy).toHaveBeenCalledWith(expect.stringContaining('Application runing at'));
+                });
+                it('should include time difference in log message', async () => {
+                    const loggerSpy = jest.spyOn(app.getLogger(), 'log');
+                    await app.printAddress();
+                    expect(loggerSpy).toHaveBeenCalledWith(expect.stringContaining('1000 ms'));
+                });
+            });
+            describe('urlFormatting', () => {
+                it('should pad URLs to align them properly', async () => {
+                    await app.setExtraUrl('http://short.com');
+                    const loggerSpy = jest.spyOn(app.getLogger(), 'log');
+                    await app.printAddress();
+                    // URLs should be padded to the same length
+                    const { calls } = loggerSpy.mock;
+                    expect(calls.length).toBeGreaterThan(1);
+                });
+                it('should print multiple URLs with proper spacing', async () => {
+                    await app.setExtraUrl(['http://first.com', 'http://second-longer-url.com']);
+                    const loggerSpy = jest.spyOn(app.getLogger(), 'log');
+                    await app.printAddress();
+                    expect(loggerSpy).toHaveBeenCalledTimes(3); // 1 main + 2 extra
+                });
+                it('should handle single URL without extra spacing', async () => {
+                    const loggerSpy = jest.spyOn(app.getLogger(), 'log');
+                    await app.printAddress();
+                    expect(loggerSpy).toHaveBeenCalledTimes(1);
+                });
+            });
+        });
+        describe('close', () => {
+            describe('[[Default]]', () => {
+                it('should call nestApp.close', async () => {
+                    await app.close();
+                    expect(mockNestApp.close).toHaveBeenCalled();
+                });
+                it('should return Promise<void>', async () => {
+                    const result = await app.close();
+                    expect(result).toBeUndefined();
+                });
+                it('should handle close errors', async () => {
+                    const error = new Error('Close failed');
+                    mockNestApp.close.mockRejectedValue(error);
+                    await expect(app.close()).rejects.toThrow('Close failed');
+                });
+            });
+        });
+        describe('isClose', () => {
+            describe('[[Default]]', () => {
+                it('should return false when server is running', () => {
+                    mockNestApp.getHttpServer.mockReturnValue({
+                        address: jest.fn().mockReturnValue({ port: 3000 }),
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    });
+                    const result = app.isClose();
+                    expect(result).toBe(false);
+                });
+                it('should return true when server address is null', () => {
+                    mockNestApp.getHttpServer.mockReturnValue({
+                        address: jest.fn().mockReturnValue(null),
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    });
+                    const result = app.isClose();
+                    expect(result).toBe(true);
+                });
+                it('should call getHttpServer and address methods', () => {
+                    const mockAddress = jest.fn().mockReturnValue({ port: 3000 });
+                    mockNestApp.getHttpServer.mockReturnValue({
+                        address: mockAddress,
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    });
+                    app.isClose();
+                    expect(mockNestApp.getHttpServer).toHaveBeenCalled();
+                    expect(mockAddress).toHaveBeenCalled();
+                });
+            });
+        });
+    });
+});
+//# sourceMappingURL=a5-application.unit.spec.js.map

package/dist/test/unit/core/a5-console-logger.unit.spec.d.ts

@@ -0,0 +1 @@
+export {};