Fix other tests

Signed-off-by: Sebastian Malton <sebastian@malton.name>

src/common/cluster/cluster.ts

@@ -25,7 +25,6 @@ import type { CanI } from "./authorization-review.injectable";
 import type { ListNamespaces } from "./list-namespaces.injectable";
 import assert from "assert";
 import type { Logger } from "../logger";
-import type { ReadFileSync } from "../fs/read-file-sync.injectable";
 import type { EmitClusterConnectionUpdate } from "../../main/cluster/emit-connection-update.injectable";
 import type { CreateKubectl } from "../../main/kubectl/create-kubectl.injectable";
 
@@ -40,9 +39,6 @@ export interface ClusterDependencies {
   createListNamespaces: (config: KubeConfig) => ListNamespaces;
   createVersionDetector: (cluster: Cluster) => VersionDetector;
   emitClusterConnectionUpdate: EmitClusterConnectionUpdate;
-
-  // TODO: creating a Cluster should not have such wild side effects
-  readFileSync: ReadFileSync;
 }
 
 /**

src/features/cluster/connection-status.test.ts

@@ -4,15 +4,11 @@
  */
 
 import type { RenderResult } from "@testing-library/react";
-import type { ObservableMap } from "mobx";
-import { observable } from "mobx";
 import type { ClusterStore } from "../../common/cluster-store/cluster-store";
 import clusterStoreInjectable from "../../common/cluster-store/cluster-store.injectable";
-import type { ClusterId } from "../../common/cluster-types";
 import type { Cluster } from "../../common/cluster/cluster";
 import type { NavigateToClusterView } from "../../common/front-end-routing/routes/cluster-view/navigate-to-cluster-view.injectable";
 import navigateToClusterViewInjectable from "../../common/front-end-routing/routes/cluster-view/navigate-to-cluster-view.injectable";
-import clusterManagerInjectable from "../../main/cluster-manager.injectable";
 import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import createClusterInjectable from "../../main/create-cluster/create-cluster.injectable";
