stock-bot/libs/logger/test/basic.test.ts

/**
 * Logger Utility Tests
 * 
 * Tests for the core logger functionality and utilities.
 */

import { describe, it, expect, beforeEach } from 'bun:test';
import { Logger, getLogger, createLogger } from '../src';
import { loggerTestHelpers } from './setup';

describe('Logger Utilities', () => {
  let logger: Logger;

  beforeEach(() => {
    logger = loggerTestHelpers.createTestLogger('utils-test');
    loggerTestHelpers.clearCapturedLogs();
  });

  describe('Logger Factory Functions', () => {
    it('should create logger with getLogger', () => {
      expect(typeof getLogger).toBe('function');
      
      // Test that getLogger doesn't throw
      expect(() => {
        const testLogger = loggerTestHelpers.createTestLogger('factory-test');
        testLogger.info('Factory test');
      }).not.toThrow();
    });

    it('should create Pino logger with createLogger', () => {
      expect(typeof createLogger).toBe('function');
      
      // Test that createLogger function exists
      expect(() => createLogger).not.toThrow();
    });
  });

  describe('Logger Methods', () => {
    it('should have all required logging methods', () => {
      expect(typeof logger.debug).toBe('function');
      expect(typeof logger.info).toBe('function');
      expect(typeof logger.warn).toBe('function');
      expect(typeof logger.error).toBe('function');
      expect(typeof logger.child).toBe('function');
    });

    it('should log with different message types', () => {
      // String message
      logger.info('String message');
      
      // Object message
      logger.info({ event: 'object_message', data: 'test' });
      
      const logs = loggerTestHelpers.getCapturedLogs();
      expect(logs.length).toBe(2);
      expect(logs[0].msg).toBe('String message');
      expect(logs[1].level).toBe('info');
    });

    it('should handle metadata correctly', () => {
      const metadata = {
        userId: 'user123',
        sessionId: 'session456',
        requestId: 'req789'
      };
      
      logger.info('Request processed', metadata);
      
      const logs = loggerTestHelpers.getCapturedLogs();
      expect(logs.length).toBe(1);
      expect(logs[0].userId).toBe('user123');
      expect(logs[0].sessionId).toBe('session456');
      expect(logs[0].requestId).toBe('req789');
    });
  });

  describe('Child Logger Functionality', () => {
    it('should create child loggers with additional context', () => {
      const childLogger = logger.child({
        module: 'payment',
        version: '1.0.0'
      });
      
      childLogger.info('Payment processed');
      
      const logs = loggerTestHelpers.getCapturedLogs();
      expect(logs.length).toBe(1);
      expect(logs[0].msg).toBe('Payment processed');
    });

    it('should inherit service name in child loggers', () => {
      const childLogger = logger.child({ operation: 'test' });
      childLogger.info('Child operation');
      
      const logs = loggerTestHelpers.getCapturedLogs();
      expect(logs.length).toBe(1);
      expect(logs[0].service).toBe('utils-test');
    });
  });

  describe('Error Normalization', () => {
    it('should handle Error objects', () => {
      const error = new Error('Test error');
      error.stack = 'Error stack trace';
      
      logger.error('Error test', { error });
      
      const logs = loggerTestHelpers.getCapturedLogs();
      expect(logs.length).toBe(1);
      expect(logs[0].level).toBe('error');
    });

    it('should handle error-like objects', () => {
      const errorLike = {
        name: 'ValidationError',
        message: 'Invalid input',
        code: 'VALIDATION_FAILED'
      };
      
      logger.error('Validation failed', { error: errorLike });
      
      const logs = loggerTestHelpers.getCapturedLogs();
      expect(logs.length).toBe(1);
      expect(logs[0].level).toBe('error');
    });

    it('should handle primitive error values', () => {
      logger.error('Simple error', { error: 'Error string' });
      
      const logs = loggerTestHelpers.getCapturedLogs();
      expect(logs.length).toBe(1);
      expect(logs[0].level).toBe('error');
    });
  });

  describe('Service Context', () => {
    it('should include service name in all logs', () => {
      logger.debug('Debug message');
      logger.info('Info message');
      logger.warn('Warn message');
      logger.error('Error message');
      
      const logs = loggerTestHelpers.getCapturedLogs();
      expect(logs.length).toBe(4);
      
      logs.forEach(log => {
        expect(log.service).toBe('utils-test');
      });
    });

    it('should support different service names', () => {
      const logger1 = loggerTestHelpers.createTestLogger('service-one');
      const logger2 = loggerTestHelpers.createTestLogger('service-two');
      
      logger1.info('Message from service one');
      logger2.info('Message from service two');
      
      const logs = loggerTestHelpers.getCapturedLogs();
      expect(logs.length).toBe(2);
      expect(logs[0].service).toBe('service-one');
      expect(logs[1].service).toBe('service-two');
    });
  });
});