@truedat/dd 6.6.0 → 6.6.1

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

@@ -11,12 +11,16 @@ describe("<StructuresBulkUpdate />", () => {
   const renderOpts = {
     mocks: [templateByNameMock({ name: "template1", domainIds: [1] })],
     state: {
-      structureCount: 10,
-      structureTypes: [{ name: "structType", template: { name: "template1" } }],
-      structureFilters: {
-        "type.raw": { values: ["structType"] },
-        taxonomy: { values: [{ id: 1 }], type: "domain" },
+      previousStructureQuery: {
+        structureCount: 10,
+        allFilters: {
+          "type.raw": { values: ["structType"] },
+          taxonomy: { values: [{ id: 1 }], type: "domain" },
+        },
+        actions: {},
+        searchParams: {},
       },
+      structureTypes: [{ name: "structType", template: { name: "template1" } }],
     },
     fallback: "lazy",
   };
@@ -31,25 +35,31 @@ describe("<StructuresBulkUpdate />", () => {
     await waitFor(() =>
       expect(queryByText(/loading/i)).not.toBeInTheDocument()
     );
-
     expect(container).toMatchSnapshot();
   });
 
   it("renders empty when no filters are selected", async () => {
-    const thisRenderOpts = _.update("state.structureFilters", () => ({}))(
-      renderOpts
+    const thisRenderOpts = _.update(
+      "state.previousStructureQuery.allFilters",
+      () => ({})
+    )(renderOpts);
+    const { container, getByText } = render(
+      <StructuresBulkUpdate />,
+      thisRenderOpts
     );
-
-    const { container } = render(<StructuresBulkUpdate />, thisRenderOpts);
-
+    const emptySearchText = getByText("Empty Search");
+    expect(emptySearchText).toBeInTheDocument();
     expect(container).toMatchSnapshot();
   });
 
   it("Publish button is available with autoPublish action", async () => {
     const dispatch = jest.fn();
-    const thisRenderOpts = _.update("state.structuresActions", () => ({
-      autoPublish: { method: "POST" },
-    }))(renderOpts);
+    const thisRenderOpts = _.update(
+      "state.previousStructureQuery.actions",
+      () => ({
+        autoPublish: { method: "POST" },
+      })
+    )(renderOpts);
 
     const { container, findByText, queryByText, findByRole } = render(
       <StructuresBulkUpdate />,
@@ -75,6 +85,7 @@ describe("<StructuresBulkUpdate />", () => {
       ...bulkUpdateStructures(),
       payload: {
         autoPublish: true,
+        searchParams: {},
         structureCount: 10,
         update_attributes: {
           df_content: {
@@ -111,6 +122,7 @@ describe("<StructuresBulkUpdate />", () => {
       ...bulkUpdateStructures(),
       payload: {
         autoPublish: false,
+        searchParams: {},
         structureCount: 10,
         update_attributes: {
           df_content: {

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

@@ -1,11 +1,12 @@
 import React from "react";
 import { render } from "@truedat/test/render";
+import SearchContextWrapper from "@truedat/core/components/common/SearchContextWrapper";
 import { StructuresDownloadOption } from "../StructuresDownloadOption";
 import en from "../../messages/en";
 
 describe("<StructuresDownloadOption />", () => {
   const downloadStructures = jest.fn();
-  const structuresLoading = false;
+
   const renderOpts = {
     messages: {
       en: {
@@ -17,18 +18,50 @@ describe("<StructuresDownloadOption />", () => {
   };
 
   it("matches the latest snapshot", () => {
-    const props = { downloadStructures, structuresLoading };
+    const props = { downloadStructures };
+    const searchProps = {
+      loading: false,
+      searchParams: {},
+      searchData: { data: [{ id: 1 }] },
+    };
+
+    const { container } = render(
+      <SearchContextWrapper props={searchProps}>
+        <StructuresDownloadOption {...props} />
+      </SearchContextWrapper>,
+      renderOpts
+    );
+    expect(container).toMatchSnapshot();
+  });
+
+  it("has filter applied", () => {
+    const props = { downloadStructures, hasFilterApplied: true };
+    const searchProps = {
+      loading: false,
+      searchParams: {},
+      searchData: { data: [{ id: 1 }] },
+    };
+
     const { container } = render(
-      <StructuresDownloadOption {...props} />,
+      <SearchContextWrapper props={searchProps}>
+        <StructuresDownloadOption {...props} />
+      </SearchContextWrapper>,
       renderOpts
     );
     expect(container).toMatchSnapshot();
   });
 
   it("is disabled if there are no structures to be downloaded", () => {
-    const props = { downloadStructures, structuresLoading, structures: [] };
+    const props = { downloadStructures };
+    const searchProps = {
+      loading: false,
+      searchData: { data: [] },
+      searchParams: {},
+    };
     const { getByRole, queryByText } = render(
-      <StructuresDownloadOption {...props} />,
+      <SearchContextWrapper props={searchProps}>
+        <StructuresDownloadOption {...props} />
+      </SearchContextWrapper>,
       renderOpts
     );
     expect(getByRole("option")).toHaveAttribute("aria-disabled");

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

@@ -1,10 +1,11 @@
 import React from "react";
 import { render } from "@truedat/test/render";
+import SearchContextWrapper from "@truedat/core/components/common/SearchContextWrapper";
 import { StructuresEditableDownloadOption } from "../StructuresEditableDownloadOption";
 
 describe("<StructuresEditableDownloadOption />", () => {
   const downloadEditableStructures = jest.fn();
-  const structuresLoading = false;
+
   const renderOpts = {
     messages: {
       en: {
@@ -15,22 +16,33 @@ describe("<StructuresEditableDownloadOption />", () => {
   };
 
   it("matches the latest snapshot", () => {
-    const props = { downloadEditableStructures, structuresLoading };
+    const searchProps = {
+      loading: false,
+      searchData: { data: [{ id: 1 }] },
+      searchParams: {},
+    };
+    const props = { downloadEditableStructures };
     const { container } = render(
-      <StructuresEditableDownloadOption {...props} />,
+      <SearchContextWrapper props={searchProps}>
+        <StructuresEditableDownloadOption {...props} />
+      </SearchContextWrapper>,
       renderOpts
     );
     expect(container).toMatchSnapshot();
   });
 
   it("is disabled if there are no structures to be downloaded", () => {
-    const props = {
-      downloadEditableStructures,
-      structuresLoading,
-      structures: {},
+    const props = { downloadEditableStructures };
+    const searchProps = {
+      loading: false,
+      searchData: { data: [] },
+      searchParams: {},
     };
+
     const { getByRole, queryByText } = render(
-      <StructuresEditableDownloadOption {...props} />,
+      <SearchContextWrapper props={searchProps}>
+        <StructuresEditableDownloadOption {...props} />
+      </SearchContextWrapper>,
       renderOpts
     );
     expect(getByRole("option")).toHaveAttribute("aria-disabled");

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

@@ -4,8 +4,8 @@ import { waitFor } from "@testing-library/react";
 import { within } from "@testing-library/dom";
 import userEvent from "@testing-library/user-event";
 import { functionsMock } from "@truedat/test/mocks";
-
-import StructuresGrantRequestView from "../StructuresGrantRequestView";
+import { StructuresGrantRequestView } from "../StructuresGrantRequestView";
+import en from "../../messages/en";
 
 const mockHistory = { push: jest.fn() };
 
@@ -15,8 +15,8 @@ jest.mock("react-router-dom", () => ({
   useHistory: () => mockHistory,
 }));
 
-const dispatch = jest.fn();
-describe("<StructuresGrantRequestView />", () => {
+jest.mock("@truedat/dd/hooks/useStructures", () => {
+  const originalModule = jest.requireActual("@truedat/dd/hooks/useStructures");
   const structures = [1, 2, 3].map((id) => ({
     id,
     name: `structure_${id}`,
@@ -30,19 +30,47 @@ describe("<StructuresGrantRequestView />", () => {
     updated_at: "2023-04-27",
   }));
 
-  const renderOpts = {
-    mocks: [functionsMock],
-    state: {
-      structures,
-      structureCount: 3,
-      userPermissions: {
-        request_grant: true,
-      },
-    },
-    dispatch,
-    fallback: "lazy",
+  const data = { data: structures };
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    useDataStructureFilters: () => ({
+      trigger: () => ({
+        then: (callback) =>
+          callback({
+            data: { data: {} },
+          }),
+      }),
+    }),
+    useDataStructureSearch: () => ({
+      trigger: () => ({
+        then: (callback) =>
+          callback({
+            data,
+            headers: { "x-total-count": 3 },
+          }),
+      }),
+    }),
   };
+});
+
+const messages = {
+  en: {
+    ...en,
+    "search.placeholder": "Searching ...",
+  },
+};
+const dispatch = jest.fn();
 
+const renderOpts = {
+  messages,
+  mocks: [functionsMock],
+  dispatch,
+  fallback: "lazy",
+};
+
+describe("<StructuresGrantRequestView />", () => {
   it("Clicking a grant request button triggers action", async () => {
     const { container, queryByText } = render(
       <StructuresGrantRequestView />,

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

@@ -1,17 +1,44 @@
 import React from "react";
-import { shallow } from "enzyme";
-import { intl } from "@truedat/test/intl-stub";
-import { StructuresLabelResults } from "../StructuresLabelResults";
+import { render } from "@truedat/test/render";
+import { SearchContextProvider } from "@truedat/core/search/SearchContext";
+import StructuresLabelResults from "../StructuresLabelResults";
 
-// workaround for enzyme issue with React.useContext
-// see https://github.com/airbnb/enzyme/issues/2176#issuecomment-532361526
-jest.spyOn(React, "useContext").mockImplementation(() => intl);
+const useFilters = () => ({
+  trigger: () => ({
+    then: (callback) =>
+      callback({
+        data: { data: {} },
+      }),
+  }),
+});
 
-describe("<StructuresLabelResults />", () => {
-  const props = { structureCount: 22 };
+const useSearch = () => ({
+  trigger: () => ({
+    then: (callback) =>
+      callback({
+        data: { data: [] },
+        headers: { "x-total-count": 22 },
+      }),
+  }),
+});
 
+const searchProps = {
+  initialSortColumn: "name.raw",
+  initialSortDirection: "ascending",
+  useSearch: useSearch,
+  userFiltersType: "structures",
+  omitFilters: [],
+  useFilters: useFilters,
+  translations: jest.fn(),
+};
+
+describe("<StructuresLabelResults />", () => {
   it("matches the latest snapshot", () => {
-    const wrapper = shallow(<StructuresLabelResults {...props} />);
-    expect(wrapper).toMatchSnapshot();
+    const { container } = render(
+      <SearchContextProvider {...searchProps}>
+        <StructuresLabelResults />
+      </SearchContextProvider>
+    );
+    expect(container).toMatchSnapshot();
   });
 });

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

@@ -1,8 +1,38 @@
 import React from "react";
 import { waitFor } from "@testing-library/react";
 import { render } from "@truedat/test/render";
+import { SearchContextProvider } from "@truedat/core/search/SearchContext";
 import StructuresOptions from "../StructuresOptions";
 
+const useFilters = () => ({
+  trigger: () => ({
+    then: (callback) =>
+      callback({
+        data: { data: {} },
+      }),
+  }),
+});
+
+const useSearch = () => ({
+  trigger: () => ({
+    then: (callback) =>
+      callback({
+        data: [],
+        headers: { "x-total-count": 22 },
+      }),
+  }),
+});
+
+const searchProps = {
+  initialSortColumn: "name.raw",
+  initialSortDirection: "ascending",
+  useSearch: useSearch,
+  userFiltersType: "structures",
+  omitFilters: [],
+  useFilters: useFilters,
+  translations: jest.fn(),
+};
+
 describe("<StructuresOptions />", () => {
   const props = {
     bulkUpload: {},
@@ -12,7 +42,38 @@ describe("<StructuresOptions />", () => {
   };
 
   it("matches the latest snapshot", async () => {
-    const { container } = render(<StructuresOptions {...props} />);
+    const { container } = render(
+      <SearchContextProvider {...searchProps}>
+        <StructuresOptions {...props} />
+      </SearchContextProvider>
+    );
+
     await waitFor(() => expect(container).toMatchSnapshot());
   });
+
+  it("Dont have permissions to upload notes", async () => {
+    const newProps = {};
+    const { queryByText } = render(
+      <SearchContextProvider {...searchProps}>
+        <StructuresOptions {...newProps} />
+      </SearchContextProvider>
+    );
+
+    await waitFor(() =>
+      expect(queryByText("Upload structure notes")).not.toBeInTheDocument()
+    );
+  });
+
+  it("Dont have permissions to upload domains", async () => {
+    const newProps = {};
+    const { queryByText } = render(
+      <SearchContextProvider {...searchProps}>
+        <StructuresOptions {...newProps} />
+      </SearchContextProvider>
+    );
+
+    await waitFor(() =>
+      expect(queryByText("Update structure domains")).not.toBeInTheDocument()
+    );
+  });
 });

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

@@ -1,23 +1,78 @@
 import React from "react";
-import { shallow } from "enzyme";
-import { StructuresSearchResults } from "../StructuresSearchResults";
-import StructuresTable from "../StructuresTable";
+import { render } from "@truedat/test/render";
+import userEvent from "@testing-library/user-event";
+import { waitFor } from "@testing-library/react";
+import SearchContextWrapper from "@truedat/core/components/common/SearchContextWrapper";
+import StructuresSearchResults from "../StructuresSearchResults";
+
+const renderOpts = {
+  messages: {
+    en: {
+      "structure.bar": "Bar",
+      "structure.foo": "Foo",
+      "search.placeholder": "Search...",
+      "structure.group": "Group",
+      "structure.system": "System",
+      "structure.name": "Name",
+      "structures.retrieved.results": "Results",
+      "structures.loading.header": "Header",
+    },
+  },
+};
+
+const structures = [1, 2, 3].map((id) => ({ id: id, foo: id }));
+
+const searchProps = {
+  searchData: {
+    _actions: {},
+    data: structures,
+  },
+  sortColumn: jest.fn(),
+  sortDirection: jest.fn(),
+  defaultFilters: jest.fn(),
+  handleSortSelection: jest.fn(),
+};
 
 describe("<StructuresSearchResults />", () => {
-  const structures = [1, 2, 3].map(id => ({ id }));
+  const columns = [{ name: "foo", sort: { name: "name.raw" } }];
 
   it("matches the latest snapshot", () => {
-    const props = { structures };
-    const wrapper = shallow(<StructuresSearchResults {...props} />);
-    expect(wrapper).toMatchSnapshot();
+    const props = { structures, columns };
+    const { container } = render(
+      <SearchContextWrapper props={searchProps}>
+        <StructuresSearchResults {...props} />
+      </SearchContextWrapper>,
+      renderOpts
+    );
+    expect(container).toMatchSnapshot();
   });
 
-  it("selecting a structure in the table will call onSelect passing the structure", () => {
+  it("selecting a structure in the table will call onSelect passing the structure", async () => {
     const onSelect = jest.fn();
-    const props = { onSelect, structures };
-    const structure = { id: 42 };
-    const wrapper = shallow(<StructuresSearchResults {...props} />);
-    wrapper.find(StructuresTable).simulate("structureSelected", structure);
+    const structure = { id: 1, foo: 1 };
+    const props = {
+      onSelect,
+      structures,
+      columns,
+      selectedStructure: structure,
+    };
+
+    const { getByRole } = render(
+      <SearchContextWrapper props={searchProps}>
+        <StructuresSearchResults {...props} />
+      </SearchContextWrapper>,
+      renderOpts
+    );
+
+    const structureRow = getByRole("cell", { name: /1/i });
+
+    userEvent.click(structureRow);
+
+    await waitFor(() => {
+      expect(onSelect).toHaveBeenCalledTimes(1);
+    });
+    expect(onSelect).toHaveBeenCalledWith(structures[0]);
+
     expect(onSelect.mock.calls.length).toBe(1);
     expect(onSelect.mock.calls[0][0]).toEqual(structure);
   });