@geekmidas/logger 0.0.1 → 0.2.0

package/src/__tests__/console.spec.ts

@@ -1,5 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { ConsoleLogger } from '../console';
+import { ConsoleLogger, createLogger } from '../console';
+import { LogLevel } from '../types';
 
 describe('ConsoleLogger', () => {
   // Mock console methods
@@ -50,19 +51,21 @@ describe('ConsoleLogger', () => {
 
   describe('Log levels', () => {
     describe('debug', () => {
-      it('should log debug message with context', () => {
-        const logger = new ConsoleLogger({ app: 'test' });
+      it('should log debug message with context when level is Debug', () => {
+        const logger = new ConsoleLogger({ app: 'test' }, LogLevel.Debug);
 
         logger.debug({ userId: 123 }, 'Debug message');
 
-        expect(console.debug).toHaveBeenCalledWith(
-          { app: 'test', userId: 123, ts: 1234567890 },
-          'Debug message',
-        );
+        expect(console.debug).toHaveBeenCalledWith({
+          app: 'test',
+          userId: 123,
+          msg: 'Debug message',
+          ts: 1234567890,
+        });
       });
 
-      it('should log debug with only context object', () => {
-        const logger = new ConsoleLogger();
+      it('should log debug with only context object when level is Debug', () => {
+        const logger = new ConsoleLogger({}, LogLevel.Debug);
 
         logger.debug({ action: 'test' });
 
@@ -79,10 +82,12 @@ describe('ConsoleLogger', () => {
 
         logger.info({ userId: 123 }, 'Info message');
 
-        expect(console.info).toHaveBeenCalledWith(
-          { app: 'test', userId: 123, ts: 1234567890 },
-          'Info message',
-        );
+        expect(console.info).toHaveBeenCalledWith({
+          app: 'test',
+          userId: 123,
+          msg: 'Info message',
+          ts: 1234567890,
+        });
       });
 
       it('should log info with only context object', () => {
@@ -103,10 +108,12 @@ describe('ConsoleLogger', () => {
 
         logger.warn({ code: 'DEPRECATED' }, 'Warning message');
 
-        expect(console.warn).toHaveBeenCalledWith(
-          { app: 'test', code: 'DEPRECATED', ts: 1234567890 },
-          'Warning message',
-        );
+        expect(console.warn).toHaveBeenCalledWith({
+          app: 'test',
+          code: 'DEPRECATED',
+          msg: 'Warning message',
+          ts: 1234567890,
+        });
       });
 
       it('should log warning with only context object', () => {
@@ -128,10 +135,12 @@ describe('ConsoleLogger', () => {
 
         logger.error({ error }, 'Error occurred');
 
-        expect(console.error).toHaveBeenCalledWith(
-          { app: 'test', error, ts: 1234567890 },
-          'Error occurred',
-        );
+        expect(console.error).toHaveBeenCalledWith({
+          app: 'test',
+          error,
+          msg: 'Error occurred',
+          ts: 1234567890,
+        });
       });
 
       it('should log error with only context object', () => {
@@ -153,10 +162,12 @@ describe('ConsoleLogger', () => {
 
         logger.fatal({ exitCode: 1 }, 'Fatal error');
 
-        expect(console.error).toHaveBeenCalledWith(
-          { app: 'test', exitCode: 1, ts: 1234567890 },
-          'Fatal error',
-        );
+        expect(console.error).toHaveBeenCalledWith({
+          app: 'test',
+          exitCode: 1,
+          msg: 'Fatal error',
+          ts: 1234567890,
+        });
       });
 
       it('should log fatal with only context object', () => {
@@ -172,19 +183,21 @@ describe('ConsoleLogger', () => {
     });
 
     describe('trace', () => {
-      it('should log trace message with context', () => {
-        const logger = new ConsoleLogger({ app: 'test' });
+      it('should log trace message with context when level is Trace', () => {
+        const logger = new ConsoleLogger({ app: 'test' }, LogLevel.Trace);
 
         logger.trace({ stack: 'trace' }, 'Trace message');
 
-        expect(console.trace).toHaveBeenCalledWith(
-          { app: 'test', stack: 'trace', ts: 1234567890 },
-          'Trace message',
-        );
+        expect(console.trace).toHaveBeenCalledWith({
+          app: 'test',
+          stack: 'trace',
+          msg: 'Trace message',
+          ts: 1234567890,
+        });
       });
 
-      it('should log trace with only context object', () => {
-        const logger = new ConsoleLogger();
+      it('should log trace with only context object when level is Trace', () => {
+        const logger = new ConsoleLogger({}, LogLevel.Trace);
 
         logger.trace({ depth: 5 });
 
@@ -196,22 +209,94 @@ describe('ConsoleLogger', () => {
     });
   });
 
+  describe('Log level filtering', () => {
+    it('should not log debug when level is Info', () => {
+      const logger = new ConsoleLogger({}, LogLevel.Info);
+
+      logger.debug('This should not appear');
+
+      expect(console.debug).not.toHaveBeenCalled();
+    });
+
+    it('should not log trace when level is Debug', () => {
+      const logger = new ConsoleLogger({}, LogLevel.Debug);
+
+      logger.trace('This should not appear');
+
+      expect(console.trace).not.toHaveBeenCalled();
+    });
+
+    it('should log debug when level is Debug', () => {
+      const logger = new ConsoleLogger({}, LogLevel.Debug);
+
+      logger.debug('Debug message');
+
+      expect(console.debug).toHaveBeenCalled();
+    });
+
+    it('should log info when level is Debug', () => {
+      const logger = new ConsoleLogger({}, LogLevel.Debug);
+
+      logger.info('Info message');
+
+      expect(console.info).toHaveBeenCalled();
+    });
+
+    it('should not log anything when level is Silent', () => {
+      const logger = new ConsoleLogger({}, LogLevel.Silent);
+
+      logger.trace('trace');
+      logger.debug('debug');
+      logger.info('info');
+      logger.warn('warn');
+      logger.error('error');
+      logger.fatal('fatal');
+
+      expect(console.trace).not.toHaveBeenCalled();
+      expect(console.debug).not.toHaveBeenCalled();
+      expect(console.info).not.toHaveBeenCalled();
+      expect(console.warn).not.toHaveBeenCalled();
+      expect(console.error).not.toHaveBeenCalled();
+    });
+
+    it('should log error when level is Error', () => {
+      const logger = new ConsoleLogger({}, LogLevel.Error);
+
+      logger.info('This should not appear');
+      logger.warn('This should not appear');
+      logger.error('Error message');
+
+      expect(console.info).not.toHaveBeenCalled();
+      expect(console.warn).not.toHaveBeenCalled();
+      expect(console.error).toHaveBeenCalled();
+    });
+
+    it('should inherit log level in child logger', () => {
+      const parent = new ConsoleLogger({}, LogLevel.Warn);
+      const child = parent.child({ module: 'test' });
+
+      child.info('This should not appear');
+      child.warn('Warning message');
+
+      expect(console.info).not.toHaveBeenCalled();
+      expect(console.warn).toHaveBeenCalled();
+    });
+  });
+
   describe('Context merging', () => {
     it('should merge logger context with log context', () => {
       const logger = new ConsoleLogger({ app: 'myApp', env: 'production' });
 
       logger.info({ userId: 123, action: 'login' }, 'User logged in');
 
-      expect(console.info).toHaveBeenCalledWith(
-        {
-          app: 'myApp',
-          env: 'production',
-          userId: 123,
-          action: 'login',
-          ts: 1234567890,
-        },
-        'User logged in',
-      );
+      expect(console.info).toHaveBeenCalledWith({
+        app: 'myApp',
+        env: 'production',
+        userId: 123,
+        action: 'login',
+        msg: 'User logged in',
+        ts: 1234567890,
+      });
     });
 
     it('should override logger context with log context', () => {
@@ -219,15 +304,13 @@ describe('ConsoleLogger', () => {
 
       logger.info({ status: 'new', userId: 456 }, 'Status updated');
 
-      expect(console.info).toHaveBeenCalledWith(
-        {
-          env: 'production',
-          status: 'new', // Overridden
-          userId: 456,
-          ts: 1234567890,
-        },
-        'Status updated',
-      );
+      expect(console.info).toHaveBeenCalledWith({
+        env: 'production',
+        status: 'new', // Overridden
+        userId: 456,
+        msg: 'Status updated',
+        ts: 1234567890,
+      });
     });
 
     it('should always add timestamp', () => {
@@ -237,7 +320,6 @@ describe('ConsoleLogger', () => {
 
       expect(console.info).toHaveBeenCalledWith(
         expect.objectContaining({ ts: 1234567890 }),
-        'Test message',
       );
     });
   });
@@ -251,15 +333,14 @@ describe('ConsoleLogger', () => {
       logger.info({ action: 'test' }, 'Message', obj1, obj2);
 
       expect(console.info).toHaveBeenCalledWith(
-        { action: 'test', ts: 1234567890 },
-        'Message',
+        { action: 'test', msg: 'Message', ts: 1234567890 },
         obj1,
         obj2,
       );
     });
 
     it('should pass additional arguments without message', () => {
-      const logger = new ConsoleLogger();
+      const logger = new ConsoleLogger({}, LogLevel.Debug);
       const extra = 'extra data';
 
       logger.debug({ action: 'test' }, undefined as any, extra);
@@ -277,7 +358,9 @@ describe('ConsoleLogger', () => {
         app: 'myApp',
         version: '1.0.0',
       });
-      const childLogger = parentLogger.child({ module: 'auth' });
+      const childLogger = parentLogger.child({
+        module: 'auth',
+      }) as ConsoleLogger;
 
       expect(childLogger.data).toEqual({
         app: 'myApp',
@@ -292,15 +375,13 @@ describe('ConsoleLogger', () => {
 
       childLogger.info({ query: 'SELECT *' }, 'Query executed');
 
-      expect(console.info).toHaveBeenCalledWith(
-        {
-          app: 'myApp',
-          module: 'database',
-          query: 'SELECT *',
-          ts: 1234567890,
-        },
-        'Query executed',
-      );
+      expect(console.info).toHaveBeenCalledWith({
+        app: 'myApp',
+        module: 'database',
+        query: 'SELECT *',
+        msg: 'Query executed',
+        ts: 1234567890,
+      });
     });
 
     it('should override parent context in child logger', () => {
@@ -308,7 +389,7 @@ describe('ConsoleLogger', () => {
       const childLogger = parentLogger.child({
         status: 'child',
         module: 'api',
-      });
+      }) as ConsoleLogger;
 
       expect(childLogger.data).toEqual({
         env: 'dev',
@@ -324,21 +405,21 @@ describe('ConsoleLogger', () => {
 
       grandchildLogger.info({ table: 'users' }, 'Query executed');
 
-      expect(console.info).toHaveBeenCalledWith(
-        {
-          app: 'myApp',
-          module: 'database',
-          operation: 'query',
-          table: 'users',
-          ts: 1234567890,
-        },
-        'Query executed',
-      );
+      expect(console.info).toHaveBeenCalledWith({
+        app: 'myApp',
+        module: 'database',
+        operation: 'query',
+        table: 'users',
+        msg: 'Query executed',
+        ts: 1234567890,
+      });
     });
 
     it('should not affect parent logger', () => {
       const parentLogger = new ConsoleLogger({ app: 'myApp' });
-      const childLogger = parentLogger.child({ module: 'auth' });
+      const childLogger = parentLogger.child({
+        module: 'auth',
+      }) as ConsoleLogger;
 
       // Child logger has additional context
       expect(childLogger.data).toEqual({ app: 'myApp', module: 'auth' });
@@ -349,15 +430,41 @@ describe('ConsoleLogger', () => {
   });
 
   describe('Edge cases', () => {
+    it('should handle string-only logging without context object', () => {
+      const logger = new ConsoleLogger({ app: 'test' });
+
+      logger.info('Simple message without context object');
+
+      expect(console.info).toHaveBeenCalledWith({
+        app: 'test',
+        msg: 'Simple message without context object',
+        ts: 1234567890,
+      });
+    });
+
+    it('should handle string-only logging with child logger', () => {
+      const logger = new ConsoleLogger({ app: 'test' });
+      const child = logger.child({ module: 'auth' });
+
+      child.warn('Warning message');
+
+      expect(console.warn).toHaveBeenCalledWith({
+        app: 'test',
+        module: 'auth',
+        msg: 'Warning message',
+        ts: 1234567890,
+      });
+    });
+
     it('should handle empty context object', () => {
       const logger = new ConsoleLogger();
 
       logger.info({}, 'Empty context');
 
-      expect(console.info).toHaveBeenCalledWith(
-        { ts: 1234567890 },
-        'Empty context',
-      );
+      expect(console.info).toHaveBeenCalledWith({
+        msg: 'Empty context',
+        ts: 1234567890,
+      });
     });
 
     it('should handle complex nested objects', () => {
@@ -374,10 +481,11 @@ describe('ConsoleLogger', () => {
 
       logger.info(complexObj, 'Complex object');
 
-      expect(console.info).toHaveBeenCalledWith(
-        { ...complexObj, ts: 1234567890 },
-        'Complex object',
-      );
+      expect(console.info).toHaveBeenCalledWith({
+        ...complexObj,
+        msg: 'Complex object',
+        ts: 1234567890,
+      });
     });
 
     it('should handle null and undefined values', () => {
@@ -385,10 +493,12 @@ describe('ConsoleLogger', () => {
 
       logger.info({ value: null, missing: undefined }, 'Null values');
 
-      expect(console.info).toHaveBeenCalledWith(
-        { value: null, missing: undefined, ts: 1234567890 },
-        'Null values',
-      );
+      expect(console.info).toHaveBeenCalledWith({
+        value: null,
+        missing: undefined,
+        msg: 'Null values',
+        ts: 1234567890,
+      });
     });
 
     it('should handle special characters in strings', () => {
@@ -396,10 +506,11 @@ describe('ConsoleLogger', () => {
 
       logger.info({ message: 'Test\n\t"quotes"' }, 'Special chars');
 
-      expect(console.info).toHaveBeenCalledWith(
-        { message: 'Test\n\t"quotes"', ts: 1234567890 },
-        'Special chars',
-      );
+      expect(console.info).toHaveBeenCalledWith({
+        message: 'Test\n\t"quotes"',
+        msg: 'Special chars',
+        ts: 1234567890,
+      });
     });
   });
 
@@ -417,17 +528,15 @@ describe('ConsoleLogger', () => {
         'HTTP request completed',
       );
 
-      expect(console.info).toHaveBeenCalledWith(
-        {
-          service: 'api',
-          method: 'POST',
-          path: '/users',
-          statusCode: 201,
-          duration: 45,
-          ts: 1234567890,
-        },
-        'HTTP request completed',
-      );
+      expect(console.info).toHaveBeenCalledWith({
+        service: 'api',
+        method: 'POST',
+        path: '/users',
+        statusCode: 201,
+        duration: 45,
+        msg: 'HTTP request completed',
+        ts: 1234567890,
+      });
     });
 
     it('should log error with stack trace', () => {
@@ -448,9 +557,9 @@ describe('ConsoleLogger', () => {
           service: 'worker',
           error: 'Database connection failed',
           operation: 'connect',
+          msg: 'Database error',
           ts: 1234567890,
         }),
-        'Database error',
       );
     });
 
@@ -468,50 +577,47 @@ describe('ConsoleLogger', () => {
         'Order created successfully',
       );
 
-      expect(console.info).toHaveBeenCalledWith(
-        {
-          app: 'ecommerce',
-          eventType: 'order.created',
-          orderId: 'ORD-123',
-          userId: 456,
-          amount: 99.99,
-          currency: 'USD',
-          ts: 1234567890,
-        },
-        'Order created successfully',
-      );
+      expect(console.info).toHaveBeenCalledWith({
+        app: 'ecommerce',
+        eventType: 'order.created',
+        orderId: 'ORD-123',
+        userId: 456,
+        amount: 99.99,
+        currency: 'USD',
+        msg: 'Order created successfully',
+        ts: 1234567890,
+      });
     });
 
     it('should use child logger for module-specific logging', () => {
-      const appLogger = new ConsoleLogger({ app: 'myApp', env: 'production' });
+      const appLogger = new ConsoleLogger(
+        { app: 'myApp', env: 'production' },
+        LogLevel.Debug,
+      );
       const authLogger = appLogger.child({ module: 'auth' });
       const dbLogger = appLogger.child({ module: 'database' });
 
       authLogger.info({ userId: 123 }, 'User authenticated');
       dbLogger.debug({ query: 'SELECT *', duration: 10 }, 'Query executed');
 
-      expect(console.info).toHaveBeenCalledWith(
-        {
-          app: 'myApp',
-          env: 'production',
-          module: 'auth',
-          userId: 123,
-          ts: 1234567890,
-        },
-        'User authenticated',
-      );
+      expect(console.info).toHaveBeenCalledWith({
+        app: 'myApp',
+        env: 'production',
+        module: 'auth',
+        userId: 123,
+        msg: 'User authenticated',
+        ts: 1234567890,
+      });
 
-      expect(console.debug).toHaveBeenCalledWith(
-        {
-          app: 'myApp',
-          env: 'production',
-          module: 'database',
-          query: 'SELECT *',
-          duration: 10,
-          ts: 1234567890,
-        },
-        'Query executed',
-      );
+      expect(console.debug).toHaveBeenCalledWith({
+        app: 'myApp',
+        env: 'production',
+        module: 'database',
+        query: 'SELECT *',
+        duration: 10,
+        msg: 'Query executed',
+        ts: 1234567890,
+      });
     });
   });
 
@@ -523,4 +629,35 @@ describe('ConsoleLogger', () => {
       expect(DEFAULT_LOGGER.data).toBeDefined();
     });
   });
+
+  describe('createLogger', () => {
+    it('should create logger with default Info level', () => {
+      const logger = createLogger();
+
+      logger.debug('This should not appear');
+      logger.info('This should appear');
+
+      expect(console.debug).not.toHaveBeenCalled();
+      expect(console.info).toHaveBeenCalled();
+    });
+
+    it('should create logger with specified level', () => {
+      const logger = createLogger({ level: LogLevel.Debug });
+
+      logger.trace('This should not appear');
+      logger.debug('This should appear');
+
+      expect(console.trace).not.toHaveBeenCalled();
+      expect(console.debug).toHaveBeenCalled();
+    });
+
+    it('should create silent logger', () => {
+      const logger = createLogger({ level: LogLevel.Silent });
+
+      logger.error('This should not appear');
+      logger.fatal('This should not appear');
+
+      expect(console.error).not.toHaveBeenCalled();
+    });
+  });
 });