@truedat/ie 7.5.7 → 7.5.10

package/src/ingests/components/__tests__/IngestRoutes.spec.js

@@ -0,0 +1,176 @@
+import React from "react";
+import { render, waitForLoad } from "@truedat/test/render";
+import IngestRoutes from "../IngestRoutes";
+import { useAuthorized } from "@truedat/core/hooks/useAuthorized";
+import {
+  INGEST,
+  INGEST_ARCHIVE,
+  INGEST_DUPLICATE,
+  INGEST_EDIT,
+  INGEST_EVENTS,
+  INGEST_RELATIONS_INGESTS,
+  INGEST_RELATIONS_STRUCTURES,
+  INGESTS,
+  INGESTS_PENDING,
+  INGESTS_NEW,
+  INGEST_EXECUTIONS,
+} from "@truedat/core/routes";
+
+jest.mock("@truedat/core/hooks/useAuthorized", () => ({
+  useAuthorized: jest.fn(() => true),
+}));
+
+// Mock all child components
+jest.mock("../Ingest", () => () => <div>Ingest</div>);
+jest.mock("../IngestArchive", () => () => <div>IngestArchive</div>);
+jest.mock("../IngestArchiveLoader", () => () => <div>IngestArchiveLoader</div>);
+jest.mock("../IngestCrumbs", () => () => <div>IngestCrumbs</div>);
+jest.mock("../IngestCompleteness", () => () => <div>IngestCompleteness</div>);
+jest.mock("../IngestDetails", () => () => <div>IngestDetails</div>);
+jest.mock("../IngestDuplicate", () => () => <div>IngestDuplicate</div>);
+jest.mock("../IngestEdit", () => () => <div>IngestEdit</div>);
+jest.mock("../IngestExecutions", () => () => <div>IngestExecutions</div>);
+jest.mock("../IngestExecutionsLoader", () => () => (
+  <div>IngestExecutionsLoader</div>
+));
+jest.mock("../IngestFiltersLoader", () => () => <div>IngestFiltersLoader</div>);
+jest.mock("../IngestForm", () => () => <div>IngestForm</div>);
+jest.mock("../IngestLoader", () => () => <div>IngestLoader</div>);
+jest.mock("../IngestSummary", () => () => <div>IngestSummary</div>);
+jest.mock("../Ingests", () => () => <div>Ingests</div>);
+jest.mock("../IngestsLoader", () => () => <div>IngestsLoader</div>);
+jest.mock("../Events", () => () => <div>Events</div>);
+jest.mock("../../relations/components/IngestRelationsRoutes", () => () => (
+  <div>IngestRelationsRoutes</div>
+));
+jest.mock("@truedat/core/components/Comments", () => () => <div>Comments</div>);
+jest.mock("@truedat/core/components/CommentsLoader", () => () => (
+  <div>CommentsLoader</div>
+));
+jest.mock("@truedat/core/router/ProtectedRoute", () => ({ children }) => (
+  <div>ProtectedRoute{children}</div>
+));
+jest.mock("@truedat/core/router/Loader", () => ({ children, loaders }) => (
+  <div>
+    Loader
+    <div>Loaders: {loaders}</div>
+    {children}
+  </div>
+));
+jest.mock("@truedat/audit/components/EventsLoader", () => () => (
+  <div>EventsLoader</div>
+));
+jest.mock("@truedat/lm/components/RelationTagsLoader", () => () => (
+  <div>RelationTagsLoader</div>
+));
+jest.mock("@truedat/core/components/TemplatesLoader", () => () => (
+  <div>TemplatesLoader</div>
+));
+jest.mock("@truedat/core/router/Unauthorized", () => () => (
+  <div>Unauthorized</div>
+));
+
+describe("<IngestRoutes />", () => {
+  it("renders correctly with default route", async () => {
+    const rendered = render(<IngestRoutes />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with ingests route", async () => {
+    const rendered = render(<IngestRoutes />, {
+      routes: [INGESTS],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with ingests pending route", async () => {
+    const rendered = render(<IngestRoutes />, {
+      routes: [INGESTS_PENDING],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with ingests new route", async () => {
+    const rendered = render(<IngestRoutes />, {
+      routes: [INGESTS_NEW],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with ingest route", async () => {
+    const rendered = render(<IngestRoutes />, {
+      routes: [INGEST.replace(":id", "123")],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with ingest executions route", async () => {
+    const rendered = render(<IngestRoutes />, {
+      routes: [INGEST_EXECUTIONS.replace(":id", "123")],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with ingest archive route", async () => {
+    const rendered = render(<IngestRoutes />, {
+      routes: [INGEST_ARCHIVE.replace(":id", "123")],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with ingest events route", async () => {
+    const rendered = render(<IngestRoutes />, {
+      routes: [INGEST_EVENTS.replace(":id", "123")],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with ingest relations structures route", async () => {
+    const rendered = render(<IngestRoutes />, {
+      routes: [INGEST_RELATIONS_STRUCTURES.replace(":id", "123")],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with ingest relations ingests route", async () => {
+    const rendered = render(<IngestRoutes />, {
+      routes: [INGEST_RELATIONS_INGESTS.replace(":id", "123")],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with ingest edit route", async () => {
+    const rendered = render(<IngestRoutes />, {
+      routes: [INGEST_EDIT.replace(":id", "123")],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with ingest duplicate route", async () => {
+    const rendered = render(<IngestRoutes />, {
+      routes: [INGEST_DUPLICATE.replace(":id", "123")],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders unauthorized component when not authorized", async () => {
+    useAuthorized.mockReturnValueOnce(false);
+    const rendered = render(<IngestRoutes />, {
+      routes: [INGESTS],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+});

package/src/ingests/components/__tests__/IngestSelectedFilters.spec.js

@@ -1,10 +1,38 @@
-import React from "react";
-import { shallow } from "enzyme";
+import { render, waitForLoad } from "@truedat/test/render";
 import { IngestSelectedFilters } from "../IngestSelectedFilters";
+import { INGESTS, INGESTS_PENDING } from "@truedat/core/routes";
+
+// Mock all child components used in routes
+jest.mock("../IngestSelectedFiltersDefault", () => () => (
+  <div>IngestSelectedFiltersDefault</div>
+));
+jest.mock("../IngestSelectedFiltersPending", () => () => (
+  <div>IngestSelectedFiltersPending</div>
+));
+jest.mock("../IngestSelectedFiltersPublished", () => () => (
+  <div>IngestSelectedFiltersPublished</div>
+));
 
 describe("<IngestSelectedFilters />", () => {
-  it("matches the latest snapshot", () => {
-    const wrapper = shallow(<IngestSelectedFilters />);
-    expect(wrapper).toMatchSnapshot();
+  it("renders correctly with default route", async () => {
+    const rendered = render(<IngestSelectedFilters />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with ingests route", async () => {
+    const rendered = render(<IngestSelectedFilters />, {
+      routes: [INGESTS],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders correctly with ingests pending route", async () => {
+    const rendered = render(<IngestSelectedFilters />, {
+      routes: [INGESTS_PENDING],
+    });
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 });

package/src/ingests/components/__tests__/Ingests.spec.js

@@ -1,14 +1,40 @@
-import React from "react";
-import { shallow } from "enzyme";
+import { render, waitForLoad } from "@truedat/test/render";
 import { Ingests } from "../Ingests";
 
+// Mock the imported components
+jest.mock("../IngestCrumbs", () => () => (
+  <div data-testid="mock-ingest-crumbs" />
+));
+jest.mock("../IngestSelectedFilters", () => () => (
+  <div data-testid="mock-ingest-selected-filters" />
+));
+jest.mock("../IngestsActions", () => () => (
+  <div data-testid="mock-ingests-actions" />
+));
+jest.mock("../IngestsLabelResults", () => () => (
+  <div data-testid="mock-ingests-label-results" />
+));
+jest.mock("../IngestsPagination", () => () => (
+  <div data-testid="mock-ingests-pagination" />
+));
+jest.mock("../IngestsSearch", () => () => (
+  <div data-testid="mock-ingests-search" />
+));
+jest.mock("../IngestsTable", () => () => (
+  <div data-testid="mock-ingests-table" />
+));
+jest.mock("../IngestsTabs", () => () => (
+  <div data-testid="mock-ingests-tabs" />
+));
+
 describe("<Ingests />", () => {
-  it("matches the latest snapshot", () => {
+  it("matches the latest snapshot", async () => {
     const ingests = [
-      { id: 1, name: "s1", description: "dd", version: "vs", status: "st" }
+      { id: 1, name: "s1", description: "dd", version: "vs", status: "st" },
     ];
     const props = { ingests };
-    const wrapper = shallow(<Ingests {...props} />);
-    expect(wrapper).toMatchSnapshot();
+    const rendered = render(<Ingests {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 });

package/src/ingests/components/__tests__/IngestsActions.spec.js

@@ -1,12 +1,12 @@
-import React from "react";
-import { shallow } from "enzyme";
+import { render, waitForLoad } from "@truedat/test/render";
 import { IngestsActions } from "../IngestsActions";
 
 describe("<IngestsActions />", () => {
   const props = { createUrl: "/url/to/create/ingest" };
 
-  it("matches the latest snapshot", () => {
-    const wrapper = shallow(<IngestsActions {...props} />);
-    expect(wrapper).toMatchSnapshot();
+  it("matches the latest snapshot", async () => {
+    const rendered = render(<IngestsActions {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 });

package/src/ingests/components/__tests__/IngestsLoader.spec.js

@@ -1,52 +1,81 @@
-import React from "react";
-import { mount, shallow } from "enzyme";
+import { render, waitForLoad } from "@truedat/test/render";
 import { IngestsLoader } from "../IngestsLoader";
 
-const getProps = () => ({
-  clearIngests: jest.fn(),
-  loading: false,
-  fetchIngests: jest.fn(),
-});
-
 describe("<IngestsLoader />", () => {
-  it("matches the latest snapshot", () => {
-    const props = getProps();
-    const wrapper = mount(<IngestsLoader {...props} />);
-    expect(wrapper).toMatchSnapshot();
+  const clearIngests = jest.fn();
+  const fetchIngests = jest.fn();
+
+  it("matches the latest snapshot", async () => {
+    const props = {
+      clearIngests,
+      fetchIngests,
+      loading: false,
+    };
+    const rendered = render(<IngestsLoader {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 
-  it("renders a loader if ingestLoading is true", () => {
-    const props = getProps();
-    const wrapper = mount(<IngestsLoader {...props} loading />);
-    expect(wrapper.find("Loading").length).toBe(1);
+  it("renders a loader if ingestLoading is true", async () => {
+    const props = {
+      clearIngests,
+      fetchIngests,
+      loading: true,
+    };
+    const rendered = render(<IngestsLoader {...props} />);
+    expect(rendered.container.querySelector(".loader")).toBeInTheDocument();
   });
 
-  it("renders null if ingestLoading is false", () => {
-    const props = getProps();
-    const wrapper = shallow(<IngestsLoader {...props} />);
-    expect(wrapper.getElement()).toBeNull();
+  it("renders null if ingestLoading is false", async () => {
+    const props = {
+      clearIngests,
+      fetchIngests,
+      loading: false,
+    };
+    const rendered = render(<IngestsLoader {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container.firstChild).toBeNull();
   });
 
-  it("calls fetchIngests when component mounts but not when it unmounts", () => {
-    const props = getProps();
-    const wrapper = mount(<IngestsLoader {...props} />);
-    expect(props.fetchIngests).toHaveBeenCalledTimes(1);
-    wrapper.unmount();
-    expect(props.fetchIngests).toHaveBeenCalledTimes(1);
+  it("calls fetchIngests when component mounts but not when it unmounts", async () => {
+    const fetchIngestsMock = jest.fn();
+    const props = {
+      clearIngests,
+      fetchIngests: fetchIngestsMock,
+      loading: false,
+    };
+    const rendered = render(<IngestsLoader {...props} />);
+    await waitForLoad(rendered);
+    expect(fetchIngestsMock).toHaveBeenCalledTimes(1);
+    rendered.unmount();
+    expect(fetchIngestsMock).toHaveBeenCalledTimes(1);
   });
 
-  it("calls clearIngests when component unmounts but not when it mounts", () => {
-    const props = getProps();
-    const wrapper = mount(<IngestsLoader {...props} />);
-    expect(props.clearIngests).toHaveBeenCalledTimes(0);
-    wrapper.unmount();
-    expect(props.clearIngests).toHaveBeenCalledTimes(1);
+  it("calls clearIngests when component unmounts but not when it mounts", async () => {
+    const clearIngestsMock = jest.fn();
+    const props = {
+      clearIngests: clearIngestsMock,
+      fetchIngests,
+      loading: false,
+    };
+    const rendered = render(<IngestsLoader {...props} />);
+    await waitForLoad(rendered);
+    expect(clearIngestsMock).toHaveBeenCalledTimes(0);
+    rendered.unmount();
+    expect(clearIngestsMock).toHaveBeenCalledTimes(1);
   });
 
-  it("merges default filters with query filters", () => {
-    const props = getProps();
+  it("merges default filters with query filters", async () => {
+    const fetchIngestsMock = jest.fn();
     const payload = { foo: "foo" };
-    mount(<IngestsLoader payload={payload} {...props} />);
-    expect(props.fetchIngests).toHaveBeenCalledWith(payload);
+    const props = {
+      clearIngests,
+      fetchIngests: fetchIngestsMock,
+      loading: false,
+      payload,
+    };
+    const rendered = render(<IngestsLoader {...props} />);
+    await waitForLoad(rendered);
+    expect(fetchIngestsMock).toHaveBeenCalledWith(payload);
   });
 });

package/src/ingests/components/__tests__/IngestsTable.spec.js

@@ -1,13 +1,22 @@
-import React from "react";
-import { shallow } from "enzyme";
+import { render, waitForLoad } from "@truedat/test/render";
 import { IngestsTable } from "../IngestsTable";
 
 describe("<IngestsTable />", () => {
-  it("matches the latest snapshot", () => {
-    const columns = ["name", "status"].map(name => ({ name }));
+  it("matches the latest snapshot", async () => {
+    const columns = ["name", "status"].map((name) => ({ name }));
     const ingests = [{ id: 1 }];
-    const props = { columns, ingests };
-    const wrapper = shallow(<IngestsTable {...props} />);
-    expect(wrapper).toMatchSnapshot();
+
+    const renderOpts = {
+      state: {
+        ingestsLoading: false,
+        ingestQuery: { sort: {} },
+        ingestsColumns: columns,
+        ingests: ingests,
+      },
+    };
+
+    const rendered = render(<IngestsTable />, renderOpts);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
   });
 });

package/src/ingests/components/__tests__/__snapshots__/Events.spec.js.snap

@@ -1,48 +1,88 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`<Events /> matches the latest snapshot 1`] = `
-<Segment
-  attached="bottom"
->
-  <Feed
-    size="small"
+<div>
+  <div
+    class="ui bottom attached segment"
   >
-    <EventRow
-      id={1}
-      key="0"
-      payload={
-        [
-          {
-            "field": "Ou",
-            "value": 5,
-          },
-          {
-            "field": "id",
-            "value": 6,
-          },
-        ]
-      }
-      resource_id={2}
-      service="My invented service 1"
-    />
-    <EventRow
-      id={2}
-      key="1"
-      payload={
-        [
-          {
-            "field": "Ou",
-            "value": 7,
-          },
-          {
-            "field": "id",
-            "value": 3,
-          },
-        ]
-      }
-      resource_id={2}
-      service="My invented service 2"
-    />
-  </Feed>
-</Segment>
+    <div
+      class="ui small feed"
+    >
+      <div
+        class="event"
+      >
+        <div
+          class="content"
+        >
+          <div
+            class="summary"
+          >
+            <a
+              class="user"
+            />
+             
+            ingest.events.undefined
+             
+            <div
+              class="date"
+            >
+              <time
+                datetime="1735689600000"
+              >
+                a few seconds ago
+              </time>
+            </div>
+          </div>
+          <div
+            class="text extra"
+          >
+            ingest.events.extra.undefined
+          </div>
+          <div
+            class="text extra"
+          >
+            ingest.events.extra.undefined
+          </div>
+        </div>
+      </div>
+      <div
+        class="event"
+      >
+        <div
+          class="content"
+        >
+          <div
+            class="summary"
+          >
+            <a
+              class="user"
+            />
+             
+            ingest.events.undefined
+             
+            <div
+              class="date"
+            >
+              <time
+                datetime="1735689600000"
+              >
+                a few seconds ago
+              </time>
+            </div>
+          </div>
+          <div
+            class="text extra"
+          >
+            ingest.events.extra.undefined
+          </div>
+          <div
+            class="text extra"
+          >
+            ingest.events.extra.undefined
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</div>
 `;

package/src/ingests/components/__tests__/__snapshots__/Ingest.spec.js.snap

@@ -1,20 +1,33 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`<Ingest /> matches the latest snapshot 1`] = `
-<Fragment>
-  <Grid>
-    <GridColumn
-      width={8}
+<div>
+  <div
+    class="ui grid"
+  >
+    <div
+      class="eight wide column"
     >
-      <Connect(IngestHeader) />
-    </GridColumn>
-    <GridColumn
-      textAlign="right"
-      width={8}
+      <div
+        data-testid="ingest-header"
+      >
+        IngestHeader Mock
+      </div>
+    </div>
+    <div
+      class="right aligned eight wide column"
     >
-      <Connect(IngestActions) />
-    </GridColumn>
-  </Grid>
-  <Connect(IngestTabs) />
-</Fragment>
+      <div
+        data-testid="ingest-actions"
+      >
+        IngestActions Mock
+      </div>
+    </div>
+  </div>
+  <div
+    data-testid="ingest-tabs"
+  >
+    IngestTabs Mock
+  </div>
+</div>
 `;

package/src/ingests/components/__tests__/__snapshots__/IngestActions.spec.js.snap

@@ -1,25 +1,24 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`<IngestActions /> matches the latest snapshot 1`] = `
-<Grid>
-  <GridColumn
-    textAlign="right"
-    width={16}
+<div>
+  <div
+    class="ui grid"
   >
-    <IngestAction
-      action="action1"
-      doAction={[MockFunction]}
-      href="/api/action1"
-      key="action1"
-      method="POST"
-    />
-    <IngestAction
-      action="action2"
-      doAction={[MockFunction]}
-      href="/api/action2"
-      key="action2"
-      method="GET"
-    />
-  </GridColumn>
-</Grid>
+    <div
+      class="right aligned sixteen wide column"
+    >
+      <button
+        class="ui button"
+      >
+        action1
+      </button>
+      <button
+        class="ui button"
+      >
+        action2
+      </button>
+    </div>
+  </div>
+</div>
 `;