@truedat/dd 7.5.9 → 7.5.10

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

@@ -1,24 +1,28 @@
-import React from "react";
-import { shallow, mount } from "enzyme";
+import { render, waitForLoad } from "@truedat/test/render";
 import { StructureTypesLoader } from "../StructureTypesLoader";
 
 describe("<StructureTypesLoader />", () => {
-  it("matches the latest snapshot", () => {
-    const fetchStructureTypes = jest.fn();
-    const props = { fetchStructureTypes };
-    const wrapper = shallow(<StructureTypesLoader {...props} />);
-    expect(wrapper).toMatchSnapshot();
+  it("matches the latest snapshot", async () => {
+    const props = {
+      fetchStructureTypes: jest.fn(),
+      clearStructureTypes: jest.fn(),
+    };
+    const rendered = render(<StructureTypesLoader {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("calls fetchStructureTypes when component mounts, clearStructureTypes when component unmounts", () => {
-    const fetchStructureTypes = jest.fn();
-    const clearStructureTypes = jest.fn();
-    const props = { fetchStructureTypes, clearStructureTypes };
-    const wrapper = mount(<StructureTypesLoader {...props} />);
-    expect(clearStructureTypes.mock.calls.length).toBe(0);
-    expect(fetchStructureTypes.mock.calls.length).toBe(1);
-    wrapper.unmount();
-    expect(clearStructureTypes.mock.calls.length).toBe(1);
-    expect(fetchStructureTypes.mock.calls.length).toBe(1);
+  it("calls fetchStructureTypes when component mounts, clearStructureTypes when component unmounts", async () => {
+    const props = {
+      fetchStructureTypes: jest.fn(),
+      clearStructureTypes: jest.fn(),
+    };
+    const rendered = render(<StructureTypesLoader {...props} />);
+    await waitForLoad(rendered);
+    expect(props.clearStructureTypes).toHaveBeenCalledTimes(0);
+    expect(props.fetchStructureTypes).toHaveBeenCalledTimes(1);
+    rendered.unmount();
+    expect(props.clearStructureTypes).toHaveBeenCalledTimes(1);
+    expect(props.fetchStructureTypes).toHaveBeenCalledTimes(1);
   });
 });

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

@@ -0,0 +1,62 @@
+import React from "react";
+import { render, waitForLoad } from "@truedat/test/render";
+import StructureTypesRoutes from "../StructureTypesRoutes";
+import { useSelector } from "react-redux";
+
+// Mock all components
+jest.mock("../StructureTypes", () => () => <div>StructureTypes</div>);
+jest.mock("../StructureType", () => () => <div>StructureType</div>);
+jest.mock("../StructureTypesCrumbs", () => () => (
+  <div>StructureTypesCrumbs</div>
+));
+jest.mock("../StructureTypeLoader", () => () => <div>StructureTypeLoader</div>);
+
+jest.mock("react-redux", () => ({
+  ...jest.requireActual("react-redux"),
+  useSelector: jest.fn(),
+}));
+
+describe("<StructureTypesRoutes />", () => {
+  beforeEach(() => {
+    useSelector.mockImplementation((selector) =>
+      selector({
+        structureType: null,
+        structureTypeLoading: false,
+      })
+    );
+  });
+
+  it("renders correctly with default route", async () => {
+    const rendered = render(<StructureTypesRoutes />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with edit route when loading", async () => {
+    useSelector.mockImplementation((selector) =>
+      selector({
+        structureType: null,
+        structureTypeLoading: true,
+      })
+    );
+    const rendered = render(<StructureTypesRoutes />, {
+      routes: ["/structure_types/123/edit"],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with edit route with data", async () => {
+    useSelector.mockImplementation((selector) =>
+      selector({
+        structureType: { id: "123" },
+        structureTypeLoading: false,
+      })
+    );
+    const rendered = render(<StructureTypesRoutes />, {
+      routes: ["/structure_types/123/edit"],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+});

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

@@ -1,23 +1,14 @@
-import React from "react";
 import { render } from "@truedat/test/render";
 import StructureTypesTable from "../StructureTypesTable";
 
 const renderOpts = {
-  messages: {
-    en: {
-      "structureType.metadataFields": "metadataFields",
-      "structureType.metadataViews": "metadataViews",
-      "structureType.template": "template",
-      "structureType.translation": "translation",
-    },
-  },
   state: {
     structureTypes: [
-      { id: 1, name: "doc", template_id: 1, translation: "docu" },
+      { id: "1", name: "doc", template_id: 1, translation: "docu" },
       {
-        id: 2,
+        id: "2",
         name: "col",
-        template_id: 2,
+        template_id: "2",
         translation: null,
         metadata_fields: ["foo"],
       },

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

@@ -1,4 +1,3 @@
-import React from "react";
 import { render } from "@truedat/test/render";
 import StructureVersionListItem from "../StructureVersionListItem";
 
@@ -6,8 +5,8 @@ describe("<StructureVersionListItem />", () => {
   it("matches the latest snapshot", () => {
     const push = jest.fn();
     const history = { push };
-    const version = 42;
-    const id = 123;
+    const version = "42";
+    const id = "123";
     const inserted_at = "2018-01-01T01:01:01.123456Z";
     const props = { id, version, inserted_at, history };
 

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

@@ -1,23 +1,23 @@
-import React from "react";
-import { shallow } from "enzyme";
+import { render, waitForLoad } from "@truedat/test/render";
 import { StructureVersions } from "../StructureVersions";
 
 describe("<StructureVersions />", () => {
-  it("matches the latest snapshot", () => {
+  it("matches the latest snapshot", async () => {
     const versions = [
       {
-        version: 0,
-        inserted_at: "2018-01-01T01:01:01.123456Z"
+        version: "0",
+        inserted_at: "2018-01-01T01:01:01.123456Z",
       },
       {
-        version: 1,
-        inserted_at: "2018-02-01T01:01:01.123456Z"
-      }
+        version: "1",
+        inserted_at: "2018-02-01T01:01:01.123456Z",
+      },
     ];
-    const id = 1;
+    const id = "1";
     const props = { id, versions };
 
-    const wrapper = shallow(<StructureVersions {...props} />);
-    expect(wrapper).toMatchSnapshot();
+    const rendered = render(<StructureVersions {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 });

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

@@ -1,10 +1,9 @@
-import React from "react";
 import { render } from "@truedat/test/render";
 import { waitFor } from "@testing-library/react";
 import StructureView from "../StructureView";
 
-jest.mock("react-router-dom", () => ({
-  ...jest.requireActual("react-router-dom"),
+jest.mock("react-router", () => ({
+  ...jest.requireActual("react-router"),
   useParams: () => ({ id: 1 }),
 }));
 

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

@@ -1,12 +1,9 @@
-import _ from "lodash/fp";
-import React from "react";
-import { waitFor } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
+import { render, waitForLoad } from "@truedat/test/render";
 import {
   templateByNameMock,
   emptyTemplateByNameMock,
 } from "@truedat/test/mocks";
-import { render } from "@truedat/test/render";
 import StructuresBulkUpdate from "../StructuresBulkUpdate";
 import { bulkUpdateStructures } from "../../routines";
 
@@ -28,69 +25,62 @@ describe("<StructuresBulkUpdate />", () => {
       },
       structureTypes: [{ name: "structType", template: { name: "template1" } }],
     },
-    fallback: "lazy",
   };
 
   it("matches the latest snapshot", async () => {
-    const { container, queryByText } = render(
-      <StructuresBulkUpdate />,
-      renderOpts
-    );
-
-    await waitFor(() => {
-      expect(queryByText(/lazy/i)).not.toBeInTheDocument();
-      expect(container.querySelector(".loader")).not.toBeInTheDocument();
-    });
-    expect(container).toMatchSnapshot();
+    const rendered = render(<StructuresBulkUpdate />, renderOpts);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
   it("renders empty when no filters are selected", async () => {
-    const thisRenderOpts = _.update(
-      "state.previousStructureQuery.allFilters",
-      () => ({})
-    )(renderOpts);
-    const { container, queryByText, getByText } = render(
-      <StructuresBulkUpdate />,
-      thisRenderOpts
-    );
-    await waitFor(() => {
-      expect(queryByText(/lazy/i)).not.toBeInTheDocument();
-      expect(container.querySelector(".loader")).not.toBeInTheDocument();
-    });
-    const emptySearchText = getByText("Empty Search");
-    expect(emptySearchText).toBeInTheDocument();
-    expect(container).toMatchSnapshot();
+    const thisRenderOpts = {
+      ...renderOpts,
+      state: {
+        ...renderOpts.state,
+        previousStructureQuery: {
+          ...renderOpts.state.previousStructureQuery,
+          allFilters: {},
+        },
+      },
+    };
+    const rendered = render(<StructuresBulkUpdate />, thisRenderOpts);
+    await waitForLoad(rendered);
+    expect(
+      rendered.getByText(/bulkUpdateStructures.no.structures.header/i)
+    ).toBeInTheDocument();
+    expect(rendered.container).toMatchSnapshot();
   });
 
   it("Publish button is available with autoPublish action", async () => {
     const dispatch = jest.fn();
-    const thisRenderOpts = _.update(
-      "state.previousStructureQuery.actions",
-      () => ({
-        autoPublish: { method: "POST" },
-      })
-    )(renderOpts);
-
-    const { container, findByText, queryByText, findByRole } = render(
-      <StructuresBulkUpdate />,
-      { ...thisRenderOpts, dispatch }
-    );
-
-    await waitFor(() => {
-      expect(queryByText(/lazy/i)).not.toBeInTheDocument();
-      expect(queryByText(/loading/i)).not.toBeInTheDocument();
-      expect(container.querySelector(".loader")).not.toBeInTheDocument();
-    });
-
-    userEvent.type(await findByRole("textbox"), "bar");
+    const thisRenderOpts = {
+      ...renderOpts,
+      state: {
+        ...renderOpts.state,
+        previousStructureQuery: {
+          ...renderOpts.state.previousStructureQuery,
+          actions: {
+            autoPublish: { method: "POST" },
+          },
+        },
+      },
+      dispatch,
+    };
 
-    userEvent.click(await findByText("Save"));
+    const rendered = render(<StructuresBulkUpdate />, thisRenderOpts);
+    await waitForLoad(rendered);
 
-    expect(container).toMatchSnapshot();
+    const user = userEvent.setup({ delay: null });
+    await user.type(rendered.getByRole("textbox"), "bar");
+    await user.click(rendered.getByText(/save/i));
 
-    expect(queryByText(/Update and publish/i)).toBeInTheDocument();
+    expect(rendered.container).toMatchSnapshot();
+    expect(
+      rendered.getByText(/bulk.confirmation.update.publish/i)
+    ).toBeInTheDocument();
 
-    userEvent.click(await findByText(/Update and publish/i));
+    await user.click(rendered.getByText(/bulk.confirmation.update.publish/i));
 
     expect(dispatch).toHaveBeenLastCalledWith({
       ...bulkUpdateStructures(),
@@ -109,25 +99,22 @@ describe("<StructuresBulkUpdate />", () => {
 
   it("Publish button is not available without autoPublish action", async () => {
     const dispatch = jest.fn();
-    const { container, findByText, queryByText, findByRole } = render(
-      <StructuresBulkUpdate />,
-      { ...renderOpts, dispatch }
-    );
-
-    await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
-    await waitFor(() =>
-      expect(queryByText(/loading/i)).not.toBeInTheDocument()
-    );
-
-    userEvent.type(await findByRole("textbox"), "bar");
-
-    userEvent.click(await findByText("Save"));
+    const rendered = render(<StructuresBulkUpdate />, {
+      ...renderOpts,
+      dispatch,
+    });
+    await waitForLoad(rendered);
 
-    expect(container).toMatchSnapshot();
+    const user = userEvent.setup({ delay: null });
+    await user.type(rendered.getByRole("textbox"), "bar");
+    await user.click(rendered.getByText(/save/i));
 
-    expect(queryByText(/Update and publish/i)).not.toBeInTheDocument();
+    expect(rendered.container).toMatchSnapshot();
+    expect(
+      rendered.queryByText(/bulk.confirmation.update.publish/i)
+    ).not.toBeInTheDocument();
 
-    userEvent.click(await findByText("Update"));
+    await user.click(rendered.getByText(/update/i));
 
     expect(dispatch).toHaveBeenLastCalledWith({
       ...bulkUpdateStructures(),

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

@@ -1,4 +1,3 @@
-import React from "react";
 import { render } from "@truedat/test/render";
 import SearchContextWrapper from "@truedat/core/components/common/SearchContextWrapper";
 import { StructuresDownloadOption } from "../StructuresDownloadOption";

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

@@ -1,4 +1,3 @@
-import React from "react";
 import { render } from "@truedat/test/render";
 import SearchContextWrapper from "@truedat/core/components/common/SearchContextWrapper";
 import { StructuresEditableDownloadOption } from "../StructuresEditableDownloadOption";

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

@@ -1,4 +1,3 @@
-import React from "react";
 import { render } from "@truedat/test/render";
 import { waitFor } from "@testing-library/react";
 import { within } from "@testing-library/dom";
@@ -7,12 +6,12 @@ import { functionsMock } from "@truedat/test/mocks";
 import { StructuresGrantRequestView } from "../StructuresGrantRequestView";
 import en from "../../messages/en";
 
-const mockHistory = { push: jest.fn() };
+const mockHistory = jest.fn();
 
-jest.mock("react-router-dom", () => ({
-  ...jest.requireActual("react-router-dom"),
+jest.mock("react-router", () => ({
+  ...jest.requireActual("react-router"),
   useLocation: () => ({ pathname: "/bar" }),
-  useHistory: () => mockHistory,
+  useNavigate: () => mockHistory,
 }));
 
 jest.mock("@truedat/dd/hooks/useStructures", () => {
@@ -68,7 +67,6 @@ const renderOpts = {
   messages,
   mocks: [functionsMock],
   dispatch,
-  fallback: "lazy",
 };
 
 describe("<StructuresGrantRequestView />", () => {

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

@@ -1,4 +1,3 @@
-import React from "react";
 import { render } from "@truedat/test/render";
 import { SearchContextProvider } from "@truedat/core/search/SearchContext";
 import StructuresLabelResults from "../StructuresLabelResults";
@@ -39,7 +38,7 @@ describe("<StructuresLabelResults />", () => {
         <StructuresLabelResults />
       </SearchContextProvider>
     );
-    await findByText(/22 structures found/);
+    await findByText(/structures.retrieved.results/);
     expect(container).toMatchSnapshot();
   });
 });

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

@@ -1,5 +1,4 @@
-import React from "react";
-import { mount } from "enzyme";
+import { render, waitForLoad } from "@truedat/test/render";
 import { StructuresLoader } from "../StructuresLoader";
 
 const getProps = () => ({
@@ -10,32 +9,39 @@ const getProps = () => ({
 });
 
 describe("<StructuresLoader />", () => {
-  it("matches the latest snapshot", () => {
+  it("matches the latest snapshot", async () => {
     const props = getProps();
-    const wrapper = mount(<StructuresLoader {...props} />);
-    expect(wrapper).toMatchSnapshot();
+    const rendered = render(<StructuresLoader {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("calls fetchStructures when component mounts but not when it unmounts", () => {
+  it("calls fetchStructures when component mounts but not when it unmounts", async () => {
     const props = getProps();
-    const wrapper = mount(<StructuresLoader {...props} />);
+    const rendered = render(<StructuresLoader {...props} />);
+    await waitForLoad(rendered);
     expect(props.fetchStructures).toHaveBeenCalledTimes(1);
-    wrapper.unmount();
+    rendered.unmount();
     expect(props.fetchStructures).toHaveBeenCalledTimes(1);
   });
 
-  it("calls clearStructures when component unmounts but not when it mounts", () => {
+  it("calls clearStructures when component unmounts but not when it mounts", async () => {
     const props = getProps();
-    const wrapper = mount(<StructuresLoader {...props} />);
+    const rendered = render(<StructuresLoader {...props} />);
+    await waitForLoad(rendered);
     expect(props.clearStructures).toHaveBeenCalledTimes(0);
-    wrapper.unmount();
+    rendered.unmount();
     expect(props.clearStructures).toHaveBeenCalledTimes(1);
   });
 
-  it("calls fetchStructures when payload is updated", () => {
+  it("calls fetchStructures when payload is updated", async () => {
     const props = getProps();
-    const wrapper = mount(<StructuresLoader {...props} />);
-    wrapper.setProps({ payload: { "system.name.raw": "XXX" } });
+    const rendered = render(<StructuresLoader {...props} />);
+    await waitForLoad(rendered);
+
+    rendered.rerender(
+      <StructuresLoader {...props} payload={{ "system.name.raw": "XXX" }} />
+    );
     expect(props.fetchStructures).toHaveBeenCalledTimes(2);
   });
 });

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

@@ -1,6 +1,5 @@
-import React from "react";
+import { render, waitForLoad } from "@truedat/test/render";
 import { waitFor } from "@testing-library/react";
-import { render } from "@truedat/test/render";
 import { SearchContextProvider } from "@truedat/core/search/SearchContext";
 import StructuresOptions from "../StructuresOptions";
 
@@ -42,40 +41,43 @@ describe("<StructuresOptions />", () => {
   };
 
   it("matches the latest snapshot", async () => {
-    const { container, findByText } = render(
-      <SearchContextProvider {...searchProps}>
-        <StructuresOptions {...props} />
-      </SearchContextProvider>
+    const rendered = render(
+      <SearchContextProvider {...searchProps}><StructuresOptions {...props} /></SearchContextProvider>
     );
+    await waitForLoad(rendered);
 
-    await findByText(/Download editable structures metadata/);
+    await waitFor(() =>
+      expect(
+        rendered.getByText(/structures.actions.editableDownload.tooltip/i)
+      ).toBeInTheDocument()
+    );
 
-    await waitFor(() => expect(container).toMatchSnapshot());
+    expect(rendered.container).toMatchSnapshot();
   });
 
   it("Dont have permissions to upload notes", async () => {
-    const newProps = {};
-    const { queryByText } = render(
-      <SearchContextProvider {...searchProps}>
-        <StructuresOptions {...newProps} />
-      </SearchContextProvider>
+    const rendered = render(
+      <SearchContextProvider {...searchProps}><StructuresOptions /></SearchContextProvider>
     );
+    await waitForLoad(rendered);
 
     await waitFor(() =>
-      expect(queryByText("Upload structure notes")).not.toBeInTheDocument()
+      expect(
+        rendered.queryByText(/structures.actions.upload.tooltip/i)
+      ).not.toBeInTheDocument()
     );
   });
 
   it("Dont have permissions to upload domains", async () => {
-    const newProps = {};
-    const { queryByText } = render(
-      <SearchContextProvider {...searchProps}>
-        <StructuresOptions {...newProps} />
-      </SearchContextProvider>
+    const rendered = render(
+      <SearchContextProvider {...searchProps}><StructuresOptions /></SearchContextProvider>
     );
+    await waitForLoad(rendered);
 
     await waitFor(() =>
-      expect(queryByText("Update structure domains")).not.toBeInTheDocument()
+      expect(
+        rendered.queryByText(/structures.actions.uploadDomains.tooltip/i)
+      ).not.toBeInTheDocument()
     );
   });
 });

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

@@ -1,19 +1,93 @@
 import React from "react";
-import { shallow } from "enzyme";
-import { intl } from "@truedat/test/intl-stub";
-import { StructuresRoutes } from "../StructuresRoutes";
+import { render, waitForLoad } from "@truedat/test/render";
+import StructuresRoutes from "../StructuresRoutes";
+import { useAuthorized } from "@truedat/core/hooks/useAuthorized";
+import {
+  STRUCTURES,
+  STRUCTURE_MEMBERS_NEW,
+  STRUCTURES_BULK_UPDATE,
+} from "@truedat/core/routes";
 
-// 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("@truedat/core/hooks", () => ({
-  useAuthorized: jest.fn(() => true)
+jest.mock("@truedat/core/hooks/useAuthorized", () => ({
+  useAuthorized: jest.fn(() => true),
 }));
 
+jest.mock("../AddStructureMember", () => () => <div>AddStructureMember</div>);
+jest.mock("../StructureCrumbs", () => () => <div>StructureCrumbs</div>);
+jest.mock("../StructureLoader", () => () => <div>StructureLoader</div>);
+jest.mock("../StructureView", () => () => <div>StructureView</div>);
+jest.mock("../StructuresBulkUpdate", () => () => (
+  <div>StructuresBulkUpdate</div>
+));
+jest.mock("../StructuresView", () => () => <div>StructuresView</div>);
+jest.mock("@truedat/dq/components/RuleImplementationsLoader", () => () => (
+  <div>RuleImplementationsLoader</div>
+));
+jest.mock("@truedat/auth/roles/components/RolesLoader", () => () => (
+  <div>RolesLoader</div>
+));
+
 describe("<StructuresRoutes />", () => {
-  it("matches the latest snapshot", () => {
-    const wrapper = shallow(<StructuresRoutes />);
-    expect(wrapper).toMatchSnapshot();
+  it("renders correctly with default route", async () => {
+    const rendered = render(<StructuresRoutes />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with structures route", async () => {
+    const rendered = render(<StructuresRoutes />, {
+      routes: [STRUCTURES],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with structure members new route", async () => {
+    const rendered = render(<StructuresRoutes />, {
+      routes: [STRUCTURE_MEMBERS_NEW.replace(":id", "123")],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with structures bulk update route", async () => {
+    const rendered = render(<StructuresRoutes />, {
+      routes: [STRUCTURES_BULK_UPDATE],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with structure detail route", async () => {
+    const renderOpts = {
+      state: {
+        userPermissions: {
+          view_quality: true, // or false, depending on the test case
+        },
+      },
+    };
+    const rendered = render(<StructuresRoutes />, {
+      ...renderOpts,
+      routes: ["/structures/123"],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders unauthorized component when not authorized", async () => {
+    const renderOpts = {
+      state: {
+        userPermissions: {
+          view_quality: false, // or true, depending on the test case
+        },
+      },
+    };
+    useAuthorized.mockReturnValueOnce(false);
+    const rendered = render(<StructuresRoutes />, {
+      ...renderOpts,
+      routes: [STRUCTURES],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 });