Behavioural tests and log file rename

Signed-off-by: Sami Tiilikainen <97873007+samitiilikainen@users.noreply.github.com>

packages/core/src/features/population-of-logs-to-a-file/population-of-logs-to-a-file.test.ts

@@ -0,0 +1,131 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { DiContainer } from "@ogre-tools/injectable";
+import winstonLoggerInjectable from "../../common/winston-logger.injectable";
+import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
+import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
+import type winston from "winston";
+import { MESSAGE } from "triple-beam";
+import { noop } from "@k8slens/utilities";
+import windowLocationInjectable from "../../common/k8s-api/window-location.injectable";
+import closeRendererLogFileInjectable from "../../renderer/logger/close-renderer-log-file.injectable";
+import createIpcFileLoggerTransportInjectable from "../../main/logger/create-ipc-file-transport.injectable";
+import browserLoggerTransportInjectable from "../../renderer/logger/browser-transport.injectable";
+import { runInAction } from "mobx";
+
+describe("Population of logs to a file", () => {
+  let builder: ApplicationBuilder;
+  let windowDi: DiContainer;
+  let logWarningInRenderer: (message: string, ...args: any) => void;
+  let frameSpecificWinstonLogInMainMock: jest.Mock;
+  let frameSpecificCloseLogInMainMock: jest.Mock;
+
+  async function setUpTestApplication({
+    testFileId,
+    isClusterFrame,
+  }: {
+    testFileId: string;
+    isClusterFrame: boolean;
+  }) {
+    builder = getApplicationBuilder();
+
+    if (isClusterFrame) {
+      builder.setEnvironmentToClusterFrame();
+    }
+
+    frameSpecificWinstonLogInMainMock = jest.fn();
+    frameSpecificCloseLogInMainMock = jest.fn();
+
+    builder.beforeApplicationStart(({ mainDi }) => {
+      mainDi.override(
+        createIpcFileLoggerTransportInjectable,
+        () => (fileId: string) =>
+          ({
+            log:
+              fileId === testFileId ? frameSpecificWinstonLogInMainMock : noop,
+            close:
+              fileId === testFileId ? frameSpecificCloseLogInMainMock : noop,
+          } as unknown as winston.transport),
+      );
+    });
+
+    builder.beforeWindowStart(({ windowDi }) => {
+      windowDi.unoverride(winstonLoggerInjectable);
+
+      // Now that we have the actual winston logger in use, let's not be noisy and deregister console transport
+      runInAction(() => {
+        windowDi.deregister(browserLoggerTransportInjectable);
+      });
+
+      if (isClusterFrame) {
+        windowDi.override(windowLocationInjectable, () => ({
+          host: "some-cluster.some-domain.localhost:irrelevant",
+          port: "irrelevant",
+        }));
+      }
+    });
+
+    await builder.render();
+    windowDi = builder.applicationWindow.only.di;
+    const winstonLogger = windowDi.inject(winstonLoggerInjectable);
+
+    logWarningInRenderer = winstonLogger.warn;
+  }
+
+  describe("given in root frame", () => {
+    beforeEach(async () => {
+      await setUpTestApplication({
+        testFileId: "renderer-root-frame",
+        isClusterFrame: false,
+      });
+    });
+
+    it("when logging a warning in renderer, writes to frame specific Winston log", async () => {
+      logWarningInRenderer("some-warning");
+      expect(frameSpecificWinstonLogInMainMock).toHaveBeenCalledWith(
+        {
+          level: "warn",
+          message: "some-warning",
+          [MESSAGE]: "warn: some-warning",
+        },
+        expect.any(Function),
+      );
+    });
+
+    it("when closing the renderer frame, closes specific log transport in main", () => {
+      const closeRendererLogFile = windowDi.inject(
+        closeRendererLogFileInjectable,
+      );
+
+      // Log something to create the transport to be closed
+      logWarningInRenderer("irrelevant");
+
+      closeRendererLogFile();
+
+      expect(frameSpecificCloseLogInMainMock).toHaveBeenCalled();
+    });
+  });
+
+  describe("given in cluster frame", () => {
+    beforeEach(async () => {
+      await setUpTestApplication({
+        testFileId: "renderer-cluster-some-cluster-frame",
+        isClusterFrame: true,
+      });
+    });
+
+    it("when logging a warning in renderer, writes to frame specific Winston log", async () => {
+      logWarningInRenderer("some-warning");
+      expect(frameSpecificWinstonLogInMainMock).toHaveBeenCalledWith(
+        {
+          level: "warn",
+          message: "some-warning",
+          [MESSAGE]: "warn: some-warning",
+        },
+        expect.any(Function),
+      );
+    });
+  });
+});

