@truedat/dq 7.11.0 → 7.11.2

package/src/components/SimpleRuleImplementationsTable.js

@@ -0,0 +1,68 @@
+import _ from "lodash/fp";
+import PropTypes from "prop-types";
+import { Table, Header, Icon } from "semantic-ui-react";
+import { useIntl } from "react-intl";
+import RuleImplementationRow from "./RuleImplementationRow";
+
+export const SimpleRuleImplementationsTable = ({
+  ruleImplementations,
+  columns,
+}) => {
+  const { formatMessage } = useIntl();
+
+  const validColumns = _.reject(
+    ({ hideOn }) => _.isFunction(hideOn) && hideOn(ruleImplementations)
+  )(columns);
+  return (
+    <>
+      {!_.isEmpty(ruleImplementations) ? (
+        <div className="implementations-table-overflow">
+          <Table sortable>
+            <Table.Header>
+              <Table.Row>
+                {validColumns
+                  ? validColumns.map((column, key) => (
+                      <Table.HeaderCell
+                        key={key}
+                        width={column.width}
+                        content={formatMessage({
+                          id: `ruleImplementations.props.${
+                            column.header || column.name
+                          }`,
+                        })}
+                        className="disabled"
+                      />
+                    ))
+                  : null}
+              </Table.Row>
+            </Table.Header>
+            <Table.Body>
+              {ruleImplementations.map((r, i) => (
+                <RuleImplementationRow
+                  key={i}
+                  ruleImplementation={r}
+                  columns={validColumns}
+                />
+              ))}
+            </Table.Body>
+          </Table>
+        </div>
+      ) : null}
+      {_.isEmpty(ruleImplementations) ? (
+        <Header as="h4">
+          <Icon name="search" />
+          <Header.Content>
+            {formatMessage({ id: "ruleImplementations.search.results.empty" })}
+          </Header.Content>
+        </Header>
+      ) : null}
+    </>
+  );
+};
+
+SimpleRuleImplementationsTable.propTypes = {
+  ruleImplementations: PropTypes.array,
+  columns: PropTypes.array,
+};
+
+export default SimpleRuleImplementationsTable;

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

@@ -1,4 +1,6 @@
+import userEvent from "@testing-library/user-event";
 import { render, waitForLoad } from "@truedat/test/render";
