@truedat/dq 7.5.9 → 7.5.11

package/src/components/__tests__/RuleImplementationsActions.spec.js

@@ -1,10 +1,7 @@
-import React from "react";
-import { shallow } from "enzyme";
-import { intl } from "@truedat/test/intl-stub";
+import { render, waitForLoad } from "@truedat/test/render";
+import userEvent from "@testing-library/user-event";
 import { RuleImplementationsActions } from "../RuleImplementationsActions";
 
-jest.spyOn(React, "useContext").mockImplementation(() => intl);
-
 describe("<RuleImplementationsActions />", () => {
   const addImplementationFilter = jest.fn();
   const toggleImplementationFilterValue = jest.fn();
@@ -29,57 +26,73 @@ describe("<RuleImplementationsActions />", () => {
     removeImplementationFilter,
   };
 
-  it("matches the latest snapshot", () => {
-    const wrapper = shallow(<RuleImplementationsActions {...props} />);
-    expect(wrapper).toMatchSnapshot();
+  it("matches the latest snapshot", async () => {
+    const rendered = render(<RuleImplementationsActions {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("as user with permissions I see execute implementations button and checkbox", () => {
-    const props = {
+  it("as user with permissions I see execute implementations button and checkbox", async () => {
+    const userProps = {
       actions: { execute: {} },
       executionGroupLoading: false,
       ruleImplementationCount: 12,
       implementationsExecution: true,
       role: "user",
     };
-    const wrapper = shallow(<RuleImplementationsActions {...props} />);
-    expect(wrapper.find({ id: "execute_checkbox" }).length).toBe(1);
-    expect(wrapper.find("Connect(ExecutionPopup)").length).toBe(1);
+    const rendered = render(<RuleImplementationsActions {...userProps} />);
+    await waitForLoad(rendered);
+    expect(
+      rendered.container.querySelector("#execute_checkbox")
+    ).toBeInTheDocument();
+    expect(
+      rendered.getByText(/ruleimplementations.actions.upload.tooltip/i)
+    ).toBeInTheDocument();
   });
 
-  it("as user I do not see execute rules actions if I have no permission", () => {
-    const props = {
+  it("as user I do not see execute rules actions if I have no permission", async () => {
+    const noPermProps = {
       actions: {},
       executionGroupLoading: false,
       ruleImplementationCount: 12,
       implementationsExecution: true,
     };
-    const wrapper = shallow(<RuleImplementationsActions {...props} />);
-    expect(wrapper.find("Checkbox").length).toBe(0);
-    expect(wrapper.find("Connect(ExecutionPopup)").length).toBe(0);
-    expect(wrapper.find({ id: "execute_button" }).length).toBe(0);
+    const rendered = render(<RuleImplementationsActions {...noPermProps} />);
+    await waitForLoad(rendered);
+    expect(
+      rendered.container.querySelector("#execute_checkbox")
+    ).not.toBeInTheDocument();
+    expect(rendered.queryByTestId(/execute_button/i)).not.toBeInTheDocument();
   });
 
-  it("as non admin user I can see an active checkbox if executeImplementationsOn", () => {
-    const props = {
+  it("as non admin user I can see an active checkbox if executeImplementationsOn", async () => {
+    const activeProps = {
       actions: { execute: {} },
       executionGroupLoading: false,
       ruleImplementationCount: 12,
       implementationsExecution: true,
       executeImplementationsOn: true,
     };
-    const wrapper = shallow(<RuleImplementationsActions {...props} />);
-    expect(wrapper.find("Checkbox").length).toBe(1);
-    expect(wrapper.find("Checkbox").props().checked).toBeTruthy();
-    expect(wrapper.find("Connect(ExecutionPopup)").length).toBe(1);
+    const rendered = render(<RuleImplementationsActions {...activeProps} />);
+    await waitForLoad(rendered);
+    const checkbox = rendered.container.querySelector("#execute_checkbox");
+    expect(checkbox).toBeInTheDocument();
+    expect(checkbox).toBeChecked();
+    expect(
+      rendered.getByText(/implementations.actions.download.tooltip/i)
+    ).toBeInTheDocument();
   });
 
-  it("handles checkbox onChange", () => {
-    const wrapper = shallow(<RuleImplementationsActions {...props} />);
-    const toCheck = wrapper.find("Checkbox");
-    expect(toCheck.length).toBe(1);
-    expect(toCheck.props().checked).toBeFalsy();
-    toCheck.simulate("change");
+  it("handles checkbox onChange", async () => {
+    const user = userEvent.setup({ delay: null }); // Asynchronous userEvent setup
+    const rendered = render(<RuleImplementationsActions {...props} />);
+    await waitForLoad(rendered);
+
+    const checkbox = rendered.container.querySelector("#execute_checkbox");
+    expect(checkbox).toBeInTheDocument();
+    expect(checkbox).not.toBeChecked();
+
+    await user.click(checkbox);
     expect(setMode).toHaveBeenCalledWith(true);
     expect(addImplementationFilter).toHaveBeenCalledWith({
       filter: "executable",
@@ -88,11 +101,21 @@ describe("<RuleImplementationsActions />", () => {
       filter: "executable",
       value: true,
     });
-    wrapper.setProps({ executeImplementationsOn: true });
+
+    // Reset and test unchecking
     setMode.mockReset();
-    const toUncheck = wrapper.find("Checkbox");
-    expect(toUncheck.props().checked).toBeTruthy();
-    toUncheck.simulate("change");
+    rendered.rerender(
+      <RuleImplementationsActions
+        {...{ ...props, executeImplementationsOn: true }}
+      />
+    );
+    await waitForLoad(rendered);
+
+    const updatedCheckbox =
+      rendered.container.querySelector("#execute_checkbox");
+    expect(updatedCheckbox).toBeChecked();
+
+    await user.click(updatedCheckbox);
     expect(setMode).toHaveBeenCalledWith(false);
     expect(removeImplementationFilter).toHaveBeenCalledWith({
       filter: "executable",

package/src/components/__tests__/RuleImplementationsFromRuleLoader.spec.js

@@ -1,53 +1,63 @@
-import React from "react";
-import { mount } from "enzyme";
+import { useParams } from "react-router";
+import { render, waitForLoad } from "@truedat/test/render";
 import { RuleImplementationsFromRuleLoader } from "../RuleImplementationsFromRuleLoader";
 
-jest.mock("react-router-dom", () => ({
-  ...jest.requireActual("react-router-dom"),
-  useParams: () => ({ id: 1 }),
+jest.mock("react-router", () => ({
+  ...jest.requireActual("react-router"),
+  useParams: jest.fn(),
 }));
 
 afterEach(() => {
   jest.clearAllMocks();
 });
 
-const fetchRuleImplementations = jest.fn();
-const clearRuleImplementations = jest.fn();
-const deletionQuery = { deleted: false };
+describe("<RuleImplementationsFromRuleLoader />", () => {
+  const fetchRuleImplementations = jest.fn();
+  const clearRuleImplementations = jest.fn();
+  const deletionQuery = { deleted: false };
 
-const props = {
-  deletionQuery,
-  fetchRuleImplementations,
-  clearRuleImplementations,
-  ruleImplementationsLoading: false,
-};
+  const props = {
+    deletionQuery,
+    fetchRuleImplementations,
+    clearRuleImplementations,
+    ruleImplementationsLoading: false,
+  };
 
-describe("<RuleImplementationsFromRuleLoader />", () => {
-  it("matches the latest snapshot", () => {
-    const wrapper = mount(<RuleImplementationsFromRuleLoader {...props} />);
-    expect(wrapper).toMatchSnapshot();
+  beforeEach(() => {
+    useParams.mockImplementation(() => ({ id: 1 }));
+  });
+
+  it("matches the latest snapshot", async () => {
+    const rendered = render(<RuleImplementationsFromRuleLoader {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("calls fetchRuleImplementations when component mounts, clearRuleImplementations when component unmounts", () => {
-    const wrapper = mount(<RuleImplementationsFromRuleLoader {...props} />);
+  it("calls fetchRuleImplementations when component mounts, clearRuleImplementations when component unmounts", async () => {
+    const rendered = render(<RuleImplementationsFromRuleLoader {...props} />);
+    await waitForLoad(rendered);
+
     expect(clearRuleImplementations).toHaveBeenCalledTimes(0);
     expect(fetchRuleImplementations).toHaveBeenCalledTimes(1);
     expect(fetchRuleImplementations).toHaveBeenCalledWith({
       id: 1,
       filters: { must_not: { status: ["versioned"] } },
     });
-    wrapper.unmount();
+
+    rendered.unmount();
     expect(clearRuleImplementations).toHaveBeenCalledTimes(1);
     expect(fetchRuleImplementations).toHaveBeenCalledTimes(1);
   });
 
-  it("renders dimmer when rule implementations loading", () => {
-    const wrapper = mount(
+  it("renders dimmer when rule implementations loading", async () => {
+    const rendered = render(
       <RuleImplementationsFromRuleLoader
         {...props}
         ruleImplementationsLoading
       />
     );
-    expect(wrapper.find("Dimmer").prop("active")).toBeTruthy();
+    expect(
+      rendered.container.querySelector(".dimmer.active")
+    ).toBeInTheDocument();
   });
 });

package/src/components/__tests__/RuleImplementationsLoader.spec.js

@@ -1,5 +1,4 @@
-import React from "react";
-import { mount } from "enzyme";
+import { render, waitForLoad } from "@truedat/test/render";
 import { RuleImplementationsLoader } from "../RuleImplementationsLoader";
 
 afterEach(() => {
@@ -11,17 +10,18 @@ describe("<RuleImplementationsLoader />", () => {
   const clearRuleImplementations = jest.fn();
   const searchRuleImplementations = jest.fn();
 
-  it("matches the latest snapshot", () => {
+  it("matches the latest snapshot", async () => {
     const props = {
       searchRuleImplementations,
       clearRuleImplementations,
-      payload: defaultFilters
+      payload: defaultFilters,
     };
-    const wrapper = mount(<RuleImplementationsLoader {...props} />);
-    expect(wrapper).toMatchSnapshot();
+    const rendered = render(<RuleImplementationsLoader {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("calls searchRuleImplementations when component mounts, clearRuleImplementations when component unmounts", () => {
+  it("calls searchRuleImplementations when component mounts, clearRuleImplementations when component unmounts", async () => {
     const defaultFilters = { structure_id: 1 };
     const clearRuleImplementations = jest.fn();
     const searchRuleImplementations = jest.fn();
@@ -29,18 +29,19 @@ describe("<RuleImplementationsLoader />", () => {
     const props = {
       clearRuleImplementations,
       searchRuleImplementations,
-      defaultFilters
+      defaultFilters,
     };
 
-    const wrapper = mount(<RuleImplementationsLoader {...props} />);
+    const rendered = render(<RuleImplementationsLoader {...props} />);
+    await waitForLoad(rendered);
     expect(clearRuleImplementations).toHaveBeenCalledTimes(0);
     expect(searchRuleImplementations).toHaveBeenCalledTimes(1);
-    wrapper.unmount();
+    rendered.unmount();
     expect(clearRuleImplementations).toHaveBeenCalledTimes(1);
     expect(searchRuleImplementations).toHaveBeenCalledTimes(1);
   });
 
-  it("calls searchRuleImplementations when component updates", () => {
+  it("calls searchRuleImplementations when component updates", async () => {
     const defaultFilters = { structure_id: 1 };
     const clearRuleImplementations = jest.fn();
     const searchRuleImplementations = jest.fn();
@@ -48,11 +49,18 @@ describe("<RuleImplementationsLoader />", () => {
     const props = {
       clearRuleImplementations,
       searchRuleImplementations,
-      defaultFilters
+      defaultFilters,
     };
-    const wrapper = mount(<RuleImplementationsLoader {...props} />);
+    const rendered = render(<RuleImplementationsLoader {...props} />);
+    await waitForLoad(rendered);
     expect(searchRuleImplementations).toHaveBeenCalledTimes(1);
-    wrapper.setProps({ payload: { filters: { structure_id: 2 } } });
+
+    rendered.rerender(
+      <RuleImplementationsLoader
+        {...props}
+        payload={{ filters: { structure_id: 2 } }}
+      />
+    );
     expect(searchRuleImplementations).toHaveBeenCalledTimes(2);
   });
 });

package/src/components/__tests__/RuleImplementationsOptions.spec.js

@@ -1,4 +1,3 @@
-import React from "react";
 import { waitFor } from "@testing-library/react";
 import { render } from "@truedat/test/render";
 import RuleImplementationsOptions from "../RuleImplementationsOptions";

package/src/components/__tests__/RuleImplementationsSearch.spec.js

@@ -1,38 +1,29 @@
-import React from "react";
-import { shallow } from "enzyme";
-import { Input } from "semantic-ui-react";
-import { intl } from "@truedat/test/intl-stub";
+import userEvent from "@testing-library/user-event";
+import { render, waitForLoad } from "@truedat/test/render";
 import { RuleImplementationsSearch } from "../RuleImplementationsSearch";
 
-// workaround for enzyme issue with React.useContext
-// see https://github.com/airbnb/enzyme/issues/2176#issuecomment-532361526
-jest.spyOn(React, "useContext").mockImplementation(() => intl);
-
 describe("<RuleImplementationsSearch/>", () => {
-  it("matches the latest snapshot", () => {
+  it("matches the latest snapshot", async () => {
     const searchImplementations = jest.fn();
     const loading = false;
     const query = "";
     const props = { searchImplementations, loading, query };
-    const wrapper = shallow(<RuleImplementationsSearch {...props} />);
-    expect(wrapper).toMatchSnapshot();
+    const rendered = render(<RuleImplementationsSearch {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("dispatches onChange when Input changes", () => {
+  it("dispatches onChange when Input changes", async () => {
     const searchImplementations = jest.fn();
     const loading = false;
     const query = "";
     const props = { searchImplementations, loading, query };
-    const eventMock = {
-      data: {
-        value: {
-          toLowerCase: jest.fn()
-        }
-      }
-    };
-    const wrapper = shallow(<RuleImplementationsSearch {...props} />);
-    expect(props.searchImplementations.mock.calls.length).toBe(0);
-    wrapper.find(Input).simulate("change", null, eventMock);
-    expect(props.searchImplementations.mock.calls.length).toBe(1);
+    const rendered = render(<RuleImplementationsSearch {...props} />);
+    await waitForLoad(rendered);
+
+    const user = userEvent.setup({ delay: null });
+    await user.type(rendered.getByRole("textbox"), "test");
+
+    expect(searchImplementations).toHaveBeenCalled();
   });
 });

package/src/components/__tests__/RuleImplementationsTable.spec.js

@@ -1,17 +1,12 @@
-import React from "react";
-import { shallow } from "enzyme";
-import { intl } from "@truedat/test/intl-stub";
+import userEvent from "@testing-library/user-event";
+import { render, waitForLoad } from "@truedat/test/render";
 import { RuleImplementationsTable } from "../RuleImplementationsTable";
 
-// workaround for enzyme issue with React.useContext
-// see https://github.com/airbnb/enzyme/issues/2176#issuecomment-532361526
-jest.spyOn(React, "useContext").mockImplementation(() => intl);
-
 describe("<RuleImplementationsTable />", () => {
-  const ruleImplementations = [1, 2, 3].map(id => ({ id }));
+  const ruleImplementations = [1, 2, 3].map((id) => ({ id }));
   const columns = [
     { name: "rule", sort: { name: "name.raw" } },
-    { name: "result", sort: { name: "bar.raw" } }
+    { name: "result", sort: { name: "bar.raw" } },
   ];
   const implementationsSort = [{ "name.raw": "desc" }];
   const sortImplementations = jest.fn();
@@ -21,62 +16,41 @@ describe("<RuleImplementationsTable />", () => {
     columns,
     ruleImplementationsLoading,
     implementationsSort,
-    sortImplementations
+    sortImplementations,
   };
 
-  it("matches the latest snapshot", () => {
-    const wrapper = shallow(<RuleImplementationsTable {...props} />);
-    expect(wrapper).toMatchSnapshot();
+  it("matches the latest snapshot", async () => {
+    const rendered = render(<RuleImplementationsTable {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("sorts column in the direction specified", () => {
-    const wrapper = shallow(<RuleImplementationsTable {...props} />);
-    const tableHeaderCells = wrapper
-      .find("TableHeader")
-      .find("TableRow")
-      .dive()
-      .find("TableHeaderCell");
+  it("sorts column in the direction specified", async () => {
+    const rendered = render(<RuleImplementationsTable {...props} />);
+    await waitForLoad(rendered);
 
-    expect(tableHeaderCells.at(0).props().sorted).toEqual("descending");
-    expect(tableHeaderCells.at(1).props().sorted).toEqual(null);
+    const headerCells = rendered.container.querySelectorAll("th");
+    expect(headerCells[0].getAttribute("class")).toContain("descending sorted");
+    expect(headerCells[1].getAttribute("class")).not.toContain("sorted");
   });
 
-  it("handles sort when column header is clicked", () => {
-    const wrapper = shallow(<RuleImplementationsTable {...props} />);
+  it("handles sort when column header is clicked", async () => {
+    const user = userEvent.setup({ delay: null });
+    const rendered = render(<RuleImplementationsTable {...props} />);
+    await waitForLoad(rendered);
+
+    const headerCells = rendered.container.querySelectorAll("th");
+
+    // Click on the second header cell
+    await user.click(headerCells[1]);
 
-    wrapper
-      .find("TableHeader")
-      .find("TableRow")
-      .dive()
-      .find("TableHeaderCell")
-      .at(1)
-      .simulate("click");
+    // Check that it's now sorted ascending
+    expect(headerCells[1].getAttribute("class")).toContain("ascending sorted");
 
-    expect(
-      wrapper
-        .find("TableHeader")
-        .find("TableRow")
-        .dive()
-        .find("TableHeaderCell")
-        .at(1)
-        .props().sorted
-    ).toEqual("ascending");
+    // Click again to sort descending
+    await user.click(headerCells[1]);
 
-    wrapper
-      .find("TableHeader")
-      .find("TableRow")
-      .dive()
-      .find("TableHeaderCell")
-      .at(1)
-      .simulate("click");
-    expect(
-      wrapper
-        .find("TableHeader")
-        .find("TableRow")
-        .dive()
-        .find("TableHeaderCell")
-        .at(1)
-        .props().sorted
-    ).toEqual("descending");
+    // Check that it's now sorted descending
+    expect(headerCells[1].getAttribute("class")).toContain("descending sorted");
   });
 });

package/src/components/__tests__/RuleProperties.spec.js

@@ -1,6 +1,4 @@
-import React from "react";
-import { waitFor } from "@testing-library/react";
-import { render } from "@truedat/test/render";
+import { render, waitForLoad } from "@truedat/test/render";
 import RuleProperties from "../RuleProperties";
 
 const rule = {
@@ -34,16 +32,12 @@ const rule = {
 
 const renderOpts = {
   state: { rule },
-  fallback: "lazy",
 };
 
 describe("<RuleProperties />", () => {
   it("matches the latest snapshot", async () => {
-    const { container, queryByText } = render(<RuleProperties />, renderOpts);
-    await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
-    await waitFor(() =>
-      expect(queryByText(/loading/i)).not.toBeInTheDocument()
-    );
-    expect(container).toMatchSnapshot();
+    const rendered = render(<RuleProperties />, renderOpts);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 });

package/src/components/__tests__/RuleResult.spec.js

@@ -1,34 +1,22 @@
-import React, { Suspense } from "react";
-import { render } from "@truedat/test/render";
-import messages from "@truedat/dq/messages";
+import { render, waitForLoad } from "@truedat/test/render";
 import { RuleResult } from "../RuleResult";
 
-jest.mock("react-router-dom", () => ({
-  ...jest.requireActual("react-router-dom"),
+jest.mock("react-router", () => ({
+  ...jest.requireActual("react-router"),
 }));
 
-const renderOpts = {
-  messages: {
-    en: {
-      ...messages.en,
-    },
-  },
-};
-
 describe("<RuleResult>", () => {
-  it("matches the latest snapshot", () => {
+  it("matches the latest snapshot", async () => {
     const props = {
-      ruleImplementation: {
+      ruleResult: {
         results: [{ foo: "bar", id: 100, details: { Query: "ImZvbyI=" } }],
       },
       ruleResultId: 123,
     };
-    const { container } = render(
-      <Suspense fallback={null}>
-        <RuleResult {...props} />
-      </Suspense>,
-      renderOpts
-    );
-    expect(container).toMatchSnapshot();
+
+    const rendered = render(<RuleResult {...props} />);
+    await waitForLoad(rendered);
+
+    expect(rendered.container).toMatchSnapshot();
   });
 });

package/src/components/__tests__/RuleResultDecorator.spec.js

@@ -1,5 +1,4 @@
-import React from "react";
-import { render } from "@truedat/test/render";
+import { render, waitForLoad } from "@truedat/test/render";
 import { RuleResultDecorator } from "../RuleResultDecorator";
 
 describe("<RuleResultDecorator />", () => {
@@ -11,39 +10,46 @@ describe("<RuleResultDecorator />", () => {
     },
   };
 
-  it("decorates a percentage result", () => {
+  it("decorates a percentage result", async () => {
     const ruleImplementation = { resultType: "percentage" };
-    const { container, queryByTitle } = render(
+    const rendered = render(
       <RuleResultDecorator ruleImplementation={ruleImplementation} {...props} />
     );
-    expect(container).toMatchSnapshot();
-    expect(container).toHaveTextContent("42%");
-    expect(queryByTitle("Something happened")).toBeInTheDocument();
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+
+    expect(rendered.container).toHaveTextContent(
+      /quality.result.percentage.description/
+    );
+    expect(rendered.queryByTitle("Something happened")).toBeInTheDocument();
   });
 
-  it("decorates an error count result", () => {
+  it("decorates an error count result", async () => {
     const ruleImplementation = { resultType: "errors_number" };
-    const { container, queryByTitle } = render(
+    const rendered = render(
       <RuleResultDecorator ruleImplementation={ruleImplementation} {...props} />
     );
-    expect(container).toMatchSnapshot();
-    expect(container).toHaveTextContent("1,234 errors");
-    expect(queryByTitle("Something happened")).toBeInTheDocument();
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+    expect(rendered.container).toHaveTextContent(
+      /quality.result.errors_number.description/
+    );
+    expect(rendered.queryByTitle("Something happened")).toBeInTheDocument();
   });
 
-  it("decorates an implementation without result data", () => {
+  it("decorates an implementation without result data", async () => {
     const ruleImplementation = { resultType: "errors_number" };
     const ruleResult = { result_text: "no_data" };
     const props = { ruleImplementation, ruleResult };
-    const { container, queryByTitle } = render(
-      <RuleResultDecorator {...props} />
-    );
-    expect(container).toMatchSnapshot();
-    expect(container).toHaveTextContent("No information about quality");
-    expect(queryByTitle("no_data")).toBeInTheDocument();
+    const rendered = render(<RuleResultDecorator {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+
+    expect(rendered.container).toHaveTextContent(/quality.result.no.data/i);
+    expect(rendered.queryByTitle("no_data")).toBeInTheDocument();
   });
 
-  it("decorates a empty dataset result", () => {
+  it("decorates a empty dataset result", async () => {
     const ruleImplementation = { resultType: "percentage" };
     const props = {
       ruleResult: {
@@ -53,15 +59,19 @@ describe("<RuleResultDecorator />", () => {
         result_text: "Empty dataset",
       },
     };
-    const { container } = render(
+    const rendered = render(
       <RuleResultDecorator ruleImplementation={ruleImplementation} {...props} />
     );
-    expect(container).toMatchSnapshot();
-    expect(container).toHaveTextContent("Empty dataset");
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+    expect(rendered.container).toHaveTextContent(
+      /quality_result.empty_dataset/
+    );
   });
 
-  it("handles missing execution result", () => {
-    const { container } = render(<RuleResultDecorator />);
-    expect(container).toBeEmptyDOMElement();
+  it("handles missing execution result", async () => {
+    const rendered = render(<RuleResultDecorator />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toBeEmptyDOMElement();
   });
 });