@truedat/dq 7.5.9 → 7.5.11

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

@@ -1,31 +1,31 @@
-import React from "react";
-import { mount } from "enzyme";
+import { render, waitForLoad } from "@truedat/test/render";
 import { ExecutionGroupLoader } from "../ExecutionGroupLoader";
 
-jest.mock("react-router-dom", () => ({
-  ...jest.requireActual("react-router-dom"),
-  useParams: () => ({ id: 1 })
+jest.mock("react-router", () => ({
+  ...jest.requireActual("react-router"),
+  useParams: () => ({ id: 1 }),
 }));
 
 describe("<ExecutionGroupLoader />", () => {
-  const fetchExecutionGroup = jest.fn();
-  const clearExecutionGroup = jest.fn();
-
-  it("calls fetchExecutionGroup when component mounts but not when it unmounts", () => {
+  it("calls fetchExecutionGroup when component mounts but not when it unmounts", async () => {
     const fetchExecutionGroup = jest.fn();
+    const clearExecutionGroup = jest.fn();
     const props = { clearExecutionGroup, fetchExecutionGroup };
-    const wrapper = mount(<ExecutionGroupLoader {...props} />);
-    expect(fetchExecutionGroup.mock.calls.length).toBe(1);
-    wrapper.unmount();
-    expect(fetchExecutionGroup.mock.calls.length).toBe(1);
+    const rendered = render(<ExecutionGroupLoader {...props} />);
+    await waitForLoad(rendered);
+    expect(fetchExecutionGroup).toHaveBeenCalledTimes(1);
+    rendered.unmount();
+    expect(fetchExecutionGroup).toHaveBeenCalledTimes(1);
   });
 
-  it("calls clearExecutionGroup when component unmounts but not when it mounts", () => {
+  it("calls clearExecutionGroup when component unmounts but not when it mounts", async () => {
+    const fetchExecutionGroup = jest.fn();
     const clearExecutionGroup = jest.fn();
     const props = { clearExecutionGroup, fetchExecutionGroup };
-    const wrapper = mount(<ExecutionGroupLoader {...props} />);
-    expect(clearExecutionGroup.mock.calls.length).toBe(0);
-    wrapper.unmount();
-    expect(clearExecutionGroup.mock.calls.length).toBe(1);
+    const rendered = render(<ExecutionGroupLoader {...props} />);
+    await waitForLoad(rendered);
+    expect(clearExecutionGroup).not.toHaveBeenCalled();
+    rendered.unmount();
+    expect(clearExecutionGroup).toHaveBeenCalledTimes(1);
   });
 });

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

@@ -1,20 +1,16 @@
-import React from "react";
-import { shallow } from "enzyme";
-import { intl } from "@truedat/test/intl-stub";
+import { render, waitForLoad } from "@truedat/test/render";
 import { ExecutionGroupMessage } from "../ExecutionGroupMessage";
 
-// workaround for enzyme issue with React.useContext
-// see https://github.com/airbnb/enzyme/issues/2176#issuecomment-532361526
-jest.spyOn(React, "useContext").mockImplementation(() => intl);
-
 describe("<ExecutionGroupMessage />", () => {
-  it("matches the latest snapshot (pending)", () => {
-    const wrapper = shallow(<ExecutionGroupMessage pending={10} />);
-    expect(wrapper).toMatchSnapshot();
+  it("matches the latest snapshot (pending)", async () => {
+    const rendered = render(<ExecutionGroupMessage pending={10} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("matches the latest snapshot (completed)", () => {
-    const wrapper = shallow(<ExecutionGroupMessage pending={0} count={10} />);
-    expect(wrapper).toMatchSnapshot();
+  it("matches the latest snapshot (completed)", async () => {
+    const rendered = render(<ExecutionGroupMessage pending={0} count={10} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 });

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

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

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

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

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

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

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

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

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

@@ -1,10 +1,9 @@
-import React from "react";
 import { render } from "@truedat/test/render";
 import ImplementationExecutionFilters from "../ImplementationExecutionFilters";
 import { implementationExecutionFiltersMock } from "./__fixtures__/executionMocks";
 
-jest.mock("react-router-dom", () => ({
-  ...jest.requireActual("react-router-dom"),
+jest.mock("react-router", () => ({
+  ...jest.requireActual("react-router"),
   useParams: () => ({ implementation_id: "123" }),
 }));
 

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

@@ -1,4 +1,3 @@
-import React from "react";
 import { render } from "@truedat/test/render";
 import ImplementationExecutions from "../ImplementationExecutions";
 import {
@@ -6,8 +5,8 @@ import {
   implementationExecutionsMock,
 } from "./__fixtures__/executionMocks";
 
-jest.mock("react-router-dom", () => ({
-  ...jest.requireActual("react-router-dom"),
+jest.mock("react-router", () => ({
+  ...jest.requireActual("react-router"),
   useParams: () => ({ implementation_id: "123" }),
 }));
 

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

@@ -1,5 +1,4 @@
-import React from "react";
-import { render } from "@truedat/test/render";
+import { render, waitForLoad } from "@truedat/test/render";
 import ImplementationResultBar from "../ImplementationResultBar";
 
 const implementation = {
@@ -13,33 +12,41 @@ const implementation = {
 };
 
 describe("<ImplementationResultBar />", () => {
-  it("render overGoal implementation", () => {
+  it("render overGoal implementation", async () => {
     const props = {
       implementation: {
         ...implementation,
         results: [{ date: "2021-07-19T00:01:20Z", result: "99.99" }],
       },
     };
-    const { container } = render(<ImplementationResultBar {...props} />);
-    expect(container).toMatchSnapshot();
-    expect(container.querySelector(".over-goal-color")).not.toBeNull();
-    expect(container).toHaveTextContent("99.99% at 2021-07-19 00:01");
+    const rendered = render(<ImplementationResultBar {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+    expect(rendered.container.querySelector(".over-goal-color")).not.toBeNull();
+    expect(rendered.container).toHaveTextContent(
+      /quality.result.percentage.date/i
+    );
   });
 
-  it("render underGoal implementation", () => {
+  it("render underGoal implementation", async () => {
     const props = {
       implementation: {
         ...implementation,
         results: [{ date: "2021-07-19T00:01:20Z", result: "70" }],
       },
     };
-    const { container } = render(<ImplementationResultBar {...props} />);
-    expect(container).toMatchSnapshot();
-    expect(container.querySelector(".under-goal-color")).not.toBeNull();
-    expect(container).toHaveTextContent("70% at 2021-07-19 00:01");
+    const rendered = render(<ImplementationResultBar {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+    expect(
+      rendered.container.querySelector(".under-goal-color")
+    ).not.toBeNull();
+    expect(rendered.container).toHaveTextContent(
+      /quality.result.percentage.date/i
+    );
   });
 
-  it("render underMinimum implementation", () => {
+  it("render underMinimum implementation", async () => {
     const props = {
       implementation: {
         ...implementation,
@@ -48,26 +55,35 @@ describe("<ImplementationResultBar />", () => {
         ],
       },
     };
-    const { container } = render(<ImplementationResultBar {...props} />);
-    expect(container).toMatchSnapshot();
-    expect(container.querySelector(".under-minimum-color")).not.toBeNull();
-    expect(container).toHaveTextContent("40% at 2021-07-19 00:01");
+    const rendered = render(<ImplementationResultBar {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+
+    expect(
+      rendered.container.querySelector(".under-minimum-color")
+    ).not.toBeNull();
+    expect(rendered.container).toHaveTextContent(
+      /quality.result.percentage.date/i
+    );
   });
 
-  it("render not executed implementation", () => {
+  it("render not executed implementation", async () => {
     const props = {
       implementation: {
         ...implementation,
         results: [],
       },
     };
-    const { container } = render(<ImplementationResultBar {...props} />);
-    expect(container).toMatchSnapshot();
-    expect(container.querySelector(".not-executed-color")).not.toBeNull();
-    expect(container).toHaveTextContent("No information about quality");
+    const rendered = render(<ImplementationResultBar {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+    expect(
+      rendered.container.querySelector(".not-executed-color")
+    ).not.toBeNull();
+    expect(rendered.container).toHaveTextContent(/quality.result.no.data/i);
   });
 
-  it("render failed implementation", () => {
+  it("render failed implementation", async () => {
     const props = {
       implementation: {
         ...implementation,
@@ -75,9 +91,10 @@ describe("<ImplementationResultBar />", () => {
         event_type: "FAILED",
       },
     };
-    const { container } = render(<ImplementationResultBar {...props} />);
-    expect(container).toMatchSnapshot();
-    expect(container.querySelector(".failed-color")).not.toBeNull();
-    expect(container).toHaveTextContent("Latest execution failed");
+    const rendered = render(<ImplementationResultBar {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+    expect(rendered.container.querySelector(".failed-color")).not.toBeNull();
+    expect(rendered.container).toHaveTextContent(/quality.error/i);
   });
 });

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

@@ -1,5 +1,4 @@
-import React from "react";
-import { shallow } from "enzyme";
+import { render, waitForLoad } from "@truedat/test/render";
 import { ImplementationSearchResults } from "../ImplementationSearchResults";
 
 jest.mock("@truedat/core/hooks", () => ({
@@ -10,35 +9,27 @@ jest.mock("@truedat/core/hooks", () => ({
 }));
 
 describe("<ImplementationSearchResults />", () => {
-  it("matches the latest snapshot", () => {
+  it("matches the latest snapshot", async () => {
     const props = {
       loading: false,
     };
-    const wrapper = shallow(<ImplementationSearchResults {...props} />);
-    expect(wrapper).toMatchSnapshot();
+    const rendered = render(<ImplementationSearchResults {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("renders executions on when executionEnabled is true", () => {
+  it("renders executions on when executionEnabled is true", async () => {
     const props = {
       loading: false,
       implementationQuery: { filters: { executable: [true] } },
     };
-    const wrapper = shallow(<ImplementationSearchResults {...props} />);
-    expect(wrapper).toMatchSnapshot();
-    expect(
-      wrapper
-        .find("Connect(RuleImplementationsLabelResults)")
-        .prop("executeImplementationsOn")
-    ).toBeTruthy();
-    expect(
-      wrapper
-        .find("Connect(RuleImplementationsActions)")
-        .prop("executeImplementationsOn")
-    ).toBeTruthy();
+    const rendered = render(<ImplementationSearchResults {...props} />);
+    await waitForLoad(rendered);
+
+    expect(rendered.container).toMatchSnapshot();
+
     expect(
-      wrapper
-        .find("Connect(RuleImplementationsTable)")
-        .prop("executeImplementationsOn")
-    ).toBeTruthy();
+      rendered.container.querySelector(".rules-label-results")
+    ).toBeInTheDocument();
   });
 });

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

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

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

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

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

@@ -1,4 +1,4 @@
-import React, { Suspense } from "react";
+import { Suspense } from "react";
 import { waitFor } from "@testing-library/react";
 import { render } from "@truedat/test/render";
 import { ImplementationStructures } from "../ImplementationStructures";
@@ -53,7 +53,6 @@ const groups = [
 
 describe("<ImplementationStructures />", () => {
   const renderOpts = {
-    fallback: "lazy",
     messages: {
       en: {
         "implementationsRelation.master.table.title": "Links to Structures",

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

@@ -1,34 +1,54 @@
-import React, { Suspense } from "react";
-import { render } from "@truedat/test/render";
+import { render, waitForLoad } from "@truedat/test/render";
 import { ImplementationStructuresNew } from "../ImplementationStructuresNew";
 
-describe("<ImplementationStructuresNew />", () => {
-  const renderOpts = {
-    messages: {
-      en: {
-        "actions.create": "create",
-        "actions.cancel": "cancel",
-        "implementationsStructures.new.header": "header",
-        "implementationsStructures.type": "type",
-        "implementationsStructures.type.dataset": "dataset",
-        "implementationsStructures.type.population": "population",
-        "implementationsStructures.type.validation": "validation",
-      },
+jest.mock("@truedat/dd/hooks/useStructures", () => {
+  const originalModule = jest.requireActual("@truedat/dd/hooks/useStructures");
+  const structures = [1, 2, 3].map((id) => ({
+    id,
+    name: `structure_${id}`,
+    type: "table",
+    external_id: `structure_ext_id_${id}`,
+    my_grants: [],
+    my_grant_request: null,
+    user_permissions: {
+      request_grant: true,
     },
+    last_change_at: "2023-04-27",
+  }));
+
+  const data = { data: structures };
+  return {
+    __esModule: true,
+    ...originalModule,
+    useDataStructureFilters: () => ({
+      trigger: () => ({
+        then: (callback) =>
+          callback({
+            data: {},
+          }),
+      }),
+    }),
+    useDataStructureSearch: () => ({
+      trigger: () => ({
+        then: (callback) =>
+          callback({
+            data,
+            headers: {},
+          }),
+      }),
+    }),
   };
+});
 
-  it("matches the latest snapshot", () => {
+describe("<ImplementationStructuresNew />", () => {
+  it("matches the latest snapshot", async () => {
     const props = {
       implementation: {},
       creatingImplementationStructure: false,
-      createImplementationStructure: () => {},
+      createImplementationStructure: jest.fn(),
     };
-    const { container } = render(
-      <Suspense fallback={null}>
-        <ImplementationStructuresNew {...props} />,
-      </Suspense>,
-      renderOpts
-    );
-    expect(container).toMatchSnapshot();
+    const rendered = render(<ImplementationStructuresNew {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 });

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

@@ -1,33 +1,8 @@
-import React from "react";
-import { shallow } from "enzyme";
-import { render } from "@truedat/test/render";
+import { waitFor } from "@testing-library/react";
+import { render, waitForLoad } from "@truedat/test/render";
 import { getValues } from "../ConditionCell";
 import { ImplementationSummary } from "../ImplementationSummary";
 
-const renderOpts = {
-  messages: {
-    en: {
-      "ruleImplementationForm.step.information": "information",
-      "quality.thresholds": "thresholds",
-      "quality.threshold": "threshold",
-      "quality.goal": "goal",
-      "ruleImplementations.props.result_type.percentage": "percentage",
-      "ruleImplementations.summary.headers.population.plural": "populations",
-      "ruleImplementation.summary.field": "Field",
-      "ruleImplementation.summary.operator": "Operator",
-      "ruleImplementation.summary.structure": "Structure",
-      "ruleImplementation.summary.values": "Values",
-      "ruleImplementations.summary.headers.dataset": "Dataset",
-      "ruleImplementations.summary.headers.validations": "Validations",
-      "ruleImplementation.props.executable.true": "Executable",
-      "ruleImplementation.props.executable.false": "Internal",
-      "ruleImplementations.summary.headers.implementation":
-        "Rule Implementation",
-      "ruleImplementation.summary.implementation_key": "Implementation key",
-    },
-  },
-};
-
 const ruleImplementation = {
   implementationKey: "ImplKey",
   executable: true,
@@ -62,7 +37,7 @@ const ruleImplementation = {
 };
 
 describe("<ImplementationSummary />", () => {
-  it("matches the latest snapshot", () => {
+  it("matches the latest snapshot", async () => {
     const steps = [
       "implementationKey",
       "executable",
@@ -74,22 +49,75 @@ describe("<ImplementationSummary />", () => {
       steps,
       ruleImplementation,
     };
-    const wrapper = shallow(<ImplementationSummary {...props} />);
-    expect(wrapper).toMatchSnapshot();
+    const renderOpts = {
+      state: {
+        messages: {
+          en: {
+            "ruleImplementationForm.step.information": "information",
+            "quality.thresholds": "thresholds",
+            "quality.threshold": "threshold",
+            "quality.goal": "goal",
+            "ruleImplementations.props.result_type.percentage": "percentage",
+            "ruleImplementations.summary.headers.population.plural":
+              "populations",
+            "ruleImplementation.summary.field": "Field",
+            "ruleImplementation.summary.operator": "Operator",
+            "ruleImplementation.summary.structure": "Structure",
+            "ruleImplementation.summary.values": "Values",
+            "ruleImplementations.summary.headers.dataset": "Dataset",
+            "ruleImplementations.summary.headers.validations": "Validations",
+            "ruleImplementation.props.executable.true": "Executable",
+            "ruleImplementation.props.executable.false": "Internal",
+            "ruleImplementations.summary.headers.implementation":
+              "Rule Implementation",
+            "ruleImplementation.summary.implementation_key":
+              "Implementation key",
+          },
+        },
+      },
+    };
+    const rendered = render(<ImplementationSummary {...props} />, renderOpts);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("displays correctly validations values of list type", () => {
+  it("displays correctly validations values of list type", async () => {
     const steps = ["dataset", "populations", "validations"];
     const props = {
       steps,
       ruleImplementation,
     };
-    const { container, queryByText } = render(
-      <ImplementationSummary {...props} />,
-      renderOpts
-    );
-    expect(container).toMatchSnapshot();
-    expect(queryByText('"4, 5, 6"')).not.toBeNull();
+    const renderOpts = {
+      state: {
+        messages: {
+          en: {
+            "ruleImplementationForm.step.information": "information",
+            "quality.thresholds": "thresholds",
+            "quality.threshold": "threshold",
+            "quality.goal": "goal",
+            "ruleImplementations.props.result_type.percentage": "percentage",
+            "ruleImplementations.summary.headers.population.plural":
+              "populations",
+            "ruleImplementation.summary.field": "Field",
+            "ruleImplementation.summary.operator": "Operator",
+            "ruleImplementation.summary.structure": "Structure",
+            "ruleImplementation.summary.values": "Values",
+            "ruleImplementations.summary.headers.dataset": "Dataset",
+            "ruleImplementations.summary.headers.validations": "Validations",
+            "ruleImplementation.props.executable.true": "Executable",
+            "ruleImplementation.props.executable.false": "Internal",
+            "ruleImplementations.summary.headers.implementation":
+              "Rule Implementation",
+            "ruleImplementation.summary.implementation_key":
+              "Implementation key",
+          },
+        },
+      },
+    };
+    const rendered = render(<ImplementationSummary {...props} />, renderOpts);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+    expect(rendered.queryByText(/"4, 5, 6"/i)).toBeInTheDocument();
   });
 
   it("getValues returns array of values that contain required keys and adds optional keys for operator with field value_type", () => {

package/src/components/__tests__/Implementations.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 Implementations from "../Implementations";
 
 const props = {
@@ -13,16 +11,12 @@ const renderOpts = {
       query: "foo",
     },
   },
-  fallback: "lazy",
 };
 
 describe("<Implementations />", () => {
   it("matches the latest snapshot", async () => {
-    const { container, queryByText } = render(
-      <Implementations {...props} />,
-      renderOpts
-    );
-    await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
-    expect(container).toMatchSnapshot();
+    const rendered = render(<Implementations {...props} />, renderOpts);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 });