chore: use better typings of consola once they are fixed #63

PruvoNet · May 7, 2020 · 9777ab8 · 9777ab8
1 parent f88d4b9
commit 9777ab8
Show file tree

Hide file tree

Showing 7 changed files with 114 additions and 32 deletions.
diff --git a/src/utils/logger/impl/logger.ts b/src/utils/logger/impl/logger.ts
@@ -7,10 +7,6 @@ export class Logger extends Consola implements ILogger {
     super(options);
   }
 
-  public isLevelEnabled(level: LogLevel): boolean {
-    return this.level >= getConoslaLogLevel(level);
-  }
-
   public isTraceEnabled(): boolean {
     return this.isLevelEnabled(LogLevel.TRACE);
   }
@@ -26,4 +22,20 @@ export class Logger extends Consola implements ILogger {
   public isWarnEnabled(): boolean {
     return this.isLevelEnabled(LogLevel.WARN);
   }
+
+  public isLogEnabled(): boolean {
+    return this.isLevelEnabled(LogLevel.LOG);
+  }
+
+  public isErrorEnabled(): boolean {
+    return this.isLevelEnabled(LogLevel.ERROR);
+  }
+
+  public isSilent(): boolean {
+    return this.isLevelEnabled(LogLevel.SILENT);
+  }
+
+  private isLevelEnabled(level: LogLevel): boolean {
+    return this.level >= getConoslaLogLevel(level);
+  }
 }
