automaker/libs/utils/tests/logger.test.ts

import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import { createLogger, LogLevel, getLogLevel, setLogLevel } from '../src/logger';

describe('logger.ts', () => {
  let originalConsoleError: typeof console.error;
  let originalConsoleWarn: typeof console.warn;
  let originalConsoleLog: typeof console.log;
  let originalLogLevel: LogLevel;

  beforeEach(() => {
    // Save original console methods and log level
    originalConsoleError = console.error;
    originalConsoleWarn = console.warn;
    originalConsoleLog = console.log;
    originalLogLevel = getLogLevel();

    // Mock console methods
    console.error = vi.fn();
    console.warn = vi.fn();
    console.log = vi.fn();
  });

  afterEach(() => {
    // Restore original console methods and log level
    console.error = originalConsoleError;
    console.warn = originalConsoleWarn;
    console.log = originalConsoleLog;
    setLogLevel(originalLogLevel);
  });

  describe('createLogger', () => {
    it('should create logger with context prefix', () => {
      const logger = createLogger('TestContext');
      setLogLevel(LogLevel.INFO);

      logger.info('test message');

      expect(console.log).toHaveBeenCalledWith('[TestContext]', 'test message');
    });

    it('should handle multiple arguments', () => {
      const logger = createLogger('Test');
      setLogLevel(LogLevel.INFO);

      logger.info('message', { data: 123 }, [1, 2, 3]);

      expect(console.log).toHaveBeenCalledWith('[Test]', 'message', { data: 123 }, [1, 2, 3]);
    });
  });

  describe('Log levels', () => {
    it('should log error at ERROR level', () => {
      const logger = createLogger('Test');
      setLogLevel(LogLevel.ERROR);

      logger.error('error message');
      logger.warn('warn message');
      logger.info('info message');
      logger.debug('debug message');

      expect(console.error).toHaveBeenCalledTimes(1);
      expect(console.warn).not.toHaveBeenCalled();
      expect(console.log).not.toHaveBeenCalled();
    });

    it('should log error and warn at WARN level', () => {
      const logger = createLogger('Test');
      setLogLevel(LogLevel.WARN);

      logger.error('error message');
      logger.warn('warn message');
      logger.info('info message');
      logger.debug('debug message');

      expect(console.error).toHaveBeenCalledTimes(1);
      expect(console.warn).toHaveBeenCalledTimes(1);
      expect(console.log).not.toHaveBeenCalled();
    });

    it('should log error, warn, and info at INFO level', () => {
      const logger = createLogger('Test');
      setLogLevel(LogLevel.INFO);

      logger.error('error message');
      logger.warn('warn message');
      logger.info('info message');
      logger.debug('debug message');

      expect(console.error).toHaveBeenCalledTimes(1);
      expect(console.warn).toHaveBeenCalledTimes(1);
      expect(console.log).toHaveBeenCalledTimes(1); // Only info, not debug
    });

    it('should log all messages at DEBUG level', () => {
      const logger = createLogger('Test');
      setLogLevel(LogLevel.DEBUG);

      logger.error('error message');
      logger.warn('warn message');
      logger.info('info message');
      logger.debug('debug message');

      expect(console.error).toHaveBeenCalledTimes(1);
      expect(console.warn).toHaveBeenCalledTimes(1);
      expect(console.log).toHaveBeenCalledTimes(2); // info + debug
    });
  });

  describe('error method', () => {
    it('should use console.error', () => {
      const logger = createLogger('ErrorTest');
      setLogLevel(LogLevel.ERROR);

      logger.error('error occurred', { code: 500 });

      expect(console.error).toHaveBeenCalledWith('[ErrorTest]', 'error occurred', { code: 500 });
    });

    it('should not log when level is below ERROR', () => {
      const logger = createLogger('Test');
      setLogLevel((LogLevel.ERROR - 1) as LogLevel);

      logger.error('should not appear');

      expect(console.error).not.toHaveBeenCalled();
    });
  });

  describe('warn method', () => {
    it('should use console.warn', () => {
      const logger = createLogger('WarnTest');
      setLogLevel(LogLevel.WARN);

      logger.warn('warning message');

      expect(console.warn).toHaveBeenCalledWith('[WarnTest]', 'warning message');
    });

    it('should not log when level is below WARN', () => {
      const logger = createLogger('Test');
      setLogLevel(LogLevel.ERROR);

      logger.warn('should not appear');

      expect(console.warn).not.toHaveBeenCalled();
    });
  });

  describe('info method', () => {
    it('should use console.log', () => {
      const logger = createLogger('InfoTest');
      setLogLevel(LogLevel.INFO);

      logger.info('info message');

      expect(console.log).toHaveBeenCalledWith('[InfoTest]', 'info message');
    });

    it('should not log when level is below INFO', () => {
      const logger = createLogger('Test');
      setLogLevel(LogLevel.WARN);

      logger.info('should not appear');

      expect(console.log).not.toHaveBeenCalled();
    });
  });

  describe('debug method', () => {
    it('should use console.log with DEBUG prefix', () => {
      const logger = createLogger('DebugTest');
      setLogLevel(LogLevel.DEBUG);

      logger.debug('debug details', { trace: '...' });

      expect(console.log).toHaveBeenCalledWith('[DebugTest]', '[DEBUG]', 'debug details', {
        trace: '...',
      });
    });

    it('should not log when level is below DEBUG', () => {
      const logger = createLogger('Test');
      setLogLevel(LogLevel.INFO);

      logger.debug('should not appear');

      expect(console.log).not.toHaveBeenCalled();
    });
  });

  describe('getLogLevel', () => {
    it('should return current log level', () => {
      setLogLevel(LogLevel.DEBUG);
      expect(getLogLevel()).toBe(LogLevel.DEBUG);

      setLogLevel(LogLevel.ERROR);
      expect(getLogLevel()).toBe(LogLevel.ERROR);
    });
  });

  describe('setLogLevel', () => {
    it('should change log level', () => {
      setLogLevel(LogLevel.WARN);
      expect(getLogLevel()).toBe(LogLevel.WARN);

      setLogLevel(LogLevel.DEBUG);
      expect(getLogLevel()).toBe(LogLevel.DEBUG);
    });

    it('should affect subsequent logging', () => {
      const logger = createLogger('Test');

      setLogLevel(LogLevel.ERROR);
      logger.info('should not log');
      expect(console.log).not.toHaveBeenCalled();

      setLogLevel(LogLevel.INFO);
      logger.info('should log');
      expect(console.log).toHaveBeenCalledWith('[Test]', 'should log');
    });
  });

  describe('Multiple logger instances', () => {
    it('should maintain separate contexts', () => {
      const logger1 = createLogger('Service1');
      const logger2 = createLogger('Service2');
      setLogLevel(LogLevel.INFO);

      logger1.info('from service 1');
      logger2.info('from service 2');

      expect(console.log).toHaveBeenNthCalledWith(1, '[Service1]', 'from service 1');
      expect(console.log).toHaveBeenNthCalledWith(2, '[Service2]', 'from service 2');
    });

    it('should share log level setting', () => {
      const logger1 = createLogger('Service1');
      const logger2 = createLogger('Service2');

      setLogLevel(LogLevel.ERROR);

      logger1.info('should not log');
      logger2.info('should not log');

      expect(console.log).not.toHaveBeenCalled();
    });
  });

  describe('Edge cases', () => {
    it('should handle empty context string', () => {
      const logger = createLogger('');
      setLogLevel(LogLevel.INFO);

      logger.info('message');

      expect(console.log).toHaveBeenCalledWith('[]', 'message');
    });

    it('should handle context with special characters', () => {
      const logger = createLogger('Test-Service_v2.0');
      setLogLevel(LogLevel.INFO);

      logger.info('message');

      expect(console.log).toHaveBeenCalledWith('[Test-Service_v2.0]', 'message');
    });

    it('should handle no arguments to log methods', () => {
      const logger = createLogger('Test');
      setLogLevel(LogLevel.INFO);

      logger.info();

      expect(console.log).toHaveBeenCalledWith('[Test]');
    });

    it('should handle complex object arguments', () => {
      const logger = createLogger('Test');
      setLogLevel(LogLevel.INFO);

      const complexObj = {
        nested: { deep: { value: 123 } },
        array: [1, 2, 3],
        fn: () => {},
      };

      logger.info('complex', complexObj);

      expect(console.log).toHaveBeenCalledWith('[Test]', 'complex', complexObj);
    });
  });
});