feat: create logger module

Author: araujogui

src/logger/__tests__/index.test.mjs

@@ -0,0 +1,19 @@
+import { ok, strictEqual } from 'node:assert';
+import { describe, it } from 'node:test';
+
+import { Logger } from '../index.mjs';
+
+describe('Logger singleton', () => {
+  it('should return the same instance on multiple calls', () => {
+    const logger1 = Logger.getInstance();
+    const logger2 = Logger.getInstance();
+
+    strictEqual(logger1, logger2);
+  });
+
+  it('should create an instance of logger', () => {
+    const logger = Logger.getInstance();
+
+    ok(logger);
+  });
+});

src/logger/__tests__/logger.test.mjs

@@ -0,0 +1,184 @@
+import { deepStrictEqual, strictEqual } from 'node:assert';
+import { describe, it } from 'node:test';
+
+import { LogLevel } from '../constants.mjs';
+import { createLogger } from '../logger.mjs';
+
+/**
+ * @type {import('../types').Metadata}
+ */
+const metadata = {
+  file: {
+    path: 'test.md',
+    position: {
+      start: { line: 1 },
+      end: { line: 1 },
+    },
+  },
+};
+
+describe('createLogger', () => {
+  describe('DEBUG', () => {
+    it('should log DEBUG messages when logger level is set to DEBUG', t => {
+      t.mock.timers.enable({ apis: ['Date'] });
+
+      const transport = t.mock.fn();
+
+      const logger = createLogger(transport, LogLevel.debug);
+
+      logger.debug('Hello, World!', metadata);
+
+      strictEqual(transport.mock.callCount(), 1);
+
+      const call = transport.mock.calls[0];
+      deepStrictEqual(call.arguments, [
+        {
+          level: LogLevel.debug,
+          message: 'Hello, World!',
+          metadata,
+          timestamp: 0,
+        },
+      ]);
+    });
+
+    it('should filter DEBUG messages when logger level is set to INFO or higher', t => {
+      [LogLevel.info, LogLevel.warn, LogLevel.error, LogLevel.fatal].forEach(
+        loggerLevel => {
+          const transport = t.mock.fn();
+
+          const logger = createLogger(transport, loggerLevel);
+
+          logger.debug('Hello, World!');
+
+          strictEqual(transport.mock.callCount(), 0);
+        }
+      );
+    });
+  });
+
+  describe('INFO', () => {
+    it('should log INFO messages when logger level is set to INFO or lower', t => {
+      t.mock.timers.enable({ apis: ['Date'] });
+      [LogLevel.info, LogLevel.debug].forEach(loggerLevel => {
+        const transport = t.mock.fn();
+
+        const logger = createLogger(transport, loggerLevel);
+
+        logger.info('Hello, World!', metadata);
+
+        strictEqual(transport.mock.callCount(), 1);
+
+        const call = transport.mock.calls[0];
+        deepStrictEqual(call.arguments, [
+          {
+            level: LogLevel.info,
+            message: 'Hello, World!',
+            metadata,
+            timestamp: 0,
+          },
+        ]);
+      });
+    });
+
+    it('should filter INFO messages when logger level is set to WARN or higher', t => {
+      [LogLevel.warn, LogLevel.error, LogLevel.fatal].forEach(loggerLevel => {
+        const transport = t.mock.fn();
+
+        const logger = createLogger(transport, loggerLevel);
+
+        logger.info('Hello, World!');
+
+        strictEqual(transport.mock.callCount(), 0);
+      });
+    });
+  });
+
+  describe('WARN', () => {
+    it('should log WARN messages when logger level is set to WARN or lower', t => {
+      t.mock.timers.enable({ apis: ['Date'] });
+
+      [LogLevel.warn, LogLevel.info, LogLevel.debug].forEach(loggerLevel => {
+        const transport = t.mock.fn();
+
+        const logger = createLogger(transport, loggerLevel);
+
+        logger.warn('Hello, World!', metadata);
+
+        strictEqual(transport.mock.callCount(), 1);
+
+        const call = transport.mock.calls[0];
+        deepStrictEqual(call.arguments, [
+          {
+            level: LogLevel.warn,
+            message: 'Hello, World!',
+            metadata,
+            timestamp: 0,
+          },
+        ]);
+      });
+    });
+
+    it('should filter WARN messages when logger level is set to ERROR or higher', t => {
+      [LogLevel.error, LogLevel.fatal].forEach(loggerLevel => {
+        const transport = t.mock.fn();
+
+        const logger = createLogger(transport, loggerLevel);
+
+        logger.warn('Hello, World!');
+
+        strictEqual(transport.mock.callCount(), 0);
+      });
+    });
+  });
+
+  describe('ERROR', () => {
+    it('should log ERROR messages when logger level is set to ERROR or lower', t => {
+      t.mock.timers.enable({ apis: ['Date'] });
+
+      [LogLevel.error, LogLevel.warn, LogLevel.info, LogLevel.debug].forEach(
+        loggerLevel => {
+          const transport = t.mock.fn();
+
+          const logger = createLogger(transport, loggerLevel);
+
+          logger.error('Hello, World!', metadata);
+
+          strictEqual(transport.mock.callCount(), 1);
+
+          const call = transport.mock.calls[0];
+          deepStrictEqual(call.arguments, [
+            {
+              level: LogLevel.error,
+              message: 'Hello, World!',
+              metadata,
+              timestamp: 0,
+            },
+          ]);
+        }
+      );
+    });
+
+    it('should filter ERROR messages when logger level is set to FATAL', t => {
+      const transport = t.mock.fn();
+
+      const logger = createLogger(transport, LogLevel.fatal);
+
+      logger.warn('Hello, World!');
+
+      strictEqual(transport.mock.callCount(), 0);
+    });
+  });
+
+  it('should filter all messages when minimum level is set above FATAL', t => {
+    const transport = t.mock.fn();
+
+    // silent logs
+    const logger = createLogger(transport, 100);
+
+    Object.keys(LogLevel).forEach(level => {
+      logger[level]('Hello, World!');
+    });
+
+    strictEqual(transport.mock.callCount(), 0);
+  });
+});