@truedat/dd 7.5.9 → 7.5.10

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

@@ -1,14 +1,13 @@
-import _ from "lodash/fp";
-import React from "react";
-import { render } from "@truedat/test/render";
-import { waitFor, waitForElementToBeRemoved } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
+import { waitFor } from "@testing-library/react";
+import { render, waitForLoad } from "@truedat/test/render";
+import _ from "lodash/fp";
 import { STRUCTURE_STRUCTURE_LINKS_QUERY } from "../../api/queries";
 import { deleteStructureStructureLink } from "../../routines";
 import StructureStructureLinks from "../StructureStructureLinks";
 
-jest.mock("react-router-dom", () => ({
-  ...jest.requireActual("react-router-dom"),
+jest.mock("react-router", () => ({
+  ...jest.requireActual("react-router"),
   useParams: () => ({ id: 60217 }),
 }));
 
@@ -183,17 +182,27 @@ describe("<StructureStructureLinks />", () => {
   };
 
   it("shows structure to structure links", async () => {
-    const { getByRole } = render(
+    const rendered = render(
       <StructureStructureLinks {...props} />,
       _.merge(renderOpts, { state: { structureActions } })
     );
+    await waitForLoad(rendered);
+
     await waitFor(() => {
-      expect(getByRole("link", { name: /alias/i })).toBeInTheDocument();
-      expect(getByRole("link", { name: /STRUCTURE_3/i })).toBeInTheDocument();
+      expect(
+        rendered.getByRole("link", { name: /alias/i })
+      ).toBeInTheDocument();
+      expect(
+        rendered.getByRole("link", { name: /structure_3/i })
+      ).toBeInTheDocument();
     });
+
     await waitFor(() => {
-      expect(getByRole("button", { name: /Add link/i })).toBeInTheDocument();
+      expect(
+        rendered.getByRole("button", { name: /links.actions.create/i })
+      ).toBeInTheDocument();
     });
+
     expect(
       document.getElementById("delete-link-60217-60218")
     ).toBeInTheDocument();
@@ -203,32 +212,37 @@ describe("<StructureStructureLinks />", () => {
   });
 
   it("matches the latest snapshot of StructureStructureLinks for alias check", async () => {
-    const { getByRole, container } = render(
-      <StructureStructureLinks {...props} />,
-      {
-        routes: ["/structures/60217/structureLinks"],
-        mocks: [linksAndAliasMock],
-        state: { navFilter: { view: "SYSTEM_STRUCTURES", filter: {} } },
-      }
-    );
+    const rendered = render(<StructureStructureLinks {...props} />, {
+      routes: ["/structures/60217/structureLinks"],
+      mocks: [linksAndAliasMock],
+      state: { navFilter: { view: "SYSTEM_STRUCTURES", filter: {} } },
+    });
+    await waitForLoad(rendered);
 
     await waitFor(() => {
-      expect(getByRole("link", { name: /alias/i })).toBeInTheDocument();
-      expect(container).toMatchSnapshot();
+      expect(
+        rendered.getByRole("link", { name: /alias/i })
+      ).toBeInTheDocument();
     });
+
+    expect(rendered.container).toMatchSnapshot();
   });
 
   it("hides the 'add link' and delete link buttons if there are no permissions", async () => {
-    const { getByRole, queryByRole } = render(
-      <StructureStructureLinks {...props} />,
-      renderOpts
-    );
+    const rendered = render(<StructureStructureLinks {...props} />, renderOpts);
+    await waitForLoad(rendered);
+
     await waitFor(() => {
-      expect(getByRole("link", { name: /alias/i })).toBeInTheDocument();
-      expect(getByRole("link", { name: /STRUCTURE_3/i })).toBeInTheDocument();
+      expect(
+        rendered.getByRole("link", { name: /alias/i })
+      ).toBeInTheDocument();
+      expect(
+        rendered.getByRole("link", { name: /structure_3/i })
+      ).toBeInTheDocument();
     });
+
     expect(
-      queryByRole("button", { name: /Add link/i })
+      rendered.queryByRole("button", { name: /links.actions.create/i })
     ).not.toBeInTheDocument();
     expect(document.getElementById("delete-link-60217-60218")).toBeNull();
     expect(document.getElementById("delete-link-151674-60217")).toBeNull();
@@ -236,26 +250,40 @@ describe("<StructureStructureLinks />", () => {
 
   it("deletes link", async () => {
     const dispatch = jest.fn();
-    const { getByText, getByRole } = render(
+    const rendered = render(
       <StructureStructureLinks {...props} />,
       _.merge(renderOpts, {
         state: { structureActions },
         dispatch,
       })
     );
+    await waitForLoad(rendered);
+
     await waitFor(() => {
-      expect(getByRole("link", { name: /alias/i })).toBeInTheDocument();
-      expect(getByRole("link", { name: /STRUCTURE_3/i })).toBeInTheDocument();
+      expect(
+        rendered.getByRole("link", { name: /alias/i })
+      ).toBeInTheDocument();
+      expect(
+        rendered.getByRole("link", { name: /structure_3/i })
+      ).toBeInTheDocument();
     });
+
     await waitFor(() => {
-      expect(getByRole("button", { name: /Add link/i })).toBeInTheDocument();
+      expect(
+        rendered.getByRole("button", { name: /links.actions.create/i })
+      ).toBeInTheDocument();
     });
 
+    const user = userEvent.setup({ delay: null });
     const deleteButton = document.getElementById("delete-link-60217-60218");
-    userEvent.click(deleteButton);
-    expect(getByText("Delete link")).toBeInTheDocument();
-    const yesButton = getByRole("button", { name: "modal-affirmative-action" });
-    userEvent.click(yesButton);
+    await user.click(deleteButton);
+    expect(
+      rendered.getByText(/delete.confirmation.header/i)
+    ).toBeInTheDocument();
+    const yesButton = rendered.getByRole("button", {
+      name: /modal-affirmative-action/i,
+    });
+    await user.click(yesButton);
 
     expect(dispatch).toHaveBeenCalledWith({
       ...deleteStructureStructureLink(),

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

@@ -1,8 +1,16 @@
-import _ from "lodash/fp";
-import React from "react";
-import { render } from "@truedat/test/render";
+import { render, waitForLoad } from "@truedat/test/render";
+import userEvent from "@testing-library/user-event";
+import {
+  STRUCTURE_TAGS_QUERY,
+  LATEST_GRANT_REQUEST_BY_DS_QUERY,
+} from "../../api/queries";
 import StructureSummary from "../StructureSummary";
 
+jest.mock("react-router", () => ({
+  ...jest.requireActual("react-router"),
+  useParams: () => ({ id: "123" }),
+}));
+
 describe("<StructureSummary />", () => {
   const structure = {
     id: 1,
@@ -17,36 +25,91 @@ describe("<StructureSummary />", () => {
     class: "table",
     type: "foo",
     system: { name: "system" },
+    classes: {
+      _grantable: true,
+    },
   };
 
-  const state = {
-    userPermissions: {
-      profile_permission: true,
-      confidential: true,
+  const renderOpts = {
+    state: {
+      userPermissions: {
+        profile_permission: true,
+        confidential: true,
+      },
+      structureVersions: [{ updated_at: "2019-01-02T03:04:05Z" }],
+      structure,
+      authentication: { role: "admin" },
     },
-    structureVersions: [{ updated_at: "2019-01-02T03:04:05Z" }],
-    structure,
-    authentication: { role: "admin" },
+    mocks: [
+      {
+        request: {
+          query: STRUCTURE_TAGS_QUERY,
+          variables: { id: "123" },
+        },
+        result: {
+          data: {
+            dataStructure: {
+              id: "123",
+              structureTags: [],
+              availableTags: [],
+            },
+          },
+        },
+      },
+      {
+        request: {
+          query: LATEST_GRANT_REQUEST_BY_DS_QUERY,
+          variables: { id: 1 },
+        },
+        result: {
+          data: { latestGrantRequest: null },
+        },
+      },
+    ],
   };
 
-  it("matches the latest snapshot", () => {
-    const { container } = render(<StructureSummary />, { state });
-    expect(container).toMatchSnapshot();
+  it("matches the latest snapshot", async () => {
+    const rendered = render(<StructureSummary />, renderOpts);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("matches the latest snapshot with alias", () => {
-    const customState = _.set("structure.alias", "some alias")(state);
-    const { container } = render(<StructureSummary />, { state: customState });
-    expect(container).toMatchSnapshot();
+  it("matches the latest snapshot with alias", async () => {
+    const stateWithAlias = {
+      ...renderOpts,
+      state: {
+        ...renderOpts.state,
+        structure: {
+          ...renderOpts.state.structure,
+          alias: "some alias",
+        },
+      },
+    };
+    const rendered = render(<StructureSummary />, stateWithAlias);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
   it("renders label when grant provided", async () => {
-    const customState = _.set("structure.grant", { detail: { foo: "bar" } })(
-      state
-    );
-    const { findByText } = render(<StructureSummary />, { state: customState });
+    const stateWithGrant = {
+      ...renderOpts,
+      state: {
+        ...renderOpts.state,
+        structure: {
+          ...renderOpts.state.structure,
+          grant: {
+            detail: { foo: "bar" },
+          },
+        },
+      },
+    };
+    const rendered = render(<StructureSummary />, stateWithGrant);
+    await waitForLoad(rendered);
+
+    userEvent.hover(rendered.container.querySelector(".shield"));
+
     expect(
-      findByText("You have granted access on this structure")
-    ).toBeTruthy();
+      await rendered.findByText(/structure.grant.has_grant/i)
+    ).toBeInTheDocument();
   });
 });

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

@@ -1,58 +1,186 @@
 import React from "react";
-import { intl } from "@truedat/test/intl-stub";
-import { shallow } from "enzyme";
+import { render, waitForLoad } from "@truedat/test/render";
 import { StructureTabPane } from "../StructureTabPane";
+import { STRUCTURE_NOTES_EDIT } from "@truedat/core/routes";
 
-jest.spyOn(React, "useContext").mockImplementation(() => intl);
+jest.mock("../StructureFields", () => () => <div>StructureFields</div>);
+jest.mock("../StructureNotes", () => () => <div>StructureNotes</div>);
+jest.mock("../StructureNotesEdit", () => () => <div>StructureNotesEdit</div>);
+jest.mock("../StructureNotesLoader", () => () => (
+  <div>StructureNotesLoader</div>
+));
+jest.mock("../StructureGrants", () => () => <div>StructureGrants</div>);
+jest.mock("../StructureStructureLinks", () => () => (
+  <div>StructureStructureLinks</div>
+));
+jest.mock("../StructureStructureForm", () => () => (
+  <div>StructureStructureForm</div>
+));
+jest.mock("../StructureParentRelations", () => () => (
+  <div>StructureParentRelations</div>
+));
+jest.mock("../StructureChildrenRelations", () => () => (
+  <div>StructureChildrenRelations</div>
+));
+jest.mock("../StructureVersions", () => () => <div>StructureVersions</div>);
+jest.mock("../StructureEvents", () => () => <div>StructureEvents</div>);
+jest.mock("../StructureRoles", () => () => <div>StructureRoles</div>);
+jest.mock("../StructureMetadata", () => () => <div>StructureMetadata</div>);
+jest.mock("../StructureLineage", () => () => <div>StructureLineage</div>);
+jest.mock("../StructureImpact", () => () => <div>StructureImpact</div>);
+
+jest.mock("@truedat/lm/components/StructureLinks", () => () => (
+  <div>StructureLinks</div>
+));
+jest.mock("@truedat/lm/components/StructureRelationForm", () => () => (
+  <div>StructureRelationForm</div>
+));
+jest.mock("@truedat/profile", () => () => <div>StructureProfile</div>);
+jest.mock("@truedat/dq/components/RuleImplementationsTable", () => () => (
+  <div>RuleImplementationsTable</div>
+));
 
 describe("<StructureTabPane />", () => {
-  const tabVisibility = { profile: true, grants: true };
-  [
-    "fields",
-    "notes",
-    "links",
-    "profile",
-    "versions",
-    "events",
-    "foo",
-    "metadata",
-    "roles",
-    "grants",
-  ].forEach((tab) =>
-    it("matches the latest snapshot: " + tab, () => {
-      const wrapper = shallow(
-        <StructureTabPane activeTab={tab} tabVisibility={tabVisibility} />
-      );
-      expect(wrapper).toMatchSnapshot();
-    })
-  );
-
-  it("does not render profile when active tab is profile and we have any profile: ", () => {
-    const wrapper = shallow(
+  const tabVisibility = {
+    profile: true,
+    grants: true,
+    metadata: true,
+    rules: true,
+  };
+
+  it("renders correctly with fields tab", async () => {
+    const rendered = render(
+      <StructureTabPane activeTab="fields" tabVisibility={tabVisibility} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with notes edit route", async () => {
+    const rendered = render(
+      <StructureTabPane activeTab="notes" tabVisibility={tabVisibility} />,
+      { routes: [STRUCTURE_NOTES_EDIT] }
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with notes default route", async () => {
+    const rendered = render(
+      <StructureTabPane activeTab="notes" tabVisibility={tabVisibility} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with grants tab", async () => {
+    const rendered = render(
+      <StructureTabPane activeTab="grants" tabVisibility={tabVisibility} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with profile tab", async () => {
+    const rendered = render(
+      <StructureTabPane activeTab="profile" tabVisibility={tabVisibility} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with metadata tab", async () => {
+    const rendered = render(
+      <StructureTabPane activeTab="metadata" tabVisibility={tabVisibility} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with rules tab", async () => {
+    const rendered = render(
       <StructureTabPane
-        activeTab="profile"
-        tabVisibility={{ profile: false }}
+        activeTab="rules"
+        tabVisibility={tabVisibility}
+        columns={[]}
       />
     );
-    expect(wrapper.find("withRouter(Connect(StructureProfiling))").length).toBe(
-      0
-    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("does not render grants when active tab is grants and we haven't any grant: ", () => {
-    const wrapper = shallow(
-      <StructureTabPane activeTab="grants" tabVisibility={{ grants: false }} />
+  it("renders correctly with links tab", async () => {
+    const rendered = render(
+      <StructureTabPane activeTab="links" tabVisibility={tabVisibility} />
     );
-    expect(wrapper.find("Connect(StructureGrants)").length).toBe(0);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("does render metadata component ", () => {
-    const wrapper = shallow(
+  it("renders correctly with structure links tab", async () => {
+    const rendered = render(
       <StructureTabPane
-        activeTab="metadata"
-        tabVisibility={{ metadata: true }}
+        activeTab="structureLinks"
+        tabVisibility={tabVisibility}
       />
     );
-    expect(wrapper.find("Connect(StructureMetadata)").length).toBe(1);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with parents tab", async () => {
+    const rendered = render(
+      <StructureTabPane activeTab="parents" tabVisibility={tabVisibility} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with children tab", async () => {
+    const rendered = render(
+      <StructureTabPane activeTab="children" tabVisibility={tabVisibility} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with versions tab", async () => {
+    const rendered = render(
+      <StructureTabPane activeTab="versions" tabVisibility={tabVisibility} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with events tab", async () => {
+    const rendered = render(
+      <StructureTabPane activeTab="events" tabVisibility={tabVisibility} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with roles tab", async () => {
+    const rendered = render(
+      <StructureTabPane activeTab="roles" tabVisibility={tabVisibility} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with lineage tab", async () => {
+    const rendered = render(
+      <StructureTabPane activeTab="lineage" tabVisibility={tabVisibility} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with impact tab", async () => {
+    const rendered = render(
+      <StructureTabPane activeTab="impact" tabVisibility={tabVisibility} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 });