cf-yoyo 1.0.0

package/__tests__/logger.test.ts

@@ -0,0 +1,274 @@
+/**
+ * logger.ts 模組測試
+ * 測試日誌輸出功能
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { LoggerClass, logger } from '../src/utils/logger';
+import { LogLevel } from '../src/types';
+
+describe('Logger', () => {
+  let consoleSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+  });
+
+  describe('constructor', () => {
+    it('should create logger instance with default level', () => {
+      const logger = new LoggerClass();
+      expect(logger).toBeInstanceOf(LoggerClass);
+      expect(logger.getLevel()).toBe(LogLevel.INFO);
+    });
+
+    it('should create logger with custom level', () => {
+      const logger = new LoggerClass({ level: LogLevel.DEBUG });
+      expect(logger.getLevel()).toBe(LogLevel.DEBUG);
+    });
+
+    it('should create logger with timestamp option', () => {
+      const logger = new LoggerClass({ timestamp: true });
+      expect(logger).toBeInstanceOf(LoggerClass);
+    });
+
+    it('should create logger with color disabled', () => {
+      const logger = new LoggerClass({ color: false });
+      expect(logger).toBeInstanceOf(LoggerClass);
+    });
+
+    it('should create logger with silent mode', () => {
+      const logger = new LoggerClass({ silent: true });
+      expect(logger).toBeInstanceOf(LoggerClass);
+    });
+  });
+
+  describe('setLevel', () => {
+    it('should change log level', () => {
+      const logger = new LoggerClass({ level: LogLevel.INFO });
+      logger.setLevel(LogLevel.DEBUG);
+      expect(logger.getLevel()).toBe(LogLevel.DEBUG);
+    });
+
+    it('should set level to ERROR', () => {
+      const logger = new LoggerClass();
+      logger.setLevel(LogLevel.ERROR);
+      expect(logger.getLevel()).toBe(LogLevel.ERROR);
+    });
+  });
+
+  describe('getLevel', () => {
+    it('should return current log level', () => {
+      const logger = new LoggerClass({ level: LogLevel.WARN });
+      expect(logger.getLevel()).toBe(LogLevel.WARN);
+    });
+  });
+
+  describe('debug', () => {
+    it('should log debug messages at DEBUG level', () => {
+      const logger = new LoggerClass({ level: LogLevel.DEBUG });
+      logger.debug('Test debug message');
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+
+    it('should not log debug messages at INFO level', () => {
+      const logger = new LoggerClass({ level: LogLevel.INFO });
+      logger.debug('Test debug message');
+      expect(consoleSpy).not.toHaveBeenCalled();
+    });
+
+    it('should respect silent mode', () => {
+      const logger = new LoggerClass({ silent: true, level: LogLevel.DEBUG });
+      logger.debug('Silent debug message');
+      expect(consoleSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('info', () => {
+    it('should log info messages at INFO level', () => {
+      const logger = new LoggerClass({ level: LogLevel.INFO });
+      logger.info('Test info message');
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+
+    it('should log info messages at DEBUG level', () => {
+      const logger = new LoggerClass({ level: LogLevel.DEBUG });
+      logger.info('Test info message');
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+
+    it('should not log info messages at WARN level', () => {
+      const logger = new LoggerClass({ level: LogLevel.WARN });
+      logger.info('Test info message');
+      expect(consoleSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('warn', () => {
+    it('should log warn messages at WARN level', () => {
+      const logger = new LoggerClass({ level: LogLevel.WARN });
+      logger.warn('Test warn message');
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+
+    it('should log warn messages at INFO level', () => {
+      const logger = new LoggerClass({ level: LogLevel.INFO });
+      logger.warn('Test warn message');
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+
+    it('should not log warn messages at ERROR level', () => {
+      const logger = new LoggerClass({ level: LogLevel.ERROR });
+      logger.warn('Test warn message');
+      expect(consoleSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('error', () => {
+    it('should log error messages at ERROR level', () => {
+      const logger = new LoggerClass({ level: LogLevel.ERROR });
+      logger.error('Test error message');
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+
+    it('should log error messages at DEBUG level', () => {
+      const logger = new LoggerClass({ level: LogLevel.DEBUG });
+      logger.error('Test error message');
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('success', () => {
+    it('should log success messages at INFO level', () => {
+      const logger = new LoggerClass({ level: LogLevel.INFO });
+      logger.success('Test success message');
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+
+    it('should not log success messages at WARN level', () => {
+      const logger = new LoggerClass({ level: LogLevel.WARN });
+      logger.success('Test success message');
+      expect(consoleSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('icon', () => {
+    it('should log icon messages at INFO level', () => {
+      const logger = new LoggerClass({ level: LogLevel.INFO });
+      logger.icon('✓', 'Test icon message');
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+
+    it('should not log icon messages at WARN level', () => {
+      const logger = new LoggerClass({ level: LogLevel.WARN });
+      logger.icon('✓', 'Test icon message');
+      expect(consoleSpy).not.toHaveBeenCalled();
+    });
+
+    it('should use plain text when color is disabled', () => {
+      const logger = new LoggerClass({ level: LogLevel.INFO, color: false });
+      logger.icon('✓', 'Test icon message');
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('empty', () => {
+    it('should output empty line', () => {
+      const logger = new LoggerClass();
+      logger.empty();
+      expect(consoleSpy).toHaveBeenCalledWith('');
+    });
+  });
+
+  describe('divider', () => {
+    it('should output default divider', () => {
+      const logger = new LoggerClass({ color: false });
+      logger.divider();
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+
+    it('should output custom divider', () => {
+      const logger = new LoggerClass({ color: false });
+      logger.divider('=', 20);
+      expect(consoleSpy).toHaveBeenCalledWith('='.repeat(20));
+    });
+
+    it('should use color when enabled', () => {
+      const logger = new LoggerClass({ color: true });
+      logger.divider('─', 40);
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('timestamp option', () => {
+    it('should include timestamp when enabled', () => {
+      const logger = new LoggerClass({ timestamp: true, level: LogLevel.INFO });
+      logger.info('Test message');
+      expect(consoleSpy).toHaveBeenCalled();
+      // The output should contain timestamp in format [YYYY-MM-DD HH:MM:SS]
+      const call = consoleSpy.mock.calls[0][0];
+      expect(call).toMatch(/\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\]/);
+    });
+
+    it('should not include timestamp when disabled', () => {
+      const logger = new LoggerClass({ timestamp: false, level: LogLevel.INFO });
+      logger.info('Test message');
+      expect(consoleSpy).toHaveBeenCalled();
+      const call = consoleSpy.mock.calls[0][0];
+      expect(call).not.toMatch(/\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\]/);
+    });
+  });
+
+  describe('log level filtering', () => {
+    it('should only log ERROR at ERROR level', () => {
+      const logger = new LoggerClass({ level: LogLevel.ERROR });
+      logger.debug('debug');
+      logger.info('info');
+      logger.warn('warn');
+      logger.error('error');
+
+      expect(consoleSpy).toHaveBeenCalledTimes(1);
+      expect(consoleSpy.mock.calls[0][0]).toContain('ERROR');
+    });
+
+    it('should log WARN and ERROR at WARN level', () => {
+      const logger = new LoggerClass({ level: LogLevel.WARN });
+      logger.debug('debug');
+      logger.info('info');
+      logger.warn('warn');
+      logger.error('error');
+
+      expect(consoleSpy).toHaveBeenCalledTimes(2);
+    });
+
+    it('should log INFO, WARN and ERROR at INFO level', () => {
+      const logger = new LoggerClass({ level: LogLevel.INFO });
+      logger.debug('debug');
+      logger.info('info');
+      logger.warn('warn');
+      logger.error('error');
+
+      expect(consoleSpy).toHaveBeenCalledTimes(3);
+    });
+
+    it('should log all at DEBUG level', () => {
+      const logger = new LoggerClass({ level: LogLevel.DEBUG });
+      logger.debug('debug');
+      logger.info('info');
+      logger.warn('warn');
+      logger.error('error');
+
+      expect(consoleSpy).toHaveBeenCalledTimes(4);
+    });
+  });
+
+  describe('singleton instance', () => {
+    it('should export a logger instance', () => {
+      expect(logger).toBeDefined();
+      expect(logger).toBeInstanceOf(LoggerClass);
+    });
+  });
+});