feat: Expose different ways to log as tokens, and add unit tests

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>
Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

packages/logger/index.ts

@@ -3,6 +3,15 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 
+export type { LogFunction } from "./src/logger.injectable";
+export {
+  logDebugInjectionToken,
+  logErrorInjectionToken,
+  logInfoInjectionToken,
+  logSillyInjectionToken,
+  logWarningInjectionToken,
+} from "./src/logger.injectable";
+
 export type { Logger } from "./src/logger";
 export { loggerInjectionToken } from "./src/logger.injectable";
 export { prefixedLoggerInjectable } from "./src/prefixed-logger.injectable";

packages/logger/package.json

@@ -25,6 +25,7 @@
   "homepage": "https://github.com/lensapp/lens",
   "scripts": {
     "build": "webpack",
+    "test:unit": "jest --coverage --runInBand",
     "lint": "lens-lint",
     "lint:fix": "lens-lint --fix"
   },
@@ -36,6 +37,7 @@
   },
   "devDependencies": {
     "@k8slens/eslint-config": "6.5.0-alpha.1",
-    "@k8slens/react-testing-library-discovery": "^1.0.0-alpha.4"
+    "@k8slens/react-testing-library-discovery": "^1.0.0-alpha.4",
+    "@k8slens/jest": "^6.5.0-alpha.5"
   }
 }

packages/logger/src/logger.injectable.ts

@@ -12,18 +12,66 @@ export const loggerInjectionToken = getInjectionToken<Logger>({
 
 export const loggerInjectable = getInjectable({
   id: "logger",
-  instantiate: (di): Logger => {
+  instantiate: (di): Logger => ({
-    const baseLogger = di.inject(winstonLoggerInjectable);
+    debug: di.inject(logDebugInjectionToken),
-
+    info: di.inject(logInfoInjectionToken),
-    return {
+    warn: di.inject(logWarningInjectionToken),
-      debug: (message, ...data) => baseLogger.debug(message, ...data),
+    error: di.inject(logErrorInjectionToken),
-      info: (message, ...data) => baseLogger.info(message, ...data),
+    silly: di.inject(logSillyInjectionToken),
-      warn: (message, ...data) => baseLogger.warn(message, ...data),
+  }),
-      error: (message, ...data) => baseLogger.error(message, ...data),
-      silly: (message, ...data) => baseLogger.silly(message, ...data),
-    };
-  },
 
   decorable: false,
   injectionToken: loggerInjectionToken,
 });
+
+export type LogFunction = (message: string, ...data: any[]) => void;
+
+export const logDebugInjectionToken = getInjectionToken<LogFunction>({
+  id: "log-debug-injection-token",
+});
+
+export const logInfoInjectionToken = getInjectionToken<LogFunction>({
+  id: "log-info-injection-token",
+});
+
+export const logWarningInjectionToken = getInjectionToken<LogFunction>({
+  id: "log-warning-injection-token",
+});
+
+export const logErrorInjectionToken = getInjectionToken<LogFunction>({
+  id: "log-error-injection-token",
+});
+
+export const logSillyInjectionToken = getInjectionToken<LogFunction>({
+  id: "log-silly-injection-token",
+});
+
+export const logDebugInjectable = getInjectable({
+  id: "log-debug",
+  instantiate: (di): LogFunction => di.inject(winstonLoggerInjectable).debug,
+  injectionToken: logDebugInjectionToken,
+});
+
+export const logInfoInjectable = getInjectable({
+  id: "log-info",
+  instantiate: (di): LogFunction => di.inject(winstonLoggerInjectable).info,
+  injectionToken: logInfoInjectionToken,
+});
+
+export const logWarningInjectable = getInjectable({
+  id: "log-warning",
+  instantiate: (di): LogFunction => di.inject(winstonLoggerInjectable).warn,
+  injectionToken: logWarningInjectionToken,
+});
+
+export const logErrorInjectable = getInjectable({
+  id: "log-error",
+  instantiate: (di): LogFunction => di.inject(winstonLoggerInjectable).error,
+  injectionToken: logErrorInjectionToken,
+});
+
+export const logSillyInjectable = getInjectable({
+  id: "log-silly",
+  instantiate: (di): LogFunction => di.inject(winstonLoggerInjectable).silly,
+  injectionToken: logSillyInjectionToken,
+});

packages/logger/src/logger.test.ts

@@ -0,0 +1,38 @@
+import { createContainer } from "@ogre-tools/injectable";
+import { registerFeature } from "@k8slens/feature-core";
+import { loggerFeature } from "./feature";
+import { winstonLoggerInjectable } from "./winston-logger.injectable";
+import {
+  logDebugInjectionToken, logErrorInjectionToken,
+  logInfoInjectionToken,
+  logSillyInjectionToken, logWarningInjectionToken,
+} from "./logger.injectable";
+
+describe("logger", () => {
+  [
+    { scenario: "debug", injectionToken: logDebugInjectionToken },
+    { scenario: "info", injectionToken: logInfoInjectionToken },
+    { scenario: "warn", injectionToken: logWarningInjectionToken },
+    { scenario: "error", injectionToken: logErrorInjectionToken },
+    { scenario: "silly", injectionToken: logSillyInjectionToken },
+  ].forEach(({ scenario, injectionToken }) => {
+    it(`when logging "${scenario}", does so`, () => {
+      const di = createContainer("irrelevant");
+
+      registerFeature(di, loggerFeature);
+
+      const winstonLoggerStub = { [scenario]: jest.fn() } as any;
+
+      di.override(winstonLoggerInjectable, () => winstonLoggerStub);
+
+      const logScenario = di.inject(injectionToken);
+
+      logScenario("some-message", "some-data");
+
+      expect(winstonLoggerStub[scenario]).toHaveBeenCalledWith(
+        "some-message",
+        "some-data"
+      );
+    });
+  });
+});