change: use regular getters and setters in LazyLoggerFactory

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);
   }

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;
   }
 }

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.

test/unit/logging/LazyLogger.test.ts

@@ -6,7 +6,7 @@ describe('LazyLogger', (): void => {
   let logger: LazyLogger;
   beforeEach(async(): Promise<void> => {
     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);

test/unit/logging/LazyLoggerFactory.test.ts

@@ -5,7 +5,7 @@ describe('LazyLoggerFactory', (): void => {
   let dummyLogger: any;
   let dummyLoggerFactory: any;
   beforeEach(async(): Promise<void> => {
-    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<void> => {
-    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<void> => {
-    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<void> => {
-    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<void> => {
-    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<void> => {
     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);

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<void> => {
-    setGlobalLoggerFactory(undefined);
+    resetGlobalLoggerFactory();
   });
 
   it('allows creating a lazy logger for a string label.', async(): Promise<void> => {
@@ -21,13 +21,13 @@ describe('LogUtil', (): void => {
 
   it('allows setting the global logger factory.', async(): Promise<void> => {
     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<void> => {
     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.'));
   });
 });