From f186bece9f0946bb2203d89ae54790ba0b467d0f Mon Sep 17 00:00:00 2001 From: Ruben Taelman Date: Wed, 23 Sep 2020 09:43:48 +0200 Subject: [PATCH] change: use regular getters and setters in LazyLoggerFactory --- src/logging/LazyLogger.ts | 3 +-- src/logging/LazyLoggerFactory.ts | 16 ++++++++++------ src/logging/LogUtil.ts | 19 ++++++++++++++----- test/unit/logging/LazyLogger.test.ts | 6 +++--- test/unit/logging/LazyLoggerFactory.test.ts | 14 +++++++------- test/unit/logging/LogUtil.test.ts | 10 +++++----- 6 files changed, 40 insertions(+), 28 deletions(-) diff --git a/src/logging/LazyLogger.ts b/src/logging/LazyLogger.ts index 87a31c705..f16f799f4 100644 --- a/src/logging/LazyLogger.ts +++ b/src/logging/LazyLogger.ts @@ -22,8 +22,7 @@ export class LazyLogger extends Logger { public log(level: LogLevel, message: string, meta: any): Logger { if (!this.logger) { - this.logger = this.lazyLoggerFactory.getLoggerFactoryOrThrow() - .createLogger(this.label); + this.logger = this.lazyLoggerFactory.loggerFactory.createLogger(this.label); } return this.logger.log(level, message, meta); } diff --git a/src/logging/LazyLoggerFactory.ts b/src/logging/LazyLoggerFactory.ts index 6444d81eb..6d6a3d3ac 100644 --- a/src/logging/LazyLoggerFactory.ts +++ b/src/logging/LazyLoggerFactory.ts @@ -14,7 +14,7 @@ import type { LoggerFactory } from './LoggerFactory'; export class LazyLoggerFactory implements LoggerFactory { private static readonly instance = new LazyLoggerFactory(); - private loggerFactory: LoggerFactory | undefined; + private ploggerFactory: LoggerFactory | undefined; private constructor() { // Singleton instance @@ -28,14 +28,18 @@ export class LazyLoggerFactory implements LoggerFactory { return new LazyLogger(this, label); } - public setLoggerFactory(loggerFactory: LoggerFactory | undefined): void { - this.loggerFactory = loggerFactory; + public resetLoggerFactory(): void { + this.ploggerFactory = undefined; } - public getLoggerFactoryOrThrow(): LoggerFactory { - if (!this.loggerFactory) { + public get loggerFactory(): LoggerFactory { + if (!this.ploggerFactory) { throw new Error('No logger factory has been set yet. Can be caused logger invocation during initialization.'); } - return this.loggerFactory; + return this.ploggerFactory; + } + + public set loggerFactory(loggerFactory: LoggerFactory) { + this.ploggerFactory = loggerFactory; } } diff --git a/src/logging/LogUtil.ts b/src/logging/LogUtil.ts index d990387c9..745429833 100644 --- a/src/logging/LogUtil.ts +++ b/src/logging/LogUtil.ts @@ -20,16 +20,25 @@ import type { LoggerFactory } from './LoggerFactory'; * * @param loggable - A class instance or a class string name. */ -export const getLoggerFor = (loggable: string | Instance): Logger => LazyLoggerFactory - .getInstance().createLogger(typeof loggable === 'string' ? loggable : loggable.constructor.name); +export const getLoggerFor = (loggable: string | Instance): Logger => LazyLoggerFactory.getInstance() + .createLogger(typeof loggable === 'string' ? loggable : loggable.constructor.name); /** * Sets the global logger factory. * This will cause all loggers created by {@link getLoggerFor} to be delegated to a logger from the given factory. - * @param loggerFactory - A logger factory, of undefined for unsetting it. + * @param loggerFactory - A logger factory. */ -export const setGlobalLoggerFactory = (loggerFactory: LoggerFactory | undefined): void => LazyLoggerFactory - .getInstance().setLoggerFactory(loggerFactory); +export const setGlobalLoggerFactory = (loggerFactory: LoggerFactory): void => { + LazyLoggerFactory.getInstance().loggerFactory = loggerFactory; +}; + +/** + * Resets the global logger factory to undefined. + * + * This typically only needs to be called during testing. + * Call this at your own risk. + */ +export const resetGlobalLoggerFactory = (): void => LazyLoggerFactory.getInstance().resetLoggerFactory(); /** * Helper interface to identify class instances. diff --git a/test/unit/logging/LazyLogger.test.ts b/test/unit/logging/LazyLogger.test.ts index b565356e8..5d9b2b60f 100644 --- a/test/unit/logging/LazyLogger.test.ts +++ b/test/unit/logging/LazyLogger.test.ts @@ -6,7 +6,7 @@ describe('LazyLogger', (): void => { let logger: LazyLogger; beforeEach(async(): Promise => { lazyLoggerFactory = LazyLoggerFactory.getInstance(); - lazyLoggerFactory.setLoggerFactory(undefined); + lazyLoggerFactory.resetLoggerFactory(); logger = new LazyLogger(lazyLoggerFactory, 'MyLabel'); }); @@ -22,7 +22,7 @@ describe('LazyLogger', (): void => { const dummyLoggerFactory: any = { createLogger: jest.fn((): any => dummyLogger), }; - lazyLoggerFactory.setLoggerFactory(dummyLoggerFactory); + lazyLoggerFactory.loggerFactory = dummyLoggerFactory; expect(logger.log('debug', 'my message', { abc: true })).toBe(dummyLogger); expect(dummyLoggerFactory.createLogger).toHaveBeenCalledTimes(1); @@ -38,7 +38,7 @@ describe('LazyLogger', (): void => { const dummyLoggerFactory: any = { createLogger: jest.fn((): any => dummyLogger), }; - lazyLoggerFactory.setLoggerFactory(dummyLoggerFactory); + lazyLoggerFactory.loggerFactory = dummyLoggerFactory; expect(logger.log('debug', 'my message 1', { abc: true })).toBe(dummyLogger); expect(logger.log('debug', 'my message 2', { abc: true })).toBe(dummyLogger); diff --git a/test/unit/logging/LazyLoggerFactory.test.ts b/test/unit/logging/LazyLoggerFactory.test.ts index a8e9cfbeb..3c27f9b47 100644 --- a/test/unit/logging/LazyLoggerFactory.test.ts +++ b/test/unit/logging/LazyLoggerFactory.test.ts @@ -5,7 +5,7 @@ describe('LazyLoggerFactory', (): void => { let dummyLogger: any; let dummyLoggerFactory: any; beforeEach(async(): Promise => { - LazyLoggerFactory.getInstance().setLoggerFactory(undefined); + LazyLoggerFactory.getInstance().resetLoggerFactory(); dummyLogger = { log: jest.fn((): any => dummyLogger), }; @@ -24,23 +24,23 @@ describe('LazyLoggerFactory', (): void => { }); it('allows LazyLoggers to be created after an inner factory was set.', async(): Promise => { - LazyLoggerFactory.getInstance().setLoggerFactory(dummyLoggerFactory); + LazyLoggerFactory.getInstance().loggerFactory = dummyLoggerFactory; const logger = LazyLoggerFactory.getInstance().createLogger('MyLabel'); expect(logger).toBeInstanceOf(LazyLogger); }); it('throws when retrieving the inner factory if none has been set.', async(): Promise => { - expect((): any => LazyLoggerFactory.getInstance().getLoggerFactoryOrThrow()) + expect((): any => LazyLoggerFactory.getInstance().loggerFactory) .toThrow(new Error('No logger factory has been set yet. Can be caused logger invocation during initialization.')); }); it('Returns the inner factory if one has been set.', async(): Promise => { - LazyLoggerFactory.getInstance().setLoggerFactory(dummyLoggerFactory); - expect(LazyLoggerFactory.getInstance().getLoggerFactoryOrThrow()).toBe(dummyLoggerFactory); + LazyLoggerFactory.getInstance().loggerFactory = dummyLoggerFactory; + expect(LazyLoggerFactory.getInstance().loggerFactory).toBe(dummyLoggerFactory); }); it('allows LazyLoggers to be invoked if a factory has been set beforehand.', async(): Promise => { - LazyLoggerFactory.getInstance().setLoggerFactory(dummyLoggerFactory); + LazyLoggerFactory.getInstance().loggerFactory = dummyLoggerFactory; const logger = LazyLoggerFactory.getInstance().createLogger('MyLabel'); logger.log('debug', 'my message', { abc: true }); @@ -50,7 +50,7 @@ describe('LazyLoggerFactory', (): void => { it('allows LazyLoggers to be invoked if a factory has been after lazy logger creation.', async(): Promise => { const logger = LazyLoggerFactory.getInstance().createLogger('MyLabel'); - LazyLoggerFactory.getInstance().setLoggerFactory(dummyLoggerFactory); + LazyLoggerFactory.getInstance().loggerFactory = dummyLoggerFactory; logger.log('debug', 'my message', { abc: true }); expect(dummyLogger.log).toHaveBeenCalledTimes(1); diff --git a/test/unit/logging/LogUtil.test.ts b/test/unit/logging/LogUtil.test.ts index 803f1d3c8..a1264e825 100644 --- a/test/unit/logging/LogUtil.test.ts +++ b/test/unit/logging/LogUtil.test.ts @@ -1,12 +1,12 @@ import { LazyLogger } from '../../../src/logging/LazyLogger'; import { LazyLoggerFactory } from '../../../src/logging/LazyLoggerFactory'; -import { getLoggerFor, setGlobalLoggerFactory } from '../../../src/logging/LogUtil'; +import { getLoggerFor, resetGlobalLoggerFactory, setGlobalLoggerFactory } from '../../../src/logging/LogUtil'; import { VoidLogger } from '../../../src/logging/VoidLogger'; import { VoidLoggerFactory } from '../../../src/logging/VoidLoggerFactory'; describe('LogUtil', (): void => { beforeEach(async(): Promise => { - setGlobalLoggerFactory(undefined); + resetGlobalLoggerFactory(); }); it('allows creating a lazy logger for a string label.', async(): Promise => { @@ -21,13 +21,13 @@ describe('LogUtil', (): void => { it('allows setting the global logger factory.', async(): Promise => { expect(setGlobalLoggerFactory(new VoidLoggerFactory())); - expect(LazyLoggerFactory.getInstance().getLoggerFactoryOrThrow()).toBeInstanceOf(VoidLoggerFactory); + expect(LazyLoggerFactory.getInstance().loggerFactory).toBeInstanceOf(VoidLoggerFactory); }); it('allows unsetting the global logger factory.', async(): Promise => { expect(setGlobalLoggerFactory(new VoidLoggerFactory())); - expect(setGlobalLoggerFactory(undefined)); - expect((): any => LazyLoggerFactory.getInstance().getLoggerFactoryOrThrow()) + expect(resetGlobalLoggerFactory()); + expect((): any => LazyLoggerFactory.getInstance().loggerFactory) .toThrow(new Error('No logger factory has been set yet. Can be caused logger invocation during initialization.')); }); });