Make HTML element discovery require less parameters

Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com>

Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>

src/features/preferences/extension-adding-preference-tabs.test.tsx

@@ -7,7 +7,8 @@ import type { IObservableValue } from "mobx";
 import { runInAction, computed, observable } from "mobx";
 import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
-import { getSingleElement, queryAllElements, querySingleElement } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import type { Discover } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import { discoverFor } from "../../renderer/components/test-utils/discovery-of-html-elements";
 import React from "react";
 
 describe("preferences: extension adding preference tabs", () => {
@@ -20,10 +21,13 @@ describe("preferences: extension adding preference tabs", () => {
   describe("given in preferences, when extension with preference tabs is enabled", () => {
     let rendered: RenderResult;
     let someObservable: IObservableValue<boolean>;
+    let discover: Discover;
 
     beforeEach(async () => {
       rendered = await builder.render();
 
+      discover = discoverFor(() => rendered);
+
       builder.preferences.navigate();
 
       someObservable = observable.box(false);
@@ -95,11 +99,11 @@ describe("preferences: extension adding preference tabs", () => {
     });
 
     it("shows tabs in order", () => {
-      const actual = queryAllElements("preference-tab-link")(
+      const actual = discover
-        rendered,
+        .queryAllElements("preference-tab-link")
-      ).attributeValues.filter((value) =>
+        .attributeValues.filter((value) =>
-        value?.startsWith("extension-some-extension"),
+          value?.startsWith("extension-some-extension"),
-      );
+        );
 
       expect(actual).toEqual([
         "extension-some-extension-some-other-preference-tab-id",
@@ -108,12 +112,12 @@ describe("preferences: extension adding preference tabs", () => {
     });
 
     it("does not show hidden tab", () => {
-      const actual = querySingleElement(
+      const { discovered } = discover.querySingleElement(
         "preference-tab-link",
         "extension-some-extension-some-preference-tab-id-with-controlled-visibility",
-      )(rendered);
+      );
 
-      expect(actual).toBeNull();
+      expect(discovered).toBeNull();
     });
 
     it("when item becomes visible, shows the tab", () => {
@@ -121,12 +125,12 @@ describe("preferences: extension adding preference tabs", () => {
         someObservable.set(true);
       });
 
-      const actual = getSingleElement(
+      const { discovered } = discover.getSingleElement(
         "preference-tab-link",
         "extension-some-extension-some-preference-tab-id-with-controlled-visibility",
-      )(rendered);
+      );
 
-      expect(actual).not.toBeNull();
+      expect(discovered).not.toBeNull();
     });
   });
 });

src/features/preferences/hiding-of-empty-branches.test.tsx

@@ -10,18 +10,22 @@ import { runInAction } from "mobx";
 import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import { preferenceItemInjectionToken } from "./renderer/preference-items/preference-item-injection-token";
-import { getSingleElement, querySingleElement } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import type { Discover } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import { discoverFor } from "../../renderer/components/test-utils/discovery-of-html-elements";
 
 describe("preferences - hiding-of-empty-branches, given in preferences page", () => {
   let builder: ApplicationBuilder;
   let rendered: RenderResult;
   let windowDi: DiContainer;
+  let discover: Discover;
 
   beforeEach(async () => {
     builder = getApplicationBuilder();
 
     rendered = await builder.render();
 
+    discover = discoverFor(() => rendered);
+
     builder.preferences.navigate();
 
     windowDi = builder.applicationWindow.only.di;
@@ -87,25 +91,24 @@ describe("preferences - hiding-of-empty-branches, given in preferences page", ()
     });
 
     it("does not render the empty tab group", () => {
-      const someTabGroup = querySingleElement(
+      const { discovered } = discover.querySingleElement(
         "preference-tab-group",
         "some-tab-group",
-      )(rendered);
+      );
 
-      expect(someTabGroup).toBeNull();
+      expect(discovered).toBeNull();
     });
 
     it("does not render the empty tabs", () => {
-      const someTab = querySingleElement(
+      const { discovered: someTab } = discover.querySingleElement(
         "preference-tab-link",
         "some-path-id-for-some-tab-id",
-      )(rendered);
+      );
 
-      const someOtherTab = querySingleElement(
+      const { discovered: someOtherTab } = discover.querySingleElement(
         "preference-tab-link",
         "some-path-id-for-some-other-tab-id",
-      )(rendered);
+      );
-
 
       expect([someTab, someOtherTab]).toEqual([null, null]);
     });
@@ -137,30 +140,30 @@ describe("preferences - hiding-of-empty-branches, given in preferences page", ()
       });
 
       it("renders the tab group that is no longer empty", () => {
-        const someTabGroup = querySingleElement(
+        const { discovered } = discover.querySingleElement(
           "preference-tab-group",
           "some-tab-group",
-        )(rendered);
+        );
 
-        expect(someTabGroup).not.toBeNull();
+        expect(discovered).not.toBeNull();
       });
 
       it("renders the tab that is no longer empty", () => {
-        const someTab = getSingleElement(
+        const { discovered } = discover.getSingleElement(
           "preference-tab-link",
           "some-path-id-for-some-tab-id",
-        )(rendered);
+        );
 
-        expect(someTab).not.toBeNull();
+        expect(discovered).not.toBeNull();
       });
 
       it("does not render the tab that is still empty", () => {
-        const someTab = querySingleElement(
+        const { discovered } = discover.querySingleElement(
           "preference-tab-link",
           "some-path-id-for-some-other-tab-id",
-        )(rendered);
+        );
 
-        expect(someTab).toBeNull();
+        expect(discovered).toBeNull();
       });
 
       describe("when an item appears for the remaining tab", () => {
@@ -190,30 +193,30 @@ describe("preferences - hiding-of-empty-branches, given in preferences page", ()
         });
 
         it("still renders the tab group that is not empty", () => {
-          const someTabGroup = getSingleElement(
+          const { discovered } = discover.getSingleElement(
             "preference-tab-group",
             "some-tab-group",
-          )(rendered);
+          );
 
-          expect(someTabGroup).not.toBeNull();
+          expect(discovered).not.toBeNull();
         });
 
         it("still renders the tab that is not empty", () => {
-          const someTab = getSingleElement(
+          const { discovered } = discover.getSingleElement(
             "preference-tab-link",
             "some-path-id-for-some-tab-id",
-          )(rendered);
+          );
 
-          expect(someTab).not.toBeNull();
+          expect(discovered).not.toBeNull();
         });
 
         it("now renders the other tab that is no longer empty", () => {
-          const someTab = getSingleElement(
+          const { discovered } = discover.getSingleElement(
             "preference-tab-link",
             "some-path-id-for-some-other-tab-id",
-          )(rendered);
+          );
 
-          expect(someTab).not.toBeNull();
+          expect(discovered).not.toBeNull();
         });
       });
     });

src/features/preferences/navigation-to-application-preferences.test.ts

@@ -6,7 +6,8 @@ import type { RenderResult } from "@testing-library/react";
 import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import navigateToProxyPreferencesInjectable from "./common/navigate-to-proxy-preferences.injectable";
-import { getSingleElement, querySingleElement } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import type { Discover } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import { discoverFor } from "../../renderer/components/test-utils/discovery-of-html-elements";
 
 describe("preferences - navigation to application preferences", () => {
   let builder: ApplicationBuilder;
@@ -17,6 +18,7 @@ describe("preferences - navigation to application preferences", () => {
 
   describe("given in some child page of preferences, when rendered", () => {
     let rendered: RenderResult;
+    let discover: Discover;
 
     beforeEach(async () => {
       builder.beforeWindowStart((windowDi) => {
@@ -26,6 +28,8 @@ describe("preferences - navigation to application preferences", () => {
       });
 
       rendered = await builder.render();
+
+      discover = discoverFor(() => rendered);
     });
 
     it("renders", () => {
@@ -33,12 +37,12 @@ describe("preferences - navigation to application preferences", () => {
     });
 
     it("does not show application preferences yet", () => {
-      const page = querySingleElement(
+      const { discovered } = discover.querySingleElement(
         "preference-page",
         "application-page",
-      )(rendered);
+      );
 
-      expect(page).toBeNull();
+      expect(discovered).toBeNull();
     });
 
     describe("when navigating to application preferences using navigation", () => {
@@ -51,12 +55,12 @@ describe("preferences - navigation to application preferences", () => {
       });
 
       it("shows application preferences", () => {
-        const page = getSingleElement(
+        const { discovered } = discover.getSingleElement(
           "preference-page",
           "application-page",
-        )(rendered);
+        );
 
-        expect(page).not.toBeNull();
+        expect(discovered).not.toBeNull();
       });
     });
 
@@ -70,12 +74,12 @@ describe("preferences - navigation to application preferences", () => {
       });
 
       it("shows tab for application preferences for it being the default", () => {
-        const page = getSingleElement(
+        const { discovered } = discover.getSingleElement(
           "preference-page",
           "application-page",
-        )(rendered);
+        );
 
-        expect(page).not.toBeNull();
+        expect(discovered).not.toBeNull();
       });
     });
   });

src/features/preferences/navigation-to-editor-preferences.test.ts

@@ -5,10 +5,12 @@
 import type { RenderResult } from "@testing-library/react";
 import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
-import { getSingleElement, querySingleElement } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import type { Discover } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import { discoverFor } from "../../renderer/components/test-utils/discovery-of-html-elements";
 
 describe("preferences - navigation to editor preferences", () => {
   let applicationBuilder: ApplicationBuilder;
+  let discover: Discover;
 
   beforeEach(() => {
     applicationBuilder = getApplicationBuilder();
@@ -23,18 +25,20 @@ describe("preferences - navigation to editor preferences", () => {
       });
 
       rendered = await applicationBuilder.render();
+
+      discover = discoverFor(() => rendered);
     });
 
     it("renders", () => {
       expect(rendered.container).toMatchSnapshot();
     });
     it("does not show editor preferences yet", () => {
-      const page = querySingleElement(
+      const { discovered } = discover.querySingleElement(
         "preference-page",
         "editor-page",
-      )(rendered);
+      );
 
-      expect(page).toBeNull();
+      expect(discovered).toBeNull();
     });
 
     describe("when navigating to editor preferences using navigation", () => {
@@ -47,10 +51,10 @@ describe("preferences - navigation to editor preferences", () => {
       });
 
       it("shows editor preferences", () => {
-        const page = getSingleElement(
+        const page = discover.getSingleElement(
           "preference-page",
           "editor-page",
-        )(rendered);
+        );
 
         expect(page).not.toBeNull();
       });

src/features/preferences/navigation-to-extension-specific-preferences.test.tsx

@@ -8,7 +8,8 @@ import { getApplicationBuilder } from "../../renderer/components/test-utils/get-
 import React from "react";
 import "@testing-library/jest-dom/extend-expect";
 import type { FakeExtensionOptions } from "../../renderer/components/test-utils/get-extension-fake";
-import { getSingleElement, queryAllElements, querySingleElement } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import type { Discover } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import { discoverFor } from "../../renderer/components/test-utils/discovery-of-html-elements";
 import logErrorInjectable from "../../common/log-error.injectable";
 
 describe("preferences - navigation to extension specific preferences", () => {
@@ -21,6 +22,7 @@ describe("preferences - navigation to extension specific preferences", () => {
   describe("given in preferences, when rendered", () => {
     let rendered: RenderResult;
     let logErrorMock: jest.Mock;
+    let discover: Discover;
 
     beforeEach(async () => {
       logErrorMock = jest.fn();
@@ -32,6 +34,8 @@ describe("preferences - navigation to extension specific preferences", () => {
       });
 
       rendered = await builder.render();
+
+      discover = discoverFor(() => rendered);
     });
 
     it("renders", () => {
@@ -40,9 +44,12 @@ describe("preferences - navigation to extension specific preferences", () => {
 
     it("does not show extension preferences yet", () => {
       // Todo: check if query is correct.
-      const page = querySingleElement("preference-page", "extension")(rendered);
+      const { discovered } = discover.querySingleElement(
+        "preference-page",
+        "extension",
+      );
 
-      expect(page).toBeNull();
+      expect(discovered).toBeNull();
     });
 
     it("does not show link for extension preferences", () => {
@@ -68,21 +75,21 @@ describe("preferences - navigation to extension specific preferences", () => {
       });
 
       it("doesn't show preferences from unrelated extension", () => {
-        const actual = querySingleElement(
+        const { discovered } = discover.querySingleElement(
           "preference-page",
           "preference-item-for-extension-some-other-test-extension-id-page",
-        )(rendered);
+        );
 
-        expect(actual).toBeNull();
+        expect(discovered).toBeNull();
       });
 
       it("shows preferences from related extension", () => {
-        const actual = getSingleElement(
+        const { discovered } = discover.getSingleElement(
           "preference-page",
           "preference-item-for-extension-some-test-extension-id-page",
-        )(rendered);
+        );
 
-        expect(actual).not.toBeNull();
+        expect(discovered).not.toBeNull();
       });
     });
 
@@ -118,12 +125,12 @@ describe("preferences - navigation to extension specific preferences", () => {
       });
 
       it("link should not be active", () => {
-        const actual = getSingleElement(
+        const { discovered } = discover.getSingleElement(
           "preference-tab-link",
           "some-test-extension-id",
-        )(rendered);
+        );
 
-        expect(actual).not.toHaveClass("active");
+        expect(discovered).not.toHaveClass("active");
       });
 
       describe("when navigating to extension preferences using navigation", () => {
@@ -136,25 +143,27 @@ describe("preferences - navigation to extension specific preferences", () => {
         });
 
         it("shows proper page title", () => {
-          const title = getSingleElement("preference-page-title")(rendered);
+          const { discovered } = discover.getSingleElement("preference-page-title");
 
-          expect(title).toHaveTextContent("some-test-extension-id preferences");
+          expect(discovered).toHaveTextContent("some-test-extension-id preferences");
         });
 
         it("shows only extension specific preference items", () => {
-          const actual = queryAllElements(
+          const { attributeValues } =
-            "preference-item",
+            discover.queryAllElements("preference-item");
-          )(rendered).attributeValues;
 
-          expect(actual).toEqual([
+          expect(attributeValues).toEqual([
             "preference-item-for-extension-some-test-extension-id-item-some-preference-item-id",
           ]);
         });
 
         it("link is active", () => {
-          const actual = getSingleElement("preference-tab-link", "some-test-extension-id")(rendered);
+          const { discovered } = discover.getSingleElement(
+            "preference-tab-link",
+            "some-test-extension-id",
+          );
 
-          expect(actual).toHaveClass("active");
+          expect(discovered).toHaveClass("active");
         });
 
         describe("when extension is disabled", () => {
@@ -167,20 +176,20 @@ describe("preferences - navigation to extension specific preferences", () => {
           });
 
           it("does not show any preference page", () => {
-            const actual = querySingleElement("preference-page")(rendered);
+            const { discovered } = discover.querySingleElement("preference-page");
 
-            expect(actual).toBeNull();
+            expect(discovered).toBeNull();
           });
 
           it("when extension is enabled again, shows the preference page", () => {
             builder.extensions.enable(extensionStubWithExtensionSpecificPreferenceItems);
 
-            const actual = getSingleElement(
+            const { discovered } = discover.getSingleElement(
               "preference-page",
               "preference-item-for-extension-some-test-extension-id-page",
-            )(rendered);
+            );
 
-            expect(actual).not.toBeNull();
+            expect(discovered).not.toBeNull();
           });
         });
       });
@@ -204,26 +213,23 @@ describe("preferences - navigation to extension specific preferences", () => {
       });
 
       it("shows extension tab in general area", () => {
-        const generalTabGroup = getSingleElement(
+        const { discovered } = discover
-          "preference-tab-group",
+          .getSingleElement("preference-tab-group", "general-tab-group")
-          "general-tab-group",
+          .getSingleElement(
-        )(rendered);
+            "preference-tab-link",
+            "extension-registered-tab-page-id-metrics-extension-tab",
+          );
 
-        const actual = getSingleElement(
+        expect(discovered).not.toBeNull();
-          "preference-tab-link",
-          "extension-registered-tab-page-id-metrics-extension-tab",
-        )(generalTabGroup);
-
-        expect(actual).not.toBeNull();
       });
 
       it("does not show tab group for extensions for there being no content", () => {
-        const actual = querySingleElement(
+        const { discovered } = discover.querySingleElement(
           "preference-tab-group",
           "extensions-tab-group",
-        )(rendered);
+        );
 
-        expect(actual).toBeNull();
+        expect(discovered).toBeNull();
       });
 
       describe("when navigating to specific extension tab", () => {
@@ -248,9 +254,11 @@ describe("preferences - navigation to extension specific preferences", () => {
         });
 
         it("shows correct page title", () => {
-          const pageTitle = getSingleElement("preference-page-title")(rendered);
+          const { discovered } = discover.getSingleElement(
+            "preference-page-title",
+          );
 
-          expect(pageTitle).toHaveTextContent("Metrics tab");
+          expect(discovered).toHaveTextContent("Metrics tab");
         });
       });
     });
@@ -264,21 +272,21 @@ describe("preferences - navigation to extension specific preferences", () => {
       });
 
       it("shows tab from the first extension", () => {
-        const actual = getSingleElement(
+        const { discovered } = discover.getSingleElement(
           "preference-tab-link",
           "extension-registered-tab-page-id-metrics-extension-tab",
-        )(rendered);
+        );
 
-        expect(actual).toBeInTheDocument();
+        expect(discovered).toBeInTheDocument();
       });
 
       it("shows tab from the second extension", () => {
-        const actual = getSingleElement(
+        const { discovered } = discover.getSingleElement(
           "preference-tab-link",
           "extension-duplicated-tab-page-id-metrics-extension-tab",
-        )(rendered);
+        );
 
-        expect(actual).toBeInTheDocument();
+        expect(discovered).toBeInTheDocument();
       });
 
       describe("when navigating to first extension tab", () => {
@@ -293,10 +301,9 @@ describe("preferences - navigation to extension specific preferences", () => {
         });
 
         it("shows related preferences for this tab", () => {
-          const actual =
+          const { attributeValues } = discover.queryAllElements("preference-item");
-            queryAllElements("preference-item")(rendered).attributeValues;
 
-          expect(actual).toEqual([
+          expect(attributeValues).toEqual([
             "preference-item-for-extension-registered-tab-page-id-item-metrics-preference-item-id",
           ]);
         });
@@ -314,10 +321,10 @@ describe("preferences - navigation to extension specific preferences", () => {
         });
 
         it("shows related preferences for this tab", () => {
-          const actual =
+          const { attributeValues } =
-            queryAllElements("preference-item")(rendered).attributeValues;
+            discover.queryAllElements("preference-item");
 
-          expect(actual).toEqual([
+          expect(attributeValues).toEqual([
             "preference-item-for-extension-duplicated-tab-page-id-item-another-metrics-preference-item-id",
           ]);
         });

src/features/preferences/navigation-to-kubernetes-preferences.test.ts

@@ -7,7 +7,8 @@ import type { ApplicationBuilder } from "../../renderer/components/test-utils/ge
 import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import callForPublicHelmRepositoriesInjectable from "../helm-charts/child-features/preferences/renderer/adding-of-public-helm-repository/public-helm-repositories/call-for-public-helm-repositories.injectable";
 import getActiveHelmRepositoriesInjectable from "../../main/helm/repositories/get-active-helm-repositories/get-active-helm-repositories.injectable";
-import { getSingleElement, querySingleElement } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import type { Discover } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import { discoverFor } from "../../renderer/components/test-utils/discovery-of-html-elements";
 
 describe("preferences - navigation to kubernetes preferences", () => {
   let builder: ApplicationBuilder;
@@ -18,6 +19,7 @@ describe("preferences - navigation to kubernetes preferences", () => {
 
   describe("given in preferences, when rendered", () => {
     let rendered: RenderResult;
+    let discover: Discover;
 
     beforeEach(async () => {
       builder.beforeApplicationStart((mainDi) => {
@@ -36,6 +38,8 @@ describe("preferences - navigation to kubernetes preferences", () => {
       });
 
       rendered = await builder.render();
+
+      discover = discoverFor(() => rendered);
     });
 
     it("renders", () => {
@@ -43,12 +47,12 @@ describe("preferences - navigation to kubernetes preferences", () => {
     });
 
     it("does not show kubernetes preferences yet", () => {
-      const page = querySingleElement(
+      const { discovered } = discover.querySingleElement(
         "preference-page",
         "kubernetes-page",
-      )(rendered);
+      );
 
-      expect(page).toBeNull();
+      expect(discovered).toBeNull();
     });
 
     describe("when navigating to kubernetes preferences using navigation", () => {
@@ -61,12 +65,12 @@ describe("preferences - navigation to kubernetes preferences", () => {
       });
 
       it("shows kubernetes preferences", () => {
-        const page = getSingleElement(
+        const { discovered } = discover.getSingleElement(
           "preference-page",
           "kubernetes-page",
-        )(rendered);
+        );
 
-        expect(page).not.toBeNull();
+        expect(discovered).not.toBeNull();
       });
     });
   });

src/features/preferences/navigation-to-proxy-preferences.test.ts

@@ -5,7 +5,8 @@
 import type { RenderResult } from "@testing-library/react";
 import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
-import { getSingleElement, querySingleElement } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import type { Discover } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import { discoverFor } from "../../renderer/components/test-utils/discovery-of-html-elements";
 
 describe("preferences - navigation to proxy preferences", () => {
   let applicationBuilder: ApplicationBuilder;
@@ -16,6 +17,7 @@ describe("preferences - navigation to proxy preferences", () => {
 
   describe("given in preferences, when rendered", () => {
     let rendered: RenderResult;
+    let discover: Discover;
 
     beforeEach(async () => {
       applicationBuilder.beforeWindowStart(() => {
@@ -23,6 +25,7 @@ describe("preferences - navigation to proxy preferences", () => {
       });
 
       rendered = await applicationBuilder.render();
+      discover = discoverFor(() => rendered);
     });
 
     it("renders", () => {
@@ -30,12 +33,12 @@ describe("preferences - navigation to proxy preferences", () => {
     });
 
     it("does not show proxy preferences yet", () => {
-      const page = querySingleElement(
+      const { discovered } = discover.querySingleElement(
         "preference-page",
         "proxy-page",
-      )(rendered);
+      );
 
-      expect(page).toBeNull();
+      expect(discovered).toBeNull();
     });
 
     describe("when navigating to proxy preferences using navigation", () => {
@@ -48,12 +51,12 @@ describe("preferences - navigation to proxy preferences", () => {
       });
 
       it("shows proxy preferences", () => {
-        const page = getSingleElement(
+        const { discovered } = discover.getSingleElement(
           "preference-page",
           "proxy-page",
-        )(rendered);
+        );
 
-        expect(page).not.toBeNull();
+        expect(discovered).not.toBeNull();
       });
     });
   });

src/features/preferences/navigation-to-telemetry-preferences.test.tsx

@@ -9,7 +9,8 @@ import { getApplicationBuilder } from "../../renderer/components/test-utils/get-
 import navigateToTelemetryPreferencesInjectable from "./common/navigate-to-telemetry-preferences.injectable";
 import sentryDataSourceNameInjectable from "../../common/vars/sentry-dsn-url.injectable";
 import type { FakeExtensionOptions } from "../../renderer/components/test-utils/get-extension-fake";
-import { getSingleElement, queryAllElements, querySingleElement } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import type { Discover } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import { discoverFor } from "../../renderer/components/test-utils/discovery-of-html-elements";
 
 describe("preferences - navigation to telemetry preferences", () => {
   let builder: ApplicationBuilder;
@@ -20,6 +21,7 @@ describe("preferences - navigation to telemetry preferences", () => {
 
   describe("given in preferences, when rendered", () => {
     let rendered: RenderResult;
+    let discover: Discover;
 
     beforeEach(async () => {
       builder.beforeWindowStart(() => {
@@ -27,6 +29,8 @@ describe("preferences - navigation to telemetry preferences", () => {
       });
 
       rendered = await builder.render();
+
+      discover = discoverFor(() => rendered);
     });
 
     it("renders", () => {
@@ -34,21 +38,21 @@ describe("preferences - navigation to telemetry preferences", () => {
     });
 
     it("does not show telemetry preferences yet", () => {
-      const page = querySingleElement(
+      const { discovered } = discover.querySingleElement(
         "preference-page",
         "telemetry-page",
-      )(rendered);
+      );
 
-      expect(page).toBeNull();
+      expect(discovered).toBeNull();
     });
 
     it("does not show link for telemetry preferences", () => {
-      const actual = querySingleElement(
+      const { discovered } = discover.querySingleElement(
         "preference-tab-link",
         "telemetry",
-      )(rendered);
+      );
 
-      expect(actual).toBeNull();
+      expect(discovered).toBeNull();
     });
 
     describe("when extension with telemetry preference items gets enabled", () => {
@@ -63,12 +67,12 @@ describe("preferences - navigation to telemetry preferences", () => {
       });
 
       it("shows link for telemetry preferences", () => {
-        const actual = getSingleElement(
+        const { discovered } = discover.getSingleElement(
           "preference-tab-link",
           "telemetry",
-        )(rendered);
+        );
 
-        expect(actual).not.toBeNull();
+        expect(discovered).not.toBeNull();
       });
 
       describe("when clicking link to telemetry preferences from navigation", () => {
@@ -81,19 +85,19 @@ describe("preferences - navigation to telemetry preferences", () => {
         });
 
         it("shows telemetry preferences", () => {
-          const page = getSingleElement(
+          const { discovered } = discover.getSingleElement(
             "preference-page",
             "telemetry-page",
-          )(rendered);
+          );
 
-          expect(page).not.toBeNull();
+          expect(discovered).not.toBeNull();
         });
 
         it("shows extension telemetry preference items", () => {
-          const actual =
+          const { attributeValues } =
-            queryAllElements("preference-item")(rendered).attributeValues;
+            discover.queryAllElements("preference-item");
 
-          expect(actual).toEqual([
+          expect(attributeValues).toEqual([
             "preference-item-for-extension-some-test-extension-name-item-some-telemetry-preference-item-id",
           ]);
         });
@@ -117,17 +121,18 @@ describe("preferences - navigation to telemetry preferences", () => {
         },
       });
 
-      const actual = querySingleElement(
+      const { discovered } = discover.querySingleElement(
         "preference-tab-link",
         "telemetry",
-      )(rendered);
+      );
 
-      expect(actual).toBeNull();
+      expect(discovered).toBeNull();
     });
   });
 
   describe("given URL for Sentry DNS, when navigating to preferences", () => {
     let rendered: RenderResult;
+    let discover: Discover;
 
     beforeEach(async () => {
       builder.beforeWindowStart((windowDi) => {
@@ -136,6 +141,8 @@ describe("preferences - navigation to telemetry preferences", () => {
 
       rendered = await builder.render();
 
+      discover = discoverFor(() => rendered);
+
       builder.preferences.navigate();
     });
 
@@ -149,17 +156,18 @@ describe("preferences - navigation to telemetry preferences", () => {
       });
 
       it("allows configuration of automatic error reporting", () => {
-        const actual = queryAllElements(
+        const { attributeValues } = discover.queryAllElements(
           "preference-item",
-        )(rendered).attributeValues;
+        );
 
-        expect(actual).toEqual(["automatic-error-reporting"]);
+        expect(attributeValues).toEqual(["automatic-error-reporting"]);
       });
     });
   });
 
   describe("given no URL for Sentry DNS, when navigating to telemetry preferences", () => {
     let rendered: RenderResult;
+    let discover: Discover;
 
     beforeEach(async () => {
       builder.beforeWindowStart((windowDi) => {
@@ -168,6 +176,8 @@ describe("preferences - navigation to telemetry preferences", () => {
 
       rendered = await builder.render();
 
+      discover = discoverFor(() => rendered);
+
       const windowDi = builder.applicationWindow.only.di;
 
       const navigateToTelemetryPreferences = windowDi.inject(navigateToTelemetryPreferencesInjectable);
@@ -180,11 +190,11 @@ describe("preferences - navigation to telemetry preferences", () => {
     });
 
     it("does not allow configuration of automatic error reporting", () => {
-      const actual = queryAllElements(
+      const { attributeValues } = discover.queryAllElements(
         "preference-item",
-      )(rendered).attributeValues;
+      );
 
-      expect(actual).toEqual([]);
+      expect(attributeValues).toEqual([]);
     });
   });
 });

src/features/preferences/navigation-to-terminal-preferences.test.ts

@@ -5,7 +5,8 @@
 import type { RenderResult } from "@testing-library/react";
 import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
-import { getSingleElement, querySingleElement } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import type { Discover } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import { discoverFor } from "../../renderer/components/test-utils/discovery-of-html-elements";
 
 describe("preferences - navigation to terminal preferences", () => {
   let applicationBuilder: ApplicationBuilder;
@@ -16,6 +17,7 @@ describe("preferences - navigation to terminal preferences", () => {
 
   describe("given in preferences, when rendered", () => {
     let rendered: RenderResult;
+    let discover: Discover;
 
     beforeEach(async () => {
       applicationBuilder.beforeWindowStart(() => {
@@ -23,6 +25,8 @@ describe("preferences - navigation to terminal preferences", () => {
       });
 
       rendered = await applicationBuilder.render();
+
+      discover = discoverFor(() => rendered);
     });
 
     it("renders", () => {
@@ -30,12 +34,12 @@ describe("preferences - navigation to terminal preferences", () => {
     });
 
     it("does not show terminal preferences yet", () => {
-      const page = querySingleElement(
+      const { discovered } = discover.querySingleElement(
         "preference-page",
         "terminal-page",
-      )(rendered);
+      );
 
-      expect(page).toBeNull();
+      expect(discovered).toBeNull();
     });
 
     describe("when navigating to terminal preferences using navigation", () => {
@@ -49,12 +53,12 @@ describe("preferences - navigation to terminal preferences", () => {
 
 
       it("shows terminal preferences", () => {
-        const page = getSingleElement(
+        const { discovered } = discover.getSingleElement(
           "preference-page",
           "terminal-page",
-        )(rendered);
+        );
 
-        expect(page).not.toBeNull();
+        expect(discovered).not.toBeNull();
       });
     });
   });

src/features/preferences/navigation-using-application-menu.test.ts

@@ -6,16 +6,19 @@
 import type { RenderResult } from "@testing-library/react";
 import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
-import { getSingleElement, querySingleElement } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import type { Discover } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import { discoverFor } from "../../renderer/components/test-utils/discovery-of-html-elements";
 
 describe("preferences - navigation using application menu", () => {
   let applicationBuilder: ApplicationBuilder;
   let rendered: RenderResult;
+  let discover: Discover;
 
   beforeEach(async () => {
     applicationBuilder = getApplicationBuilder();
 
     rendered = await applicationBuilder.render();
+    discover = discoverFor(() => rendered);
   });
 
   it("renders", () => {
@@ -23,12 +26,12 @@ describe("preferences - navigation using application menu", () => {
   });
 
   it("does not show application preferences yet", () => {
-    const page = querySingleElement(
+    const { discovered } = discover.querySingleElement(
       "preference-page",
       "application-page",
-    )(rendered);
+    );
 
-    expect(page).toBeNull();
+    expect(discovered).toBeNull();
   });
 
   describe("when navigating to preferences using application menu", () => {
@@ -41,12 +44,12 @@ describe("preferences - navigation using application menu", () => {
     });
 
     it("shows application preferences", () => {
-      const page = getSingleElement(
+      const { discovered } = discover.getSingleElement(
         "preference-page",
         "application-page",
-      )(rendered);
+      );
 
-      expect(page).not.toBeNull();
+      expect(discovered).not.toBeNull();
     });
   });
 });

src/features/preferences/navigation-using-tray.test.ts

@@ -5,16 +5,19 @@
 import type { RenderResult } from "@testing-library/react";
 import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
-import { getSingleElement, querySingleElement } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import type { Discover } from "../../renderer/components/test-utils/discovery-of-html-elements";
+import { discoverFor } from "../../renderer/components/test-utils/discovery-of-html-elements";
 
 describe("show-about-using-tray", () => {
   let applicationBuilder: ApplicationBuilder;
   let rendered: RenderResult;
+  let discover: Discover;
 
   beforeEach(async () => {
     applicationBuilder = getApplicationBuilder();
 
     rendered = await applicationBuilder.render();
+    discover = discoverFor(() => rendered);
   });
 
   it("renders", () => {
@@ -22,12 +25,12 @@ describe("show-about-using-tray", () => {
   });
 
   it("does not show application preferences yet", () => {
-    const page = querySingleElement(
+    const { discovered } = discover.querySingleElement(
       "preference-page",
       "application-page",
-    )(rendered);
+    );
 
-    expect(page).toBeNull();
+    expect(discovered).toBeNull();
   });
 
   describe("when navigating using tray", () => {
@@ -40,12 +43,12 @@ describe("show-about-using-tray", () => {
     });
 
     it("shows application preferences", () => {
-      const page = getSingleElement(
+      const { discovered } = discover.getSingleElement(
         "preference-page",
         "application-page",
-      )(rendered);
+      );
 
-      expect(page).not.toBeNull();
+      expect(discovered).not.toBeNull();
     });
   });
 });

src/renderer/components/test-utils/discovery-of-html-elements.ts

@@ -6,45 +6,96 @@ import type { RenderResult } from "@testing-library/react";
 
 type DiscoverySourceTypes = RenderResult | Element;
 
+export type QuerySingleElement = (
+  attributeName: string,
+  attributeValue?: string
+) => { discovered: Element | null } & Discover;
+
+export type GetSingleElement = (
+  attributeName: string,
+  attributeValue?: string
+) => { discovered: Element } & Discover;
+
+export type QueryAllElements = (attributeName: string) => {
+  discovered: Element[];
+  attributeValues: (string | null)[];
+};
+
+export interface Discover {
+  querySingleElement: QuerySingleElement;
+  queryAllElements: QueryAllElements;
+  getSingleElement: GetSingleElement;
+}
+
+export const discoverFor = (getSource: () => DiscoverySourceTypes): Discover => ({
+  querySingleElement: querySingleElement(getSource),
+  queryAllElements: queryAllElements(getSource),
+  getSingleElement: getSingleElement(getSource),
+});
+
 export const querySingleElement =
-  (attributeName: string, attributeValue?: string) =>
+  (getSource: () => DiscoverySourceTypes): QuerySingleElement =>
-    (source: DiscoverySourceTypes) => {
+    (attributeName, attributeValue) => {
+      const source = getSource();
+
       const dataAttribute = `data-${attributeName}-test`;
 
-      const selector =  attributeValue ? `[${dataAttribute}="${attributeValue}"]` : `[${dataAttribute}]` ;
+      const selector = attributeValue
+        ? `[${dataAttribute}="${attributeValue}"]`
+        : `[${dataAttribute}]`;
 
-      return getBaseElement(source).querySelector(selector);
+      const discovered = getBaseElement(source).querySelector(selector);
+
+      const nestedDiscover = discoverFor(() => {
+        if (!discovered) {
+          throw new Error("Tried to do nested discover using source that does not exist");
+        }
+
+        return discovered;
+      });
+
+      return {
+        discovered,
+
+        ...nestedDiscover,
+      };
     };
 
 export const queryAllElements =
-  (attributeName: string) => (source: DiscoverySourceTypes) => {
+  (getSource: () => DiscoverySourceTypes): QueryAllElements =>
-    const dataAttribute = `data-${attributeName}-test`;
+    (attributeName) => {
+      const source = getSource();
 
-    const results = [
-      ...getBaseElement(source).querySelectorAll(`[${dataAttribute}]`),
-    ];
-
-    return {
-      elements: results,
-
-      attributeValues: results.map((result) =>
-        result.getAttribute(dataAttribute),
-      ),
-    };
-  };
-
-export const getSingleElement =
-  (attributeName: string, attributeValue?: string) =>
-    (source: DiscoverySourceTypes) => {
       const dataAttribute = `data-${attributeName}-test`;
 
-      const element = querySingleElement(attributeName, attributeValue)(source);
+      const results = [
+        ...getBaseElement(source).querySelectorAll(`[${dataAttribute}]`),
+      ];
 
-      if (!element) {
+      return {
+        discovered: results,
+
+        attributeValues: results.map((result) =>
+          result.getAttribute(dataAttribute),
+        ),
+      };
+    };
+
+export const getSingleElement =
+  (getSource: () => DiscoverySourceTypes): GetSingleElement =>
+    (attributeName, attributeValue) => {
+      const dataAttribute = `data-${attributeName}-test`;
+
+      const { discovered, ...nestedDiscover } = querySingleElement(getSource)(
+        attributeName,
+        attributeValue,
+      );
+
+      if (!discovered) {
         const validValues =
-        queryAllElements(attributeName)(source).attributeValues;
+        queryAllElements(getSource)(attributeName).attributeValues;
 
-        if(attributeValue) {
+        if (attributeValue) {
           throw new Error(
             `Couldn't find HTML-element with attribute "${dataAttribute}" with value "${attributeValue}". Present values are:\n\n"${validValues.join(
               '",\n"',
@@ -52,10 +103,12 @@ export const getSingleElement =
           );
         }
 
-        throw new Error(`Couldn't find HTML-element with attribute "${dataAttribute}"`);
+        throw new Error(
+          `Couldn't find HTML-element with attribute "${dataAttribute}"`,
+        );
       }
 
-      return element;
+      return { discovered, ...nestedDiscover };
     };
 
 const getBaseElement = (source: DiscoverySourceTypes) =>

src/renderer/components/test-utils/get-application-builder.tsx

@@ -69,7 +69,7 @@ import { getCompositePaths } from "../../../common/utils/composite/get-composite
 import { getCompositeNormalization } from "../../../common/utils/composite/get-composite-normalization/get-composite-normalization";
 import type { ClickableMenuItem } from "../../../features/application-menu/main/menu-items/application-menu-item-injection-token";
 import type { Composite } from "../../../common/utils/composite/get-composite/get-composite";
-import { getSingleElement } from "./discovery-of-html-elements";
+import { discoverFor } from "./discovery-of-html-elements";
 
 type Callback = (di: DiContainer) => void | Promise<void>;
 
@@ -447,7 +447,12 @@ export const getApplicationBuilder = () => {
         click: (pathId: string) => {
           const { rendered } = builder.applicationWindow.only;
 
-          const link = getSingleElement("preference-tab-link", pathId)(rendered);
+          const discover = discoverFor(() => rendered);
+
+          const { discovered: link } = discover.getSingleElement(
+            "preference-tab-link",
+            pathId,
+          );
 
           fireEvent.click(link);
         },