@truedat/bg 7.5.9 → 7.5.11

package/src/taxonomy/components/__tests__/DomainStructures.spec.js

@@ -1,5 +1,4 @@
-import React from "react";
-import { render } from "@truedat/test/render";
+import { render, waitForLoad } from "@truedat/test/render";
 import { waitFor } from "@testing-library/react";
 import SearchContextWrapper from "@truedat/core/components/common/SearchContextWrapper";
 import DomainStructures from "../DomainStructures";
@@ -29,62 +28,22 @@ jest.mock("@truedat/dd/hooks/useStructures", () => {
     }),
   };
 });
+jest.mock("@truedat/core/hooks/useUserFilters");
 
 describe("<DomainStructures />", () => {
-  const renderOpts = {
-    messages: {
-      en: {
-        "search.placeholder": "Search...",
-        "structures.loading.header": "Loading structures...",
-        "structures.actions.download.tooltip": "Download structures metadata",
-        "structures.actions.download.popup":
-          "You must search or filter to download structures",
-        "structures.actions.editableDownload.tooltip":
-          "Download editable structures metadata",
-        "structures.props.deleted_at": "Deleted",
-        "structures.props.inserted_at": "Inserted",
-        "structures.props.description": "Description",
-        "structures.props.path": "Path",
-        "structures.props.metadata": "Metadata",
-        "structures.props.system": "System",
-        "structures.props.domain": "Domain",
-        "structures.props.group": "Group",
-        "structures.props.external_id": "External Id",
-        "structures.props.link_to_structure": "Link to structure",
-        "structures.props.alias_name": "Alias",
-        "structures.props.tech_name": "Technical Name",
-        "structures.props.type": "Type",
-        "structure.type.undefined.text": "text",
-        "structure.updated_at": "updated_at",
-        "search.placeholder": "Search...",
-        "structure.group": "Group",
-        "structure.system": "System",
-        "structure.name": "Name",
-        "structures.retrieved.results": "Results",
-        "structures.loading.header": "Header",
-        "structure.relation.relation_type_name": "type",
-        "structure.type": "type",
-        "structures.not_found.header": "Header",
-        "structures.not_found.body":
-          "No structures have been found matching these filters.",
-      },
-    },
-    fallback: "lazy",
-  };
+  const props = { domain: { id: 1, name: "domain" } };
 
   it("matches the latest snapshot", async () => {
-    const props = { domain: { id: 1, name: "domain" } };
-    const { container, findByText } = render(
-      <SearchContextWrapper>
-        <DomainStructures {...props} />
-      </SearchContextWrapper>,
-      renderOpts
+    const rendered = render(
+      <SearchContextWrapper><DomainStructures {...props} /></SearchContextWrapper>
     );
+    await waitForLoad(rendered);
     await waitFor(() =>
-      expect(container.querySelector(".loader")).not.toBeInTheDocument()
+      expect(
+        rendered.queryByText(/structures.not_found.body/i)
+      ).toBeInTheDocument()
     );
-    await findByText(/No structures have been found matching these filters./);
 
-    expect(container).toMatchSnapshot();
+    expect(rendered.container).toMatchSnapshot();
   });
 });

package/src/taxonomy/components/__tests__/DomainTabs.spec.js

@@ -1,4 +1,3 @@
-import React from "react";
 import { render } from "@truedat/test/render";
 import { useAuthorized } from "@truedat/core/hooks";
 import DomainTabs from "../DomainTabs";
@@ -9,7 +8,7 @@ jest.mock("@truedat/core/hooks", () => ({
 
 describe("<DomainTabs />", () => {
   const domain = {
-    id: 1,
+    id: "1",
     name: "Test Domain",
   };
 
@@ -18,37 +17,23 @@ describe("<DomainTabs />", () => {
     hiddenTabs: [],
   };
 
-  const renderOpts = {
-    messages: {
-      en: {
-        "tabs.subdomains": "Subdomains",
-        "tabs.concepts": "Concepts",
-        "tabs.structures": "Structures",
-        "tabs.implementations": "Implementations",
-        "tabs.members": "Members",
-      },
-    },
-  };
-
   it("matches the latest snapshot", () => {
     const { container } = render(
-      <DomainTabs domain={domain} taxonomyConfig={taxonomyConfig} />,
-      renderOpts
+      <DomainTabs domain={domain} taxonomyConfig={taxonomyConfig} />
     );
     expect(container).toMatchSnapshot();
   });
 
   it("renders all tabs", () => {
     const { getByText } = render(
-      <DomainTabs domain={domain} taxonomyConfig={taxonomyConfig} />,
-      renderOpts
+      <DomainTabs domain={domain} taxonomyConfig={taxonomyConfig} />
     );
 
-    expect(getByText("Subdomains")).toBeInTheDocument();
-    expect(getByText("Concepts")).toBeInTheDocument();
-    expect(getByText("Structures")).toBeInTheDocument();
-    expect(getByText("Implementations")).toBeInTheDocument();
-    expect(getByText("Members")).toBeInTheDocument();
+    expect(getByText("tabs.subdomains")).toBeInTheDocument();
+    expect(getByText("tabs.concepts")).toBeInTheDocument();
+    expect(getByText("tabs.structures")).toBeInTheDocument();
+    expect(getByText("tabs.implementations")).toBeInTheDocument();
+    expect(getByText("tabs.members")).toBeInTheDocument();
   });
 
   it("hides tabs based on hiddenTabs config", () => {
@@ -58,8 +43,7 @@ describe("<DomainTabs />", () => {
     };
 
     const { queryByText } = render(
-      <DomainTabs domain={domain} taxonomyConfig={hiddenTabsConfig} />,
-      renderOpts
+      <DomainTabs domain={domain} taxonomyConfig={hiddenTabsConfig} />
     );
 
     expect(queryByText("Structures")).not.toBeInTheDocument();
@@ -73,13 +57,12 @@ describe("<DomainTabs />", () => {
     };
 
     const { container } = render(
-      <DomainTabs domain={domain} taxonomyConfig={priorityTabsConfig} />,
-      renderOpts
+      <DomainTabs domain={domain} taxonomyConfig={priorityTabsConfig} />
     );
 
     const tabs = container.querySelectorAll(".item");
-    expect(tabs[0].textContent).toBe("Implementations");
-    expect(tabs[1].textContent).toBe("Concepts");
+    expect(tabs[0].textContent).toBe("tabs.implementations");
+    expect(tabs[1].textContent).toBe("tabs.concepts");
   });
 
   it("hides 'implementations' tab if dqAuthorized is false", () => {
@@ -88,8 +71,7 @@ describe("<DomainTabs />", () => {
     );
 
     const { queryByText } = render(
-      <DomainTabs domain={domain} taxonomyConfig={taxonomyConfig} />,
-      renderOpts
+      <DomainTabs domain={domain} taxonomyConfig={taxonomyConfig} />
     );
 
     expect(queryByText("Implementations")).not.toBeInTheDocument();
@@ -99,8 +81,7 @@ describe("<DomainTabs />", () => {
     useAuthorized.mockImplementation((permission) => permission == "quality");
 
     const { queryByText } = render(
-      <DomainTabs domain={domain} taxonomyConfig={taxonomyConfig} />,
-      renderOpts
+      <DomainTabs domain={domain} taxonomyConfig={taxonomyConfig} />
     );
 
     expect(queryByText("Structures")).not.toBeInTheDocument();

package/src/taxonomy/components/__tests__/DomainTaxonomy.spec.js

@@ -1,6 +1,5 @@
 import _ from "lodash/fp";
-import React from "react";
-import { shallow } from "enzyme";
+import { render, waitForLoad } from "@truedat/test/render";
 import { DomainTaxonomy } from "../DomainTaxonomy";
 
 describe("<DomainTaxonomy />", () => {
@@ -8,28 +7,30 @@ describe("<DomainTaxonomy />", () => {
     id: 3,
     parents: [
       { id: 1, name: "foo", external_id: "foo" },
-      { id: 2, name: "bar", external_id: "bar" }
-    ]
+      { id: 2, name: "bar", external_id: "bar" },
+    ],
   };
 
-  it("matches the latest snapshot when we have parents", () => {
+  it("matches the latest snapshot when we have parents", async () => {
     const props = { domain };
-    const wrapper = shallow(<DomainTaxonomy {...props} />);
-    expect(wrapper).toMatchSnapshot();
+    const rendered = render(<DomainTaxonomy {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("matches the latest snapshot if no parents provided", () => {
+  it("matches the latest snapshot if no parents provided", async () => {
     const props = { domain: _.omit(["parents"])(domain) };
-    const wrapper = shallow(<DomainTaxonomy {...props} />);
-    expect(wrapper).toMatchSnapshot();
+    const rendered = render(<DomainTaxonomy {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("renders parents reversed", () => {
+  it("renders parents reversed", async () => {
     const props = { domain };
-    const wrapper = shallow(<DomainTaxonomy {...props} />);
-    const DomainItem = wrapper.find("DomainItem");
-    expect(DomainItem).toHaveLength(2);
-    expect(DomainItem.at(0).prop("domain")).toEqual(domain.parents[1]);
-    expect(DomainItem.at(1).prop("domain")).toEqual(domain.parents[0]);
+    const rendered = render(<DomainTaxonomy {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container.querySelectorAll(".highlighted")).toHaveLength(2);
+    expect(rendered.getAllByText(/bar/i)).toHaveLength(1);
+    expect(rendered.getAllByText(/foo/i)).toHaveLength(1);
   });
 });

package/src/taxonomy/components/__tests__/Domains.spec.js

@@ -1,23 +1,22 @@
-import React from "react";
-import { waitFor } from "@testing-library/react";
-import { DOMAINS_QUERY } from "@truedat/core/api/queries";
+import { useParams, useNavigate } from "react-router";
 import userEvent from "@testing-library/user-event";
-import { useParams, useHistory } from "react-router-dom";
-import { render } from "@truedat/test/render";
+import { render, waitForLoad } from "@truedat/test/render";
+import { domainsMock } from "@truedat/test/mocks";
 import { useDomains } from "../../../hooks/useDomains";
 import Domains from "../Domains";
 
 jest.mock("../../assets/searching.png", () => "mocked-searching.png");
 
-jest.mock("react-router-dom", () => ({
-  ...jest.requireActual("react-router-dom"),
-  useHistory: jest.fn(),
+jest.mock("react-router", () => ({
+  ...jest.requireActual("react-router"),
   useParams: jest.fn(() => ({ id: 3 })),
+  useNavigate: jest.fn(),
 }));
 
-jest.mock("../../../hooks/useDomains", () => ({
-  ...jest.requireActual("../../../hooks/useDomains"),
-  useDomains: jest.fn(() => ({
+jest.mock("../../../hooks/useDomains");
+
+useDomains.mockImplementation(
+  jest.fn(() => ({
     data: [
       {
         description: "No tiene padre",
@@ -107,8 +106,8 @@ jest.mock("../../../hooks/useDomains", () => ({
         method: "GET",
       },
     },
-  })),
-}));
+  }))
+);
 
 const domains = [
   {
@@ -122,66 +121,54 @@ const domains = [
 
 const variables = {
   action: "viewDomain",
-};
-
-const domainsMock = {
-  request: { query: DOMAINS_QUERY, variables },
-  result: { data: { domains: domains } },
+  domainActions: undefined,
+  ids: undefined,
 };
 
 const renderOpts = {
-  mocks: [domainsMock, domainsMock],
-  fallback: "lazy",
+  mocks: [
+    domainsMock({ action: "viewDomain", fetchPolicy: "no-cache" }, domains),
+    domainsMock(variables, domains),
+    domainsMock(variables, domains),
+  ],
 };
 
 describe("<Domains />", () => {
   it("matches the latest snapshot", async () => {
-    const { container, queryByText } = render(<Domains />, renderOpts);
-
-    await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
-    await waitFor(() =>
-      expect(queryByText(/loading/i)).not.toBeInTheDocument()
-    );
-    expect(container).toMatchSnapshot();
+    const rendered = render(<Domains />, renderOpts);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
   it("renders the correct number of domain elements", async () => {
-    const { getAllByText, queryByText } = render(<Domains />, renderOpts);
-
-    await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
-    await waitFor(() =>
-      expect(queryByText(/loading/i)).not.toBeInTheDocument()
-    );
-    const domainElements = getAllByText(/element_/);
+    const rendered = render(<Domains />, renderOpts);
+    await waitForLoad(rendered);
+    const domainElements = rendered.getAllByText(/element_/i);
     expect(domainElements.length).toBe(2);
   });
 
   it("renders domain elements with correct names", async () => {
-    const { getByText, queryByText } = render(<Domains />, renderOpts);
-    await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
-    await waitFor(() =>
-      expect(queryByText(/loading/i)).not.toBeInTheDocument()
-    );
+    const rendered = render(<Domains />, renderOpts);
+    await waitForLoad(rendered);
 
-    expect(getByText("element_2")).toBeInTheDocument();
-    expect(getByText("element_3")).toBeInTheDocument();
+    expect(rendered.getByText(/element_2/i)).toBeInTheDocument();
+    expect(rendered.getByText(/element_3/i)).toBeInTheDocument();
 
-    expect(queryByText("element_1")).not.toBeInTheDocument();
-    expect(queryByText("element_4")).not.toBeInTheDocument();
-    expect(queryByText("element_5")).not.toBeInTheDocument();
-    expect(queryByText("element_6")).not.toBeInTheDocument();
+    expect(rendered.queryByText(/element_1/i)).not.toBeInTheDocument();
+    expect(rendered.queryByText(/element_4/i)).not.toBeInTheDocument();
+    expect(rendered.queryByText(/element_5/i)).not.toBeInTheDocument();
+    expect(rendered.queryByText(/element_6/i)).not.toBeInTheDocument();
   });
 
   it("redirects to domains list if domainId is invalid", async () => {
     const mockHistoryPush = jest.fn();
-    useHistory.mockImplementationOnce(() => ({ push: mockHistoryPush }));
+    useNavigate.mockImplementationOnce(() => mockHistoryPush);
     useParams.mockImplementationOnce(() => ({ id: 999 }));
 
-    render(<Domains />, renderOpts);
+    const rendered = render(<Domains />, renderOpts);
+    await waitForLoad(rendered);
 
-    await waitFor(() => {
-      expect(mockHistoryPush).toHaveBeenCalledWith("/domains");
-    });
+    expect(mockHistoryPush).toHaveBeenCalledWith("/domains");
   });
 
   it("renders EmptyImage when no domains available", async () => {
@@ -192,67 +179,48 @@ describe("<Domains />", () => {
       loading: false,
     }));
     const mockHistoryPush = jest.fn();
-    useHistory.mockImplementationOnce(() => ({ push: mockHistoryPush }));
+    useNavigate.mockImplementationOnce(() => mockHistoryPush);
 
-    const { queryByText } = render(<Domains />, renderOpts);
+    const rendered = render(<Domains />, renderOpts);
+    await waitForLoad(rendered);
 
-    await waitFor(() => {
-      expect(
-        queryByText(
-          "Please, select a domain on the left pane to see the detail."
-        )
-      ).toBeInTheDocument();
-    });
+    expect(rendered.getByText(/domains.general.message/i)).toBeInTheDocument();
   });
 
   it("handles grid control buttons correctly", async () => {
-    const { container, queryByText, queryByTestId } = render(
-      <Domains />,
-      renderOpts
-    );
-
-    await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
-    await waitFor(() =>
-      expect(queryByText(/loading/i)).not.toBeInTheDocument()
-    );
+    const user = userEvent.setup({ delay: null });
+    const rendered = render(<Domains />, renderOpts);
+    await waitForLoad(rendered);
 
-    await waitFor(() => {
-      expect(
-        container.querySelector(".taxonomy-domains-breadcrumb")
-      ).toBeInTheDocument();
-    });
+    expect(
+      rendered.container.querySelector(".taxonomy-domains-breadcrumb")
+    ).toBeInTheDocument();
 
-    const hideButton = container.querySelector(
-      "button[data-tooltip='Hide Domains List']"
+    const hideButton = rendered.container.querySelector(
+      "button[data-tooltip='domains.list.hide']"
     );
 
-    const minimizeButton = container.querySelector(
+    const minimizeButton = rendered.container.querySelector(
       "button[data-tooltip='domains.list.minimize']"
     );
 
-    const maximizeButton = container.querySelector(
+    const maximizeButton = rendered.container.querySelector(
       "button[data-tooltip='domains.list.maximize']"
     );
 
-    userEvent.click(hideButton);
-    await waitFor(() => {
-      expect(
-        container.querySelector(".taxonomy-domains-grid-animation")
-      ).toBeNull();
-    });
+    await user.click(hideButton);
+    expect(
+      rendered.container.querySelector(".taxonomy-domains-grid-animation")
+    ).toBeNull();
 
-    userEvent.click(minimizeButton);
-    await waitFor(() => {
-      expect(
-        container.querySelector(".taxonomy-domains-grid-animation")
-      ).toBeNull();
-    });
+    await user.click(minimizeButton);
+    expect(
+      rendered.container.querySelector(".taxonomy-domains-grid-animation")
+    ).toBeNull();
 
-    userEvent.click(maximizeButton);
-    await waitFor(() => {
-      expect(
-        container.querySelector(".taxonomy-domains-grid-animation")
-      ).toBeInTheDocument();
-    });
+    await user.click(maximizeButton);
+    expect(
+      rendered.container.querySelector(".taxonomy-domains-grid-animation")
+    ).toBeInTheDocument();
   });
 });

package/src/taxonomy/components/__tests__/DomainsActions.spec.js

@@ -1,22 +1,23 @@
-import React from "react";
-import { render } from "@truedat/test/render";
+import { render, waitForLoad } from "@truedat/test/render";
 import { DomainsActions } from "../DomainsActions";
 
 describe("<DomainsActions />", () => {
-  it("matches the latest snapshot", () => {
+  it("matches the latest snapshot", async () => {
     const actions = {
       create: { href: "/api/domains", input: {}, method: "POST" },
       index: { href: "/api/domains", input: {}, method: "GET" },
     };
-    const { container, getByText } = render(
-      <DomainsActions actions={actions} />
-    );
-    expect(container).toMatchSnapshot();
-    expect(getByText("New Domain")).toBeInTheDocument();
+    const rendered = render(<DomainsActions actions={actions} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+    expect(rendered.getByText(/domains.actions.create/i)).toBeInTheDocument();
   });
 
-  it("Do not show the button if not have actions", () => {
-    const { queryByText } = render(<DomainsActions />);
-    expect(queryByText("New Domain")).not.toBeInTheDocument();
+  it("does not show the button if no actions exist", async () => {
+    const rendered = render(<DomainsActions />);
+    await waitForLoad(rendered);
+    expect(
+      rendered.queryByText(/domains.actions.create/i)
+    ).not.toBeInTheDocument();
   });
 });

package/src/taxonomy/components/__tests__/EditDomain.spec.js

@@ -1,65 +1,24 @@
-import React from "react";
-import { useHistory } from "react-router-dom";
-import { useQuery } from "@apollo/client";
-import { render } from "@truedat/test/render";
-import { useDomainUpdate } from "../../../hooks/useDomains";
+import { render, waitForLoad } from "@truedat/test/render";
+import { domainsMock } from "@truedat/test/mocks";
 import { EditDomain } from "../EditDomain";
 
-jest.mock("react-router-dom", () => ({
-  ...jest.requireActual("react-router-dom"),
-  useHistory: jest.fn(),
-}));
-
-jest.mock("../../../hooks/useDomains", () => ({
-  ...jest.requireActual("../../../hooks/useDomains"),
-  useDomainUpdate: jest.fn(),
-}));
-
-jest.mock("@apollo/client", () => ({
-  ...jest.requireActual("@apollo/client"),
-  useQuery: jest.fn(),
-}));
+jest.mock("../../../hooks/useDomains");
 
 const renderOpts = {
-  messages: {
-    en: {
-      "actions.save": "Save",
-      "actions.cancel": "Cancel",
-      "domain.actions.edit.header": "Edit domain",
-      "domain.label.domain_group": "New Group ",
-      "domain.props.name": "Name",
-      "domain.props.name.placeholder": "Name-placeholder",
-      "domain.props.external_id": "External_id",
-      "domain.props.external_id.placeholder": "External_id-placeholder",
-      "domain.props.domain_group": "Domain_group",
-      "domain.props.domain_group.placeholder": "Domain_group-placeholder",
-      "domain.props.type": "Type",
-      "domain.props.type.placeholder": "Type-placeholder",
-      "domain.props.description.placeholder": "Description-placeholder",
-      "domain.props.description": "Description",
-      "form.validation.required": "{prop} is required",
-    },
-  },
-  fallback: "lazy",
+  mocks: [
+    domainsMock({
+      action: "viewDomain",
+      fetchPolicy: "no-cache",
+    }),
+  ],
 };
 
 describe("<EditDomain />", () => {
-  const mockHistoryPush = jest.fn();
-  const mockCreateDomain = jest.fn();
-  const mockClientResetStore = jest.fn();
-
   const domain = { id: 1, name: "nn", description: "dd" };
 
-  beforeEach(() => {
-    useHistory.mockReturnValue({ push: mockHistoryPush });
-    useDomainUpdate.mockReturnValue({ trigger: mockCreateDomain });
-    useQuery.mockReturnValue({
-      client: { resetStore: mockClientResetStore },
-    });
-  });
-
-  it("matches the latest snapshot", () => {
-    const { container } = render(<EditDomain domain={domain} />, renderOpts);
-    expect(container).toMatchSnapshot();
+  it("matches the latest snapshot", async () => {
+    const rendered = render(<EditDomain domain={domain} />, renderOpts);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 });