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.
TypeScript 2d-game-engine3d3d-game-engineandroidcppecsgame-editorgame-enginegamedeviostypescriptwebassemblywebglwebgpuwechat-minigame
// 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();
});
});
});