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

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

@@ -0,0 +1,998 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const a5_console_logger_1 = require("../../../core/a5-console-logger");
+const color_util_1 = require("../../../util/color.util");
+// Test helper class to access protected members
+class TestableA5ConsoleLogger extends a5_console_logger_1.A5ConsoleLogger {
+    static getLastTimestampAt() {
+        return a5_console_logger_1.A5ConsoleLogger.lastTimestampAt;
+    }
+    static setLastTimestampAt(value) {
+        a5_console_logger_1.A5ConsoleLogger.lastTimestampAt = value;
+    }
+    getOriginalContext() {
+        return this.originalContext;
+    }
+    getInternalContext() {
+        return this.context;
+    }
+    getOptions() {
+        return this.options;
+    }
+    testPrintMessages(messages, context, logLevel = 'log', writeStreamType) {
+        return this.printMessages(messages, context, logLevel, writeStreamType);
+    }
+    testFormatMessage(options) {
+        return this.formatMessage(options);
+    }
+    testFormatMessageStructure(options) {
+        return this.formatMessageStructure(options);
+    }
+    testFormatPrefix() {
+        return this.formatPrefix();
+    }
+    testFormatPid() {
+        return this.formatPid();
+    }
+    testFormatLogLevel(logLevel) {
+        return this.formatLogLevel(logLevel);
+    }
+    testFormatTimestamp(dateMilliseconds) {
+        return this.formatTimestamp(dateMilliseconds);
+    }
+    testFormatContext(context) {
+        return this.formatContext(context);
+    }
+    testStringifyMessage(message, logLevel) {
+        return this.stringifyMessage(message, logLevel);
+    }
+    testColorize(message, logLevel) {
+        return this.colorize(message, logLevel);
+    }
+    testPrintStackTrace(stack) {
+        return this.printStackTrace(stack);
+    }
+    testUpdateAndGetTimestampDiff() {
+        return this.updateAndGetTimestampDiff();
+    }
+    testFormatTimestampDiff(timestampDiff) {
+        return this.formatTimestampDiff(timestampDiff);
+    }
+    testContextNeedApologeticReplace(context) {
+        return this._contextNeedApologeticReplace(context);
+    }
+    testContextApologeticReplace(context) {
+        return this._contextApologeticReplace(context);
+    }
+    testMessageApologeticReplace(message) {
+        return this._messageApologeticReplace(message);
+    }
+    testGetContextAndMessagesToPrint(args) {
+        return super.getContextAndMessagesToPrint(args);
+    }
+    testGetContextAndStackAndMessagesToPrint(args) {
+        return super.getContextAndStackAndMessagesToPrint(args);
+    }
+    testIsStackFormat(stack) {
+        return super.isStackFormat(stack);
+    }
+    testRemoveLastUndefined(args) {
+        return super.removeLastUndefined(args);
+    }
+    testGetColorByLogLevel(level) {
+        return super.getColorByLogLevel(level);
+    }
+}
+describe('A5ConsoleLogger Unit Test', () => {
+    const toClearLines = (lines) => lines.map(([text]) => color_util_1.ColorUtil.clear(text.trim()));
+    // eslint-disable-next-line init-declarations
+    let logger;
+    // eslint-disable-next-line init-declarations
+    let processStdoutWriteSpy;
+    // eslint-disable-next-line init-declarations
+    let processStderrWriteSpy;
+    beforeEach(async () => {
+        processStdoutWriteSpy = jest.spyOn(process.stdout, 'write').mockImplementation();
+        processStderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation();
+        logger = new TestableA5ConsoleLogger();
+    });
+    afterEach(() => {
+        processStdoutWriteSpy.mockRestore();
+        processStderrWriteSpy.mockRestore();
+    });
+    describe('[[Static Protected Properties]]', () => {
+        describe('[[Properties]]', () => {
+            describe('lastTimestampAt', () => {
+                it('should be undefined initially', () => {
+                    TestableA5ConsoleLogger.setLastTimestampAt(undefined);
+                    expect(TestableA5ConsoleLogger.getLastTimestampAt()).toBeUndefined();
+                });
+                it('should be settable to a number', () => {
+                    const timestamp = Date.now();
+                    TestableA5ConsoleLogger.setLastTimestampAt(timestamp);
+                    expect(TestableA5ConsoleLogger.getLastTimestampAt()).toBe(timestamp);
+                });
+                it('should be settable to undefined', () => {
+                    TestableA5ConsoleLogger.setLastTimestampAt(123456);
+                    TestableA5ConsoleLogger.setLastTimestampAt(undefined);
+                    expect(TestableA5ConsoleLogger.getLastTimestampAt()).toBeUndefined();
+                });
+                it('should persist across logger instances', () => {
+                    const timestamp = 1000000;
+                    TestableA5ConsoleLogger.setLastTimestampAt(timestamp);
+                    // Create new instances to verify static property persistence
+                    new TestableA5ConsoleLogger();
+                    new TestableA5ConsoleLogger();
+                    expect(TestableA5ConsoleLogger.getLastTimestampAt()).toBe(timestamp);
+                });
+                it('should handle zero value', () => {
+                    TestableA5ConsoleLogger.setLastTimestampAt(0);
+                    expect(TestableA5ConsoleLogger.getLastTimestampAt()).toBe(0);
+                });
+                it('should handle negative values', () => {
+                    TestableA5ConsoleLogger.setLastTimestampAt(-1000);
+                    expect(TestableA5ConsoleLogger.getLastTimestampAt()).toBe(-1000);
+                });
+                it('should handle maximum safe integer', () => {
+                    TestableA5ConsoleLogger.setLastTimestampAt(Number.MAX_SAFE_INTEGER);
+                    expect(TestableA5ConsoleLogger.getLastTimestampAt()).toBe(Number.MAX_SAFE_INTEGER);
+                });
+            });
+        });
+    });
+    describe('[[Constructor]]', () => {
+        describe('[[Constructor]]', () => {
+            describe('[[Default]]', () => {
+                it('should create instance with default options', () => {
+                    const defaultLogger = new TestableA5ConsoleLogger();
+                    expect(defaultLogger).toBeInstanceOf(a5_console_logger_1.A5ConsoleLogger);
+                    expect(defaultLogger.getOptions()).toMatchObject({
+                        logLevels: ['log', 'error', 'warn', 'debug', 'verbose', 'fatal'],
+                        timestamp: false,
+                    });
+                    expect(defaultLogger.getOriginalContext()).toBe('');
+                    expect(defaultLogger.getInternalContext()).toBe('');
+                });
+            });
+            describe('options', () => {
+                it('should accept custom context', () => {
+                    const options = { context: 'TestContext' };
+                    const contextLogger = new TestableA5ConsoleLogger(options);
+                    expect(contextLogger.getOriginalContext()).toBe('TestContext');
+                    expect(contextLogger.getInternalContext()).toBe('TestContext');
+                });
+                it('should accept empty string context', () => {
+                    const options = { context: '' };
+                    const contextLogger = new TestableA5ConsoleLogger(options);
+                    expect(contextLogger.getOriginalContext()).toBe('');
+                    expect(contextLogger.getInternalContext()).toBe('');
+                });
+                it('should accept undefined context', () => {
+                    const options = { context: undefined };
+                    const contextLogger = new TestableA5ConsoleLogger(options);
+                    expect(contextLogger.getOriginalContext()).toBe('');
+                    expect(contextLogger.getInternalContext()).toBe('');
+                });
+                it('should accept custom logLevels', () => {
+                    const options = { logLevels: ['error', 'warn'] };
+                    const levelsLogger = new TestableA5ConsoleLogger(options);
+                    expect(levelsLogger.getOptions().logLevels).toEqual(['error', 'warn']);
+                });
+                it('should handle empty logLevels array', () => {
+                    const options = { logLevels: [] };
+                    const levelsLogger = new TestableA5ConsoleLogger(options);
+                    expect(levelsLogger.getOptions().logLevels).toEqual([]);
+                });
+                it('should handle undefined logLevels', () => {
+                    const options = { logLevels: undefined };
+                    const levelsLogger = new TestableA5ConsoleLogger(options);
+                    expect(levelsLogger.getOptions().logLevels).toEqual(['log', 'error', 'warn', 'debug', 'verbose', 'fatal']);
+                });
+                it('should accept custom timestamp option true', () => {
+                    const options = { timestamp: true };
+                    const timestampLogger = new TestableA5ConsoleLogger(options);
+                    expect(timestampLogger.getOptions().timestamp).toBe(true);
+                });
+                it('should accept custom timestamp option false', () => {
+                    const options = { timestamp: false };
+                    const timestampLogger = new TestableA5ConsoleLogger(options);
+                    expect(timestampLogger.getOptions().timestamp).toBe(false);
+                });
+                it('should handle undefined timestamp', () => {
+                    const options = { timestamp: undefined };
+                    const timestampLogger = new TestableA5ConsoleLogger(options);
+                    expect(timestampLogger.getOptions().timestamp).toBe(false);
+                });
+                it('should handle empty options object', () => {
+                    const emptyLogger = new TestableA5ConsoleLogger({});
+                    expect(emptyLogger.getOptions()).toMatchObject({
+                        logLevels: ['log', 'error', 'warn', 'debug', 'verbose', 'fatal'],
+                        timestamp: false,
+                    });
+                });
+                it('should handle complex options', () => {
+                    const options = {
+                        context: 'ComplexTest',
+                        logLevels: ['debug', 'verbose'],
+                        timestamp: true,
+                    };
+                    const complexLogger = new TestableA5ConsoleLogger(options);
+                    expect(complexLogger.getOriginalContext()).toBe('ComplexTest');
+                    expect(complexLogger.getInternalContext()).toBe('ComplexTest');
+                    expect(complexLogger.getOptions().logLevels).toEqual(['debug', 'verbose']);
+                    expect(complexLogger.getOptions().timestamp).toBe(true);
+                });
+            });
+        });
+    });
+    describe('[[Protected Properties]]', () => {
+        describe('[[Properties]]', () => {
+            describe('originalContext', () => {
+                it('should return empty string for default constructor', () => {
+                    expect(logger.getOriginalContext()).toBe('');
+                });
+                it('should return the context set in constructor', () => {
+                    const testLogger = new TestableA5ConsoleLogger({ context: 'TestCtx' });
+                    expect(testLogger.getOriginalContext()).toBe('TestCtx');
+                });
+                it('should not change when context is updated', () => {
+                    const testLogger = new TestableA5ConsoleLogger({ context: 'Original' });
+                    testLogger.setContext('Modified');
+                    expect(testLogger.getOriginalContext()).toBe('Original');
+                    expect(testLogger.getInternalContext()).toBe('Modified');
+                });
+            });
+            describe('context', () => {
+                it('should return empty string for default constructor', () => {
+                    expect(logger.getInternalContext()).toBe('');
+                });
+                it('should return the context set in constructor', () => {
+                    const testLogger = new TestableA5ConsoleLogger({ context: 'TestCtx' });
+                    expect(testLogger.getInternalContext()).toBe('TestCtx');
+                });
+                it('should change when setContext is called', () => {
+                    logger.setContext('NewContext');
+                    expect(logger.getInternalContext()).toBe('NewContext');
+                });
+            });
+            describe('options', () => {
+                it('should return default options for default constructor', () => {
+                    const options = logger.getOptions();
+                    expect(options).toMatchObject({
+                        logLevels: ['log', 'error', 'warn', 'debug', 'verbose', 'fatal'],
+                        timestamp: false,
+                    });
+                });
+                it('should return custom options when provided', () => {
+                    const customOptions = { logLevels: ['error'], timestamp: true };
+                    const testLogger = new TestableA5ConsoleLogger(customOptions);
+                    expect(testLogger.getOptions()).toMatchObject(customOptions);
+                });
+            });
+        });
+    });
+    describe('[[Protected Methods]]', () => {
+        describe('printMessages', () => {
+            describe('messages', () => {
+                it('should print multiple messages', () => {
+                    const messages = ['message1', 'message2'];
+                    logger.testPrintMessages(messages, 'TestContext', 'log', 'stdout');
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(2);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[TestContext\s+\] message1$/);
+                    expect(lines[1]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[TestContext\s+\] message2$/);
+                });
+                it('should print single message', () => {
+                    logger.testPrintMessages(['single message'], 'TestContext');
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[TestContext\s+\] single message$/);
+                });
+                it('should handle empty array', () => {
+                    logger.testPrintMessages([], 'TestContext');
+                    expect(processStdoutWriteSpy).not.toHaveBeenCalled();
+                });
+            });
+            describe('context', () => {
+                it('should use provided context', () => {
+                    logger.testPrintMessages(['test'], 'ProvidedContext');
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[ProvidedContex\] test$/);
+                });
+                it('should handle empty context', () => {
+                    logger.testPrintMessages(['test'], '');
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG test$/);
+                });
+            });
+            describe('logLevel', () => {
+                it('should default to log level', () => {
+                    logger.testPrintMessages(['test'], 'Context');
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[Context\s+\] test$/);
+                });
+                it('should use provided log level', () => {
+                    logger.testPrintMessages(['test'], 'Context', 'error');
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+ERROR \[Context\s+\] test$/);
+                });
+            });
+            describe('writeStreamType', () => {
+                it('should default to stdout', () => {
+                    logger.testPrintMessages(['test'], 'Context');
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    expect(processStderrWriteSpy).not.toHaveBeenCalled();
+                });
+                it('should write to stderr when specified', () => {
+                    logger.testPrintMessages(['test'], 'Context', 'error', 'stderr');
+                    expect(processStderrWriteSpy).toHaveBeenCalledTimes(1);
+                    expect(processStdoutWriteSpy).not.toHaveBeenCalled();
+                    const lines = toClearLines(processStderrWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+ERROR \[Context\s+\] test$/);
+                });
+            });
+        });
+        describe('formatMessage', () => {
+            describe('options', () => {
+                it('should format message with all components', () => {
+                    const options = { logLevel: 'log', context: 'TestCtx', message: 'test msg' };
+                    const result = logger.testFormatMessage(options);
+                    expect(result).toContain('[A5]');
+                    expect(result).toContain('LOG');
+                    expect(result).toContain('TestCtx');
+                    expect(result).toContain('test msg');
+                    expect(result).toContain('\n');
+                });
+                it('should handle empty context', () => {
+                    const options = { logLevel: 'warn', context: '', message: 'warning' };
+                    const result = logger.testFormatMessage(options);
+                    expect(result).toContain('WARN');
+                    expect(result).toContain('warning');
+                });
+                it('should handle object message', () => {
+                    const options = { logLevel: 'debug', context: 'Debug', message: { key: 'value' } };
+                    const result = logger.testFormatMessage(options);
+                    expect(result).toContain('Object:');
+                    expect(result).toContain('"key": "value"');
+                });
+            });
+        });
+        describe('formatMessageStructure', () => {
+            describe('options', () => {
+                it('should return complete message structure', () => {
+                    const options = { logLevel: 'info', context: 'TestCtx', message: 'test' };
+                    const result = logger.testFormatMessageStructure(options);
+                    expect(result).toHaveProperty('prefix', '[A5]');
+                    expect(result).toHaveProperty('pid');
+                    expect(result).toHaveProperty('timestamp');
+                    expect(result).toHaveProperty('timestampStr');
+                    expect(result).toHaveProperty('logLevel', '   INFO');
+                    expect(result).toHaveProperty('context', '[TestCtx       ]');
+                    expect(result.output).toContain('test'); // Output includes color codes
+                    expect(result).toHaveProperty('timestampDiff');
+                    expect(result).toHaveProperty('timestampDiffStr');
+                });
+                it('should handle different log levels', () => {
+                    const errorOptions = { logLevel: 'error', context: 'Err', message: 'error msg' };
+                    const result = logger.testFormatMessageStructure(errorOptions);
+                    expect(result.logLevel).toBe('  ERROR');
+                });
+            });
+        });
+        describe('formatPrefix', () => {
+            describe('[[Default]]', () => {
+                it('should return A5 prefix', () => {
+                    const result = logger.testFormatPrefix();
+                    expect(result).toBe('[A5]');
+                });
+            });
+        });
+        describe('formatPid', () => {
+            describe('[[Default]]', () => {
+                it('should return process PID padded to 6 characters', () => {
+                    const result = logger.testFormatPid();
+                    expect(result).toHaveLength(6);
+                    expect(result).toContain(process.pid.toString());
+                });
+            });
+        });
+        describe('formatLogLevel', () => {
+            describe('logLevel', () => {
+                it('should format log level with uppercase and padding', () => {
+                    expect(logger.testFormatLogLevel('log')).toBe('    LOG');
+                    expect(logger.testFormatLogLevel('error')).toBe('  ERROR');
+                    expect(logger.testFormatLogLevel('warn')).toBe('   WARN');
+                    expect(logger.testFormatLogLevel('debug')).toBe('  DEBUG');
+                    expect(logger.testFormatLogLevel('verbose')).toBe('VERBOSE');
+                    expect(logger.testFormatLogLevel('fatal')).toBe('  FATAL');
+                });
+            });
+        });
+        describe('formatTimestamp', () => {
+            describe('dateMilliseconds', () => {
+                it('should format timestamp in ISO format', () => {
+                    const timestamp = new Date('2023-12-25T10:30:45.123Z').getTime();
+                    const result = logger.testFormatTimestamp(timestamp);
+                    expect(result).toMatch(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}/);
+                });
+                it('should handle current timestamp', () => {
+                    const now = Date.now();
+                    const result = logger.testFormatTimestamp(now);
+                    expect(result).toBeTruthy();
+                    expect(result.length).toBeGreaterThan(20);
+                });
+            });
+        });
+        describe('formatContext', () => {
+            describe('context', () => {
+                it('should return empty string for empty context', () => {
+                    const result = logger.testFormatContext('');
+                    expect(result).toBe('');
+                });
+                it('should format context with brackets and padding', () => {
+                    const result = logger.testFormatContext('Test');
+                    expect(result).toBe('[Test          ]');
+                });
+                it('should truncate long context to 14 characters', () => {
+                    const longContext = 'VeryLongContextThatExceeds14Characters';
+                    const result = logger.testFormatContext(longContext);
+                    expect(result).toBe('[VeryLongContex]'); // Truncates to first 14 chars
+                    expect(result.length).toBe(16); // [14 chars + brackets]
+                });
+                it('should pad short context to 14 characters', () => {
+                    const result = logger.testFormatContext('ABC');
+                    expect(result).toBe('[ABC           ]');
+                    expect(result.length).toBe(16);
+                });
+            });
+        });
+        describe('stringifyMessage', () => {
+            describe('message', () => {
+                it('should return string as is with color', () => {
+                    const result = logger.testStringifyMessage('simple text', 'log');
+                    expect(result).toContain('simple text');
+                });
+                it('should format object with JSON', () => {
+                    const obj = { name: 'test', value: 123 };
+                    const result = logger.testStringifyMessage(obj, 'debug');
+                    expect(result).toContain('Object:');
+                    expect(result).toContain('"name": "test"');
+                    expect(result).toContain('"value": 123');
+                });
+                it('should format array with JSON', () => {
+                    const arr = [1, 2, 3];
+                    const result = logger.testStringifyMessage(arr, 'verbose');
+                    expect(result).toContain('Object:');
+                    expect(result).toContain('[\n  1,\n  2,\n  3\n]');
+                });
+                it('should call function and stringify result', () => {
+                    const fn = () => 'function result';
+                    const result = logger.testStringifyMessage(fn, 'log');
+                    expect(result).toContain('function result');
+                });
+                it('should handle class constructor', () => {
+                    class TestClass {
+                    }
+                    const result = logger.testStringifyMessage(TestClass, 'log');
+                    expect(result).toContain('TestClass');
+                });
+                it('should handle bigint values in objects', () => {
+                    const objWithBigInt = { id: BigInt(123456789012345) };
+                    const result = logger.testStringifyMessage(objWithBigInt, 'log');
+                    expect(result).toContain('"123456789012345"');
+                });
+            });
+        });
+        describe('colorize', () => {
+            describe('message', () => {
+                it('should apply color based on log level', () => {
+                    const message = 'test message';
+                    const result = logger.testColorize(message, 'error');
+                    expect(result).toBeTruthy();
+                });
+            });
+        });
+        describe('printStackTrace', () => {
+            describe('stack', () => {
+                it('should not write anything for undefined stack', () => {
+                    logger.testPrintStackTrace(undefined);
+                    expect(processStderrWriteSpy).not.toHaveBeenCalled();
+                });
+                it('should write stack trace to stderr', () => {
+                    const { stack } = new Error();
+                    logger.testPrintStackTrace(stack);
+                    expect(processStderrWriteSpy).toHaveBeenCalledTimes(1);
+                    expect(processStderrWriteSpy).toHaveBeenCalledWith(`${stack}\n`);
+                });
+            });
+        });
+        describe('updateAndGetTimestampDiff', () => {
+            describe('[[Default]]', () => {
+                it('should return null when timestamp is disabled', () => {
+                    const logger2 = new TestableA5ConsoleLogger({ timestamp: false });
+                    const result = logger2.testUpdateAndGetTimestampDiff();
+                    expect(result).toBeNull();
+                });
+                it('should return timestamp diff when enabled', () => {
+                    const logger2 = new TestableA5ConsoleLogger({ timestamp: true });
+                    TestableA5ConsoleLogger.setLastTimestampAt(undefined);
+                    const result1 = logger2.testUpdateAndGetTimestampDiff();
+                    expect(result1).toBe(0); // First call returns 0 as diff from initialization
+                    const result2 = logger2.testUpdateAndGetTimestampDiff();
+                    expect(result2).toBeGreaterThanOrEqual(0);
+                });
+            });
+        });
+        describe('formatTimestampDiff', () => {
+            describe('timestampDiff', () => {
+                it('should return empty string for null', () => {
+                    const result = logger.testFormatTimestampDiff(null);
+                    expect(result).toBe('');
+                });
+                it('should format timestamp diff with ms suffix', () => {
+                    const result = logger.testFormatTimestampDiff(150);
+                    expect(result).toBe('+150ms');
+                });
+                it('should handle zero diff', () => {
+                    const result = logger.testFormatTimestampDiff(0);
+                    expect(result).toBe('+0ms');
+                });
+            });
+        });
+        describe('getContextAndMessagesToPrint', () => {
+            describe('args', () => {
+                it('should return default context for single argument', () => {
+                    logger.setContext('DefaultCtx');
+                    const result = logger.testGetContextAndMessagesToPrint(['message']);
+                    expect(result.context).toBe('DefaultCtx');
+                    expect(result.messages).toEqual(['message']);
+                });
+                it('should extract context from last string argument', () => {
+                    const result = logger.testGetContextAndMessagesToPrint(['msg1', 'msg2', 'CustomContext']);
+                    expect(result.context).toBe('CustomContext');
+                    expect(result.messages).toEqual(['msg1', 'msg2']);
+                });
+                it('should use default context when last argument is not string', () => {
+                    logger.setContext('DefaultCtx');
+                    const result = logger.testGetContextAndMessagesToPrint(['msg1', 'msg2', 123]);
+                    expect(result.context).toBe('DefaultCtx');
+                    expect(result.messages).toEqual(['msg1', 'msg2', 123]);
+                });
+                it('should handle empty args', () => {
+                    logger.setContext('DefaultCtx');
+                    const result = logger.testGetContextAndMessagesToPrint([]);
+                    expect(result.context).toBe('DefaultCtx');
+                    expect(result.messages).toEqual([]);
+                });
+            });
+        });
+        describe('getContextAndStackAndMessagesToPrint', () => {
+            describe('args', () => {
+                it('should identify stack trace in 2-argument case', () => {
+                    const { stack } = new Error();
+                    const result = logger.testGetContextAndStackAndMessagesToPrint(['error msg', stack]);
+                    expect(result.messages).toEqual(['error msg']);
+                    expect(result.stack).toBe(stack);
+                    expect(result.context).toBe(logger.getInternalContext());
+                });
+                it('should treat second argument as context when not stack format', () => {
+                    const result = logger.testGetContextAndStackAndMessagesToPrint(['error msg', 'ErrorContext']);
+                    expect(result.messages).toEqual(['error msg']);
+                    expect(result.context).toBe('ErrorContext');
+                    expect(result.stack).toBeUndefined();
+                });
+                it('should extract stack from last message', () => {
+                    const { stack } = new Error();
+                    const result = logger.testGetContextAndStackAndMessagesToPrint(['msg1', 'msg2', stack, 'Context']);
+                    expect(result.messages).toEqual(['msg1', 'msg2']);
+                    expect(result.context).toBe('Context');
+                    expect(result.stack).toBe(stack);
+                });
+            });
+        });
+        describe('isStackFormat', () => {
+            describe('stack', () => {
+                it('should return true for valid stack format', () => {
+                    const { stack } = new Error();
+                    const result = logger.testIsStackFormat(stack);
+                    expect(result).toBe(true);
+                });
+                it('should return false for invalid stack format', () => {
+                    const invalidStack = 'Just a simple error message';
+                    const result = logger.testIsStackFormat(invalidStack);
+                    expect(result).toBe(false);
+                });
+                it('should return false for non-string input', () => {
+                    expect(logger.testIsStackFormat(123)).toBe(false);
+                    expect(logger.testIsStackFormat(null)).toBe(false);
+                    expect(logger.testIsStackFormat(undefined)).toBe(false);
+                    expect(logger.testIsStackFormat({})).toBe(false);
+                });
+            });
+        });
+        describe('removeLastUndefined', () => {
+            describe('args', () => {
+                it('should remove trailing undefined values', () => {
+                    const result = logger.testRemoveLastUndefined(['a', 'b', undefined, undefined]);
+                    expect(result).toEqual(['a', 'b']);
+                });
+                it('should keep non-undefined values', () => {
+                    const result = logger.testRemoveLastUndefined(['a', 'b', 'c']);
+                    expect(result).toEqual(['a', 'b', 'c']);
+                });
+                it('should handle mixed undefined positions', () => {
+                    const result = logger.testRemoveLastUndefined(['a', undefined, 'b', undefined]);
+                    expect(result).toEqual(['a', undefined, 'b']);
+                });
+                it('should handle all undefined', () => {
+                    const result = logger.testRemoveLastUndefined([undefined, undefined]);
+                    expect(result).toEqual([]);
+                });
+                it('should handle empty array', () => {
+                    const result = logger.testRemoveLastUndefined([]);
+                    expect(result).toEqual([]);
+                });
+            });
+        });
+        describe('getColorByLogLevel', () => {
+            describe('level', () => {
+                it('should return appropriate color functions', () => {
+                    expect(logger.testGetColorByLogLevel('debug')).toBeDefined();
+                    expect(logger.testGetColorByLogLevel('warn')).toBeDefined();
+                    expect(logger.testGetColorByLogLevel('error')).toBeDefined();
+                    expect(logger.testGetColorByLogLevel('verbose')).toBeDefined();
+                    expect(logger.testGetColorByLogLevel('fatal')).toBeDefined();
+                    expect(logger.testGetColorByLogLevel('log')).toBeDefined();
+                });
+                it('should return function that transforms text', () => {
+                    const colorFn = logger.testGetColorByLogLevel('error');
+                    const result = colorFn('test text');
+                    expect(typeof result).toBe('string');
+                });
+            });
+        });
+        describe('_contextNeedApologeticReplace', () => {
+            describe('context', () => {
+                it('should return true for NestFactory context', () => {
+                    const result = logger.testContextNeedApologeticReplace('NestFactory');
+                    expect(result).toBe(true);
+                });
+                it('should return true for NestApplication context', () => {
+                    const result = logger.testContextNeedApologeticReplace('NestApplication');
+                    expect(result).toBe(true);
+                });
+                it('should return false for other contexts', () => {
+                    expect(logger.testContextNeedApologeticReplace('CustomContext')).toBe(false);
+                    expect(logger.testContextNeedApologeticReplace('SomeOtherContext')).toBe(false);
+                    expect(logger.testContextNeedApologeticReplace('')).toBe(false);
+                });
+            });
+        });
+        describe('_contextApologeticReplace', () => {
+            describe('context', () => {
+                it('should replace NestFactory with A5Factory', () => {
+                    const result = logger.testContextApologeticReplace('NestFactory');
+                    expect(result).toBe('A5Factory');
+                });
+                it('should replace NestApplication with A5Application', () => {
+                    const result = logger.testContextApologeticReplace('NestApplication');
+                    expect(result).toBe('A5Application');
+                });
+            });
+        });
+        describe('_messageApologeticReplace', () => {
+            describe('message', () => {
+                it('should replace Nest startup message', () => {
+                    const result = logger.testMessageApologeticReplace('Starting Nest application...');
+                    expect(result).toBe('Starting A5 application...');
+                });
+                it('should replace Nest success message', () => {
+                    const result = logger.testMessageApologeticReplace('Nest application successfully started');
+                    expect(result).toBe('A5 application successfully started');
+                });
+                it('should replace Nest microservice message', () => {
+                    const result = logger.testMessageApologeticReplace('Nest microservice successfully started');
+                    expect(result).toBe('A5 microservice successfully started');
+                });
+                it('should return original message for non-matching strings', () => {
+                    const originalMsg = 'Custom application message';
+                    const result = logger.testMessageApologeticReplace(originalMsg);
+                    expect(result).toBe(originalMsg);
+                });
+                it('should return non-string messages unchanged', () => {
+                    expect(logger.testMessageApologeticReplace(123)).toBe(123);
+                    expect(logger.testMessageApologeticReplace(null)).toBe(null);
+                    expect(logger.testMessageApologeticReplace(undefined)).toBe(undefined);
+                    expect(logger.testMessageApologeticReplace({ key: 'value' })).toEqual({ key: 'value' });
+                });
+            });
+        });
+    });
+    describe('[[Public Methods]]', () => {
+        describe('log', () => {
+            describe('message', () => {
+                it('should log simple string message', () => {
+                    logger.log('test message');
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG test message$/);
+                });
+                it('should log object message', () => {
+                    const testObj = { key: 'value' };
+                    logger.log(testObj);
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG Object:/);
+                    expect(lines[0]).toContain(JSON.stringify(testObj, null, 2));
+                });
+                it('should log number message', () => {
+                    logger.log(123);
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG 123$/);
+                });
+                it('should log boolean message', () => {
+                    logger.log(true);
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG true$/);
+                });
+                it('should log null message', () => {
+                    logger.log(null);
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG null$/);
+                });
+                it('should log undefined message', () => {
+                    logger.log(undefined);
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG undefined$/);
+                });
+                it('should log array message', () => {
+                    const testArray = [1, 2, 3];
+                    logger.log(testArray);
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG Object:/);
+                    expect(lines[0]).toContain(JSON.stringify(testArray, null, 2));
+                });
+                it('should log function message by calling it', () => {
+                    const testFn = () => 'function result';
+                    logger.log(testFn);
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG function result$/);
+                });
+                it('should log class constructor by name', () => {
+                    class TestClass {
+                    }
+                    logger.log(TestClass);
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG TestClass$/);
+                });
+            });
+            describe('context', () => {
+                it('should use instance context when no context provided', () => {
+                    logger.setContext('TestContext');
+                    logger.log('test message');
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[TestContext\s+\] test message$/);
+                });
+                it('should use provided context', () => {
+                    logger.log('test message', 'ProvidedContext');
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+LOG \[ProvidedContex\] test message$/);
+                });
+                it('should not log when log level is disabled', () => {
+                    logger.setLogLevels(['error']);
+                    logger.log('test message');
+                    expect(processStdoutWriteSpy).not.toHaveBeenCalled();
+                });
+            });
+        });
+        describe('error', () => {
+            describe('message', () => {
+                it('should log error message to stderr', () => {
+                    logger.error('error message');
+                    expect(processStderrWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStderrWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+ERROR error message$/);
+                });
+                it('should not log when error level is disabled', () => {
+                    logger.setLogLevels([]); // empty array means no levels enabled
+                    logger.error('error message');
+                    expect(processStderrWriteSpy).not.toHaveBeenCalled();
+                });
+            });
+            describe('stack', () => {
+                it('should log stack trace when provided', () => {
+                    const { stack } = new Error();
+                    logger.error('error message', stack);
+                    expect(processStderrWriteSpy).toHaveBeenCalledTimes(2); // message + stack
+                    const { calls } = processStderrWriteSpy.mock;
+                    const lines = toClearLines([calls[0]]);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+ERROR error message$/);
+                    expect(calls[1][0]).toBe(`${stack}\n`);
+                });
+                it('should handle string context parameter', () => {
+                    logger.error('error message', 'ErrorContext');
+                    expect(processStderrWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStderrWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+ERROR \[ErrorContext\s+\] error message$/);
+                });
+                it('should handle both stack and context', () => {
+                    const { stack } = new Error();
+                    logger.error('error message', stack, 'ErrorContext');
+                    expect(processStderrWriteSpy).toHaveBeenCalledTimes(2);
+                    const { calls } = processStderrWriteSpy.mock;
+                    const lines = toClearLines([calls[0]]);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+ERROR \[ErrorContext\s+\] error message$/);
+                    expect(calls[1][0]).toBe(`${stack}\n`);
+                });
+            });
+        });
+        describe('warn', () => {
+            describe('message', () => {
+                it('should log warning message', () => {
+                    logger.warn('warning message');
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+WARN warning message$/);
+                });
+                it('should not log when warn level is disabled', () => {
+                    logger.setLogLevels(['error']);
+                    logger.warn('warning message');
+                    expect(processStdoutWriteSpy).not.toHaveBeenCalled();
+                });
+            });
+        });
+        describe('debug', () => {
+            describe('message', () => {
+                it('should log debug message', () => {
+                    logger.debug('debug message');
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+DEBUG debug message$/);
+                });
+                it('should not log when debug level is disabled', () => {
+                    logger.setLogLevels(['error']);
+                    logger.debug('debug message');
+                    expect(processStdoutWriteSpy).not.toHaveBeenCalled();
+                });
+            });
+        });
+        describe('verbose', () => {
+            describe('message', () => {
+                it('should log verbose message', () => {
+                    logger.verbose('verbose message');
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+VERBOSE verbose message$/);
+                });
+                it('should not log when verbose level is disabled', () => {
+                    logger.setLogLevels(['error']);
+                    logger.verbose('verbose message');
+                    expect(processStdoutWriteSpy).not.toHaveBeenCalled();
+                });
+            });
+        });
+        describe('fatal', () => {
+            describe('message', () => {
+                it('should log fatal message', () => {
+                    logger.fatal('fatal message');
+                    expect(processStdoutWriteSpy).toHaveBeenCalledTimes(1);
+                    const lines = toClearLines(processStdoutWriteSpy.mock.calls);
+                    expect(lines[0]).toMatch(/^\[A5\] \d+\s+- \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\s+FATAL fatal message$/);
+                });
+                it('should not log when fatal level is disabled', () => {
+                    logger.setLogLevels([]); // empty array means no levels enabled
+                    logger.fatal('fatal message');
+                    expect(processStdoutWriteSpy).not.toHaveBeenCalled();
+                });
+            });
+        });
+        describe('setLogLevels', () => {
+            describe('levels', () => {
+                it('should set log levels to provided array', () => {
+                    const customLevels = ['error', 'warn'];
+                    logger.setLogLevels(customLevels);
+                    expect(logger.getOptions().logLevels).toEqual(customLevels);
+                });
+                it('should accept empty array', () => {
+                    logger.setLogLevels([]);
+                    expect(logger.getOptions().logLevels).toEqual([]);
+                });
+                it('should accept single level', () => {
+                    logger.setLogLevels(['error']);
+                    expect(logger.getOptions().logLevels).toEqual(['error']);
+                });
+                it('should accept all levels', () => {
+                    const allLevels = ['log', 'error', 'warn', 'debug', 'verbose', 'fatal'];
+                    logger.setLogLevels(allLevels);
+                    expect(logger.getOptions().logLevels).toEqual(allLevels);
+                });
+            });
+        });
+        describe('setContext', () => {
+            describe('context', () => {
+                it('should set context to provided string', () => {
+                    logger.setContext('NewContext');
+                    expect(logger.getInternalContext()).toBe('NewContext');
+                });
+                it('should accept empty string', () => {
+                    logger.setContext('');
+                    expect(logger.getInternalContext()).toBe('');
+                });
+                it('should accept long context string', () => {
+                    const longContext = 'VeryLongContextThatExceeds14Characters';
+                    logger.setContext(longContext);
+                    expect(logger.getInternalContext()).toBe(longContext);
+                });
+            });
+        });
+        describe('getContext', () => {
+            describe('[[Default]]', () => {
+                it('should return current context', () => {
+                    logger.setContext('TestGetContext');
+                    expect(logger.getContext()).toBe('TestGetContext');
+                });
+                it('should return empty string for default', () => {
+                    const defaultLogger = new TestableA5ConsoleLogger();
+                    expect(defaultLogger.getContext()).toBe('');
+                });
+            });
+        });
+        describe('resetContext', () => {
+            describe('[[Default]]', () => {
+                it('should reset to original context', () => {
+                    const originalLogger = new TestableA5ConsoleLogger({ context: 'Original' });
+                    originalLogger.setContext('Modified');
+                    expect(originalLogger.getInternalContext()).toBe('Modified');
+                    originalLogger.resetContext();
+                    expect(originalLogger.getInternalContext()).toBe('Original');
+                });
+                it('should reset to empty string when no original context', () => {
+                    logger.setContext('Modified');
+                    expect(logger.getInternalContext()).toBe('Modified');
+                    logger.resetContext();
+                    expect(logger.getInternalContext()).toBe('');
+                });
+            });
+        });
+        describe('isLevelEnabled', () => {
+            describe('level', () => {
+                it('should return true for enabled levels', () => {
+                    logger.setLogLevels(['error', 'warn']);
+                    expect(logger.isLevelEnabled('error')).toBe(true);
+                    expect(logger.isLevelEnabled('warn')).toBe(true);
+                });
+                it('should return false for disabled levels', () => {
+                    logger.setLogLevels(['error']);
+                    expect(logger.isLevelEnabled('warn')).toBe(false);
+                    expect(logger.isLevelEnabled('debug')).toBe(false);
+                });
+                it('should handle all log levels correctly', () => {
+                    const allLevels = ['log', 'error', 'warn', 'debug', 'verbose', 'fatal'];
+                    logger.setLogLevels(allLevels);
+                    allLevels.forEach((level) => {
+                        expect(logger.isLevelEnabled(level)).toBe(true);
+                    });
+                });
+                it('should return false when no levels enabled', () => {
+                    logger.setLogLevels([]);
+                    expect(logger.isLevelEnabled('error')).toBe(false);
+                    expect(logger.isLevelEnabled('log')).toBe(false);
+                });
+            });
+        });
+    });
+});
+//# sourceMappingURL=a5-console-logger.unit.spec.js.map