+import { useSearchContext } from "@truedat/core/search/SearchContext";
 import { ImplementationSearchResults } from "../ImplementationSearchResults";
 
 jest.mock("@truedat/core/hooks", () => ({
@@ -8,7 +10,29 @@ jest.mock("@truedat/core/hooks", () => ({
   ),
 }));
 
+jest.mock("@truedat/core/search/SearchContext", () => {
+  const originalModule = jest.requireActual(
+    "@truedat/core/search/SearchContext"
+  );
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    useSearchContext: jest.fn(),
+  };
+});
+
 describe("<ImplementationSearchResults />", () => {
+  beforeEach(() => {
+    useSearchContext.mockReturnValue({
+      searchData: { data: [{ id: 1 }], _actions: { execute: {} } },
+      count: 1,
+      searchMust: {},
+      toggleHiddenFilterValue: jest.fn(),
+      setOnSearchChange: jest.fn(),
+    });
+  });
+
   it("matches the latest snapshot", async () => {
     const props = {
       loading: false,
@@ -19,13 +43,17 @@ describe("<ImplementationSearchResults />", () => {
   });
 
   it("renders executions on when executionEnabled is true", async () => {
-    const props = {
-      loading: false,
-      implementationQuery: { filters: { executable: [true] } },
-    };
+    const user = userEvent.setup({ delay: null });
+    const props = { loading: false };
     const rendered = render(<ImplementationSearchResults {...props} />);
     await waitForLoad(rendered);
 
+    const updatedCheckbox =
+      rendered.container.querySelector("#execute_checkbox");
+
+    await user.click(updatedCheckbox);
+    expect(updatedCheckbox).toBeChecked();
+
     expect(rendered.container).toMatchSnapshot();
 
     expect(

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

@@ -0,0 +1,28 @@
+import { render, waitForLoad } from "@truedat/test/render";
+import { ImplementationUploadJobBreadcrumbs } from "../ImplementationUploadJobBreadcrumbs";
+
+describe("ImplementationUploadJobBreadcrumbs", () => {
+  it("renders breadcrumbs without filename", async () => {
+    const rendered = render(<ImplementationUploadJobBreadcrumbs />);
+    await waitForLoad(rendered);
+
+    expect(
+      rendered.getByText(/sidemenu.implementations_upload_jobs/i)
+    ).toBeInTheDocument();
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders breadcrumbs with filename", async () => {
+    const filename = "test.csv";
+    const rendered = render(
+      <ImplementationUploadJobBreadcrumbs filename={filename} />
+    );
+    await waitForLoad(rendered);
+
+    expect(
+      rendered.getByText(/sidemenu.implementations_upload_jobs/i)
+    ).toBeInTheDocument();
+    expect(rendered.getByText(filename)).toBeInTheDocument();
+    expect(rendered.container).toMatchSnapshot();
+  });
+});

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

@@ -1,6 +1,20 @@
 import { render, waitForLoad } from "@truedat/test/render";
 import Implementations from "../Implementations";
 
+jest.mock("@truedat/core/search/SearchContext", () => {
+  const originalModule = jest.requireActual(
+    "@truedat/core/search/SearchContext"
+  );
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    useSearchContext: jest.fn(),
+  };
+});
+
+const { useSearchContext } = require("@truedat/core/search/SearchContext");
+
 const props = {
   defaultFilters: { status: ["baz", "bar"] },
 };
@@ -14,6 +28,35 @@ const renderOpts = {
 };
 
 describe("<Implementations />", () => {
+  beforeEach(() => {
+    useSearchContext.mockReturnValue({
+      searchData: {
+        data: [
+          {
+            deleted_at: null,
+            df_content: {},
+            df_name: "fooDomain",
+            domain_id: 1,
+            id: 1330,
+            implementation_ref: 1330,
+            implementation_key: "bar_impl",
+            implementation_type: "basic",
+            goal: 20,
+            minimum: 10,
+            result_type: "percentage",
+            results: [],
+            rule_id: null,
+            status: "draft",
+            version: 1,
+          },
+        ],
+        scroll_id: null,
+      },
+      searchMust: { status: ["pending"] },
+      setOnSearchChange: jest.fn(),
+    });
+  });
+
   it("matches the latest snapshot", async () => {
     const rendered = render(<Implementations {...props} />, renderOpts);
     await waitForLoad(rendered);

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

@@ -1,16 +1,30 @@
 import { waitFor, fireEvent } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { render, waitForLoad } from "@truedat/test/render";
+import { useSearchContext } from "@truedat/core/search/SearchContext";
+
+import { useImplementationsUpload } from "../../hooks/useImplementations";
 import { ImplementationsUploadButton } from "../ImplementationsUploadButton";
 
-describe.skip("<ImplementationsUploadButton />", () => {
-  const uploadImplementationsMock = jest.fn();
-  const props = {
-    uploadImplementations: uploadImplementationsMock,
-    loading: false,
+jest.mock("../../hooks/useImplementations", () => ({
+  useImplementationsUpload: jest.fn(),
+}));
+jest.mock("@truedat/core/search/SearchContext", () => {
+  const originalModule = jest.requireActual(
+    "@truedat/core/search/SearchContext"
+  );
+  return {
+    __esModule: true,
+    ...originalModule,
+    useSearchContext: jest.fn(),
   };
-  const user = userEvent.setup({ delay: null });
+});
 
+describe("<ImplementationsUploadButton />", () => {
+  const user = userEvent.setup({ delay: null });
+  const uploadImplementationsMock = jest.fn(() => ({
+    then: jest.fn(),
+  }));
   // See https://react-dropzone.js.org/ "Testing" section
   const mockData = (files) => {
     return {
@@ -26,52 +40,77 @@ describe.skip("<ImplementationsUploadButton />", () => {
     };
   };
 
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    useImplementationsUpload.mockReturnValue({
+      trigger: uploadImplementationsMock,
+    });
+    useSearchContext.mockReturnValue({
+      searchData: {
+        _actions: {
+          autoPublish: true,
+        },
+      },
+    });
+  });
+
   it("shows the modal", async () => {
-    const rendered = render(
-      <ImplementationsUploadButton {...{ ...props, canAutoPublish: true }} />
-    );
+    const rendered = render(<ImplementationsUploadButton />);
     await waitForLoad(rendered);
 
     await user.click(
-      rendered.getByRole("option", { name: /actions.upload.tooltip/i })
+      rendered.getByRole("option", {
+        name: /ruleimplementations.actions.upload.tooltip/i,
+      })
     );
 
     const uploadButton = rendered.getByRole("button", {
-      name: /uploadModal.accept.update/i,
+      name: /uploadmodal.accept.update/i,
     });
     expect(uploadButton).toBeDisabled();
     const publishButton = rendered.getByRole("button", {
-      name: /uploadModal.accept.publish/i,
+      name: /uploadmodal.accept.publish/i,
     });
     expect(publishButton).toBeDisabled();
 
-    expect(rendered.getByText(/actions.upload.tooltip/i)).toBeInTheDocument();
+    expect(
+      rendered.getByText(/ruleimplementations.actions.upload.tooltip/i)
+    ).toBeInTheDocument();
     expect(
       rendered.getByText(/uploadModal.actions.upload.confirmation.content/i)
     ).toBeInTheDocument();
   });
 
   it("false canAutoPublish makes the modal not show the publish button; update using an implementations CSV", async () => {
-    const rendered = render(
-      <ImplementationsUploadButton {...{ ...props, canAutoPublish: false }} />
-    );
+    useSearchContext.mockReturnValue({
+      searchData: {
+        _actions: {
+          autoPublish: false,
+        },
+      },
+    });
+
+    const rendered = render(<ImplementationsUploadButton />);
     await waitForLoad(rendered);
 
     await user.click(
-      rendered.getByRole("option", { name: /actions.upload.tooltip/i })
+      rendered.getByRole("option", {
+        name: /ruleimplementations.actions.upload.tooltip/i,
+      })
     );
 
     const updateButton = rendered.getByRole("button", {
-      name: /uploadModal.accept.update/i,
+      name: /uploadmodal.accept.update/i,
     });
     expect(updateButton).toBeDisabled();
 
     const publishButton = rendered.queryByRole("button", {
-      name: /uploadModal.accept.publish/i,
+      name: /uploadmodal.accept.publish/i,
     });
     expect(publishButton).not.toBeInTheDocument();
 
-    const fakeFile = new File(["implementations"], "implementations.csv", {
+    const fakeFile = new File(["implementations"], "implementations.xslx", {
       type: "text/csv",
     });
     const formData = new FormData();
@@ -91,32 +130,26 @@ describe.skip("<ImplementationsUploadButton />", () => {
 
     await user.click(updateButton);
 
-    expect(uploadImplementationsMock).toHaveBeenCalledWith({
-      action: "upload",
-      formData,
-      lang: "en",
-      href: "/api/rule_implementations/upload",
-      method: "POST",
-    });
+    expect(uploadImplementationsMock).toHaveBeenCalled();
   });
 
   it("true canAutoPublish makes the modal show the publish button; publishing an implementations CSV puts auto_publish FormData to true", async () => {
-    const rendered = render(
-      <ImplementationsUploadButton {...{ ...props, canAutoPublish: true }} />
-    );
+    const rendered = render(<ImplementationsUploadButton />);
     await waitForLoad(rendered);
 
     await user.click(
-      rendered.getByRole("option", { name: /actions.upload.tooltip/i })
+      rendered.getByRole("option", {
+        name: /ruleimplementations.actions.upload.tooltip/i,
+      })
     );
 
     const updateButton = rendered.getByRole("button", {
-      name: /uploadModal.accept.update/i,
+      name: /uploadmodal.accept.update/i,
     });
     expect(updateButton).toBeDisabled();
 
     const publishButton = rendered.getByRole("button", {
-      name: /uploadModal.accept.publish/i,
+      name: /uploadmodal.accept.publish/i,
     });
     expect(updateButton).toBeDisabled();
 
@@ -142,12 +175,6 @@ describe.skip("<ImplementationsUploadButton />", () => {
 
     await user.click(publishButton);
 
-    expect(uploadImplementationsMock).toHaveBeenCalledWith({
-      action: "upload",
-      formData,
-      lang: "en",
-      href: "/api/rule_implementations/upload",
-      method: "POST",
-    });
+    expect(uploadImplementationsMock).toHaveBeenCalled();
   });
 });

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

@@ -0,0 +1,112 @@
+import { render, waitForLoad } from "@truedat/test/render";
+import userEvent from "@testing-library/user-event";
+import { waitFor } from "@testing-library/react";
+
+import { useImplementationsUploadJob } from "../../hooks/useImplementations";
+import ImplementationsUploadJob from "../ImplementationsUploadJob";
+
+jest.mock("../../hooks/useImplementations", () => ({
+  useImplementationsUploadJob: jest.fn(),
+}));
+jest.mock("react-router", () => ({
+  ...jest.requireActual("react-router"),
+  useParams: () => ({ id: "123" }),
+}));
+
+describe("<ImplementationsUploadJob />", () => {
+  const user = userEvent.setup({ delay: null });
+
+  beforeEach(() => {
+    useImplementationsUploadJob.mockReset();
+  });
+
+  it("renders loading state", async () => {
+    useImplementationsUploadJob.mockReturnValue({
+      loading: true,
+      data: null,
+    });
+
+    const rendered = render(<ImplementationsUploadJob />);
+
+    expect(rendered.container.querySelector(".ui.loader")).toBeInTheDocument();
+  });
+
+  it("renders empty state when no events", async () => {
+    useImplementationsUploadJob.mockReturnValue({
+      loading: false,
+      data: {
+        data: {
+          filename: "test.xlsx",
+          hash: "abc123",
+          latest_status: "COMPLETED",
+          latest_event_at: "2023-01-01T00:00:00Z",
+          events: [],
+        },
+      },
+    });
+
+    const rendered = render(<ImplementationsUploadJob />);
+    await waitForLoad(rendered);
+
+    expect(rendered.getAllByText(/test.xlsx/i)).toHaveLength(2);
+    expect(rendered.getByText(/abc123/i)).toBeInTheDocument();
+    expect(rendered.getByText(/no events found/i)).toBeInTheDocument();
+  });
+
+  it("renders events grouped by status", async () => {
+    useImplementationsUploadJob.mockReturnValue({
+      loading: false,
+      data: {
+        data: {
+          filename: "test.xlsx",
+          hash: "abc123",
+          latest_status: "COMPLETED",
+          latest_event_at: "2023-01-01T00:00:00Z",
+          events: [
+            {
+              status: "INFO",
+              inserted_at: "2023-01-01T00:00:00Z",
+              response: { type: "info_message" },
+            },
+            {
+              status: "ERROR",
+              inserted_at: "2023-01-01T00:00:00Z",
+              response: { type: "error_message" },
+            },
+            {
+              status: "COMPLETED",
+              inserted_at: "2023-01-01T00:00:00Z",
+              response: { type: "completed_message" },
+            },
+          ],
+        },
+      },
+    });
+
+    const rendered = render(<ImplementationsUploadJob />);
+    await waitForLoad(rendered);
+
+    // Check group headers exist
+    expect(rendered.getByText(/info \(1\)/i)).toBeInTheDocument();
+    expect(rendered.getByText(/error \(1\)/i)).toBeInTheDocument();
+
+    // Expand INFO group
+    await user.click(rendered.getByText(/info \(1\)/i));
+    await waitFor(() => {
+      expect(rendered.getByText(/info_message/i)).toBeInTheDocument();
+    });
+
+    // Expand ERROR group
+    await user.click(rendered.getByText(/error \(1\)/i));
+    await waitFor(() => {
+      expect(rendered.getByText(/error_message/i)).toBeInTheDocument();
+    });
+
+    // COMPLETED events are always visible
+    expect(
+      rendered.getAllByText(
+        /implementations.bulkUpload.event.status.COMPLETED/i
+      )
+    ).toHaveLength(2);
+  });
+});

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

@@ -0,0 +1,60 @@
+import { render, waitForLoad } from "@truedat/test/render";
+import { useImplementationsUploadJobs } from "../../hooks/useImplementations";
+import ImplementationsUploadJobs from "../ImplementationsUploadJobs";
+
+jest.mock("../../hooks/useImplementations", () => ({
+  useImplementationsUploadJobs: jest.fn(),
+}));
+
+describe("<ImplementationsUploadJobs />", () => {
+  it("renders loading state", async () => {
+    useImplementationsUploadJobs.mockReturnValue({
+      loading: true,
+      data: null,
+    });
+
+    const rendered = render(<ImplementationsUploadJobs />);
+
+    expect(rendered.container.querySelector(".ui.loader")).toBeInTheDocument();
+  });
+
+  it("renders empty state", async () => {
+    useImplementationsUploadJobs.mockReturnValue({
+      loading: false,
+      data: {
+        data: [],
+      },
+    });
+
+    const rendered = render(<ImplementationsUploadJobs />);
+    await waitForLoad(rendered);
+
+    expect(rendered.getByText(/No jobs found./i)).toBeInTheDocument();
+  });
+
+  it("renders jobs list", async () => {
+    const mockJobs = [
+      {
+        id: 1,
+        filename: "test.csv",
+        latest_status: "completed",
+        latest_event_response: "Success",
+        latest_event_at: "2023-01-01T00:00:00Z",
+      },
+    ];
+
+    useImplementationsUploadJobs.mockReturnValue({
+      loading: false,
+      data: {
+        data: mockJobs,
+      },
+    });
+
+    const rendered = render(<ImplementationsUploadJobs />);
+    await waitForLoad(rendered);
+
+    expect(rendered.getByText(/test.csv/i)).toBeInTheDocument();
+    expect(rendered.getByText(/completed/i)).toBeInTheDocument();
+    expect(rendered.getByText(/success/i)).toBeInTheDocument();
+  });
+});