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

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

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

package/dist/test/unit/middleware/a5-console-logger.middleware.unit.spec.js

@@ -0,0 +1,379 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@nestjs/common");
+const a5_console_logger_1 = require("../../../core/a5-console-logger");
+const a5_console_logger_middleware_1 = require("../../../middleware/a5-console-logger.middleware");
+const color_util_1 = require("../../../util/color.util");
+// Test helper class to access protected members
+class TestableA5ConsoleLoggerMiddleware extends a5_console_logger_middleware_1.A5ConsoleLoggerMiddleware {
+    getLogger() {
+        return this.logger;
+    }
+}
+describe('A5ConsoleLoggerMiddleware Unit Test', () => {
+    const toClearLines = (lines) => lines.map(([text]) => color_util_1.ColorUtil.clear(text.trim()));
+    // eslint-disable-next-line init-declarations
+    let middleware;
+    // eslint-disable-next-line init-declarations
+    let mockRequest;
+    // eslint-disable-next-line init-declarations
+    let mockResponse;
+    // eslint-disable-next-line init-declarations
+    let mockNext;
+    // eslint-disable-next-line init-declarations
+    let processStdoutWriteSpy;
+    beforeEach(() => {
+        middleware = new TestableA5ConsoleLoggerMiddleware();
+        common_1.Logger.overrideLogger(new a5_console_logger_1.A5ConsoleLogger());
+        mockNext = jest.fn();
+        // Mock request
+        mockRequest = {
+            method: 'GET',
+            url: '/test',
+            headers: {
+                referer: 'http://example.com',
+                'user-agent': 'Mozilla/5.0',
+            },
+            httpVersion: '1.1',
+            socket: {
+                remoteAddress: '127.0.0.1',
+            },
+        };
+        // Mock response
+        const mockListeners = {};
+        mockResponse = {
+            statusCode: 200,
+            write: jest.fn().mockReturnValue(true),
+            end: jest.fn().mockReturnValue(true),
+            on: jest.fn().mockImplementation((event, callback) => {
+                if (!mockListeners[event]) {
+                    mockListeners[event] = [];
+                }
+                mockListeners[event].push(callback);
+            }),
+            emit: jest.fn().mockImplementation((event, ...args) => {
+                if (mockListeners[event]) {
+                    mockListeners[event].forEach((callback) => callback(...args));
+                }
+            }),
+        };
+        // Spy on process.stdout.write to capture log output
+        processStdoutWriteSpy = jest.spyOn(process.stdout, 'write').mockImplementation();
+        jest.clearAllMocks();
+    });
+    afterEach(() => {
+        processStdoutWriteSpy.mockRestore();
+        jest.restoreAllMocks();
+    });
+    describe('[[Protected Properties]]', () => {
+        describe('logger', () => {
+            describe('instance', () => {
+                it('should have logger instance', () => {
+                    const logger = middleware.getLogger();
+                    expect(logger).toBeDefined();
+                    expect(logger).toHaveProperty('log');
+                    expect(typeof logger.log).toBe('function');
+                });
+            });
+        });
+    });
+    describe('[[Public Methods]]', () => {
+        describe('use', () => {
+            describe('req', () => {
+                it('should handle request with all required properties', () => {
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    expect(mockNext).toHaveBeenCalled();
+                });
+                it('should handle request without socket remoteAddress', () => {
+                    mockRequest.socket = undefined;
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] - - "GET \/test HTTP\/1\.1" 200 0 \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+                it('should handle request without referer header', () => {
+                    delete mockRequest.headers.referer;
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "GET \/test HTTP\/1\.1" 200 0 \d+ms "-" "Mozilla\/5\.0"$/);
+                });
+                it('should handle request without user-agent header', () => {
+                    delete mockRequest.headers['user-agent'];
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "GET \/test HTTP\/1\.1" 200 0 \d+ms "http:\/\/example\.com" "-"$/);
+                });
+                it('should handle POST request', () => {
+                    mockRequest.method = 'POST';
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "POST \/test HTTP\/1\.1" 200 0 \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+                it('should handle PUT request', () => {
+                    mockRequest.method = 'PUT';
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "PUT \/test HTTP\/1\.1" 200 0 \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+                it('should handle DELETE request', () => {
+                    mockRequest.method = 'DELETE';
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "DELETE \/test HTTP\/1\.1" 200 0 \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+                it('should handle different HTTP versions', () => {
+                    mockRequest.httpVersion = '2.0';
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "GET \/test HTTP\/2\.0" 200 0 \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+                it('should handle different URLs', () => {
+                    mockRequest.url = '/api/users/123';
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "GET \/api\/users\/123 HTTP\/1\.1" 200 0 \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+            });
+            describe('res', () => {
+                it('should handle response with 200 status code', () => {
+                    mockResponse.statusCode = 200;
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "GET \/test HTTP\/1\.1" 200 0 \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+                it('should handle response with 404 status code', () => {
+                    mockResponse.statusCode = 404;
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "GET \/test HTTP\/1\.1" 404 0 \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+                it('should handle response with 500 status code', () => {
+                    mockResponse.statusCode = 500;
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "GET \/test HTTP\/1\.1" 500 0 \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+                it('should track bytes written through write method with string chunk', () => {
+                    const testContent = 'test response content';
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    // Simulate writing content
+                    mockResponse.write(testContent);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(new RegExp(`^\\[A5\\] \\d+\\s+ - \\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}\\s+LOG \\[HttpRequest   \\] 127\\.0\\.0\\.1 - "GET \\/test HTTP\\/1\\.1" 200 ${Buffer.byteLength(testContent)} \\d+ms "http:\\/\\/example\\.com" "Mozilla\\/5\\.0"$`));
+                });
+                it('should track bytes written through write method with Buffer chunk', () => {
+                    const testBuffer = Buffer.from('test buffer content');
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    // Simulate writing buffer
+                    mockResponse.write(testBuffer);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(new RegExp(`^\\[A5\\] \\d+\\s+ - \\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}\\s+LOG \\[HttpRequest   \\] 127\\.0\\.0\\.1 - "GET \\/test HTTP\\/1\\.1" 200 ${testBuffer.length} \\d+ms "http:\\/\\/example\\.com" "Mozilla\\/5\\.0"$`));
+                });
+                it('should track bytes written through end method with string chunk', () => {
+                    const testContent = 'final response content';
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    // Simulate ending with content
+                    mockResponse.end(testContent);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(new RegExp(`^\\[A5\\] \\d+\\s+ - \\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}\\s+LOG \\[HttpRequest   \\] 127\\.0\\.0\\.1 - "GET \\/test HTTP\\/1\\.1" 200 ${Buffer.byteLength(testContent)} \\d+ms "http:\\/\\/example\\.com" "Mozilla\\/5\\.0"$`));
+                });
+                it('should track bytes written through end method with Buffer chunk', () => {
+                    const testBuffer = Buffer.from('final buffer content');
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    // Simulate ending with buffer
+                    mockResponse.end(testBuffer);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(new RegExp(`^\\[A5\\] \\d+\\s+ - \\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}\\s+LOG \\[HttpRequest   \\] 127\\.0\\.0\\.1 - "GET \\/test HTTP\\/1\\.1" 200 ${testBuffer.length} \\d+ms "http:\\/\\/example\\.com" "Mozilla\\/5\\.0"$`));
+                });
+                it('should handle both write and end with content', () => {
+                    const writeContent = 'first part';
+                    const endContent = 'second part';
+                    const totalBytes = Buffer.byteLength(writeContent) + Buffer.byteLength(endContent);
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    // Simulate writing and ending with content
+                    mockResponse.write(writeContent);
+                    mockResponse.end(endContent);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(new RegExp(`^\\[A5\\] \\d+\\s+ - \\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}\\s+LOG \\[HttpRequest   \\] 127\\.0\\.0\\.1 - "GET \\/test HTTP\\/1\\.1" 200 ${totalBytes} \\d+ms "http:\\/\\/example\\.com" "Mozilla\\/5\\.0"$`));
+                });
+                it('should handle write method with null chunk', () => {
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    // Simulate writing null
+                    mockResponse.write(null);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "GET \/test HTTP\/1\.1" 200 0 \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+                it('should handle end method with null chunk', () => {
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    // Simulate ending with null
+                    mockResponse.end(null);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "GET \/test HTTP\/1\.1" 200 0 \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+                it('should handle write method with undefined chunk', () => {
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    // Simulate writing undefined
+                    mockResponse.write(undefined);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "GET \/test HTTP\/1\.1" 200 0 \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+                it('should handle end method with undefined chunk', () => {
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    // Simulate ending with undefined
+                    mockResponse.end(undefined);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "GET \/test HTTP\/1\.1" 200 0 \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+            });
+            describe('next', () => {
+                it('should call next function immediately', () => {
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    expect(mockNext).toHaveBeenCalledWith();
+                    expect(mockNext).toHaveBeenCalledTimes(1);
+                });
+                it('should call next function before response finish event', () => {
+                    const callOrder = [];
+                    mockNext.mockImplementation(() => {
+                        callOrder.push('next');
+                    });
+                    // Mock the original stdout write to track log calls
+                    processStdoutWriteSpy.mockImplementation((...args) => {
+                        callOrder.push('log');
+                        return true;
+                    });
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.emit('finish');
+                    expect(callOrder).toEqual(['next', 'log']);
+                });
+            });
+            describe('[[Default]]', () => {
+                it('should log request in Nginx access log format', () => {
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "GET \/test HTTP\/1\.1" 200 0 \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+                it('should calculate request time correctly', () => {
+                    const startTime = Date.now();
+                    jest
+                        .spyOn(Date, 'now')
+                        .mockReturnValueOnce(startTime) // First call in middleware
+                        .mockReturnValueOnce(startTime + 100); // Second call in finish event
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "GET \/test HTTP\/1\.1" 200 0 100ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+                it('should preserve original write and end methods functionality', () => {
+                    const originalWrite = mockResponse.write;
+                    const originalEnd = mockResponse.end;
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    // Verify that write and end methods are called
+                    const testData = 'test data';
+                    mockResponse.write(testData);
+                    mockResponse.end(testData);
+                    expect(originalWrite).toHaveBeenCalledWith(testData);
+                    expect(originalEnd).toHaveBeenCalledWith(testData);
+                });
+                it('should handle multiple write calls before end', () => {
+                    const data1 = 'first chunk';
+                    const data2 = 'second chunk';
+                    const data3 = 'third chunk';
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.write(data1);
+                    mockResponse.write(data2);
+                    mockResponse.end(data3);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "GET \/test HTTP\/1\.1" 200 \d+ \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+                it('should handle ArrayBuffer chunks in write method', () => {
+                    const arrayBuffer = new ArrayBuffer(16);
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.write(arrayBuffer);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "GET \/test HTTP\/1\.1" 200 16 \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+                it('should handle ArrayBuffer chunks in end method', () => {
+                    const arrayBuffer = new ArrayBuffer(32);
+                    middleware.use(mockRequest, mockResponse, mockNext);
+                    mockResponse.end(arrayBuffer);
+                    mockResponse.emit('finish');
+                    expect(processStdoutWriteSpy).toHaveBeenCalled();
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines.length).toBe(1);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+ - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[HttpRequest\s+\] 127\.0\.0\.1 - "GET \/test HTTP\/1\.1" 200 32 \d+ms "http:\/\/example\.com" "Mozilla\/5\.0"$/);
+                });
+            });
+        });
+    });
+});
+//# sourceMappingURL=a5-console-logger.middleware.unit.spec.js.map

package/dist/test/unit/util/a5.util.unit.spec.d.ts

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

package/dist/test/unit/util/a5.util.unit.spec.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = require("node:path");
+const a5_util_1 = require("../../../util/a5.util");
+describe('A5Util Unit Test', () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        jest.resetModules();
+        process.env = { ...originalEnv };
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    describe('[[Static Public Methods]]', () => {
+        describe('sleep', () => {
+            describe('t', () => {
+                it('should resolve after specified milliseconds for positive number', async () => {
+                    const startTime = Date.now();
+                    await a5_util_1.A5Util.sleep(100);
+                    const endTime = Date.now();
+                    expect(endTime - startTime).toBeGreaterThanOrEqual(90);
+                    expect(endTime - startTime).toBeLessThan(150);
+                });
+                it('should resolve immediately for zero', async () => {
+                    const startTime = Date.now();
+                    await a5_util_1.A5Util.sleep(0);
+                    const endTime = Date.now();
+                    expect(endTime - startTime).toBeLessThan(50);
+                });
+                it('should resolve immediately for negative number', async () => {
+                    const startTime = Date.now();
+                    await a5_util_1.A5Util.sleep(-100);
+                    const endTime = Date.now();
+                    expect(endTime - startTime).toBeLessThan(50);
+                });
+                it('should resolve after specified milliseconds for large number', async () => {
+                    const startTime = Date.now();
+                    await a5_util_1.A5Util.sleep(200);
+                    const endTime = Date.now();
+                    expect(endTime - startTime).toBeGreaterThanOrEqual(190);
+                    expect(endTime - startTime).toBeLessThan(250);
+                });
+                it('should resolve after specified milliseconds for decimal number', async () => {
+                    const startTime = Date.now();
+                    await a5_util_1.A5Util.sleep(50.5);
+                    const endTime = Date.now();
+                    expect(endTime - startTime).toBeGreaterThanOrEqual(40);
+                    expect(endTime - startTime).toBeLessThan(100);
+                });
+            });
+        });
+        describe('tryWithAbsolutePath', () => {
+            describe('sourcePath', () => {
+                it('should return normalized absolute path when sourcePath is absolute on Unix', () => {
+                    const result = a5_util_1.A5Util.tryWithAbsolutePath('/home/user/file.txt', '/base/path');
+                    expect(result).toBe('/home/user/file.txt');
+                });
+                // TODO: Add support for Windows
+                // it('should return normalized absolute path when sourcePath is absolute on Windows', () => {
+                //   const result = A5Util.tryWithAbsolutePath('C:\\Users\\file.txt', '/base/path')
+                //   expect(result).toBe('C:/Users/file.txt')
+                // })
+                it('should resolve relative path when sourcePath is relative', () => {
+                    const result = a5_util_1.A5Util.tryWithAbsolutePath('relative/file.txt', '/base/path');
+                    expect(result).toBe('/base/path/relative/file.txt');
+                });
+                it('should handle empty string sourcePath', () => {
+                    const result = a5_util_1.A5Util.tryWithAbsolutePath('', '/base/path');
+                    expect(result).toBe('/base/path');
+                });
+                it('should handle dot notation sourcePath', () => {
+                    const result = a5_util_1.A5Util.tryWithAbsolutePath('./file.txt', '/base/path');
+                    expect(result).toBe('/base/path/file.txt');
+                });
+                it('should handle double dot notation sourcePath', () => {
+                    const result = a5_util_1.A5Util.tryWithAbsolutePath('../file.txt', '/base/path');
+                    expect(result).toBe('/base/file.txt');
+                });
+                it('should handle sourcePath with special characters', () => {
+                    const result = a5_util_1.A5Util.tryWithAbsolutePath('file with spaces.txt', '/base/path');
+                    expect(result).toBe('/base/path/file with spaces.txt');
+                });
+            });
+            describe('basePath', () => {
+                it('should use basePath for resolving relative sourcePath', () => {
+                    const result = a5_util_1.A5Util.tryWithAbsolutePath('file.txt', '/custom/base');
+                    expect(result).toBe('/custom/base/file.txt');
+                });
+                it('should handle empty basePath', () => {
+                    const result = a5_util_1.A5Util.tryWithAbsolutePath('file.txt', '');
+                    expect((0, node_path_1.basename)(result)).toBe('file.txt');
+                });
+                it('should handle basePath with trailing slash', () => {
+                    const result = a5_util_1.A5Util.tryWithAbsolutePath('file.txt', '/base/path/');
+                    expect(result).toBe('/base/path/file.txt');
+                });
+                it('should handle basePath without leading slash', () => {
+                    const result = a5_util_1.A5Util.tryWithAbsolutePath('file.txt', 'base/path');
+                    expect(result).toContain('file.txt');
+                });
+                it('should handle basePath with special characters', () => {
+                    const result = a5_util_1.A5Util.tryWithAbsolutePath('file.txt', '/base path/sub dir');
+                    expect(result).toBe('/base path/sub dir/file.txt');
+                });
+            });
+        });
+    });
+});
+//# sourceMappingURL=a5.util.unit.spec.js.map

package/dist/test/unit/util/color.util.unit.spec.d.ts

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