@@ -25,7 +21,6 @@ import type { ContextHandler } from "../../main/context-handler/context-handler"
 
 describe("cluster connection status", () => {
   let clusterStore: ClusterStore;
-  let clusters: ObservableMap<ClusterId, Cluster>;
   let cluster: Cluster;
   let cluster2: Cluster;
   let applicationBuilder: ApplicationBuilder;
@@ -35,26 +30,12 @@ describe("cluster connection status", () => {
   beforeEach(async () => {
     applicationBuilder = getApplicationBuilder();
 
-    applicationBuilder.dis.mainDi.override(clusterManagerInjectable, () => ({}));
     applicationBuilder.dis.mainDi.override(createKubeconfigManagerInjectable, () => () => ({} as KubeconfigManager));
     applicationBuilder.dis.mainDi.override(createKubectlInjectable, () => () => ({} as Kubectl));
     applicationBuilder.dis.mainDi.override(createContextHandlerInjectable, () => () => ({} as ContextHandler));
 
-    applicationBuilder.beforeApplicationStart(() => {
-      clusters = observable.map();
-      clusterStore = ({
-        clusters,
-        get clustersList() {
-          return [...clusters.values()];
-        },
-        getById: (id) => clusters.get(id),
-      }) as ClusterStore;
-
-      applicationBuilder.dis.mainDi.override(clusterStoreInjectable, () => clusterStore);
-      applicationBuilder.dis.rendererDi.override(clusterStoreInjectable, () => clusterStore);
-    });
-
     applicationBuilder.beforeRender(() => {
+      clusterStore = applicationBuilder.dis.mainDi.inject(clusterStoreInjectable);
       navigateToClusterView = applicationBuilder.dis.rendererDi.inject(navigateToClusterViewInjectable);
 
       const createCluster = applicationBuilder.dis.mainDi.inject(createClusterInjectable);
@@ -77,7 +58,7 @@ describe("cluster connection status", () => {
       });
       cluster2.activate = jest.fn(); // override for test
 
-      clusters.replace([
+      clusterStore.clusters.replace([
         [cluster.id, cluster],
         [cluster2.id, cluster2],
       ]);

src/main/__test__/kube-auth-proxy.test.ts

@@ -3,39 +3,11 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 
-jest.mock("winston", () => ({
-  format: {
-    colorize: jest.fn(),
-    combine: jest.fn(),
-    simple: jest.fn(),
-    label: jest.fn(),
-    timestamp: jest.fn(),
-    printf: jest.fn(),
-    padLevels: jest.fn(),
-    ms: jest.fn(),
-    splat: jest.fn(),
-  },
-  createLogger: jest.fn().mockReturnValue({
-    silly: jest.fn(),
-    debug: jest.fn(),
-    log: jest.fn(),
-    info: jest.fn(),
-    error: jest.fn(),
-    crit: jest.fn(),
-  }),
-  transports: {
-    Console: jest.fn(),
-    File: jest.fn(),
-  },
-}));
-
-jest.mock("../../common/ipc");
 jest.mock("child_process");
 jest.mock("tcp-port-used");
 
 import type { Cluster } from "../../common/cluster/cluster";
 import type { KubeAuthProxy } from "../kube-auth-proxy/kube-auth-proxy";
-import { broadcastMessage } from "../../common/ipc";
 import type { ChildProcess } from "child_process";
 import { spawn } from "child_process";
 import { Kubectl } from "../kubectl/kubectl";
@@ -59,10 +31,11 @@ import directoryForTempInjectable from "../../common/app-paths/directory-for-tem
 import normalizedPlatformInjectable from "../../common/vars/normalized-platform.injectable";
 import kubectlBinaryNameInjectable from "../kubectl/binary-name.injectable";
 import kubectlDownloadingNormalizedArchInjectable from "../kubectl/normalized-arch.injectable";
+import type { EmitClusterConnectionUpdate } from "../cluster/emit-connection-update.injectable";
+import emitClusterConnectionUpdateInjectable from "../cluster/emit-connection-update.injectable";
 
 console = new Console(stdout, stderr);
 
-const mockBroadcastIpc = broadcastMessage as jest.MockedFunction<typeof broadcastMessage>;
 const mockSpawn = spawn as jest.MockedFunction<typeof spawn>;
 const mockWaitUntilUsed = waitUntilUsed as jest.MockedFunction<typeof waitUntilUsed>;
 const clusterServerUrl = "https://192.168.64.3:8443";
@@ -70,6 +43,7 @@ const clusterServerUrl = "https://192.168.64.3:8443";
 describe("kube auth proxy tests", () => {
   let createCluster: CreateCluster;
   let createKubeAuthProxy: (cluster: Cluster, environmentVariables: NodeJS.ProcessEnv) => KubeAuthProxy;
+  let mockEmitClusterConnectionUpdate: jest.MockedFunction<EmitClusterConnectionUpdate>;
 
   beforeEach(async () => {
     jest.clearAllMocks();
@@ -102,9 +76,12 @@ describe("kube auth proxy tests", () => {
 
     const di = getDiForUnitTesting({ doGeneralOverrides: true });
 
+    mockEmitClusterConnectionUpdate = jest.fn();
+
     di.override(directoryForUserDataInjectable, () => "some-directory-for-user-data");
     di.override(directoryForTempInjectable, () => "some-directory-for-temp");
 
+    di.override(emitClusterConnectionUpdateInjectable, () => mockEmitClusterConnectionUpdate);
     di.override(spawnInjectable, () => mockSpawn);
     di.override(kubectlBinaryNameInjectable, () => "kubectl");
     di.override(kubectlDownloadingNormalizedArchInjectable, () => "amd64");
@@ -233,34 +210,49 @@ describe("kube auth proxy tests", () => {
       await proxy.run();
       listeners.emit("error", { message: "foobarbat" });
 
-      expect(mockBroadcastIpc).toBeCalledWith("cluster:connection-update", "some-cluster-id", { message: "foobarbat", isError: true });
+      expect(mockEmitClusterConnectionUpdate).toBeCalledWith({
+        clusterId: "some-cluster-id",
+        update: { message: "foobarbat", isError: true },
+      });
     });
 
     it("should call spawn and broadcast exit", async () => {
       await proxy.run();
       listeners.emit("exit", 0);
 
-      expect(mockBroadcastIpc).toBeCalledWith("cluster:connection-update", "some-cluster-id", { message: "proxy exited with code: 0", isError: false });
+      expect(mockEmitClusterConnectionUpdate).toBeCalledWith({
+        clusterId: "some-cluster-id",
+        update: { message: "proxy exited with code: 0", isError: false },
+      });
     });
 
     it("should call spawn and broadcast errors from stderr", async () => {
       await proxy.run();
       listeners.emit("stderr/data", "an error");
 
-      expect(mockBroadcastIpc).toBeCalledWith("cluster:connection-update", "some-cluster-id", { message: "an error", isError: true });
+      expect(mockEmitClusterConnectionUpdate).toBeCalledWith({
+        clusterId: "some-cluster-id",
+        update: { message: "an error", isError: true },
+      });
     });
 
     it("should call spawn and broadcast stdout serving info", async () => {
       await proxy.run();
 
-      expect(mockBroadcastIpc).toBeCalledWith("cluster:connection-update", "some-cluster-id", { message: "Authentication proxy started", isError: false });
+      expect(mockEmitClusterConnectionUpdate).toBeCalledWith({
+        clusterId: "some-cluster-id",
+        update: { message: "Authentication proxy started", isError: false },
+      });
     });
 
     it("should call spawn and broadcast stdout other info", async () => {
       await proxy.run();
       listeners.emit("stdout/data", "some info");
 
-      expect(mockBroadcastIpc).toBeCalledWith("cluster:connection-update", "some-cluster-id", { message: "some info", isError: false });
+      expect(mockEmitClusterConnectionUpdate).toBeCalledWith({
+        clusterId: "some-cluster-id",
+        update: { message: "some info", isError: false },
+      });
     });
   });
 });

src/main/__test__/kubeconfig-manager.test.ts

@@ -23,6 +23,7 @@ import directoryForUserDataInjectable from "../../common/app-paths/directory-for
 import normalizedPlatformInjectable from "../../common/vars/normalized-platform.injectable";
 import kubectlBinaryNameInjectable from "../kubectl/binary-name.injectable";
 import kubectlDownloadingNormalizedArchInjectable from "../kubectl/normalized-arch.injectable";
+import fsInjectable from "../../common/fs/fs.injectable";
 
 console = new Console(process.stdout, process.stderr); // fix mockFS
 
@@ -42,6 +43,7 @@ describe("kubeconfig manager tests", () => {
     di.override(kubectlBinaryNameInjectable, () => "kubectl");
     di.override(kubectlDownloadingNormalizedArchInjectable, () => "amd64");
     di.override(normalizedPlatformInjectable, () => "darwin");
+    di.permitSideEffects(fsInjectable); // still using mockFs
 
     loggerMock = {
       warn: jest.fn(),

src/main/cluster-manager.ts

@@ -12,7 +12,6 @@ import { apiKubePrefix } from "../common/vars";
 import { getClusterIdFromHost, isErrnoException } from "../common/utils";
 import type { KubernetesClusterPrometheusMetrics } from "../common/catalog-entities/kubernetes-cluster";
 import { isKubernetesCluster, KubernetesCluster, LensKubernetesClusterStatus } from "../common/catalog-entities/kubernetes-cluster";
-import { ipcMainOn } from "../common/ipc";
 import { once } from "lodash";
 import type { ClusterStore } from "../common/cluster-store/cluster-store";
 import type { ClusterId } from "../common/cluster-types";
@@ -74,9 +73,6 @@ export class ClusterManager {
         this.updateEntityStatus(this.dependencies.entityRegistry.findById(change.newValue) as KubernetesCluster);
       }
     });
-
-    ipcMainOn("network:offline", this.onNetworkOffline);
-    ipcMainOn("network:online", this.onNetworkOnline);
   });
 
   @action
@@ -235,7 +231,7 @@ export class ClusterManager {
     }
   }
 
-  protected onNetworkOffline = () => {
+  onNetworkOffline = () => {
     logger.info(`${logPrefix} network is offline`);
     this.dependencies.store.clustersList.forEach((cluster) => {
       if (!cluster.disconnected) {
@@ -246,7 +242,7 @@ export class ClusterManager {
     });
   };
 
-  protected onNetworkOnline = () => {
+  onNetworkOnline = () => {
     logger.info(`${logPrefix} network is online`);
     this.dependencies.store.clustersList.forEach((cluster) => {
       if (!cluster.disconnected) {

src/main/create-cluster/create-cluster.injectable.ts

@@ -15,7 +15,6 @@ import listNamespacesInjectable from "../../common/cluster/list-namespaces.injec
 import loggerInjectable from "../../common/logger.injectable";
 import detectorRegistryInjectable from "../cluster-detectors/detector-registry.injectable";
 import createVersionDetectorInjectable from "../cluster-detectors/create-version-detector.injectable";
-import readFileSyncInjectable from "../../common/fs/read-file-sync.injectable";
 import emitClusterConnectionUpdateInjectable from "../cluster/emit-connection-update.injectable";
 
 const createClusterInjectable = getInjectable({
@@ -32,7 +31,6 @@ const createClusterInjectable = getInjectable({
       logger: di.inject(loggerInjectable),
       detectorRegistry: di.inject(detectorRegistryInjectable),
       createVersionDetector: di.inject(createVersionDetectorInjectable),
-      readFileSync: di.inject(readFileSyncInjectable),
       emitClusterConnectionUpdate: di.inject(emitClusterConnectionUpdateInjectable),
     };
 

src/main/getDiForUnitTesting.ts

@@ -8,9 +8,6 @@ import type { DiContainer, Injectable } from "@ogre-tools/injectable";
 import { createContainer } from "@ogre-tools/injectable";
 import { Environments, setLegacyGlobalDiForExtensionApi } from "../extensions/as-legacy-globals-for-extension-api/legacy-global-di-for-extension-api";
 import appNameInjectable from "./app-paths/app-name/app-name.injectable";
-import writeJsonFileInjectable from "../common/fs/write-json-file.injectable";
-import readJsonFileInjectable from "../common/fs/read-json-file.injectable";
-import readFileInjectable from "../common/fs/read-file.injectable";
 import loggerInjectable from "../common/logger.injectable";
 import spawnInjectable from "./child-process/spawn.injectable";
 import extensionsStoreInjectable from "../extensions/extensions-store/extensions-store.injectable";
@@ -95,7 +92,7 @@ import { registerMobX } from "@ogre-tools/injectable-extension-for-mobx";
 import electronInjectable from "./utils/resolve-system-proxy/electron.injectable";
 import type { HotbarStore } from "../common/hotbars/store";
 import focusApplicationInjectable from "./electron-app/features/focus-application.injectable";
-import readFileSyncInjectable from "../common/fs/read-file-sync.injectable";
+import type { IpcMain } from "electron";
 import type { GlobalOverride } from "../common/test-utils/get-global-override";
 
 export function getDiForUnitTesting(opts: { doGeneralOverrides?: boolean } = {}) {
@@ -174,11 +171,7 @@ export function getDiForUnitTesting(opts: { doGeneralOverrides?: boolean } = {})
       listHelmReleasesInjectable,
       rollbackHelmReleaseInjectable,
       updateHelmReleaseInjectable,
-      writeJsonFileInjectable,
-      readJsonFileInjectable,
-      readFileInjectable,
       execFileInjectable,
-      readFileSyncInjectable,
     ]);
 
     // TODO: Remove usages of globally exported appEventBus to get rid of this
@@ -254,7 +247,9 @@ const overrideElectronFeatures = (di: DiContainer) => {
   di.override(shouldStartHiddenInjectable, () => false);
   di.override(showMessagePopupInjectable, () => () => {});
   di.override(waitForElectronToBeReadyInjectable, () => () => Promise.resolve());
-  di.override(ipcMainInjectable, () => ({}));
+  di.override(ipcMainInjectable, () => ({
+    on: jest.fn(),
+  } as Partial<IpcMain>));
   di.override(getElectronThemeInjectable, () => () => "dark");
   di.override(syncThemeFromOperatingSystemInjectable, () => ({ start: () => {}, stop: () => {} }));
   di.override(electronQuitAndInstallUpdateInjectable, () => () => {});

src/main/ipc/cluster-manager-ipc-listeners.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import clusterManagerInjectable from "../cluster-manager.injectable";
+import { beforeApplicationIsLoadingInjectionToken } from "../start-main-application/runnable-tokens/before-application-is-loading-injection-token";
+import ipcMainInjectable from "../utils/channel/ipc-main/ipc-main.injectable";
+
+const clusterManagerIpcNetworkListenersInjectable = getInjectable({
+  id: "cluster-manager-ipc-network-listeners",
+  instantiate: (di) => {
+    const manager = di.inject(clusterManagerInjectable);
+    const ipcMain = di.inject(ipcMainInjectable);
+
+    return {
+      run: () => {
+        ipcMain.on("network:offline", manager.onNetworkOffline);
+        ipcMain.on("network:online", manager.onNetworkOnline);
+      },
+    };
+  },
+  injectionToken: beforeApplicationIsLoadingInjectionToken,
+});
+
+export default clusterManagerIpcNetworkListenersInjectable;

src/main/kube-auth-proxy/kube-auth-proxy.ts

@@ -7,7 +7,6 @@ import type { ChildProcess } from "child_process";
 import { waitUntilUsed } from "tcp-port-used";
 import { randomBytes } from "crypto";
 import type { Cluster } from "../../common/cluster/cluster";
-import logger from "../logger";
 import { getPortFrom } from "../utils/get-port";
 import { makeObservable, observable, when } from "mobx";
 import type { SelfSignedCert } from "selfsigned";
@@ -106,13 +105,13 @@ export class KubeAuthProxy {
       onFind: () => this.cluster.broadcastConnectUpdate("Authentication proxy started"),
     });
 
-    logger.info(`[KUBE-AUTH-PROXY]: found port=${this._port}`);
+    this.dependencies.logger.info(`[KUBE-AUTH-PROXY]: found port=${this._port}`);
 
     try {
       await waitUntilUsed(this.port, 500, 10000);
       this.ready = true;
     } catch (error) {
-      logger.warn("[KUBE-AUTH-PROXY]: waitUntilUsed failed", error);
+      this.dependencies.logger.warn("[KUBE-AUTH-PROXY]: waitUntilUsed failed", error);
       this.cluster.broadcastConnectUpdate("Proxy port failed to be used within timelimit, restarting...", true);
       this.exit();
 
@@ -124,7 +123,7 @@ export class KubeAuthProxy {
     this.ready = false;
 
     if (this.proxyProcess) {
-      logger.debug("[KUBE-AUTH]: stopping local proxy", this.cluster.getMeta());
+      this.dependencies.logger.debug("[KUBE-AUTH]: stopping local proxy", this.cluster.getMeta());
       this.proxyProcess.removeAllListeners();
       this.proxyProcess.stderr?.removeAllListeners();
       this.proxyProcess.stdout?.removeAllListeners();

src/renderer/components/+preferences/extension-preference-model.injectable.ts

@@ -3,22 +3,36 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
+import type { IComputedValue } from "mobx";
 import { computed } from "mobx";
 import extensionPreferencesRouteInjectable from "../../../common/front-end-routing/routes/preferences/extension/extension-preferences-route.injectable";
 import rendererExtensionsInjectable from "../../../extensions/renderer-extensions.injectable";
 import routePathParametersInjectable from "../../routes/route-path-parameters.injectable";
+import type { RegisteredAppPreference } from "./app-preferences/app-preference-registration";
 import { getExtensionPreferenceItems } from "./get-extension-preference-items";
 
+export interface ExtensionPreferenceModel {
+  preferenceItems: RegisteredAppPreference[];
+  extensionName?: string;
+  preferencePageTitle: string;
+}
+
 const extensionPreferencesModelInjectable = getInjectable({
   id: "extension-preferences-model",
 
-  instantiate: (di) => {
+  instantiate: (di): IComputedValue<ExtensionPreferenceModel | null> => {
     const route = di.inject(extensionPreferencesRouteInjectable);
-    const pathParameters = di.inject(routePathParametersInjectable, route);
+    const pathParameters = di.inject(routePathParametersInjectable)(route);
     const extensions = di.inject(rendererExtensionsInjectable);
 
     return computed(() => {
-      const { extensionId, tabId } = pathParameters.get();
+      const params = pathParameters.get();
+
+      if (!params) {
+        return null;
+      }
+
+      const { extensionId, tabId } = params;
       const targetExtension = extensions.get().find((extension) => extension.sanitizedExtensionId === extensionId);
       const targetAppTab = targetExtension?.appPreferenceTabs.find(tab => tab.id === tabId);
       const preferencePageTitle = targetAppTab?.title || `${targetExtension?.manifest.name || "Extension"} preferences`;

src/renderer/components/+preferences/extensions.tsx

@@ -7,21 +7,23 @@ import { withInjectables } from "@ogre-tools/injectable-react";
 import type { IComputedValue } from "mobx";
 import { observer } from "mobx-react";
 import React from "react";
-import type { RegisteredAppPreference } from "./app-preferences/app-preference-registration";
+import type { ExtensionPreferenceModel } from "./extension-preference-model.injectable";
 import extensionPreferencesModelInjectable from "./extension-preference-model.injectable";
 import { ExtensionSettings } from "./extension-settings";
 import { Preferences } from "./preferences";
 
 interface Dependencies {
-  model: IComputedValue<{
+  model: IComputedValue<ExtensionPreferenceModel | null>;
-    preferenceItems: RegisteredAppPreference[];
-    extensionName?: string;
-    preferencePageTitle?: string;
-  }>;
 }
 
-const NonInjectedExtensions = ({ model }: Dependencies) => {
+const NonInjectedExtensions = observer(({ model }: Dependencies) => {
-  const { extensionName, preferenceItems, preferencePageTitle } = model.get();
+  const data = model.get();
+
+  if (!data) {
+    return null;
+  }
+
+  const { extensionName, preferenceItems, preferencePageTitle } = data;
 
   return (
     <Preferences data-testid="extension-preferences-page">
@@ -48,14 +50,10 @@ const NonInjectedExtensions = ({ model }: Dependencies) => {
       </section>
     </Preferences>
   );
-};
+});
 
-export const Extensions = withInjectables<Dependencies>(
+export const Extensions = withInjectables<Dependencies>(NonInjectedExtensions, {
-  observer(NonInjectedExtensions),
+  getProps: (di) => ({
-
+    model: di.inject(extensionPreferencesModelInjectable),
-  {
+  }),
-    getProps: (di) => ({
+});
-      model: di.inject(extensionPreferencesModelInjectable),
-    }),
-  },
-);

src/renderer/components/+preferences/preferences-navigation/extension-tab-preferences-navigation-item.injectable.ts

@@ -6,7 +6,6 @@ import { getInjectable } from "@ogre-tools/injectable";
 import { computed } from "mobx";
 import { map } from "lodash/fp";
 
-import routeIsActiveInjectable from "../../../routes/route-is-active.injectable";
 import { preferenceNavigationItemInjectionToken } from "./preference-navigation-items.injectable";
 
 import type { LensRendererExtension } from "../../../../extensions/lens-renderer-extension";
@@ -23,19 +22,20 @@ const extensionSpecificTabNavigationItemRegistratorInjectable = getInjectable({
   instantiate: (di) => {
     return (ext: LensExtension) => {
       const extension = ext as LensRendererExtension;
-      const navigateToExtensionPreferences = di.inject(
+      const navigateToExtensionPreferences = di.inject(navigateToExtensionPreferencesInjectable);
-        navigateToExtensionPreferencesInjectable,
-      );
       const route = di.inject(extensionPreferencesRouteInjectable);
-      const routeIsActive = di.inject(routeIsActiveInjectable, route);
+      const pathParameters = di.inject(routePathParametersInjectable)(route);
-      const pathParameters = di.inject(routePathParametersInjectable, route);
 
       return pipeline(
         extension.appPreferenceTabs,
 
         map((tab) => {
           const id = `extension-${extension.sanitizedExtensionId}-nav-item-${tab.id}`;
-          const isActive = computed(() => routeIsActive.get() && pathParameters.get().tabId === tab.id);
+          const isActive = computed(() => {
+            const params = pathParameters.get();
+
+            return params !== null && params.tabId === tab.id;
+          });
 
           return getInjectable({
             id,

src/renderer/components/+preferences/preferences-navigation/extensions-preferences-navigation-item-registrator.injectable.ts

@@ -8,7 +8,6 @@ import extensionPreferencesRouteInjectable from "../../../../common/front-end-ro
 import navigateToExtensionPreferencesInjectable from "../../../../common/front-end-routing/routes/preferences/extension/navigate-to-extension-preferences.injectable";
 import { extensionRegistratorInjectionToken } from "../../../../extensions/extension-loader/extension-registrator-injection-token";
 import type { LensRendererExtension } from "../../../../extensions/lens-renderer-extension";
-import routeIsActiveInjectable from "../../../routes/route-is-active.injectable";
 import routePathParametersInjectable from "../../../routes/route-path-parameters.injectable";
 import { preferenceNavigationItemInjectionToken } from "./preference-navigation-items.injectable";
 
@@ -28,9 +27,12 @@ const extensionPreferencesNavigationItemRegistratorInjectable = getInjectable({
       );
       const isVisible = computed(() => extensionHasPreferences && extensionHasGeneralPreferences);
       const extensionRoute = di.inject(extensionPreferencesRouteInjectable);
-      const pathParameters = di.inject(routePathParametersInjectable, extensionRoute);
+      const pathParameters = di.inject(routePathParametersInjectable)(extensionRoute);
-      const routeIsActive = di.inject(routeIsActiveInjectable, extensionRoute);
+      const isActive = computed(() => {
-      const isActive = computed(() => routeIsActive.get() && pathParameters.get().extensionId === extension.sanitizedExtensionId);
+        const params = pathParameters.get();
+
+        return params !== null && params.extensionId === extension.sanitizedExtensionId;
+      });
       const id = `extension-preferences-navigation-item-${extension.sanitizedExtensionId}`;
 
       const injectable = getInjectable({

src/renderer/create-cluster/create-cluster.injectable.ts

@@ -8,7 +8,6 @@ import { Cluster } from "../../common/cluster/cluster";
 import directoryForKubeConfigsInjectable from "../../common/app-paths/directory-for-kube-configs/directory-for-kube-configs.injectable";
 import { createClusterInjectionToken } from "../../common/cluster/create-cluster-injection-token";
 import loggerInjectable from "../../common/logger.injectable";
-import readFileSyncInjectable from "../../common/fs/read-file-sync.injectable";
 
 const createClusterInjectable = getInjectable({
   id: "create-cluster",
@@ -17,7 +16,6 @@ const createClusterInjectable = getInjectable({
     const dependencies: ClusterDependencies = {
       directoryForKubeConfigs: di.inject(directoryForKubeConfigsInjectable),
       logger: di.inject(loggerInjectable),
-      readFileSync: di.inject(readFileSyncInjectable),
 
       // TODO: Dismantle wrong abstraction
       // Note: "as never" to get around strictness in unnatural scenario