@truedat/dd 4.44.2 → 4.44.5

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

@@ -3,21 +3,6 @@ import { waitFor } from "@testing-library/react";
 import { render } from "@truedat/test/render";
 import PendingStructureNoteRow from "../PendingStructureNoteRow";
 
-const renderOpts = {
-  messages: {
-    en: {
-      "pendingStructureNotes.search.results.empty": "Empty",
-      "pendingStructureNotes.props.structure": "Structure",
-      "pendingStructureNotes.props.status": "Status",
-      "pendingStructureNotes.props.system": "System",
-      "pendingStructureNotes.props.domains": "Domains",
-      "structure.notes.status.deprecated": "Deprecated",
-      "structure.notes.status.draft": "Draft",
-      "structure.notes.status.rejected": "Rejected",
-    },
-  },
-};
-
 const props = {
   structureNote: {
     id: "7207",
@@ -40,8 +25,7 @@ describe("<PendingStructureNoteRow />", () => {
         <tbody>
           <PendingStructureNoteRow {...props} />
         </tbody>
-      </table>,
-      renderOpts
+      </table>
     );
     expect(container).toMatchSnapshot();
 

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

@@ -1,44 +1,17 @@
 import React, { Suspense } from "react";
 import { waitFor } from "@testing-library/react";
 import { render } from "@truedat/test/render";
-import {
-  PendingStructureNotes,
+import PendingStructureNotes, {
   STRUCTURE_NOTES,
 } from "../PendingStructureNotes";
 
-jest.mock("react-redux", () => ({
-  ...jest.requireActual("react-redux"),
-  useSelector: jest.fn((selector) =>
-    selector({
-      systems: [
-        { external_id: "some_external_id", id: 10, name: "some system" },
-      ],
-    })
-  ),
-}));
-
 const domains = [
   { id: 1, name: "Domain 1", level: 0 },
   { id: 2, name: "Domain 2", level: 0 },
 ];
-
-const messages = {
-  en: {
-    "structure.notes.status.pending_approval": "Empty",
-    "pendingStructureNotes.filters": "Filters",
-    "pendingStructureNotes.props.status": "Status",
-    "pendingStructureNotes.props.system": "System",
-    "pendingStructureNotes.props.domains": "Domains",
-    "structure.notes.status.draft": "Draft",
-    "structure.notes.status.rejected": "Rejected",
-    "pendingStructureNotes.header": "Header",
-    "pendingStructureNotes.subheader": "Sub header",
-    "pendingStructureNotes.search.results.empty": "Serch Empty",
-    "domain.selector.placeholder": "Place Holder",
-    "domain.selector.label": "label",
-    "template.form.validation.empty_required": "empty required",
-  },
-};
+const systems = [
+  { external_id: "some_external_id", id: 10, name: "some system" },
+];
 
 const structureNotes = {
   loading: false,
@@ -77,8 +50,7 @@ const structureNotesMock = {
 
 const renderOpts = {
   mocks: [structureNotesMock],
-  messages,
-  state: { domains },
+  state: { domains, systems },
 };
 
 describe("<PendingStructureNotes />", () => {

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

@@ -0,0 +1,64 @@
+import React from "react";
+import { waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { render } from "@truedat/test/render";
+import ReferenceDataset from "../ReferenceDataset";
+
+const dataset = {
+  id: "123",
+  name: "foo",
+  headers: ["foo", "bar", "baz"],
+  rows: [
+    ["foo1", "bar1", "baz1"],
+    ["foo2", "bar2", "baz2"],
+  ],
+};
+
+describe("<ReferenceDataset /> show dataset view", () => {
+  const renderOpts = { routes: ["/referenceDatasets/123"] };
+  const props = { dataset };
+
+  it("matches the latest snapshot", () => {
+    const { container } = render(<ReferenceDataset {...props} />, renderOpts);
+    expect(container).toMatchSnapshot();
+  });
+
+  it("contains the right number of rows", () => {
+    const { queryAllByRole } = render(
+      <ReferenceDataset {...props} />,
+      renderOpts
+    );
+    expect(queryAllByRole("row")).toHaveLength(3);
+  });
+});
+
+describe("<ReferenceDataset /> edit dataset view", () => {
+  const renderOpts = { routes: ["/referenceDatasets/123/edit"] };
+  const props = { dataset };
+
+  it("matches the latest snapshot", async () => {
+    const { container, findByText } = render(
+      <ReferenceDataset {...props} />,
+      renderOpts
+    );
+    await findByText("Save");
+    expect(container).toMatchSnapshot();
+  });
+
+  it("form is disabled until modified", async () => {
+    const { findByText, findByRole, getByRole, queryByRole } = render(
+      <ReferenceDataset {...props} />,
+      renderOpts
+    );
+    await findByText("Save");
+
+    // Form is disabled until modified
+    expect(queryByRole("button", { name: /Save/ })).toBeDisabled();
+    userEvent.type(await findByRole("textbox"), "bar");
+
+    // Form is now enabled
+    await waitFor(() =>
+      expect(getByRole("button", { name: /Save/ })).not.toBeDisabled()
+    );
+  });
+});

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

@@ -0,0 +1,17 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import ReferenceDatasetActions from "../ReferenceDatasetActions";
+
+const dataset = {
+  id: "123",
+  name: "foo",
+};
+
+describe("<ReferenceDatasetActions />", () => {
+  const props = { dataset };
+
+  it("matches the latest snapshot", () => {
+    const { container } = render(<ReferenceDatasetActions {...props} />);
+    expect(container).toMatchSnapshot();
+  });
+});

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

@@ -0,0 +1,12 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import ReferenceDatasetBreadcrumbs from "../ReferenceDatasetBreadcrumbs";
+
+describe("<ReferenceDatasetBreadcrumbs />", () => {
+  const props = { text: "foo" };
+
+  it("matches the latest snapshot", () => {
+    const { container } = render(<ReferenceDatasetBreadcrumbs {...props} />);
+    expect(container).toMatchSnapshot();
+  });
+});

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

@@ -0,0 +1,12 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import ReferenceDatasetCreate from "../ReferenceDatasetCreate";
+
+describe("<ReferenceDatasetCreate />", () => {
+  const props = { createReferenceDataset: jest.fn() };
+
+  it("matches the latest snapshot", () => {
+    const { container } = render(<ReferenceDatasetCreate {...props} />);
+    expect(container).toMatchSnapshot();
+  });
+});

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

@@ -0,0 +1,37 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import ReferenceDatasetDetail from "../ReferenceDatasetDetail";
+
+const dataset = {
+  id: "123",
+  name: "foo",
+  headers: ["foo", "bar", "baz"],
+  rows: [
+    ["foo1", "bar1", "baz1"],
+    ["foo2", "bar2", "baz2"],
+  ],
+};
+
+describe("<ReferenceDatasetDetail />", () => {
+  const props = { dataset };
+
+  it("matches the latest snapshot (edit route)", async () => {
+    const renderOpts = { routes: ["/referenceDatasets/123/edit"] };
+    const { container, findByRole } = render(
+      <ReferenceDatasetDetail {...props} />,
+      renderOpts
+    );
+    await findByRole("button", { name: "Save" });
+    expect(container).toMatchSnapshot();
+  });
+
+  it("matches the latest snapshot (view route)", async () => {
+    const renderOpts = { routes: ["/referenceDatasets/123"] };
+    const { container, findByText } = render(
+      <ReferenceDatasetDetail {...props} />,
+      renderOpts
+    );
+    await findByText("foo");
+    expect(container).toMatchSnapshot();
+  });
+});

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

@@ -0,0 +1,51 @@
+import React from "react";
+import { waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { render } from "@truedat/test/render";
+import ReferenceDatasetForm from "../ReferenceDatasetForm";
+
+const dataset = {
+  id: "123",
+  name: "foo",
+  headers: ["foo", "bar", "baz"],
+  rows: [
+    ["foo1", "bar1", "baz1"],
+    ["foo2", "bar2", "baz2"],
+  ],
+};
+
+describe("<ReferenceDatasetForm />", () => {
+  const onSubmit = jest.fn();
+  const props = { dataset, onSubmit };
+
+  it("matches the latest snapshot", async () => {
+    const { container, findByText } = render(
+      <ReferenceDatasetForm {...props} />
+    );
+    await findByText("Save");
+    expect(container).toMatchSnapshot();
+  });
+
+  it("form is disabled until modified", async () => {
+    const { findByText, findByRole, getByRole, queryByRole } = render(
+      <ReferenceDatasetForm {...props} />
+    );
+    await findByText("Save");
+
+    // Form is disabled until modified
+    expect(queryByRole("button", { name: /Save/ })).toBeDisabled();
+    userEvent.type(await findByRole("textbox"), "bar");
+
+    // Form is now enabled
+    await waitFor(() =>
+      expect(getByRole("button", { name: /Save/ })).not.toBeDisabled()
+    );
+
+    // Submit
+    await waitFor(() => {
+      userEvent.click(getByRole("button", { name: /Save/ }));
+    });
+
+    expect(onSubmit).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,17 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import ReferenceDatasetHeader from "../ReferenceDatasetHeader";
+
+const dataset = {
+  id: "123",
+  name: "foo",
+};
+
+describe("<ReferenceDatasetHeader />", () => {
+  const props = { dataset };
+
+  it("matches the latest snapshot", () => {
+    const { container } = render(<ReferenceDatasetHeader {...props} />);
+    expect(container).toMatchSnapshot();
+  });
+});

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

@@ -0,0 +1,74 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import ReferenceDatasetRoutes from "../ReferenceDatasetRoutes";
+import {
+  REFERENCE_DATASET_QUERY,
+  REFERENCE_DATASETS_QUERY,
+} from "../../api/queries";
+
+jest.mock("@truedat/core/hooks", () => ({
+  useAuthorized: jest.fn(() => true),
+}));
+
+const dataset = {
+  __typename: "ReferenceDataset",
+  id: "123",
+  name: "foo",
+  headers: ["foo", "bar", "baz"],
+  rowCount: 2,
+  rows: [
+    ["foo1", "bar1", "baz1"],
+    ["foo2", "bar2", "baz2"],
+  ],
+  updatedAt: "2020-01-01T00:00:00.000Z",
+};
+
+const datasetsMock = {
+  request: { query: REFERENCE_DATASETS_QUERY },
+  result: { data: { referenceDatasets: [dataset] } },
+};
+
+const datasetMock = {
+  request: { query: REFERENCE_DATASET_QUERY, variables: { id: "123" } },
+  result: { data: { referenceDataset: dataset } },
+};
+
+describe("<ReferenceDatasetRoutes />", () => {
+  const props = { dataset };
+
+  it("matches the latest snapshot (list route)", async () => {
+    const renderOpts = {
+      routes: ["/referenceDatasets"],
+      mocks: [datasetsMock],
+    };
+    const { container, findByText } = render(
+      <ReferenceDatasetRoutes {...props} />,
+      renderOpts
+    );
+    await findByText("foo");
+    expect(container).toMatchSnapshot();
+  });
+
+  it("matches the latest snapshot (create route)", async () => {
+    const renderOpts = { routes: ["/referenceDatasets/new"] };
+    const { container, findByRole } = render(
+      <ReferenceDatasetRoutes {...props} />,
+      renderOpts
+    );
+    await findByRole("button", { name: "Save" });
+    expect(container).toMatchSnapshot();
+  });
+
+  it("matches the latest snapshot (view route)", async () => {
+    const renderOpts = {
+      routes: ["/referenceDatasets/123"],
+      mocks: [datasetMock],
+    };
+    const { container, findByText } = render(
+      <ReferenceDatasetRoutes {...props} />,
+      renderOpts
+    );
+    await findByText("baz2");
+    expect(container).toMatchSnapshot();
+  });
+});

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

@@ -0,0 +1,18 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import ReferenceDatasetTable from "../ReferenceDatasetTable";
+
+const props = {
+  headers: ["foo", "bar", "baz"],
+  rows: [
+    ["foo1", "bar1", "baz1"],
+    ["foo2", "bar2", "baz2"],
+  ],
+};
+
+describe("<ReferenceDatasetTable />", () => {
+  it("matches the latest snapshot", () => {
+    const { container } = render(<ReferenceDatasetTable {...props} />);
+    expect(container).toMatchSnapshot();
+  });
+});

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

@@ -0,0 +1,32 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import ReferenceDatasets from "../ReferenceDatasets";
+import { REFERENCE_DATASETS_QUERY } from "../../api/queries";
+
+const dataset = {
+  __typename: "ReferenceDataset",
+  id: "123",
+  name: "foo",
+  headers: ["foo", "bar", "baz"],
+  rowCount: 2,
+  rows: [
+    ["foo1", "bar1", "baz1"],
+    ["foo2", "bar2", "baz2"],
+  ],
+  updatedAt: "2020-01-01T00:00:00.000Z",
+};
+
+const datasetsMock = {
+  request: { query: REFERENCE_DATASETS_QUERY },
+  result: { data: { referenceDatasets: [dataset] } },
+};
+
+const renderOpts = { mocks: [datasetsMock] };
+
+describe("<ReferenceDatasets />", () => {
+  it("matches the latest snapshot", async () => {
+    const { container, findByText } = render(<ReferenceDatasets />, renderOpts);
+    await findByText("One dataset found");
+    expect(container).toMatchSnapshot();
+  });
+});

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

@@ -0,0 +1,22 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import ReferenceDatasetsTable from "../ReferenceDatasetsTable";
+
+const props = {
+  datasets: [
+    {
+      id: "123",
+      name: "foo",
+      headers: ["foo", "bar", "baz"],
+      rowCount: 2,
+      updatedAt: "2020-01-01T00:00:00.000Z",
+    },
+  ],
+};
+
+describe("<ReferenceDatasetsTable />", () => {
+  it("matches the latest snapshot", () => {
+    const { container } = render(<ReferenceDatasetsTable {...props} />);
+    expect(container).toMatchSnapshot();
+  });
+});

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

@@ -1,45 +1,41 @@
 import React from "react";
-import { shallowWithIntl } from "@truedat/test/intl-stub";
-import { StructureConfidentialButton } from "../StructureConfidentialButton";
+import { render } from "@truedat/test/render";
+import StructureConfidentialButton from "../StructureConfidentialButton";
 
 describe("<StructureConfidentialButton />", () => {
-  const updateStructure = jest.fn();
-  const props = {
+  const state = {
     structure: { id: 1, confidential: false },
     structureUpdating: false,
-    updateStructure: updateStructure,
     userPermissions: {
       update: true,
-      confidential: true
-    }
+      confidential: true,
+    },
   };
+
   it("matches the latest snapshot", () => {
-    const wrapper = shallowWithIntl(<StructureConfidentialButton {...props} />);
-    expect(wrapper).toMatchSnapshot();
+    const { container } = render(<StructureConfidentialButton />, { state });
+    expect(container).toMatchSnapshot();
   });
-  it("matches snapshot without permission", () => {
-    const props_no_update = {
-      ...props,
-      userPermissions: {
-        update: false,
-        confidential: true
-      }
+
+  it("matches snapshot without update permission", () => {
+    const userPermissions = {
+      update: false,
+      confidential: true,
     };
-    const wrapper_update = shallowWithIntl(
-      <StructureConfidentialButton {...props_no_update} />
-    );
-    expect(wrapper_update).toMatchSnapshot();
+    const { container } = render(<StructureConfidentialButton />, {
+      state: { ...state, userPermissions },
+    });
+    expect(container).toMatchSnapshot();
+  });
 
-    const props_no_confidential = {
-      ...props,
-      userPermissions: {
-        update: true,
-        confidential: false
-      }
+  it("matches snapshot without confidential permission", () => {
+    const userPermissions = {
+      update: true,
+      confidential: false,
     };
-    const wrapper_confidential = shallowWithIntl(
-      <StructureConfidentialButton {...props_no_confidential} />
-    );
-    expect(wrapper_confidential).toMatchSnapshot();
+    const { container } = render(<StructureConfidentialButton />, {
+      state: { ...state, userPermissions },
+    });
+    expect(container).toMatchSnapshot();
   });
 });

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

@@ -2,25 +2,15 @@ import React from "react";
 import { waitFor } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { render } from "@truedat/test/render";
-
 import { StructureGrantRequestButton } from "../StructureGrantRequestButton";
 
-import messages from "../../messages/en";
-
-const renderOpts = {
-  messages: { en: messages },
-};
-
 describe("<StructureGrantRequestButton />", () => {
   it("render a button", async () => {
     const props = {
       requested: false,
       authorized: true,
     };
-    const { getByText } = render(
-      <StructureGrantRequestButton {...props} />,
-      renderOpts
-    );
+    const { getByText } = render(<StructureGrantRequestButton {...props} />);
     expect(getByText("Request grant")).toMatchSnapshot();
   });
 
@@ -33,10 +23,7 @@ describe("<StructureGrantRequestButton />", () => {
       removeGrantRequestFromCart: removeRequest,
       authorized: true,
     };
-    const { findByText } = render(
-      <StructureGrantRequestButton {...props} />,
-      renderOpts
-    );
+    const { findByText } = render(<StructureGrantRequestButton {...props} />);
     userEvent.click(await findByText("Request grant"));
     await waitFor(() => {
       expect(addRequest.mock.calls.length).toBe(1);
@@ -53,10 +40,7 @@ describe("<StructureGrantRequestButton />", () => {
       removeGrantRequestFromCart: removeRequest,
       authorized: true,
     };
-    const { findByText } = render(
-      <StructureGrantRequestButton {...props} />,
-      renderOpts
-    );
+    const { findByText } = render(<StructureGrantRequestButton {...props} />);
     userEvent.click(await findByText("Pending request"));
     await waitFor(() => {
       expect(addRequest.mock.calls.length).toBe(0);
@@ -73,10 +57,7 @@ describe("<StructureGrantRequestButton />", () => {
       removeGrantRequestFromCart: removeRequest,
       authorized: false,
     };
-    const component = render(
-      <StructureGrantRequestButton {...props} />,
-      renderOpts
-    );
+    const component = render(<StructureGrantRequestButton {...props} />);
     const { queryAllByText } = component;
     expect(queryAllByText("Request grant")).toHaveLength(0);
     expect(queryAllByText("Pending request")).toHaveLength(0);

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

@@ -4,17 +4,6 @@ import { waitFor } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { render } from "@truedat/test/render";
 import { StructureNoteActions } from "../StructureNoteActions";
-import messages from "../../messages/en";
-
-const renderOpts = {
-  messages: {
-    en: {
-      ...messages,
-      "confirmation.no": "No",
-      "confirmation.yes": "Yes",
-    },
-  },
-};
 
 describe("<StructureNoteActions />", () => {
   it("matches the latest snapshot", () => {
@@ -47,10 +36,7 @@ describe("<StructureNoteActions />", () => {
       structure: { id: 1 },
     };
 
-    const { findByText } = render(
-      <StructureNoteActions {...props} />,
-      renderOpts
-    );
+    const { findByText } = render(<StructureNoteActions {...props} />);
 
     userEvent.click(await findByText(/Delete/));
 
@@ -85,10 +71,7 @@ describe("<StructureNoteActions />", () => {
       structure: { id: 1 },
     };
 
-    const { findByText } = render(
-      <StructureNoteActions {...props} />,
-      renderOpts
-    );
+    const { findByText } = render(<StructureNoteActions {...props} />);
 
     userEvent.click(await findByText(/Send to approve/));