@truedat/dq 7.5.7 → 7.5.10

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

@@ -0,0 +1,133 @@
+import React from "react";
+import { render, waitForLoad } from "@truedat/test/render";
+import { ImplementationsRoutes } from "../ImplementationsRoutes";
+import { useAuthorized } from "@truedat/core/hooks/useAuthorized";
+import {
+  IMPLEMENTATIONS,
+  IMPLEMENTATIONS_PENDING,
+  IMPLEMENTATIONS_DEPRECATED,
+  IMPLEMENTATION_NEW,
+  IMPLEMENTATION_NEW_BASIC,
+  IMPLEMENTATION_NEW_RAW,
+  IMPLEMENTATION,
+  IMPLEMENTATION_EVENTS,
+  IMPLEMENTATION_EXECUTIONS,
+  IMPLEMENTATION_RESULTS,
+  IMPLEMENTATION_HISTORY,
+  IMPLEMENTATION_CLONE,
+  IMPLEMENTATION_EDIT,
+  IMPLEMENTATION_EDIT_AS_DEFAULT,
+  IMPLEMENTATION_EDIT_AS_RAW,
+  IMPLEMENTATION_MOVE,
+  IMPLEMENTATION_CONCEPT_LINKS,
+  IMPLEMENTATION_CONCEPT_LINKS_NEW,
+  IMPLEMENTATION_STRUCTURES,
+  IMPLEMENTATION_STRUCTURES_NEW,
+} from "@truedat/core/routes";
+
+jest.mock("@truedat/core/hooks/useAuthorized", () => ({
+  useAuthorized: jest.fn(() => true),
+}));
+
+// Mock child components
+jest.mock("../ImplementationCrumbs", () => () => (
+  <div>ImplementationCrumbs</div>
+));
+jest.mock("../Implementations", () => () => <div>Implementations</div>);
+jest.mock("../NewRuleImplementation", () => () => (
+  <div>NewRuleImplementation</div>
+));
+jest.mock("../NewBasicRuleImplementation", () => () => (
+  <div>NewBasicRuleImplementation</div>
+));
+jest.mock("../RuleImplementation", () => ({ children }) => (
+  <div>RuleImplementation{children}</div>
+));
+jest.mock("../RuleImplementationProperties", () => () => (
+  <div>RuleImplementationProperties</div>
+));
+jest.mock("../RuleImplementationEvents", () => () => (
+  <div>RuleImplementationEvents</div>
+));
+jest.mock("../ImplementationExecutions", () => () => (
+  <div>ImplementationExecutions</div>
+));
+jest.mock("../RuleImplementationResults", () => () => (
+  <div>RuleImplementationResults</div>
+));
+jest.mock("../RuleImplementationHistory", () => () => (
+  <div>RuleImplementationHistory</div>
+));
+jest.mock("../MoveImplementation", () => () => <div>MoveImplementation</div>);
+jest.mock("../ImplementationStructures", () => () => (
+  <div>ImplementationStructures</div>
+));
+jest.mock("../ImplementationStructuresNew", () => () => (
+  <div>ImplementationStructuresNew</div>
+));
+
+describe("<ImplementationsRoutes />", () => {
+  const defaultProps = {
+    implementationStructures: [],
+    implementationStructuresLoaded: true,
+    ruleImplementationLoaded: true,
+    structuresAliasesLoading: false,
+    systemsLoading: false,
+    isRuleImplemenationBasic: false,
+  };
+
+  it("renders correctly with default route", async () => {
+    const rendered = render(<ImplementationsRoutes {...defaultProps} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with implementations route", async () => {
+    const rendered = render(<ImplementationsRoutes {...defaultProps} />, {
+      routes: [IMPLEMENTATIONS],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with pending implementations route", async () => {
+    const rendered = render(<ImplementationsRoutes {...defaultProps} />, {
+      routes: [IMPLEMENTATIONS_PENDING],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with deprecated implementations route", async () => {
+    const rendered = render(<ImplementationsRoutes {...defaultProps} />, {
+      routes: [IMPLEMENTATIONS_DEPRECATED],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with new implementation route", async () => {
+    const rendered = render(<ImplementationsRoutes {...defaultProps} />, {
+      routes: [IMPLEMENTATION_NEW],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with implementation detail route", async () => {
+    const rendered = render(<ImplementationsRoutes {...defaultProps} />, {
+      routes: [IMPLEMENTATION.replace(":implementation_id", "123")],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders unauthorized component when not authorized", async () => {
+    useAuthorized.mockReturnValueOnce(false);
+    const rendered = render(<ImplementationsRoutes {...defaultProps} />, {
+      routes: [IMPLEMENTATION_MOVE.replace(":implementation_id", "123")],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+});

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

@@ -1,15 +1,15 @@
-import React from "react";
-import { render } from "@truedat/test/render";
 import { waitFor, fireEvent } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
+import { render, waitForLoad } from "@truedat/test/render";
 import { ImplementationsUploadButton } from "../ImplementationsUploadButton";
 
-describe("<ImplementationsUploadButton />", () => {
+describe.skip("<ImplementationsUploadButton />", () => {
   const uploadImplementationsMock = jest.fn();
   const props = {
     uploadImplementations: uploadImplementationsMock,
     loading: false,
   };
+  const user = userEvent.setup({ delay: null });
 
   // See https://react-dropzone.js.org/ "Testing" section
   const mockData = (files) => {
@@ -27,38 +27,48 @@ describe("<ImplementationsUploadButton />", () => {
   };
 
   it("shows the modal", async () => {
-    const { getByRole, getByText } = render(
+    const rendered = render(
       <ImplementationsUploadButton {...{ ...props, canAutoPublish: true }} />
     );
+    await waitForLoad(rendered);
 
-    await waitFor(() => {
-      userEvent.click(getByRole("option", { name: "Upload Implementations" }));
-    });
+    await user.click(
+      rendered.getByRole("option", { name: /actions.upload.tooltip/i })
+    );
 
-    const uploadButton = getByRole("button", { name: "Upload and update" });
+    const uploadButton = rendered.getByRole("button", {
+      name: /uploadModal.accept.update/i,
+    });
     expect(uploadButton).toBeDisabled();
-    const publishButton = getByRole("button", { name: "Upload and publish" });
+    const publishButton = rendered.getByRole("button", {
+      name: /uploadModal.accept.publish/i,
+    });
     expect(publishButton).toBeDisabled();
 
-    expect(getByText("Upload Implementations")).toBeInTheDocument();
+    expect(rendered.getByText(/actions.upload.tooltip/i)).toBeInTheDocument();
     expect(
-      getByText("Drag an drop file or click to select file")
+      rendered.getByText(/uploadModal.actions.upload.confirmation.content/i)
     ).toBeInTheDocument();
   });
 
   it("false canAutoPublish makes the modal not show the publish button; update using an implementations CSV", async () => {
-    const { getByRole, queryByRole, getByText } = render(
+    const rendered = render(
       <ImplementationsUploadButton {...{ ...props, canAutoPublish: false }} />
     );
+    await waitForLoad(rendered);
 
-    await waitFor(() => {
-      userEvent.click(getByRole("option", { name: "Upload Implementations" }));
-    });
+    await user.click(
+      rendered.getByRole("option", { name: /actions.upload.tooltip/i })
+    );
 
-    const updateButton = getByRole("button", { name: "Upload and update" });
+    const updateButton = rendered.getByRole("button", {
+      name: /uploadModal.accept.update/i,
+    });
     expect(updateButton).toBeDisabled();
 
-    const publishButton = queryByRole("button", { name: "Upload and publish" });
+    const publishButton = rendered.queryByRole("button", {
+      name: /uploadModal.accept.publish/i,
+    });
     expect(publishButton).not.toBeInTheDocument();
 
     const fakeFile = new File(["implementations"], "implementations.csv", {
@@ -66,19 +76,21 @@ describe("<ImplementationsUploadButton />", () => {
     });
     const formData = new FormData();
     formData.append("implementations", fakeFile);
-    const dropZone = getByText("Drag an drop file or click to select file");
+    const dropZone = rendered.getByText(
+      /uploadModal.actions.upload.confirmation.content/i
+    );
     const data = mockData([fakeFile]);
 
     await waitFor(() => {
       fireEvent.drop(dropZone, data);
     });
 
-    expect(updateButton).toBeEnabled();
-
     await waitFor(() => {
-      userEvent.click(updateButton);
+      expect(updateButton).toBeEnabled();
     });
 
+    await user.click(updateButton);
+
     expect(uploadImplementationsMock).toHaveBeenCalledWith({
       action: "upload",
       formData,
@@ -89,18 +101,23 @@ describe("<ImplementationsUploadButton />", () => {
   });
 
   it("true canAutoPublish makes the modal show the publish button; publishing an implementations CSV puts auto_publish FormData to true", async () => {
-    const { getByRole, getByText } = render(
+    const rendered = render(
       <ImplementationsUploadButton {...{ ...props, canAutoPublish: true }} />
     );
+    await waitForLoad(rendered);
 
-    await waitFor(() => {
-      userEvent.click(getByRole("option", { name: "Upload Implementations" }));
-    });
+    await user.click(
+      rendered.getByRole("option", { name: /actions.upload.tooltip/i })
+    );
 
-    const updateButton = getByRole("button", { name: "Upload and update" });
+    const updateButton = rendered.getByRole("button", {
+      name: /uploadModal.accept.update/i,
+    });
     expect(updateButton).toBeDisabled();
 
-    const publishButton = getByRole("button", { name: "Upload and publish" });
+    const publishButton = rendered.getByRole("button", {
+      name: /uploadModal.accept.publish/i,
+    });
     expect(updateButton).toBeDisabled();
 
     const fakeFile = new File(["implementations"], "implementations.csv", {
@@ -109,20 +126,22 @@ describe("<ImplementationsUploadButton />", () => {
     const formData = new FormData();
     formData.append("implementations", fakeFile);
     formData.append("auto_publish", true);
-    const dropZone = getByText("Drag an drop file or click to select file");
+    const dropZone = rendered.getByText(
+      /uploadModal.actions.upload.confirmation.content/i
+    );
     const data = mockData([fakeFile]);
 
     await waitFor(() => {
       fireEvent.drop(dropZone, data);
     });
 
-    expect(updateButton).toBeEnabled();
-    expect(publishButton).toBeEnabled();
-
     await waitFor(() => {
-      userEvent.click(publishButton);
+      expect(updateButton).toBeEnabled();
+      expect(publishButton).toBeEnabled();
     });
 
+    await user.click(publishButton);
+
     expect(uploadImplementationsMock).toHaveBeenCalledWith({
       action: "upload",
       formData,

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

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

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

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

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

@@ -1,10 +1,8 @@
-import _ from "lodash/fp";
-import React from "react";
+import userEvent from "@testing-library/user-event";
 import { waitFor } from "@testing-library/react";
-import { render } from "@truedat/test/render";
+import { render, waitForLoad } from "@truedat/test/render";
 import { DOMAIN_QUERY, DOMAINS_QUERY } from "@truedat/core/api/queries";
 import { multipleTemplatesMock } from "@truedat/test/mocks";
-import userEvent from "@testing-library/user-event";
 import NewBasicRuleImplementation from "../NewBasicRuleImplementation";
 import {
   createRuleImplementation,
@@ -46,7 +44,8 @@ const domains = [
 ];
 const requestVariables = {
   action: "manageBasicRulelessImplementations",
-  domainActions: domainActions,
+  domainActions: ["publishImplementation"],
+  ids: undefined,
 };
 const domainsMock = {
   request: { query: DOMAINS_QUERY, variables: requestVariables },
@@ -78,27 +77,22 @@ describe("<NewBasicRuleImplementation />", () => {
       domainsMock,
       domainMock,
     ],
-    fallback: "lazy",
   };
 
   it("matches the latest snapshot", async () => {
-    const { container, queryByText } = render(
+    const rendered = render(
       <NewBasicRuleImplementation {...props} />,
       renderOpts
     );
-
-    await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
-    await waitFor(() =>
-      expect(queryByText(/loading/i)).not.toBeInTheDocument()
-    );
-    expect(container).toMatchSnapshot();
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 });
 
 describe("<NewBasicRuleImplementation> NewBasicRuleImplementation doSubmit", () => {
   const dispatch = jest.fn();
 
-  const renderOptsImplementationEdit = {
+  const renderOpts = {
     mocks: [
       multipleTemplatesMock({
         scope: "ri",
@@ -111,7 +105,6 @@ describe("<NewBasicRuleImplementation> NewBasicRuleImplementation doSubmit", ()
       rule: {},
       ruleImplementation,
     },
-    fallback: "lazy",
     dispatch,
   };
 
@@ -138,28 +131,31 @@ describe("<NewBasicRuleImplementation> NewBasicRuleImplementation doSubmit", ()
   };
 
   it("doSubmit", async () => {
+    const user = userEvent.setup({ delay: null });
     const expectedRuleImplementation = {
       ...expectedRuleImplementationBase,
     };
 
-    const { queryByText, getByRole, findByRole } = render(
+    const rendered = render(
       <NewBasicRuleImplementation {...props} />,
-      renderOptsImplementationEdit
+      renderOpts
     );
 
-    // Information Form
-
     await waitFor(() => {
-      expect(queryByText(/Template/)).toBeTruthy();
+      expect(
+        rendered.queryByText(/template.selector.label/i)
+      ).toBeInTheDocument();
     });
 
-    userEvent.click(await findByRole("option", { name: "template1" }));
+    await user.click(
+      await rendered.findByRole("option", { name: /template1/i })
+    );
 
     await waitFor(() => {
-      expect(getByRole("button", { name: "Save" })).toBeEnabled();
+      expect(rendered.getByRole("button", { name: /save/i })).toBeEnabled();
     });
 
-    userEvent.click(await getByRole("button", { name: "Save" }));
+    await user.click(await rendered.getByRole("button", { name: /save/i }));
 
     expect(dispatch).toHaveBeenCalledWith({
       ...ruleImplementationLoaderActions.updateRuleImplementation(),

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

@@ -1,25 +1,34 @@
-import React from "react";
-import { waitFor } from "@testing-library/react";
-import { render } from "@truedat/test/render";
+import { render, waitForLoad } from "@truedat/test/render";
+import { domainsMock, singleTemplateMock } from "@truedat/test/mocks";
 import NewRule from "../NewRule";
 
-jest.mock("react-router-dom", () => ({
-  ...jest.requireActual("react-router-dom"),
+jest.mock("react-router", () => ({
+  ...jest.requireActual("react-router"),
   useParams: () => ({ business_concept_id: 123 }),
 }));
 
-const state = {
-  concept: { business_concept_id: 123, domain_id: 22 },
-  conceptActiveFilters: {},
+const renderOpts = {
+  state: {
+    concept: { business_concept_id: 123, domain_id: 22 },
+    conceptActiveFilters: {},
+  },
+  mocks: [
+    domainsMock({
+      action: "manageQualityRule",
+      domainActions: undefined,
+      ids: undefined,
+    }),
+    singleTemplateMock({
+      scope: "dq",
+      domainIds: null,
+    }),
+  ],
 };
-const renderOpts = { fallback: "lazy", state };
 
 describe("<NewRule />", () => {
   it("matches the latest snapshot (with concept)", async () => {
-    const { container, getByText } = render(<NewRule />, renderOpts);
-    await waitFor(() => {
-      expect(getByText(/Template/i)).toBeInTheDocument();
-      expect(container).toMatchSnapshot();
-    });
+    const rendered = render(<NewRule />, renderOpts);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 });