Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

11.2 KB
Raw Blame
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team
import { describe, it, expect, beforeEach, vi } from 'vitest';
import { Logger, LogLevel, ConsoleLogHandler, type LogHandler, type LogEntry } from '../src/util/logger';

describe('Logger', () => {
    let logger: Logger;
    let mockHandler: LogHandler;
    let capturedEntries: LogEntry[];

    beforeEach(() => {
        logger = new Logger();
        logger.clearHandlers();
        capturedEntries = [];

        mockHandler = {
            handle: (entry: LogEntry) => {
                capturedEntries.push(entry);
            },
        };

        logger.addHandler(mockHandler);
    });

    describe('log levels', () => {
        it('should log debug messages', () => {
            logger.setMinLevel(LogLevel.Debug);
            logger.debug('Test', 'Debug message');

            expect(capturedEntries).toHaveLength(1);
            expect(capturedEntries[0].level).toBe(LogLevel.Debug);
            expect(capturedEntries[0].message).toBe('Debug message');
        });

        it('should log info messages', () => {
            logger.info('Test', 'Info message');

            expect(capturedEntries).toHaveLength(1);
            expect(capturedEntries[0].level).toBe(LogLevel.Info);
        });

        it('should log warn messages', () => {
            logger.warn('Test', 'Warning message');

            expect(capturedEntries).toHaveLength(1);
            expect(capturedEntries[0].level).toBe(LogLevel.Warn);
        });

        it('should log error messages', () => {
            logger.error('Test', 'Error message');

            expect(capturedEntries).toHaveLength(1);
            expect(capturedEntries[0].level).toBe(LogLevel.Error);
        });
    });

    describe('filtering', () => {
        it('should filter messages below min level', () => {
            logger.setMinLevel(LogLevel.Warn);

            logger.debug('Test', 'Debug');
            logger.info('Test', 'Info');
            logger.warn('Test', 'Warning');
            logger.error('Test', 'Error');

            expect(capturedEntries).toHaveLength(2);
            expect(capturedEntries[0].level).toBe(LogLevel.Warn);
            expect(capturedEntries[1].level).toBe(LogLevel.Error);
        });

        it('should default to Info level', () => {
            const defaultLogger = new Logger();
            defaultLogger.clearHandlers();
            defaultLogger.addHandler(mockHandler);

            defaultLogger.debug('Test', 'Debug');
            defaultLogger.info('Test', 'Info');

            expect(capturedEntries).toHaveLength(1);
            expect(capturedEntries[0].level).toBe(LogLevel.Info);
        });
    });

    describe('categories', () => {
        it('should include category in log entry', () => {
            logger.info('SDK:AssetServer', 'Message');

            expect(capturedEntries[0].category).toBe('SDK:AssetServer');
        });

        it('should support different categories', () => {
            logger.info('SDK:World', 'Message 1');
            logger.info('SDK:Query', 'Message 2');

            expect(capturedEntries[0].category).toBe('SDK:World');
            expect(capturedEntries[1].category).toBe('SDK:Query');
        });
    });

    describe('data', () => {
        it('should include data in log entry', () => {
            logger.info('Test', 'Message', { key: 'value' });

            expect(capturedEntries[0].data).toEqual({ key: 'value' });
        });

        it('should handle undefined data', () => {
            logger.info('Test', 'Message');

            expect(capturedEntries[0].data).toBeUndefined();
        });

        it('should handle complex data', () => {
            const data = {
                nested: { value: 42 },
                array: [1, 2, 3],
                string: 'test',
            };

            logger.info('Test', 'Message', data);

            expect(capturedEntries[0].data).toEqual(data);
        });
    });

    describe('console handler error rendering', () => {
        it('renders a foreign-context error (fails instanceof, has stack) as text, not {}', () => {
            const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
            try {
                new ConsoleLogHandler().handle({
                    timestamp: Date.now(), level: LogLevel.Warn, category: 'runtime',
                    message: 'Failed to load texture: a.png',
                    data: { message: 'boom', stack: 'FakeError: boom\n    at x' },
                });
                expect(spy).toHaveBeenCalledTimes(1);
                const line = spy.mock.calls[0][0] as string;
                expect(line).toContain('FakeError: boom');
                expect(line).not.toContain('{}');
            } finally {
                spy.mockRestore();
            }
        });

        it('renders a real Error natively as a second console arg', () => {
            const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
            try {
                const err = new Error('kaput');
                new ConsoleLogHandler().handle({
                    timestamp: Date.now(), level: LogLevel.Error, category: 'runtime',
                    message: 'boom', data: err,
                });
                expect(spy.mock.calls[0][1]).toBe(err);
            } finally {
                spy.mockRestore();
            }
        });
    });

    describe('timestamps', () => {
        it('should include timestamp in log entry', () => {
            const before = Date.now();
            logger.info('Test', 'Message');
            const after = Date.now();

            expect(capturedEntries[0].timestamp).toBeGreaterThanOrEqual(before);
            expect(capturedEntries[0].timestamp).toBeLessThanOrEqual(after);
        });
    });

    describe('handlers', () => {
        it('should support multiple handlers', () => {
            const entries1: LogEntry[] = [];
            const entries2: LogEntry[] = [];

            logger.addHandler({ handle: (e) => entries1.push(e) });
            logger.addHandler({ handle: (e) => entries2.push(e) });

            logger.info('Test', 'Message');

            expect(entries1).toHaveLength(1);
            expect(entries2).toHaveLength(1);
            expect(capturedEntries).toHaveLength(1);
        });

        it('should remove handlers', () => {
            const handler2 = { handle: vi.fn() };
            logger.addHandler(handler2);

            logger.removeHandler(mockHandler);
            logger.info('Test', 'Message');

            expect(capturedEntries).toHaveLength(0);
            expect(handler2.handle).toHaveBeenCalledTimes(1);
        });

        it('should clear all handlers', () => {
            logger.clearHandlers();
            logger.info('Test', 'Message');

            expect(capturedEntries).toHaveLength(0);
        });

        it('should catch handler errors', () => {
            const errorHandler: LogHandler = {
                handle: () => {
                    throw new Error('Handler error');
                },
            };

            logger.addHandler(errorHandler);

            expect(() => {
                logger.info('Test', 'Message');
            }).not.toThrow();

            expect(capturedEntries).toHaveLength(1);
        });
    });

    describe('console handler', () => {
        it('should log to console by default', () => {
            const consoleSpy = vi.spyOn(console, 'log');
            const newLogger = new Logger();

            newLogger.info('Test', 'Message');

            expect(consoleSpy).toHaveBeenCalled();
            consoleSpy.mockRestore();
        });
    });

    describe('global functions', () => {
        it('should export convenience functions', async () => {
            const { getLogger, setLogLevel, debug, info, warn, error } = await import('../src/util/logger');

            expect(getLogger).toBeDefined();
            expect(setLogLevel).toBeDefined();
            expect(debug).toBeDefined();
            expect(info).toBeDefined();
            expect(warn).toBeDefined();
            expect(error).toBeDefined();
        });

        it('getLogger should return a Logger instance', async () => {
            const { getLogger } = await import('../src/util/logger');
            expect(getLogger()).toBeInstanceOf(Logger);
        });

        it('setLogLevel should change default logger level', async () => {
            const { getLogger, setLogLevel } = await import('../src/util/logger');
            const l = getLogger();
            l.clearHandlers();
            l.addHandler(mockHandler);

            setLogLevel(LogLevel.Debug);
            l.debug('Test', 'should appear');
            expect(capturedEntries.length).toBeGreaterThan(0);
            setLogLevel(LogLevel.Info);
        });

        it('shorthand functions should log through default logger', async () => {
            const mod = await import('../src/util/logger');
            const l = mod.getLogger();
            l.clearHandlers();
            l.addHandler(mockHandler);

            mod.setLogLevel(LogLevel.Debug);
            mod.debug('Cat', 'debug msg');
            mod.info('Cat', 'info msg');
            mod.warn('Cat', 'warn msg');
            mod.error('Cat', 'error msg');

            expect(capturedEntries).toHaveLength(4);
            expect(capturedEntries[0].level).toBe(LogLevel.Debug);
            expect(capturedEntries[1].level).toBe(LogLevel.Info);
            expect(capturedEntries[2].level).toBe(LogLevel.Warn);
            expect(capturedEntries[3].level).toBe(LogLevel.Error);
            mod.setLogLevel(LogLevel.Info);
        });
    });

    describe('ConsoleLogHandler branches', () => {
        it('should call console.debug for Debug level', () => {
            const spy = vi.spyOn(console, 'debug').mockImplementation(() => {});
            const l = new Logger();
            l.setMinLevel(LogLevel.Debug);
            l.debug('Test', 'dbg');
            expect(spy).toHaveBeenCalled();
            spy.mockRestore();
        });

        it('should call console.log for Info level', () => {
            const spy = vi.spyOn(console, 'log').mockImplementation(() => {});
            const l = new Logger();
            l.info('Test', 'inf');
            expect(spy).toHaveBeenCalled();
            spy.mockRestore();
        });

        it('should call console.warn for Warn level', () => {
            const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
            const l = new Logger();
            l.warn('Test', 'wrn');
            expect(spy).toHaveBeenCalled();
            spy.mockRestore();
        });

        it('should call console.error for Error level', () => {
            const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
            const l = new Logger();
            l.error('Test', 'err');
            expect(spy).toHaveBeenCalled();
            spy.mockRestore();
        });

        it('should include data in console output', () => {
            const spy = vi.spyOn(console, 'log').mockImplementation(() => {});
            const l = new Logger();
            l.info('Test', 'msg', { key: 'val' });
            // Single-arg style: non-Error data is JSON-stringified into the line.
            expect(spy).toHaveBeenCalledWith(expect.stringContaining('"key":"val"'));
            spy.mockRestore();
        });
    });
});