diff --git a/src/utils/logger/impl/loggerFactory.ts b/src/utils/logger/impl/loggerFactory.ts
@@ -12,13 +12,10 @@ import { getConoslaLogLevel } from './logLevel';
 @injectable()
 export class LoggerFactory extends ILoggerFactory {
   private readonly options: ConsolaOptions;
-  constructor(settings: ILoggerSettings) {
+  constructor({ logLevel }: ILoggerSettings) {
     super();
-    const isDebug = settings.debugMode;
-    const isTrace = settings.traceMode;
-    const level = isTrace ? LogLevel.TRACE : isDebug ? LogLevel.DEBUG : LogLevel.INFO;
     this.options = {
-      level: getConoslaLogLevel(level),
+      level: getConoslaLogLevel(logLevel ?? LogLevel.INFO),
       reporters: [
         new LogReporter({
           secondaryColor: `grey`,

diff --git a/src/utils/logger/interfaces/ILogger.ts b/src/utils/logger/interfaces/ILogger.ts
@@ -25,9 +25,11 @@ export interface ILogger {
 
   trace(...args: unknown[]): void;
 
+  isErrorEnabled(): boolean;
+  isWarnEnabled(): boolean;
+  isLogEnabled(): boolean;
+  isInfoEnabled(): boolean;
   isDebugEnabled(): boolean;
   isTraceEnabled(): boolean;
-  isInfoEnabled(): boolean;
-  isWarnEnabled(): boolean;
-  isLevelEnabled(level: LogLevel): boolean;
+  isSilent(): boolean;
 }
diff --git a/src/utils/logger/interfaces/ILoggerSettings.ts b/src/utils/logger/interfaces/ILoggerSettings.ts
@@ -1,4 +1,5 @@
+import { LogLevel } from './ILogger';
+
 export abstract class ILoggerSettings {
-  public abstract readonly debugMode: boolean;
-  public abstract readonly traceMode: boolean;
+  public abstract readonly logLevel: LogLevel | undefined;
 }
diff --git a/test/common/logger.ts b/test/common/logger.ts
@@ -1,8 +1,8 @@
 import { LoggerFactory } from '../../src/utils/logger/impl/loggerFactory';
 import { ILoggerFactory, ILoggerSettings } from '../../src/utils/logger';
+import { LogLevel } from '../../src/utils/logger/interfaces/ILogger';
 
 export const loggerSettings: ILoggerSettings = {
-  debugMode: true,
-  traceMode: true,
+  logLevel: LogLevel.TRACE,
 };
 export const loggerFactory: ILoggerFactory = new LoggerFactory(loggerSettings);
diff --git a/test/src/utils/logger/impl/loggerFactory.spec.ts b/test/src/utils/logger/impl/loggerFactory.spec.ts
@@ -16,12 +16,17 @@ describe(`logger factory`, () => {
   });
   it(`should set reporter`, async () => {
     const settings: ILoggerSettings = {
-      debugMode: true,
-      traceMode: true,
+      logLevel: undefined,
     };
     const loggerFactory = new LoggerFactory(settings);
     const logger = loggerFactory.getLogger(`test`);
-    expect(logger.isTraceEnabled()).toBe(true);
+    expect(logger.isSilent()).toBe(false);
+    expect(logger.isTraceEnabled()).toBe(false);
+    expect(logger.isDebugEnabled()).toBe(false);
+    expect(logger.isInfoEnabled()).toBe(true);
+    expect(logger.isLogEnabled()).toBe(true);
+    expect(logger.isWarnEnabled()).toBe(true);
+    expect(logger.isErrorEnabled()).toBe(true);
     // @ts-ignore
     // eslint-disable-next-line no-underscore-dangle
     const reporters = logger._reporters;
@@ -30,47 +35,112 @@ describe(`logger factory`, () => {
   });
   it(`should set debug log level from settings`, async () => {
     const settings: ILoggerSettings = {
-      debugMode: true,
-      traceMode: false,
+      logLevel: LogLevel.DEBUG,
     };
     const loggerFactory = new LoggerFactory(settings);
     const logger = loggerFactory.getLogger(`test`);
-    expect(logger.isDebugEnabled()).toBe(true);
+    expect(logger.isSilent()).toBe(false);
     expect(logger.isTraceEnabled()).toBe(false);
+    expect(logger.isDebugEnabled()).toBe(true);
     expect(logger.isInfoEnabled()).toBe(true);
+    expect(logger.isLogEnabled()).toBe(true);
     expect(logger.isWarnEnabled()).toBe(true);
+    expect(logger.isErrorEnabled()).toBe(true);
   });
   it(`should set trace log level from settings`, async () => {
     const settings: ILoggerSettings = {
-      debugMode: false,
-      traceMode: true,
+      logLevel: LogLevel.TRACE,
     };
     const loggerFactory = new LoggerFactory(settings);
     const logger = loggerFactory.getLogger(`test`);
     expect(logger).toBeInstanceOf(Consola);
-    expect(logger.isDebugEnabled()).toBe(true);
+    expect(logger.isSilent()).toBe(false);
     expect(logger.isTraceEnabled()).toBe(true);
+    expect(logger.isDebugEnabled()).toBe(true);
     expect(logger.isInfoEnabled()).toBe(true);
+    expect(logger.isLogEnabled()).toBe(true);
     expect(logger.isWarnEnabled()).toBe(true);
+    expect(logger.isErrorEnabled()).toBe(true);
   });
 
-  it(`should not set debug log level from settings`, async () => {
+  it(`should not set info log level from settings`, async () => {
     const settings: ILoggerSettings = {
-      debugMode: false,
-      traceMode: false,
+      logLevel: LogLevel.INFO,
     };
     const loggerFactory = new LoggerFactory(settings);
     const logger = loggerFactory.getLogger(`test`);
+    expect(logger.isSilent()).toBe(false);
+    expect(logger.isTraceEnabled()).toBe(false);
+    expect(logger.isDebugEnabled()).toBe(false);
     expect(logger.isInfoEnabled()).toBe(true);
+    expect(logger.isLogEnabled()).toBe(true);
+    expect(logger.isWarnEnabled()).toBe(true);
+    expect(logger.isErrorEnabled()).toBe(true);
+  });
+
+  it(`should not set log log level from settings`, async () => {
+    const settings: ILoggerSettings = {
+      logLevel: LogLevel.LOG,
+    };
+    const loggerFactory = new LoggerFactory(settings);
+    const logger = loggerFactory.getLogger(`test`);
+    expect(logger.isSilent()).toBe(false);
+    expect(logger.isTraceEnabled()).toBe(false);
     expect(logger.isDebugEnabled()).toBe(false);
+    expect(logger.isInfoEnabled()).toBe(false);
+    expect(logger.isLogEnabled()).toBe(true);
+    expect(logger.isWarnEnabled()).toBe(true);
+    expect(logger.isErrorEnabled()).toBe(true);
+  });
+
+  it(`should not set warn log level from settings`, async () => {
+    const settings: ILoggerSettings = {
+      logLevel: LogLevel.WARN,
+    };
+    const loggerFactory = new LoggerFactory(settings);
+    const logger = loggerFactory.getLogger(`test`);
+    expect(logger.isSilent()).toBe(false);
     expect(logger.isTraceEnabled()).toBe(false);
+    expect(logger.isDebugEnabled()).toBe(false);
+    expect(logger.isInfoEnabled()).toBe(false);
+    expect(logger.isLogEnabled()).toBe(false);
     expect(logger.isWarnEnabled()).toBe(true);
+    expect(logger.isErrorEnabled()).toBe(true);
+  });
+
+  it(`should not set error log level from settings`, async () => {
+    const settings: ILoggerSettings = {
+      logLevel: LogLevel.ERROR,
+    };
+    const loggerFactory = new LoggerFactory(settings);
+    const logger = loggerFactory.getLogger(`test`);
+    expect(logger.isSilent()).toBe(false);
+    expect(logger.isTraceEnabled()).toBe(false);
+    expect(logger.isDebugEnabled()).toBe(false);
+    expect(logger.isInfoEnabled()).toBe(false);
+    expect(logger.isLogEnabled()).toBe(false);
+    expect(logger.isWarnEnabled()).toBe(false);
+    expect(logger.isErrorEnabled()).toBe(true);
+  });
+
+  it(`should not set silent log level from settings`, async () => {
+    const settings: ILoggerSettings = {
+      logLevel: LogLevel.SILENT,
+    };
+    const loggerFactory = new LoggerFactory(settings);
+    const logger = loggerFactory.getLogger(`test`);
+    expect(logger.isSilent()).toBe(true);
+    expect(logger.isTraceEnabled()).toBe(false);
+    expect(logger.isDebugEnabled()).toBe(false);
+    expect(logger.isInfoEnabled()).toBe(false);
+    expect(logger.isLogEnabled()).toBe(false);
+    expect(logger.isWarnEnabled()).toBe(false);
+    expect(logger.isErrorEnabled()).toBe(false);
   });
 
   it(`should cache logger`, async () => {
     const settings: ILoggerSettings = {
-      debugMode: true,
-      traceMode: false,
+      logLevel: undefined,
     };
     const loggerFactory = new LoggerFactory(settings);
     const logger1 = loggerFactory.getLogger(`test`);

diff --git a/tools/utils/logger.ts b/tools/utils/logger.ts
@@ -1,8 +1,8 @@
 import { LoggerFactory } from '../../src/utils/logger/impl/loggerFactory';
 import { ILoggerFactory, ILoggerSettings } from '../../src/utils/logger';
+import { LogLevel } from '../../src/utils/logger/interfaces/ILogger';
 
 export const loggerSettings: ILoggerSettings = {
-  debugMode: true,
-  traceMode: true,
+  logLevel: LogLevel.TRACE,
 };
 export const loggerFactory: ILoggerFactory = new LoggerFactory(loggerSettings);