@truedat/bg 7.5.8 → 7.5.10

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

@@ -1,168 +1,148 @@
-import _ from "lodash/fp";
 import React from "react";
-import { render } from "@truedat/test/render";
-import { MemoryRouter } from "react-router-dom";
+import { render, waitForLoad } from "@truedat/test/render";
 import DomainContent from "../DomainContent";
+import { useAuthorized } from "@truedat/core/hooks/useAuthorized";
+import {
+  DOMAIN_CONCEPTS,
+  DOMAIN_IMPLEMENTATIONS,
+  DOMAIN_MEMBERS,
+  DOMAIN_MEMBERS_NEW,
+  DOMAIN_STRUCTURES,
+  DOMAIN_SUBDOMAINS,
+} from "@truedat/core/routes";
 
-jest.mock("../../../hooks/useDomains", () => ({
-  ...jest.requireActual("../../../hooks/useDomains"),
-  useDomain: jest.fn((domainId) => ({
-    data: {
-      description: "DOMAIN DESCRIPTION",
-      domain_group: null,
-      external_id: "EXTERNAL ID",
-      id: domainId,
-      name: "DOMAIN NAME",
-      parent_id: 6,
-      parents: null,
-      type: null,
-    },
-  })),
+jest.mock("@truedat/core/hooks/useAuthorized", () => ({
+  useAuthorized: jest.fn(() => true),
 }));
 
+// Mock child components
+jest.mock("../../../concepts/components/DomainConcepts", () => () => (
+  <div>DomainConcepts</div>
+));
+
+jest.mock("../DomainCards", () => () => <div>DomainCards</div>);
+
+jest.mock("../DomainStructures", () => () => <div>DomainStructures</div>);
+
+jest.mock("../DomainImplementations", () => () => (
+  <div>DomainImplementations</div>
+));
+
+jest.mock("../DomainMembers", () => () => <div>DomainMembers</div>);
+
+jest.mock("../AddDomainMember", () => () => <div>AddDomainMember</div>);
+
+jest.mock("@truedat/dd/components/UserSearchFiltersLoader", () => () => (
+  <div>UserSearchFiltersLoader</div>
+));
+
+jest.mock("@truedat/auth/roles/components/RolesLoader", () => () => (
+  <div>RolesLoader</div>
+));
+
 describe("<DomainContent />", () => {
-  const domains = [
-    {
-      id: 1,
-      name: "rootNoSub",
-      type: null,
-      description: "Root domain with no subdomains",
-      parents: [
-        {
-          id: 1,
-          name: "rootNoSub",
-          external_id: "rootNoSub",
-        },
-      ],
-      domain_group: {
-        id: 1,
-        name: "DomainGroup",
-      },
-      parent_id: null,
-      external_id: "rootNoSub",
-    },
-    {
-      id: 2,
-      name: "rootWithSub",
-      type: null,
-      description: null,
-      parents: [
-        {
-          id: 2,
-          name: "rootWithSub",
-          external_id: "rootWithSub",
-        },
-      ],
-      domain_group: {
-        id: 1,
-        name: "DomainGroup",
-      },
-      parent_id: null,
-      external_id: "rootWithSub",
-    },
-    {
-      id: 3,
-      name: "rootOtherGroup",
-      type: null,
-      description: null,
-      parents: [
-        {
-          id: 3,
-          name: "rootOtherGroup",
-          external_id: "rootOtherGroup",
-        },
-      ],
-      domain_group: {
-        id: 2,
-        name: "OtherDomainGroup",
-      },
-      parent_id: null,
-      external_id: "rootOtherGroup",
-    },
-    {
-      id: 4,
-      name: "childSubdomain",
-      type: null,
-      description: null,
-      parents: [
-        {
-          id: 3,
-          name: "childSubdomain",
-          external_id: "subdomain",
-        },
-        {
-          id: 2,
-          name: "rootWithSub",
-          external_id: "rootWithSub",
-        },
-      ],
-      domain_group: {
-        id: 1,
-        name: "DomainGroup",
-      },
-      parent_id: 2,
-      external_id: "subdomain",
-    },
-  ];
-
-  const taxonomyConfig = {
-    priorityTabs: [],
-    hiddenTabs: [],
+  const domain = {
+    id: "1",
+    name: "Test Domain",
   };
 
-  const testList = [
-    {
-      content: "subdomains",
-      domainId: 1,
-      textToSearch: "This domain has no subdomains",
-    },
-    {
-      content: "subdomains",
-      domainId: 2,
-      textToSearch: "childSubdomain",
-    },
-    {
-      content: "concepts",
-      domainId: 1,
-      textToSearch: "Searching...",
-    },
-    {
-      content: "structures",
-      domainId: 1,
-      textToSearch: "You are not authorized to view this content",
-    },
-    {
-      content: "implementations",
-      domainId: 1,
-      textToSearch: "You are not authorized to view this content",
-    },
-    {
-      content: "members",
-      domainId: 1,
-      textToSearch: "This domain has no members",
-    },
-  ];
-  const renderOpts = {
-    mocks: [],
-    fallback: "lazy",
-  };
+  const domains = [domain];
+
+  it("renders correctly with default route", async () => {
+    const rendered = render(
+      <DomainContent domain={domain} domains={domains} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with concepts route", async () => {
+    const rendered = render(
+      <DomainContent domain={domain} domains={domains} />,
+      {
+        routes: [DOMAIN_CONCEPTS],
+      }
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with structures route", async () => {
+    const rendered = render(
+      <DomainContent domain={domain} domains={domains} />,
+      {
+        routes: [DOMAIN_STRUCTURES],
+      }
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders unauthorized component when not authorized for structures", async () => {
+    useAuthorized.mockReturnValueOnce(false);
+    const rendered = render(
+      <DomainContent domain={domain} domains={domains} />,
+      {
+        routes: [DOMAIN_STRUCTURES],
+      }
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with implementations route", async () => {
+    const rendered = render(
+      <DomainContent domain={domain} domains={domains} />,
+      {
+        routes: [DOMAIN_IMPLEMENTATIONS],
+      }
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders unauthorized component when not authorized for implementations", async () => {
+    useAuthorized.mockReturnValueOnce(false);
+    const rendered = render(
+      <DomainContent domain={domain} domains={domains} />,
+      {
+        routes: [DOMAIN_IMPLEMENTATIONS],
+      }
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with members route", async () => {
+    const rendered = render(
+      <DomainContent domain={domain} domains={domains} />,
+      {
+        routes: [DOMAIN_MEMBERS],
+      }
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with new member route", async () => {
+    const rendered = render(
+      <DomainContent domain={domain} domains={domains} />,
+      {
+        routes: [DOMAIN_MEMBERS_NEW],
+      }
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
 
-  test.each(testList)(
-    "Render %s content for %s domain with text %s",
-    ({ content, domainId, textToSearch }) => {
-      const domain = _.find(["id", domainId])(domains);
-      const { container, getByText } = render(
-        <MemoryRouter initialEntries={[`/domains/${domainId}/${content}`]}>
-          <DomainContent
-            domain={domain}
-            domains={domains}
-            taxonomyConfig={taxonomyConfig}
-          />
-        </MemoryRouter>,
-        renderOpts
-      );
-      expect(container).toMatchSnapshot();
-      expect(getByText(textToSearch)).toBeInTheDocument();
-    }
-  );
+  it("renders correctly with subdomains route", async () => {
+    const rendered = render(
+      <DomainContent domain={domain} domains={domains} />,
+      {
+        routes: [DOMAIN_SUBDOMAINS],
+      }
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
 });

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

@@ -1,30 +1,25 @@
-import React from "react";
-import { render } from "@truedat/test/render";
-import { useDomains } from "../../../hooks/useDomains";
+import { render, waitForLoad } from "@truedat/test/render";
 import { DomainCrumbs } from "../DomainCrumbs";
 
 jest.mock("../../../hooks/useDomains", () => ({
   ...jest.requireActual("../../../hooks/useDomains"),
-  useDomains: jest.fn(),
+  useDomains: () => ({
+    data: [
+      { id: "1", name: "foo", parent_id: null },
+      { id: "2", name: "bar", parent_id: "1" },
+      { id: "3", name: "baz", parent_id: "2" },
+      { id: "4", name: "qux", parent_id: null },
+    ],
+  }),
 }));
 
 describe("<DomainCrumbs />", () => {
-  const domain = { id: 3, name: "domain" };
+  const domain = { id: "3", name: "domain" };
   const props = { domain, actionCrumb: "domain" };
 
-  beforeEach(() => {
-    require("../../../hooks/useDomains").useDomains.mockReturnValue({
-      data: [
-        { id: 1, name: "foo", parent_id: null },
-        { id: 2, name: "bar", parent_id: 1 },
-        { id: 3, name: "baz", parent_id: 2 },
-        { id: 4, name: "qux", parent_id: null },
-      ],
-    });
-  });
-
-  it("matches the latest snapshot", () => {
-    const { container } = render(<DomainCrumbs {...props} />);
-    expect(container).toMatchSnapshot();
+  it("matches the latest snapshot", async () => {
+    const rendered = render(<DomainCrumbs {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 });

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

@@ -1,4 +1,3 @@
-import React from "react";
 import { render } from "@truedat/test/render";
 import { DomainDetail } from "../DomainDetail";
 
@@ -14,7 +13,7 @@ jest.mock("../../../hooks/useDomains", () => ({
 }));
 
 describe("<DomainDetail />", () => {
-  const id = 7;
+  const id = "7";
   const props = { id };
 
   beforeEach(() => {
@@ -23,7 +22,7 @@ describe("<DomainDetail />", () => {
         description: "el padre es element_6",
         domain_group: null,
         external_id: "7",
-        id: 7,
+        id: "7",
         name: "element_7",
         parent_id: 6,
         parents: null,

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

@@ -1,7 +1,6 @@
-import React from "react";
 import userEvent from "@testing-library/user-event";
-import { fireEvent, waitFor } from "@testing-library/react";
-import { render } from "@truedat/test/render";
+import { act } from "@testing-library/react";
+import { render, waitForLoad } from "@truedat/test/render";
 import { DomainForm } from "../DomainForm";
 import { useDomains } from "../../../hooks/useDomains";
 
@@ -83,30 +82,6 @@ jest.mock("../../../hooks/useDomains", () => ({
   })),
 }));
 
-const renderOpts = {
-  messages: {
-    en: {
-      "domain.label.domain_group": "New Group ",
-      "form.validation.required": "Prop is required",
-      "domain.props.parent": "Parent Domain",
-      "domain.selector.placeholder": "Select a domain...",
-      "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",
-      "actions.save": "Save",
-      "actions.cancel": "Cancel",
-    },
-  },
-  fallback: "lazy",
-};
-
 describe("<DomainForm />", () => {
   const onSubmit = jest.fn();
   const domain = { id: 1, name: "nn", external_id: "foo", description: "dd" };
@@ -114,27 +89,38 @@ describe("<DomainForm />", () => {
   const props = { domain, onSubmit, isSubmitting };
 
   it("matches the latest snapshot", async () => {
-    const { container, queryByText } = render(
-      <DomainForm {...props} />,
-      renderOpts
-    );
-    await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
-    expect(container).toMatchSnapshot();
+    const rendered = render(<DomainForm {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
   it("enables submit when required fields have values", async () => {
     const props = { domain: {}, onSubmit: jest.fn() };
-    const { findByRole } = render(<DomainForm {...props} />, renderOpts);
-
-    expect(await findByRole("button", { name: "Save" })).toBeDisabled();
-
-    userEvent.type(await findByRole("textbox", { name: "Name" }), "name");
-    userEvent.type(await findByRole("textbox", { name: "External_id" }), "id");
-
-    expect(await findByRole("button", { name: "Save" })).toBeEnabled();
+    const rendered = render(<DomainForm {...props} />);
+    await waitForLoad(rendered);
+
+    expect(
+      await rendered.findByRole("button", { name: /save/i })
+    ).toBeDisabled();
+
+    const user = userEvent.setup({ delay: null });
+    await act(async () => {
+      await user.type(
+        await rendered.findByRole("textbox", { name: /name/i }),
+        "name"
+      );
+      await user.type(
+        await rendered.findByRole("textbox", { name: /external_id/i }),
+        "id"
+      );
+    });
+
+    expect(
+      await rendered.findByRole("button", { name: /save/i })
+    ).toBeEnabled();
   });
 
-  it("should generate unique domain group options", () => {
+  it("should generate unique domain group options", async () => {
     useDomains.mockImplementationOnce(() => ({
       data: [
         { domain_group: { name: "DomainGroup1" } },
@@ -147,16 +133,12 @@ describe("<DomainForm />", () => {
       ],
     }));
 
-    const { getByText, getAllByRole } = render(
-      <DomainForm onSubmit={jest.fn()} />,
-      renderOpts
-    );
-
-    const domainGroupPlaceholder = getByText("Domain_group-placeholder");
+    const rendered = render(<DomainForm onSubmit={jest.fn()} />);
+    await waitForLoad(rendered);
 
-    fireEvent.click(domainGroupPlaceholder);
-
-    const options = getAllByRole("option").map((option) => option.textContent);
+    const options = rendered
+      .getAllByRole("option")
+      .map((option) => option.textContent);
 
     expect(options).toMatchObject([
       "DomainGroup1",
@@ -179,12 +161,12 @@ describe("<DomainForm />", () => {
       ],
     }));
 
-    const { getAllByRole } = render(
-      <DomainForm onSubmit={jest.fn()} />,
-      renderOpts
-    );
+    const rendered = render(<DomainForm onSubmit={jest.fn()} />);
+    await waitForLoad(rendered);
 
-    const options = getAllByRole("option").map((option) => option.textContent);
+    const options = rendered
+      .getAllByRole("option")
+      .map((option) => option.textContent);
 
     expect(options).toMatchObject(["", "Type1", "Type2", "Type3", "Type4"]);
   });
@@ -192,12 +174,14 @@ describe("<DomainForm />", () => {
   it("should generate domain parent options", async () => {
     const domain = { id: 2, parentable_ids: [1, 5, 6, 7] };
 
-    const { getAllByRole } = render(
-      <DomainForm domain={domain} onSubmit={jest.fn()} />,
-      renderOpts
+    const rendered = render(
+      <DomainForm domain={domain} onSubmit={jest.fn()} />
     );
+    await waitForLoad(rendered);
 
-    const options = getAllByRole("option").map((option) => option.textContent);
+    const options = rendered
+      .getAllByRole("option")
+      .map((option) => option.textContent);
 
     expect(options).toMatchObject([
       "domain_1",

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

@@ -1,25 +1,28 @@
-import React from "react";
-import { shallow } from "enzyme";
+import { render, waitForLoad } from "@truedat/test/render";
 import { DomainItem } from "../DomainItem";
 
 describe("<DomainItem />", () => {
   const domain = { name: "foo" };
   const props = { domain, index: 0, size: 1 };
-  it("matches the latest snapshot", () => {
-    const wrapper = shallow(<DomainItem {...props} />);
-    expect(wrapper).toMatchSnapshot();
+
+  it("matches the latest snapshot", async () => {
+    const rendered = render(<DomainItem {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("renders name and icon when the domain is not the last item", () => {
-    const wrapper = shallow(<DomainItem {...props} />);
-    expect(wrapper.find("span").text()).toEqual(domain.name);
-    expect(wrapper.find("Icon")).toHaveLength(1);
+  it("renders name and icon when the domain is not the last item", async () => {
+    const rendered = render(<DomainItem {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.getByText(/foo/i)).toBeInTheDocument();
+    expect(rendered.container.querySelector(".icon")).toBeInTheDocument();
   });
 
-  it("renders name but not icon when the domain is the last item", () => {
-    const props = { domain, index: 1, size: 1 };
-    const wrapper = shallow(<DomainItem {...props} />);
-    expect(wrapper.find("span").text()).toEqual(domain.name);
-    expect(wrapper.find("Icon")).toHaveLength(0);
+  it("renders name but not icon when the domain is the last item", async () => {
+    const lastItemProps = { domain, index: 1, size: 1 };
+    const rendered = render(<DomainItem {...lastItemProps} />);
+    await waitForLoad(rendered);
+    expect(rendered.getByText(/foo/i)).toBeInTheDocument();
+    expect(rendered.container.querySelector(".icon")).not.toBeInTheDocument();
   });
 });

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

@@ -1,21 +1,17 @@
-import React from "react";
-import { render } from "@testing-library/react";
-import { intl } from "@truedat/test/intl-stub";
+import { render, waitForLoad } from "@truedat/test/render";
 import { DomainMembers } from "../DomainMembers";
 
-// workaround for enzyme issue with React.useContext
-// see https://github.com/airbnb/enzyme/issues/2176#issuecomment-532361526
-jest.spyOn(React, "useContext").mockImplementation(() => intl);
-jest.mock("react-router-dom", () => ({
-  ...jest.requireActual("react-router-dom"),
-  useParams: jest.fn().mockReturnValue({ id: 1 }),
+jest.mock("react-router", () => ({
+  ...jest.requireActual("react-router"),
+  useParams: jest.fn().mockReturnValue({ id: "1" }),
 }));
 
 describe("<DomainMembers />", () => {
-  const props = { domainId: 1 };
+  const props = { domainId: "1" };
 
-  it("matches the latest snapshot", () => {
-    const { container } = render(<DomainMembers {...props} />);
-    expect(container).toMatchSnapshot();
+  it("matches the latest snapshot", async () => {
+    const rendered = render(<DomainMembers {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 });

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

@@ -0,0 +1,54 @@
+import React from "react";
+import { render, waitForLoad } from "@truedat/test/render";
+import DomainRoutes from "../DomainRoutes";
+import { useAuthorized } from "@truedat/core/hooks/useAuthorized";
+import { DOMAINS, DOMAIN, DOMAINS_NEW } from "@truedat/core/routes";
+
+jest.mock("@truedat/core/hooks/useAuthorized", () => ({
+  useAuthorized: jest.fn(() => true),
+}));
+
+// Mock all components used in DomainRoutes
+jest.mock("../NewDomain", () => () => <div>NewDomain</div>);
+jest.mock("../Domains", () => () => <div>Domains</div>);
+
+describe("<DomainRoutes />", () => {
+  it("renders correctly with default route", async () => {
+    const rendered = render(<DomainRoutes />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with domains route", async () => {
+    const rendered = render(<DomainRoutes />, {
+      routes: ["/domains"],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with domain detail route", async () => {
+    const rendered = render(<DomainRoutes />, {
+      routes: ["/domains/123"],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with new domain route", async () => {
+    const rendered = render(<DomainRoutes />, {
+      routes: ["/domains/new"],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders unauthorized component when not authorized", async () => {
+    useAuthorized.mockReturnValueOnce(false);
+    const rendered = render(<DomainRoutes />, {
+      routes: ["/domains"],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+});