Switch to using messaging and startable stoppable from NPM package (#7368)

* Add custom jest resolver to fix requiring "uuid" module Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Update dependencies Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Introduce test utils for rendering and running with thrown mobx reactions Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Extract startable-stoppable to NPM package Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Extract messaging to NPM package Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com> Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using startable-stoppable from NPM package Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using messaging from the Feature Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Remove old implementation of messaging Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Make setupping app paths happen earlier in renderer Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Fix typo Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Add kludge to make testing-library work properly from test-utils package Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Fix code style Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Add lint:fix -root script Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Fix unrelated failing unit tests Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Turn of no-floating-promises from typescript linting for being broken Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Make linting not happen for dist -directories Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Make linting failures appear as failure Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Stop running prettier twice It already gets ran as eslint-plugin. Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Make CI run unit tests for all packages by consolidating name of NPM script Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com> Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Add missing unit tests for coverage Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com> Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Skip coverage for test utils Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com> Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Remove check for coverage in packages which are not ready for it Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Stop collecting coverage from index.ts files them being indirections to the implementation Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com> Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Implement sending message to channel in main Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Add missing feature dependencies Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Add dummy implementations for requesting in main from renderer Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Re-enable communicating from main to cluster frames Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Ignore trivial files from coverage Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Update package-lock Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Extract message-bridge to separate NPM package to prevent dev dependencies being in the production bundle Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Extract computed channel to own NPM package for clear dependencies Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Consolidate electron related stuff to a directory Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Add missing publish configurations Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Ignore test implementation from coverage being not interesting Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> --------- Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>
2025-05-20 05:10:56 +00:00 · 2023-03-21 11:38:43 +02:00
1 parent df49ff9b96
commit 0f1f030a06
@@ -0,0 +1,5 @@
+export interface Channel<MessageTemplate = void, ReturnTemplate = void> {
+  id: string;
+  _messageTemplate?: MessageTemplate;
+  _returnTemplate?: ReturnTemplate;
+}
@@ -0,0 +1,18 @@
+import { autoRegister } from "@ogre-tools/injectable-extension-for-auto-registration";
+import { applicationFeature } from "@k8slens/application";
+import { getFeature } from "@k8slens/feature-core";
+
+export const messagingFeature = getFeature({
+  id: "messaging",
+
+  dependencies: [applicationFeature],
+
+  register: (di) => {
+    autoRegister({
+      di,
+      targetModule: module,
+
+      getRequireContexts: () => [require.context("./", true, /\.injectable\.(ts|tsx)$/)],
+    });
+  },
+});
@@ -0,0 +1,53 @@
+/* c8 ignore next */
+export { messagingFeature } from "./feature";
+
+export { getRequestChannel } from "./request/get-request-channel";
+export { getMessageChannel } from "./message/get-message-channel";
+
+export { requestFromChannelInjectionToken } from "./request/request-from-channel-injection-token";
+
+export type { Channel } from "./channel.no-coverage";
+
+export { sendMessageToChannelInjectionToken } from "./message/message-to-channel-injection-token";
+export type { SendMessageToChannel } from "./message/message-to-channel-injection-token";
+
+export type {
+  GetMessageChannelListenerInfo,
+  MessageChannel,
+  MessageChannelHandler,
+  MessageChannelListener,
+} from "./message/message-channel-listener-injection-token";
+
+export {
+  messageChannelListenerInjectionToken,
+  getMessageChannelListenerInjectable,
+} from "./message/message-channel-listener-injection-token";
+
+export type {
+  RequestChannel,
+  RequestChannelHandler,
+} from "./request/request-channel-listener-injection-token";
+
+export type {
+  RequestFromChannel,
+  ChannelRequester,
+} from "./request/request-from-channel-injection-token";
+
+export type { EnlistMessageChannelListener } from "./message/enlist-message-channel-listener-injection-token";
+export { enlistMessageChannelListenerInjectionToken } from "./message/enlist-message-channel-listener-injection-token";
+
+export type { EnlistRequestChannelListener } from "./request/enlist-request-channel-listener-injection-token";
+export { enlistRequestChannelListenerInjectionToken } from "./request/enlist-request-channel-listener-injection-token";
+
+export type { ListeningOfChannels } from "./listening-of-channels/listening-of-channels.injectable";
+export { listeningOfChannelsInjectionToken } from "./listening-of-channels/listening-of-channels.injectable";
+
+export type {
+  GetRequestChannelListenerInjectableInfo,
+  RequestChannelListener,
+} from "./request/request-channel-listener-injection-token";
+
+export {
+  getRequestChannelListenerInjectable,
+  requestChannelListenerInjectionToken,
+} from "./request/request-channel-listener-injection-token";
@@ -0,0 +1,106 @@
+import { getInjectable, getInjectionToken } from "@ogre-tools/injectable";
+import { enlistMessageChannelListenerInjectionToken } from "../message/enlist-message-channel-listener-injection-token";
+
+import { getStartableStoppable, StartableStoppable } from "@k8slens/startable-stoppable";
+
+import { computedInjectManyInjectable } from "@ogre-tools/injectable-extension-for-mobx";
+import { IComputedValue, reaction } from "mobx";
+
+import { messageChannelListenerInjectionToken } from "../message/message-channel-listener-injection-token";
+import { requestChannelListenerInjectionToken } from "../request/request-channel-listener-injection-token";
+import { enlistRequestChannelListenerInjectionToken } from "../request/enlist-request-channel-listener-injection-token";
+import type { Channel } from "../channel.no-coverage";
+
+export type ListeningOfChannels = StartableStoppable;
+export const listeningOfChannelsInjectionToken = getInjectionToken<ListeningOfChannels>({
+  id: "listening-of-channels-injection-token",
+});
+
+const listening = <T extends { id: string; channel: Channel<unknown> }>(
+  channelListeners: IComputedValue<T[]>,
+  enlistChannelListener: (listener: T) => () => void,
+  getId: (listener: T) => string,
+) => {
+  const listenerDisposers = new Map<string, () => void>();
+
+  const reactionDisposer = reaction(
+    () => channelListeners.get(),
+    (newValues, oldValues = []) => {
+      const addedListeners = newValues.filter(
+        (newValue) => !oldValues.some((oldValue) => oldValue.id === newValue.id),
+      );
+
+      const removedListeners = oldValues.filter(
+        (oldValue) => !newValues.some((newValue) => newValue.id === oldValue.id),
+      );
+
+      addedListeners.forEach((listener) => {
+        const id = getId(listener);
+
+        if (listenerDisposers.has(id)) {
+          throw new Error(
+            `Tried to add listener for channel "${listener.channel.id}" but listener already exists.`,
+          );
+        }
+
+        const disposer = enlistChannelListener(listener);
+
+        listenerDisposers.set(id, disposer);
+      });
+
+      removedListeners.forEach((listener) => {
+        const dispose = listenerDisposers.get(getId(listener));
+
+        dispose?.();
+
+        listenerDisposers.delete(getId(listener));
+      });
+    },
+
+    { fireImmediately: true },
+  );
+
+  return () => {
+    reactionDisposer();
+    listenerDisposers.forEach((dispose) => dispose());
+  };
+};
+
+const listeningOfChannelsInjectable = getInjectable({
+  id: "listening-of-channels",
+
+  instantiate: (di) => {
+    const enlistMessageChannelListener = di.inject(enlistMessageChannelListenerInjectionToken);
+
+    const enlistRequestChannelListener = di.inject(enlistRequestChannelListenerInjectionToken);
+
+    const computedInjectMany = di.inject(computedInjectManyInjectable);
+
+    const messageChannelListeners = computedInjectMany(messageChannelListenerInjectionToken);
+
+    const requestChannelListeners = computedInjectMany(requestChannelListenerInjectionToken);
+
+    return getStartableStoppable("listening-of-channels", () => {
+      const stopListeningOfMessageChannels = listening(
+        messageChannelListeners,
+        enlistMessageChannelListener,
+        (x) => x.id,
+      );
+
+      const stopListeningOfRequestChannels = listening(
+        requestChannelListeners,
+        enlistRequestChannelListener,
+        (x) => x.channel.id,
+      );
+
+      return () => {
+        stopListeningOfMessageChannels();
+        stopListeningOfRequestChannels();
+      };
+    });
+  },
+
+  injectionToken: listeningOfChannelsInjectionToken,
+});
+
+export default listeningOfChannelsInjectable;
@@ -0,0 +1,21 @@
+import { getInjectable } from "@ogre-tools/injectable";
+import { onLoadOfApplicationInjectionToken } from "@k8slens/application";
+import { listeningOfChannelsInjectionToken } from "./listening-of-channels.injectable";
+
+const startListeningOfChannelsInjectable = getInjectable({
+  id: "start-listening-of-channels",
+
+  instantiate: (di) => {
+    const listeningOfChannels = di.inject(listeningOfChannelsInjectionToken);
+
+    return {
+      run: async () => {
+        await listeningOfChannels.start();
+      },
+    };
+  },
+
+  injectionToken: onLoadOfApplicationInjectionToken,
+});
+
+export default startListeningOfChannelsInjectable;
@@ -0,0 +1,15 @@
+import { getInjectionToken } from "@ogre-tools/injectable";
+
+import type {
+  MessageChannel,
+  MessageChannelListener,
+} from "./message-channel-listener-injection-token";
+
+export type EnlistMessageChannelListener = (
+  listener: MessageChannelListener<MessageChannel<unknown>>,
+) => () => void;
+
+export const enlistMessageChannelListenerInjectionToken =
+  getInjectionToken<EnlistMessageChannelListener>({
+    id: "listening-to-a-message-channel",
+  });
@@ -0,0 +1,5 @@
+import type { MessageChannel } from "./message-channel-listener-injection-token";
+
+export const getMessageChannel = <Request>(id: string): MessageChannel<Request> => ({
+  id,
+});
@@ -0,0 +1,51 @@
+import type { DiContainerForInjection } from "@ogre-tools/injectable";
+import { getInjectable, getInjectionToken } from "@ogre-tools/injectable";
+
+export interface MessageChannel<Message> {
+  id: string;
+  _messageSignature?: Message;
+}
+
+export type ExtraData = { processId: number; frameId: number };
+
+export type MessageChannelHandler<Channel> = Channel extends MessageChannel<infer Message>
+  ? (message: Message, data: ExtraData) => void
+  : never;
+
+export interface MessageChannelListener<Channel> {
+  id: string;
+  channel: Channel;
+  handler: MessageChannelHandler<Channel>;
+}
+
+export const messageChannelListenerInjectionToken = getInjectionToken<
+  MessageChannelListener<MessageChannel<unknown>>
+>({
+  id: "message-channel-listener",
+});
+
+export interface GetMessageChannelListenerInfo<Channel extends MessageChannel<Message>, Message> {
+  id: string;
+  channel: Channel;
+  getHandler: (di: DiContainerForInjection) => MessageChannelHandler<Channel>;
+  causesSideEffects?: boolean;
+}
+
+export const getMessageChannelListenerInjectable = <
+  Channel extends MessageChannel<Message>,
+  Message,
+>(
+  info: GetMessageChannelListenerInfo<Channel, Message>,
+) =>
+  getInjectable({
+    id: `${info.channel.id}-message-listener-${info.id}`,
+
+    instantiate: (di): MessageChannelListener<Channel> => ({
+      id: `${info.channel.id}-message-listener-${info.id}`,
+      channel: info.channel,
+      handler: info.getHandler(di),
+    }),
+
+    injectionToken: messageChannelListenerInjectionToken,
+    causesSideEffects: info.causesSideEffects,
+  });
@@ -0,0 +1,11 @@
+import { getInjectionToken } from "@ogre-tools/injectable";
+import type { MessageChannel } from "./message-channel-listener-injection-token";
+
+export interface SendMessageToChannel {
+  (channel: MessageChannel<void>): void;
+  <Message>(channel: MessageChannel<Message>, message: Message): void;
+}
+
+export const sendMessageToChannelInjectionToken = getInjectionToken<SendMessageToChannel>({
+  id: "send-message-to-message-channel",
+});
@@ -0,0 +1,15 @@
+import { getInjectionToken } from "@ogre-tools/injectable";
+
+import type {
+  RequestChannel,
+  RequestChannelListener,
+} from "./request-channel-listener-injection-token";
+
+export type EnlistRequestChannelListener = (
+  listener: RequestChannelListener<RequestChannel<unknown, unknown>>,
+) => () => void;
+
+export const enlistRequestChannelListenerInjectionToken =
+  getInjectionToken<EnlistRequestChannelListener>({
+    id: "listening-to-a-request-channel",
+  });
@@ -0,0 +1,7 @@
+import type { RequestChannel } from "./request-channel-listener-injection-token";
+
+export const getRequestChannel = <Request, Response>(
+  id: string,
+): RequestChannel<Request, Response> => ({
+  id,
+});
@@ -0,0 +1,56 @@
+import type { DiContainerForInjection } from "@ogre-tools/injectable";
+import { getInjectable, getInjectionToken } from "@ogre-tools/injectable";
+
+export interface RequestChannel<Request, Response> {
+  id: string;
+  _requestSignature?: Request;
+  _responseSignature?: Response;
+}
+
+export type RequestChannelHandler<Channel> = Channel extends RequestChannel<
+  infer Request,
+  infer Response
+>
+  ? (req: Request) => Promise<Response> | Response
+  : never;
+
+export interface RequestChannelListener<Channel> {
+  id: string;
+  channel: Channel;
+  handler: RequestChannelHandler<Channel>;
+}
+
+export const requestChannelListenerInjectionToken = getInjectionToken<
+  RequestChannelListener<RequestChannel<unknown, unknown>>
+>({
+  id: "request-channel-listener",
+});
+
+export interface GetRequestChannelListenerInjectableInfo<
+  Channel extends RequestChannel<Request, Response>,
+  Request,
+  Response,
+> {
+  id: string;
+  channel: Channel;
+  getHandler: (di: DiContainerForInjection) => RequestChannelHandler<Channel>;
+}
+
+export const getRequestChannelListenerInjectable = <
+  Channel extends RequestChannel<Request, Response>,
+  Request,
+  Response,
+>(
+  info: GetRequestChannelListenerInjectableInfo<Channel, Request, Response>,
+) =>
+  getInjectable({
+    id: `${info.channel.id}-request-listener-${info.id}`,
+
+    instantiate: (di) => ({
+      id: `${info.channel.id}-request-listener-${info.id}`,
+      channel: info.channel,
+      handler: info.getHandler(di),
+    }),
+
+    injectionToken: requestChannelListenerInjectionToken,
+  });
@@ -0,0 +1,21 @@
+import { getInjectionToken } from "@ogre-tools/injectable";
+import type { RequestChannel } from "./request-channel-listener-injection-token";
+
+export interface RequestFromChannel {
+  <Request, Response>(
+    channel: RequestChannel<Request, Response>,
+    request: Request,
+  ): Promise<Response>;
+  <Response>(channel: RequestChannel<void, Response>): Promise<Response>;
+}
+
+export type ChannelRequester<Channel> = Channel extends RequestChannel<
+  infer Request,
+  infer Response
+>
+  ? (req: Request) => Promise<Awaited<Response>>
+  : never;
+
+export const requestFromChannelInjectionToken = getInjectionToken<RequestFromChannel>({
+  id: "request-from-request-channel",
+});
@@ -0,0 +1,18 @@
+import { autoRegister } from "@ogre-tools/injectable-extension-for-auto-registration";
+import { getFeature } from "@k8slens/feature-core";
+import { messagingFeature } from "../actual/feature";
+
+export const messagingFeatureForUnitTesting = getFeature({
+  id: "messaging-for-unit-testing",
+
+  dependencies: [messagingFeature],
+
+  register: (di) => {
+    autoRegister({
+      di,
+      targetModule: module,
+
+      getRequireContexts: () => [require.context("./", true, /\.injectable\.(ts|tsx)$/)],
+    });
+  },
+});
@@ -0,0 +1 @@
+export { messagingFeatureForUnitTesting } from "./feature";
@@ -0,0 +1,31 @@
+import { sendMessageToChannelInjectionToken } from "../actual/message/message-to-channel-injection-token";
+import { enlistMessageChannelListenerInjectionToken } from "../actual/message/enlist-message-channel-listener-injection-token";
+import { requestFromChannelInjectionToken } from "../actual/request/request-from-channel-injection-token";
+import { enlistRequestChannelListenerInjectionToken } from "../actual/request/enlist-request-channel-listener-injection-token";
+import { getInjectable } from "@ogre-tools/injectable";
+
+export const sendMessageToChannelStubInjectable = getInjectable({
+  id: "send-message-to-channel-stub",
+  /* c8 ignore next */
+  instantiate: () => () => {},
+  injectionToken: sendMessageToChannelInjectionToken,
+});
+
+export const enlistMessageChannelListenerStubInjectable = getInjectable({
+  id: "enlist-message-channel-listener-stub",
+  instantiate: () => () => () => {},
+  injectionToken: enlistMessageChannelListenerInjectionToken,
+});
+
+export const requestFromChannelStubInjectable = getInjectable({
+  id: "request-from-channel-stub",
+  /* c8 ignore next */
+  instantiate: () => () => Promise.resolve(),
+  injectionToken: requestFromChannelInjectionToken,
+});
+
+export const enlistRequestChannelListenerStubInjectable = getInjectable({
+  id: "enlist-request-channel-listener-stub",
+  instantiate: () => () => () => {},
+  injectionToken: enlistRequestChannelListenerInjectionToken,
+});
@@ -0,0 +1,169 @@
+import { createContainer, DiContainer, Injectable } from "@ogre-tools/injectable";
+
+import { registerFeature } from "@k8slens/feature-core";
+import { registerMobX } from "@ogre-tools/injectable-extension-for-mobx";
+import { runInAction } from "mobx";
+
+import {
+  EnlistMessageChannelListener,
+  enlistMessageChannelListenerInjectionToken,
+} from "./features/actual/message/enlist-message-channel-listener-injection-token";
+
+import { messagingFeatureForUnitTesting } from "./features/unit-testing";
+
+import {
+  getMessageChannelListenerInjectable,
+  MessageChannel,
+  MessageChannelListener,
+} from "./features/actual/message/message-channel-listener-injection-token";
+
+import { listeningOfChannelsInjectionToken } from "./features/actual/listening-of-channels/listening-of-channels.injectable";
+
+import { getMessageChannel } from "./features/actual/message/get-message-channel";
+import { applicationFeature, startApplicationInjectionToken } from "@k8slens/application";
+
+describe("listening-of-messages", () => {
+  let di: DiContainer;
+  let enlistMessageChannelListenerMock: jest.MockedFunction<EnlistMessageChannelListener>;
+  let disposeSomeListenerMock: jest.Mock;
+  let disposeSomeUnrelatedListenerMock: jest.Mock;
+
+  beforeEach(() => {
+    di = createContainer("irrelevant");
+
+    registerMobX(di);
+
+    disposeSomeListenerMock = jest.fn();
+    disposeSomeUnrelatedListenerMock = jest.fn();
+
+    enlistMessageChannelListenerMock = jest.fn((listener) =>
+      listener.id === "some-channel-id-message-listener-some-listener"
+        ? disposeSomeListenerMock
+        : disposeSomeUnrelatedListenerMock,
+    );
+
+    runInAction(() => {
+      registerFeature(di, applicationFeature, messagingFeatureForUnitTesting);
+    });
+
+    di.override(enlistMessageChannelListenerInjectionToken, () => enlistMessageChannelListenerMock);
+  });
+
+  describe("given listening of channels has not started yet", () => {
+    describe("when a new listener gets registered", () => {
+      let someChannel: MessageChannel<string>;
+      let someMessageHandler: () => void;
+
+      let someListenerInjectable: Injectable<
+        MessageChannelListener<MessageChannel<string>>,
+        MessageChannelListener<MessageChannel<unknown>>
+      >;
+
+      beforeEach(() => {
+        someChannel = getMessageChannel("some-channel-id");
+
+        someMessageHandler = () => {};
+
+        someListenerInjectable = getMessageChannelListenerInjectable({
+          id: "some-listener",
+          channel: someChannel,
+          getHandler: () => someMessageHandler,
+        });
+
+        runInAction(() => {
+          di.register(someListenerInjectable);
+        });
+      });
+
+      describe("when application is started", () => {
+        beforeEach(async () => {
+          const startApplication = di.inject(startApplicationInjectionToken);
+
+          await startApplication();
+        });
+
+        it("enlists a listener for the channel", () => {
+          expect(enlistMessageChannelListenerMock).toHaveBeenCalledWith({
+            id: "some-channel-id-message-listener-some-listener",
+            channel: someChannel,
+            handler: someMessageHandler,
+          });
+        });
+
+        describe("when another listener gets registered", () => {
+          let someOtherListenerInjectable: Injectable<
+            MessageChannelListener<MessageChannel<string>>,
+            MessageChannelListener<MessageChannel<unknown>>,
+            void
+          >;
+
+          beforeEach(() => {
+            const handler = () => someMessageHandler;
+
+            someOtherListenerInjectable = getMessageChannelListenerInjectable({
+              id: "some-other-listener",
+              channel: someChannel,
+              getHandler: handler,
+            });
+
+            enlistMessageChannelListenerMock.mockClear();
+
+            runInAction(() => {
+              di.register(someOtherListenerInjectable);
+            });
+          });
+
+          it("only enlists it as well", () => {
+            expect(enlistMessageChannelListenerMock.mock.calls).toEqual([
+              [
+                {
+                  id: "some-channel-id-message-listener-some-other-listener",
+                  channel: someChannel,
+                  handler: someMessageHandler,
+                },
+              ],
+            ]);
+          });
+
+          describe("when one of the listeners gets deregistered", () => {
+            beforeEach(() => {
+              runInAction(() => {
+                di.deregister(someListenerInjectable);
+              });
+            });
+
+            it("the listener gets disposed", () => {
+              expect(disposeSomeListenerMock).toHaveBeenCalled();
+            });
+
+            it("the unrelated listener does not get disposed", () => {
+              expect(disposeSomeUnrelatedListenerMock).not.toHaveBeenCalled();
+            });
+
+            describe("when listening of channels stops", () => {
+              beforeEach(() => {
+                const listening = di.inject(listeningOfChannelsInjectionToken);
+
+                listening.stop();
+              });
+
+              it("remaining listeners get disposed", () => {
+                expect(disposeSomeUnrelatedListenerMock).toHaveBeenCalled();
+              });
+
+              it("when yet another listener gets registered, does not enlist it", () => {
+                enlistMessageChannelListenerMock.mockClear();
+
+                runInAction(() => {
+                  di.register(someListenerInjectable);
+                });
+
+                expect(enlistMessageChannelListenerMock).not.toHaveBeenCalled();
+              });
+            });
+          });
+        });
+      });
+    });
+  });
+});
@@ -0,0 +1,204 @@
+import { createContainer, DiContainer, Injectable } from "@ogre-tools/injectable";
+
+import { registerFeature } from "@k8slens/feature-core";
+import { registerMobX } from "@ogre-tools/injectable-extension-for-mobx";
+import { _resetGlobalState, configure, runInAction } from "mobx";
+
+import {
+  EnlistRequestChannelListener,
+  enlistRequestChannelListenerInjectionToken,
+} from "./features/actual/request/enlist-request-channel-listener-injection-token";
+
+import { messagingFeatureForUnitTesting } from "./features/unit-testing";
+
+import {
+  getRequestChannelListenerInjectable,
+  RequestChannel,
+  RequestChannelListener,
+} from "./features/actual/request/request-channel-listener-injection-token";
+
+import { listeningOfChannelsInjectionToken } from "./features/actual/listening-of-channels/listening-of-channels.injectable";
+import { noop } from "lodash/fp";
+import { getRequestChannel } from "./features/actual/request/get-request-channel";
+import { applicationFeature, startApplicationInjectionToken } from "@k8slens/application";
+
+describe("listening-of-requests", () => {
+  let di: DiContainer;
+  let enlistRequestChannelListenerMock: jest.MockedFunction<EnlistRequestChannelListener>;
+  let disposeSomeListenerMock: jest.Mock;
+  let disposeSomeUnrelatedListenerMock: jest.Mock;
+
+  beforeEach(() => {
+    configure({
+      disableErrorBoundaries: false,
+    });
+
+    _resetGlobalState();
+
+    di = createContainer("irrelevant");
+
+    registerMobX(di);
+
+    disposeSomeListenerMock = jest.fn();
+    disposeSomeUnrelatedListenerMock = jest.fn();
+
+    enlistRequestChannelListenerMock = jest.fn((listener) =>
+      listener.id === "some-channel-id-request-listener-some-listener"
+        ? disposeSomeListenerMock
+        : disposeSomeUnrelatedListenerMock,
+    );
+
+    runInAction(() => {
+      registerFeature(di, applicationFeature, messagingFeatureForUnitTesting);
+    });
+
+    di.override(enlistRequestChannelListenerInjectionToken, () => enlistRequestChannelListenerMock);
+  });
+
+  describe("given listening of channels has not started yet", () => {
+    describe("when a new listener gets registered", () => {
+      let someChannel: RequestChannel<string, string>;
+      let someOtherChannel: RequestChannel<string, string>;
+      let someRequestHandler: () => string;
+
+      let someListenerInjectable: Injectable<
+        RequestChannelListener<RequestChannel<string, string>>,
+        RequestChannelListener<RequestChannel<unknown, unknown>>
+      >;
+
+      beforeEach(() => {
+        someChannel = getRequestChannel("some-channel-id");
+        someOtherChannel = getRequestChannel("some-other-channel-id");
+
+        someRequestHandler = () => "some-response";
+
+        someListenerInjectable = getRequestChannelListenerInjectable({
+          id: "some-listener",
+          channel: someChannel,
+          getHandler: () => someRequestHandler,
+        });
+
+        runInAction(() => {
+          di.register(someListenerInjectable);
+        });
+      });
+
+      describe("when application is started", () => {
+        beforeEach(async () => {
+          const startApplication = di.inject(startApplicationInjectionToken);
+
+          await startApplication();
+        });
+
+        it("enlists a listener for the channel", () => {
+          expect(enlistRequestChannelListenerMock).toHaveBeenCalledWith({
+            id: "some-channel-id-request-listener-some-listener",
+            channel: someChannel,
+            handler: someRequestHandler,
+          });
+        });
+
+        it("when another listener for same channel gets registered, throws", () => {
+          const originalConsoleWarn = console.warn;
+
+          console.warn = noop;
+
+          configure({
+            disableErrorBoundaries: true,
+          });
+
+          console.warn = originalConsoleWarn;
+
+          const handler = () => someRequestHandler;
+
+          const someConflictingListenerInjectable = getRequestChannelListenerInjectable({
+            id: "some-other-listener",
+            channel: someChannel,
+            getHandler: handler,
+          });
+
+          expect(() => {
+            runInAction(() => {
+              di.register(someConflictingListenerInjectable);
+            });
+          }).toThrow(
+            'Tried to add listener for channel "some-channel-id" but listener already exists.',
+          );
+        });
+
+        describe("when another listener gets registered", () => {
+          let someOtherListenerInjectable: Injectable<
+            RequestChannelListener<RequestChannel<string, string>>,
+            RequestChannelListener<RequestChannel<unknown, unknown>>
+          >;
+
+          beforeEach(() => {
+            const handler = () => someRequestHandler;
+
+            someOtherListenerInjectable = getRequestChannelListenerInjectable({
+              id: "some-other-listener",
+              channel: someOtherChannel,
+              getHandler: handler,
+            });
+
+            enlistRequestChannelListenerMock.mockClear();
+
+            runInAction(() => {
+              di.register(someOtherListenerInjectable);
+            });
+          });
+
+          it("only enlists it as well", () => {
+            expect(enlistRequestChannelListenerMock.mock.calls).toEqual([
+              [
+                {
+                  id: "some-other-channel-id-request-listener-some-other-listener",
+                  channel: someOtherChannel,
+                  handler: someRequestHandler,
+                },
+              ],
+            ]);
+          });
+
+          describe("when one of the listeners gets deregistered", () => {
+            beforeEach(() => {
+              runInAction(() => {
+                di.deregister(someListenerInjectable);
+              });
+            });
+
+            it("the listener gets disposed", () => {
+              expect(disposeSomeListenerMock).toHaveBeenCalled();
+            });
+
+            it("the unrelated listener does not get disposed", () => {
+              expect(disposeSomeUnrelatedListenerMock).not.toHaveBeenCalled();
+            });
+
+            describe("when listening of channels stops", () => {
+              beforeEach(() => {
+                const listening = di.inject(listeningOfChannelsInjectionToken);
+
+                listening.stop();
+              });
+
+              it("remaining listeners get disposed", () => {
+                expect(disposeSomeUnrelatedListenerMock).toHaveBeenCalled();
+              });
+
+              it("when yet another listener gets registered, does not enlist it", () => {
+                enlistRequestChannelListenerMock.mockClear();
+
+                runInAction(() => {
+                  di.register(someListenerInjectable);
+                });
+
+                expect(enlistRequestChannelListenerMock).not.toHaveBeenCalled();
+              });
+            });
+          });
+        });
+      });
+    });
+  });
+});
				`@@ -0,0 +1 @@`
				`export { messagingFeatureForUnitTesting } from "./feature";`