@vvlad1973/simple-logger 2.1.10 → 2.2.1

package/src/__test__/simple-logger.test.ts

@@ -1,81 +1,511 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import SimpleLogger from '../classes/simple-logger.js';
-import type { ExternalLogger } from '../types/simple-logger.types.js';
+import type { ExternalLogger, LoggerFactory } from '../types/simple-logger.types.js';
 
 describe('SimpleLogger', () => {
   let consoleSpy: ReturnType<typeof vi.spyOn>;
+  let consoleWarnSpy: ReturnType<typeof vi.spyOn>;
 
   beforeEach(() => {
     consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
   });
 
   afterEach(() => {
     consoleSpy.mockRestore();
+    consoleWarnSpy.mockRestore();
   });
 
-  it('should log using console when no external logger is provided', () => {
-    const logger = new SimpleLogger();
-    logger.info('test message');
-    expect(consoleSpy).toHaveBeenCalledOnce();
-    expect(consoleSpy.mock.calls[0][0]).toMatch(/test message/);
+  describe('Initialization Cases', () => {
+    it('CASE 1: should use console when no external logger is provided', () => {
+      const logger = new SimpleLogger();
+      expect(logger.isExternal).toBe(false);
+      logger.info('test message');
+      expect(consoleSpy).toHaveBeenCalledOnce();
+      expect(consoleSpy.mock.calls[0][0]).toMatch(/test message/);
+    });
+
+    it('CASE 2: should call logger factory with options', () => {
+      const mockLogger: ExternalLogger = {
+        info: vi.fn(),
+        level: 'info',
+      };
+      const factory: LoggerFactory = vi.fn(() => mockLogger);
+
+      const logger = new SimpleLogger(factory, { level: 'debug', msgPrefix: 'TEST' });
+
+      expect(factory).toHaveBeenCalledWith({
+        level: 'debug',
+        msgPrefix: 'TEST',
+      });
+      expect(logger.isExternal).toBe(true);
+    });
+
+    it('CASE 3: should fallback to console for invalid external logger', () => {
+      const logger = new SimpleLogger({} as ExternalLogger);
+      expect(logger.isExternal).toBe(false);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        'Invalid or console logger passed, falling back to internal console.'
+      );
+    });
+
+    it('CASE 3b: should fallback to console when console is passed', () => {
+      const logger = new SimpleLogger(console as unknown as ExternalLogger);
+      expect(logger.isExternal).toBe(false);
+    });
+
+    it('CASE 4: should use external logger without params', () => {
+      const external: ExternalLogger = {
+        info: vi.fn(),
+        warn: vi.fn(),
+        level: 'info',
+      };
+      const logger = new SimpleLogger(external);
+      expect(logger.isExternal).toBe(true);
+
+      logger.info('test');
+      expect(external.info).toHaveBeenCalledWith('test');
+    });
+
+    it('CASE 5: should create child logger when external has .child() method', () => {
+      const childLogger: ExternalLogger = {
+        info: vi.fn(),
+        level: 'info',
+      };
+      const childFn = vi.fn(() => childLogger);
+      const external: ExternalLogger = {
+        info: vi.fn(),
+        level: 'info',
+        child: childFn,
+      };
+
+      const logger = new SimpleLogger(external, {
+        level: 'debug',
+        bindings: { app: 'test' },
+        msgPrefix: 'PREFIX',
+      });
+
+      expect(childFn).toHaveBeenCalledWith(
+        { app: 'test' },
+        { level: 'debug', msgPrefix: 'PREFIX' }
+      );
+      expect(logger.isExternal).toBe(true);
+    });
+
+    it('CASE 6: should use external logger directly without .child() and set level', () => {
+      const external: ExternalLogger = {
+        info: vi.fn(),
+        level: 'info',
+      };
+
+      const logger = new SimpleLogger(external, { level: 'debug' });
+
+      expect(external.level).toBe('debug');
+      expect(logger.isExternal).toBe(true);
+    });
+  });
+
+  describe('Logging Methods', () => {
+    it('should log at all levels', () => {
+      const logger = new SimpleLogger(null, { level: 'trace' });
+
+      logger.trace('trace msg');
+      logger.debug('debug msg');
+      logger.info('info msg');
+      logger.warn('warn msg');
+      logger.error('error msg');
+      logger.fatal('fatal msg');
+
+      expect(consoleSpy).toHaveBeenCalledTimes(6);
+    });
+
+    it('should not log below current level', () => {
+      const logger = new SimpleLogger(null, { level: 'warn' });
+
+      logger.trace('should not log');
+      logger.debug('should not log');
+      logger.info('should not log');
+      logger.warn('should log');
+      logger.error('should log');
+
+      expect(consoleSpy).toHaveBeenCalledTimes(2);
+    });
+
+    it('should respect msgPrefix in console output', () => {
+      const logger = new SimpleLogger(null, { msgPrefix: '[PREFIX]' });
+      logger.info('message');
+      expect(consoleSpy.mock.calls[0][0]).toMatch(/\[PREFIX\]/);
+    });
+
+    it('should include bindings in console output', () => {
+      const logger = new SimpleLogger(null, { bindings: { user: 'john', id: 123 } });
+      logger.info('message');
+      const output = consoleSpy.mock.calls[0][0];
+      expect(output).toMatch(/user=john/);
+      expect(output).toMatch(/id=123/);
+    });
+
+    it('should handle object context with message', () => {
+      const logger = new SimpleLogger();
+      logger.info({ userId: 123 }, 'user action');
+      const output = consoleSpy.mock.calls[0][0];
+      expect(output).toMatch(/userId=123/);
+      expect(output).toMatch(/user action/);
+    });
+
+    it('should handle message with format arguments', () => {
+      const logger = new SimpleLogger();
+      logger.info('Hello %s, you are %d years old', 'John', 30);
+      const output = consoleSpy.mock.calls[0][0];
+      expect(output).toMatch(/Hello John, you are 30 years old/);
+    });
+
+    it('should handle object-only logging', () => {
+      const logger = new SimpleLogger();
+      logger.info({ status: 'ok' });
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('External Logger Integration', () => {
+    it('should call external logger with string message', () => {
+      const external: ExternalLogger = {
+        info: vi.fn(),
+        level: 'info',
+      };
+      const logger = new SimpleLogger(external);
+
+      logger.info('test message');
+
+      expect(external.info).toHaveBeenCalledWith('test message');
+    });
+
+    it('should call external logger with object and message', () => {
+      const external: ExternalLogger = {
+        info: vi.fn(),
+        level: 'info',
+      };
+      const logger = new SimpleLogger(external);
+
+      logger.info({ userId: 123 }, 'user action');
+
+      expect(external.info).toHaveBeenCalledWith({ userId: 123 }, 'user action');
+    });
+
+    it('should call external logger with object only', () => {
+      const external: ExternalLogger = {
+        info: vi.fn(),
+        level: 'info',
+      };
+      const logger = new SimpleLogger(external);
+
+      logger.info({ status: 'ok' });
+
+      expect(external.info).toHaveBeenCalledWith({ status: 'ok' }, undefined);
+    });
+
+    it('should call external logger with message and format args', () => {
+      const external: ExternalLogger = {
+        info: vi.fn(),
+        level: 'info',
+      };
+      const logger = new SimpleLogger(external);
+
+      logger.info('Hello %s', 'world');
+
+      expect(external.info).toHaveBeenCalledWith('Hello %s', 'world');
+    });
+
+    it('should skip logging if method does not exist on external logger', () => {
+      const external: ExternalLogger = {
+        info: vi.fn(),
+        level: 'info',
+      };
+      const logger = new SimpleLogger(external);
+
+      logger.debug('should not call');
+
+      expect(external.info).not.toHaveBeenCalled();
+    });
+
+    it('should warn on invalid log arguments', () => {
+      const external: ExternalLogger = {
+        info: vi.fn(),
+        level: 'info',
+      };
+      const logger = new SimpleLogger(external);
+
+      // Simulate invalid prepared args by calling with invalid types
+      (logger as any).callExternalLogMethod('info', [undefined]);
+
+      expect(consoleWarnSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('Level Management', () => {
+    it('should get current level', () => {
+      const logger = new SimpleLogger(null, { level: 'warn' });
+      expect(logger.getLevel()).toBe('warn');
+    });
+
+    it('should set new level', () => {
+      const logger = new SimpleLogger(null, { level: 'info' });
+      expect(logger.getLevel()).toBe('info');
+
+      logger.setLevel('error');
+      expect(logger.getLevel()).toBe('error');
+
+      logger.info('should not log');
+      logger.error('should log');
+
+      expect(consoleSpy).toHaveBeenCalledOnce();
+    });
+
+    it('should sync level with external logger', () => {
+      const external: ExternalLogger = {
+        info: vi.fn(),
+        level: 'info',
+      };
+      const logger = new SimpleLogger(external);
+
+      logger.setLevel('debug');
+
+      expect(external.level).toBe('debug');
+    });
+
+    it('should resolve level from external logger', () => {
+      const external: ExternalLogger = {
+        info: vi.fn(),
+        level: 'warn',
+      };
+      const logger = new SimpleLogger(external);
+
+      expect(logger.getLevel()).toBe('warn');
+    });
+
+    it('should prioritize explicit level over logger level', () => {
+      const external: ExternalLogger = {
+        info: vi.fn(),
+        level: 'warn',
+      };
+      const logger = new SimpleLogger(external, { level: 'debug' });
+
+      expect(logger.getLevel()).toBe('debug');
+    });
+
+    it('should ignore invalid level in external logger', () => {
+      const external: ExternalLogger = {
+        info: vi.fn(),
+        level: 'invalid_level' as any,
+      };
+      const logger = new SimpleLogger(external);
+
+      // Should fall back to default level
+      expect(logger.getLevel()).toBe('info');
+    });
   });
 
-  it('should not log below current level', () => {
-    const logger = new SimpleLogger(null, { level: 'warn' });
-    logger.info('should not log');
-    logger.warn('should log');
-    expect(consoleSpy).toHaveBeenCalledOnce();
-    expect(consoleSpy.mock.calls[0][0]).toMatch(/should log/);
+  describe('Enable/Disable', () => {
+    it('should disable all logging when disabled', () => {
+      const logger = new SimpleLogger(null, { level: 'trace' });
+
+      logger.disable();
+
+      logger.trace('should not log');
+      logger.info('should not log');
+      logger.error('should not log');
+
+      expect(consoleSpy).not.toHaveBeenCalled();
+    });
+
+    it('should enable logging when re-enabled', () => {
+      const logger = new SimpleLogger(null, { level: 'info' });
+
+      logger.disable();
+      logger.info('should not log');
+
+      logger.enable();
+      logger.info('should log');
+
+      expect(consoleSpy).toHaveBeenCalledOnce();
+    });
   });
 
-  it('should respect msgPrefix', () => {
-    const logger = new SimpleLogger(null, { msgPrefix: '[PREFIX]' });
-    logger.info('message');
-    expect(consoleSpy.mock.calls[0][0]).toMatch(/\[PREFIX\]/);
+  describe('Child Logger', () => {
+    it('should create child logger with merged bindings', () => {
+      const logger = new SimpleLogger(null, { bindings: { user: 'A' } });
+      const child = logger.child({ request: '123' });
+
+      child.info('child message');
+
+      const output = consoleSpy.mock.calls[0][0];
+      expect(output).toMatch(/user=A/);
+      expect(output).toMatch(/request=123/);
+      expect(output).toMatch(/child message/);
+    });
+
+    it('should call external logger .child() method if available', () => {
+      const childLogger: ExternalLogger = {
+        info: vi.fn(),
+        level: 'info',
+      };
+      const childFn = vi.fn(() => childLogger);
+      const external: ExternalLogger = {
+        level: 'info',
+        child: childFn,
+        info: vi.fn(),
+      };
+
+      const logger = new SimpleLogger(external);
+      const child = logger.child({ traceId: 'xyz' });
+
+      child.info('from child');
+
+      expect(childFn).toHaveBeenCalledWith({ traceId: 'xyz' });
+      expect(childLogger.info).toHaveBeenCalledWith('from child');
+    });
+
+    it('should create child without calling external .child() if not function', () => {
+      const external: ExternalLogger = {
+        info: vi.fn(),
+        level: 'info',
+      };
+
+      const logger = new SimpleLogger(external);
+      const child = logger.child({ req: '456' });
+
+      expect(child).toBeInstanceOf(SimpleLogger);
+    });
   });
 
-  it('should use external logger methods if provided', () => {
-    const external: ExternalLogger = {
-      info: vi.fn(),
-      level: 'info',
-    };
-    const logger = new SimpleLogger(external);
-    logger.info('external log');
-    expect(external.info).toHaveBeenCalledOnce();
-    expect(external.info).toHaveBeenCalledWith('external log');
+  describe('Function Logging', () => {
+    it('should log function start', () => {
+      const logger = new SimpleLogger(null, { level: 'trace' });
+
+      logger.logFunctionStart('myFunction');
+
+      expect(consoleSpy).toHaveBeenCalled();
+      expect(consoleSpy.mock.calls[0][0]).toMatch(/Function start: myFunction/);
+    });
+
+    it('should log function end', () => {
+      const logger = new SimpleLogger(null, { level: 'trace' });
+
+      logger.logFunctionEnd('myFunction');
+
+      expect(consoleSpy).toHaveBeenCalled();
+      expect(consoleSpy.mock.calls[0][0]).toMatch(/Function end: myFunction/);
+    });
+
+    it('should use caller name if not provided', () => {
+      const logger = new SimpleLogger(null, { level: 'trace' });
+
+      logger.logFunctionStart();
+      logger.logFunctionEnd();
+
+      expect(consoleSpy).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('Flush Method', () => {
+    it('should return immediately if not external logger', async () => {
+      const logger = new SimpleLogger();
+
+      await expect(logger.flush()).resolves.toBeUndefined();
+    });
+
+    it('should call flush on external logger if available', async () => {
+      const flushFn = vi.fn((cb: (err?: Error) => void) => cb());
+      const external: ExternalLogger & { flush: typeof flushFn } = {
+        info: vi.fn(),
+        level: 'info',
+        flush: flushFn,
+      };
+
+      const logger = new SimpleLogger(external);
+
+      await logger.flush();
+
+      expect(flushFn).toHaveBeenCalled();
+    });
+
+    it('should handle flush errors gracefully', async () => {
+      const flushFn = vi.fn((cb: (err?: Error) => void) => cb(new Error('Flush error')));
+      const external: ExternalLogger & { flush: typeof flushFn } = {
+        info: vi.fn(),
+        level: 'info',
+        flush: flushFn,
+      };
+
+      const logger = new SimpleLogger(external);
+
+      await expect(logger.flush()).resolves.toBeUndefined();
+    });
+
+    it('should return immediately if flush is not a function', async () => {
+      const external: ExternalLogger = {
+        info: vi.fn(),
+        level: 'info',
+      };
+
+      const logger = new SimpleLogger(external);
+
+      await expect(logger.flush()).resolves.toBeUndefined();
+    });
   });
 
-  it('should fallback to console for invalid external logger', () => {
-    const logger = new SimpleLogger({} as ExternalLogger);
-    logger.info('fallback');
-    expect(consoleSpy).toHaveBeenCalled();
+  describe('Silent Level', () => {
+    it('should not log anything at silent level', () => {
+      const logger = new SimpleLogger(null, { level: 'silent' });
+
+      logger.trace('should not log');
+      logger.debug('should not log');
+      logger.info('should not log');
+      logger.warn('should not log');
+      logger.error('should not log');
+      logger.fatal('should not log');
+
+      expect(consoleSpy).not.toHaveBeenCalled();
+    });
   });
 
-  it('should create child logger with merged bindings', () => {
-    const logger = new SimpleLogger(null, { bindings: { user: 'A' } });
-    const child = logger.child({ request: '123' });
-  
-    child.info('child message');
-  
-    expect(consoleSpy.mock.calls.length).toBe(1);
-    const output = consoleSpy.mock.calls[0][0];
-  
-    expect(output).toMatch(/user=A/);
-    expect(output).toMatch(/request=123/);
-    expect(output).toMatch(/child message/);
+  describe('Level Resolution', () => {
+    it('should handle logger without level property', () => {
+      const external: ExternalLogger = {
+        info: vi.fn(),
+      };
+
+      const logger = new SimpleLogger(external);
+
+      expect(logger.getLevel()).toBe('info');
+    });
+
+    it('should not update level on external logger without level property', () => {
+      const external: ExternalLogger = {
+        info: vi.fn(),
+      };
+
+      const logger = new SimpleLogger(external);
+      logger.setLevel('debug');
+
+      expect(external.level).toBeUndefined();
+    });
   });
-  
-  
-
-  it('should call .child if external logger supports it', () => {
-    const childFn = vi.fn(() => ({
-      info: vi.fn(),
-      level: 'info',
-    }));
-    const external = { level: 'info', child: childFn, info: vi.fn() };
-    const logger = new SimpleLogger(external);
-    const child = logger.child({ traceId: 'xyz' });
-    child.info('from child');
-    expect(childFn).toHaveBeenCalledWith({ traceId: 'xyz' });
+
+  describe('Factory with Transport', () => {
+    it('should pass transport option to factory', () => {
+      const mockLogger: ExternalLogger = {
+        info: vi.fn(),
+        level: 'info',
+      };
+      const factory: LoggerFactory = vi.fn(() => mockLogger);
+      const transport = { target: 'pino/file' };
+
+      new SimpleLogger(factory, { level: 'info', transport });
+
+      expect(factory).toHaveBeenCalledWith({
+        level: 'info',
+        transport,
+      });
+    });
   });
 });