packages/core/src/main/logger/ipc-logging-listener.injectable.ts

@@ -2,11 +2,11 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import ipcFileLoggerInjectable from "./ipc-file-logger.injectable";
 import { getMessageChannelListenerInjectable } from "../../common/utils/channel/message-channel-listener-injection-token";
 import type { IpcFileLogObject } from "../../common/logger/ipc-file-logger-channel";
 import { ipcFileLoggerChannel } from "../../common/logger/ipc-file-logger-channel";
 import { MESSAGE } from "triple-beam";
+import ipcFileLoggerInjectable from "./ipc-file-logger.injectable";
 
 /**
  * Winston uses symbol property for the actual message.
@@ -29,10 +29,10 @@ const ipcFileLoggingListenerInjectable = getMessageChannelListenerInjectable({
   id: "ipc-file-logging",
   channel: ipcFileLoggerChannel,
   handler: (di) => {
-    const logger = di.inject(ipcFileLoggerInjectable);
+    const ipcFileLogger = di.inject(ipcFileLoggerInjectable);
 
     return (ipcFileLogObject) =>
-      logger.log(deserializeLogFromIpc(ipcFileLogObject));
+      ipcFileLogger.log(deserializeLogFromIpc(ipcFileLogObject));
   },
 });
 

packages/core/src/renderer/logger/close-renderer-log-file-id.test.ts

@@ -33,17 +33,6 @@ describe("close renderer file logging", () => {
     di.override(ipcLogTransportInjectable, () => ipcTransportMock);
   });
 
-  it("sends the ipc close message with correct log id", () => {
-    const closeLog = di.inject(closeRendererLogFileInjectable);
-
-    closeLog();
-
-    expect(sendIpcMock).toHaveBeenCalledWith(
-      { id: "close-ipc-file-logger-channel" },
-      "some-log-id",
-    );
-  });
-
   it("removes the transport to prevent further logging to closed file", () => {
     const closeLog = di.inject(closeRendererLogFileInjectable);
 

packages/core/src/renderer/logger/renderer-log-file-id.injectable.ts

@@ -19,10 +19,10 @@ const rendererLogFileIdInjectable = getInjectable({
 
       frameId = `cluster-${clusterId}`;
     } else {
-      frameId = "main";
+      frameId = "root";
     }
 
-    return `renderer-${frameId}`;
+    return `renderer-${frameId}-frame`;
   },
 });
 

packages/core/src/renderer/logger/renderer-log-file-id.test.ts

@@ -1,34 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import windowLocationInjectable from "../../common/k8s-api/window-location.injectable";
-import { getDiForUnitTesting } from "../getDiForUnitTesting";
-import currentlyInClusterFrameInjectable from "../routes/currently-in-cluster-frame.injectable";
-import rendererLogFileIdInjectable from "./renderer-log-file-id.injectable";
-
-describe("renderer log file id", () => {
-
-  it("clearly names log for renderer main frame", () => {
-    const di = getDiForUnitTesting();
-
-    di.override(currentlyInClusterFrameInjectable, () => false);
-
-    const mainFileId = di.inject(rendererLogFileIdInjectable);
-
-    expect(mainFileId).toBe("renderer-main");
-  });
-
-  it("includes cluster id in renderer log file names", () => {
-    const di = getDiForUnitTesting();
-
-    di.override(currentlyInClusterFrameInjectable, () => true);
-    di.override(windowLocationInjectable, () => ({
-      host: "some-cluster.lens.app",
-      port: "irrelevant",
-    }));
-    const clusterFileId = di.inject(rendererLogFileIdInjectable);
-
-    expect(clusterFileId).toBe("renderer-cluster-some-cluster");
-  });
-});