updating logger tests

libs/logger/test/basic.test.ts

@@ -0,0 +1,164 @@
+/**
+ * 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');
+    });
+  });
+});