@truedat/qx 7.0.8 → 7.1.1

package/src/components/qualityControls/__tests__/QualityControlQueryModal.spec.js

@@ -0,0 +1,77 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import { fireEvent } from "@testing-library/react";
+import { messages } from "@truedat/qx/components/__tests__/__fixtures__/helper";
+import QualityControlQueryModal from "../QualityControlQueryModal";
+
+const data = {
+  data: {
+    queries: [
+      {
+        resource: {
+          select: null,
+          queryables: [
+            {
+              resource: null,
+              __type__: "from",
+              resource_ref: 0,
+            },
+          ],
+          __type__: "data_view",
+          resource_refs: {
+            0: {
+              alias: null,
+              id: 11859650,
+              type: "data_structure",
+            },
+          },
+        },
+        action: "count",
+        __type__: "query",
+        query_ref: "error_count",
+      },
+    ],
+    resources_lookup: {
+      "data_structure:11859650": {
+        id: 11859650,
+        name: "ACCOUNTING_RULES",
+        metadata: {
+          database: "SECURITYDBO",
+          table: "ACCOUNTING_RULES",
+        },
+      },
+    },
+  },
+};
+
+jest.mock("@truedat/qx/hooks/useQualityControls", () => {
+  return {
+    useQualityControlQueries: jest.fn(() => ({
+      data,
+      loading: false,
+    })),
+  };
+});
+
+const renderOpts = { messages };
+
+describe("<QualityControlQueryModal />", () => {
+  it("matches the latest snapshot", () => {
+    const { container } = render(
+      <QualityControlQueryModal qualityControlId={8} />,
+      renderOpts
+    );
+
+    expect(container).toMatchSnapshot();
+  });
+
+  it("open modal", () => {
+    const { container, getByRole } = render(
+      <QualityControlQueryModal qualityControlId={8} />,
+      renderOpts
+    );
+
+    fireEvent.click(getByRole("button"));
+    expect(container).toMatchSnapshot();
+  });
+});

package/src/components/qualityControls/__tests__/QualityControlRow.spec.js

@@ -0,0 +1,91 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import { waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { messages } from "@truedat/qx/components/__tests__/__fixtures__/helper";
+import { columns } from "../QualityControlsTable";
+import QualityControlRow from "../QualityControlRow";
+import { qualityControlData } from "./__fixtures__/qualityControlHelper";
+
+const mockHistory = {
+  push: jest.fn(),
+};
+
+jest.mock("react-router-dom", () => ({
+  ...jest.requireActual("react-router-dom"),
+  useHistory: () => mockHistory,
+}));
+
+const renderOpts = {
+  messages,
+  fallback: "lazy",
+};
+
+const props = {
+  onChange: jest.fn(),
+  qualityControl: qualityControlData(),
+  columns: columns,
+};
+
+describe("<QualityControlRow />", () => {
+  it("matches the latest snapshot", () => {
+    const { container } = render(
+      <table>
+        <tbody>
+          <QualityControlRow {...props} />
+        </tbody>
+      </table>,
+
+      renderOpts
+    );
+    expect(container).toMatchSnapshot();
+  });
+
+  it("withCheck set to true", async () => {
+    const newProps = {
+      ...props,
+      withCheck: true,
+      checked: true,
+    };
+    const { container } = render(
+      <table>
+        <tbody>
+          <QualityControlRow {...newProps} />
+        </tbody>
+      </table>,
+      renderOpts
+    );
+    expect(container).toMatchSnapshot();
+  });
+
+  it("render Quality control route", () => {
+    const { queryByText } = render(
+      <table>
+        <tbody>
+          <QualityControlRow {...props} />
+        </tbody>
+      </table>,
+      renderOpts
+    );
+    const link = queryByText("test");
+    expect(link).toHaveAttribute("href", "/qualityControls/8");
+  });
+
+  it("renders empty table columns are empty", () => {
+    const newProps = {
+      ...props,
+      columns: [],
+    };
+
+    const { queryByText } = render(
+      <table>
+        <tbody>
+          <QualityControlRow {...newProps} />
+        </tbody>
+      </table>,
+      renderOpts
+    );
+
+    expect(queryByText("test")).not.toBeInTheDocument();
+  });
+});

package/src/components/qualityControls/__tests__/QualityControlScores.spec.js

@@ -0,0 +1,139 @@
+import _ from "lodash/fp";
+import React from "react";
+import { render } from "@truedat/test/render";
+import { waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import TestFormWrapper from "@truedat/qx/components/common/TestFormWrapper";
+import { messages } from "@truedat/qx/components/__tests__/__fixtures__/helper";
+import {
+  useQualityControlScores,
+  useScoreDelete,
+} from "@truedat/qx/hooks/useScores";
+import QualityControlScores from "../QualityControlScores";
+import { qualityControlData } from "./__fixtures__/qualityControlHelper";
+
+jest.mock("react-router-dom", () => ({
+  ...jest.requireActual("react-router-dom"),
+  useParams: () => ({ id: "8" }),
+}));
+
+jest.mock("@truedat/qx/hooks/useScores", () => {
+  const { scoreData } = jest.requireActual(
+    "@truedat/qx/components/scores/__tests__/__fixtures__/scoreHelper"
+  );
+  const data = [scoreData(), scoreData({ id: 16, status: "QUEUED" })];
+  const mutate = jest.fn();
+  return {
+    useQualityControlScores: jest.fn(() => ({
+      data: { data: data },
+      loading: false,
+      mutate,
+    })),
+    useScoreDelete: jest.fn(() => ({
+      trigger: () => ({
+        then: (callback) =>
+          callback({
+            data: {},
+          }),
+      }),
+    })),
+  };
+});
+
+const renderOpts = { messages };
+const mutate = jest.fn();
+
+const context = {
+  qualityControl: qualityControlData(),
+  loading: false,
+  actions: ["delete_score"],
+  mutate,
+};
+
+describe("<QualityControlScores />", () => {
+  it("matches the latest snapshot", () => {
+    const { container } = render(
+      <TestFormWrapper context={context}>
+        <QualityControlScores />
+      </TestFormWrapper>,
+      renderOpts
+    );
+
+    expect(container).toMatchSnapshot();
+  });
+
+  it("shows a message when there are no scores", () => {
+    useQualityControlScores.mockReturnValueOnce({
+      data: { data: [] },
+      loading: false,
+      mutate,
+    });
+
+    const context = {
+      qualityControl: qualityControlData(),
+      loading: false,
+      actions: ["delete_score"],
+      mutate,
+    };
+
+    const { getByText } = render(
+      <TestFormWrapper context={context}>
+        <QualityControlScores />
+      </TestFormWrapper>,
+      renderOpts
+    );
+
+    expect(getByText("No scores found")).toBeInTheDocument();
+  });
+
+  it("does not show delete button when user does not have delete_score action", () => {
+    const context = {
+      qualityControl: qualityControlData(),
+      loading: false,
+      actions: [],
+      mutate,
+    };
+
+    const { container } = render(
+      <TestFormWrapper context={context}>
+        <QualityControlScores />
+      </TestFormWrapper>,
+      renderOpts
+    );
+
+    const deleteButtons = container.querySelectorAll(
+      ".ui.red.basic.icon.button"
+    );
+
+    expect(deleteButtons.length).toBe(0);
+  });
+
+  it("deletes a score when the delete button is clicked", async () => {
+    const trigger = jest.fn(() =>
+      Promise.resolve({
+        data: {},
+      })
+    );
+
+    useScoreDelete.mockImplementation(() => ({
+      trigger,
+    }));
+
+    const { container, getByText } = render(
+      <TestFormWrapper context={context}>
+        <QualityControlScores />
+      </TestFormWrapper>,
+      renderOpts
+    );
+
+    const deleteButtons = container.querySelectorAll(
+      ".ui.red.basic.icon.button"
+    );
+
+    userEvent.click(deleteButtons[0]);
+    userEvent.click(getByText(/confirm_yes/));
+    await waitFor(() => {
+      expect(trigger).toHaveBeenCalled();
+    });
+  });
+});

package/src/components/qualityControls/__tests__/QualityControlTabs.spec.js

@@ -0,0 +1,20 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import { messages } from "@truedat/qx/components/__tests__/__fixtures__/helper";
+import QualityControlTabs from "../QualityControlTabs";
+
+jest.mock("react-router-dom", () => ({
+  ...jest.requireActual("react-router-dom"),
+  useParams: () => ({ id: "8" }),
+  useLocation: () => ({ pathname: "/qualityControls/8" }),
+}));
+
+const renderOpts = { messages };
+
+describe("<QualityControlTabs />", () => {
+  it("matches the latest snapshot", () => {
+    const { container } = render(<QualityControlTabs />, renderOpts);
+
+    expect(container).toMatchSnapshot();
+  });
+});

package/src/components/qualityControls/__tests__/QualityControls.spec.js

@@ -0,0 +1,202 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import { waitFor } from "@testing-library/react";
+import { within } from "@testing-library/dom";
+import userEvent from "@testing-library/user-event";
+import { singleTemplateMock } from "@truedat/test/mocks";
+import SearchContext from "@truedat/core/search/SearchContext";
+import { useScoreGroupCreate } from "@truedat/qx/hooks/useScoreGroups";
+import { messages } from "@truedat/qx/components/__tests__/__fixtures__/helper";
+import QualityControls from "../QualityControls";
+import { qualityControlData } from "./__fixtures__/qualityControlHelper";
+
+jest.mock("@truedat/core/hooks/useAuthorizedAction", () => ({
+  ...jest.requireActual("@truedat/core/hooks/useAuthorizedAction"),
+  __esModule: true,
+  default: () => ({
+    data: { has_any_domain: true },
+  }),
+}));
+
+jest.mock("@truedat/qx/hooks/useScoreGroups", () => ({
+  useScoreGroupCreate: jest.fn(() => ({})),
+}));
+
+const renderOpts = {
+  mocks: [singleTemplateMock({ scope: "qe", domainIds: undefined })],
+  messages,
+  fallback: "loading",
+};
+
+const searchProps = {
+  count: 1,
+  query: "",
+  searchMust: "",
+  hiddenFilters: "",
+  searchData: {
+    data: [qualityControlData({ status: "published" })],
+    actions: { execute: true },
+  },
+  defaultFilters: { status: "published" },
+  toggleHiddenFilterValue: jest.fn(),
+  loading: false,
+};
+
+describe("<QualityControls />", () => {
+  it("matches the latest snapshot", () => {
+    const { container } = render(
+      <SearchContext.Provider value={searchProps}>
+        <QualityControls />
+      </SearchContext.Provider>,
+      renderOpts
+    );
+
+    expect(container).toMatchSnapshot();
+  });
+
+  it("activate/desactivate execution", async () => {
+    const toggleHiddenFilterValue = jest.fn();
+    const removeHiddenFilter = jest.fn();
+
+    const thisSearchProps = {
+      ...searchProps,
+      toggleHiddenFilterValue,
+      removeHiddenFilter,
+    };
+    const { container, getByRole } = render(
+      <SearchContext.Provider value={thisSearchProps}>
+        <QualityControls />
+      </SearchContext.Provider>,
+      renderOpts
+    );
+
+    expect(
+      getByRole("button", { name: /Execute quality control/i })
+    ).toBeDisabled();
+
+    userEvent.click(container.querySelector("#execute_checkbox"));
+
+    expect(toggleHiddenFilterValue).toHaveBeenCalledWith({
+      filter: "for_execution",
+      value: true,
+    });
+    expect(
+      getByRole("button", { name: /Execute quality control/i })
+    ).toBeEnabled();
+
+    expect(
+      container.querySelector("#row-checkbox-8").parentElement
+    ).not.toHaveClass("checked");
+
+    userEvent.click(container.querySelector("#selectQualityControl"));
+
+    expect(
+      container.querySelector("#row-checkbox-8").parentElement
+    ).toHaveClass("checked");
+
+    userEvent.click(container.querySelector("#row-checkbox-8"));
+
+    expect(
+      container.querySelector("#row-checkbox-8").parentElement
+    ).not.toHaveClass("checked");
+
+    userEvent.click(container.querySelector("#execute_checkbox"));
+
+    expect(removeHiddenFilter).toHaveBeenCalledWith({
+      filter: "for_execution",
+    });
+
+    expect(container.querySelector("#row-checkbox-8")).not.toBeInTheDocument();
+  });
+
+  it("submit execution with search", async () => {
+    const trigger = jest.fn(() =>
+      Promise.resolve({ data: { data: { id: "9" } } })
+    );
+    useScoreGroupCreate.mockImplementation(() => ({
+      trigger,
+      loading: false,
+    }));
+
+    const { container, getByRole, queryByText } = render(
+      <SearchContext.Provider value={searchProps}>
+        <QualityControls />
+      </SearchContext.Provider>,
+      renderOpts
+    );
+
+    userEvent.click(container.querySelector("#execute_checkbox"));
+
+    expect(
+      getByRole("button", { name: /Execute quality control/i })
+    ).toBeEnabled();
+
+    userEvent.click(getByRole("button", { name: /Execute quality control/i }));
+
+    await waitFor(() =>
+      expect(queryByText(/loading/i)).not.toBeInTheDocument()
+    );
+    await waitFor(() => expect(queryByText(/loader/i)).not.toBeInTheDocument());
+
+    const modal = queryByText(/Quality controls execution/i).parentElement;
+    userEvent.click(within(modal).getByRole("button", { name: /Create/i }));
+
+    expect(trigger).toHaveBeenCalledWith({
+      score_group: {
+        df_type: "template1",
+        dynamic_content: {},
+      },
+      search: {
+        must: "",
+        query: "",
+      },
+    });
+  });
+
+  it("submit execution with select", async () => {
+    const trigger = jest.fn(() =>
+      Promise.resolve({ data: { data: { id: "9" } } })
+    );
+    useScoreGroupCreate.mockImplementation(() => ({
+      trigger,
+      loading: false,
+    }));
+
+    const { container, getByRole, queryByText } = render(
+      <SearchContext.Provider value={searchProps}>
+        <QualityControls />
+      </SearchContext.Provider>,
+      renderOpts
+    );
+
+    userEvent.click(container.querySelector("#execute_checkbox"));
+
+    expect(
+      getByRole("button", { name: /Execute quality control/i })
+    ).toBeEnabled();
+
+    userEvent.click(container.querySelector("#selectQualityControl"));
+
+    expect(
+      container.querySelector("#row-checkbox-8").parentElement
+    ).toHaveClass("checked");
+
+    userEvent.click(getByRole("button", { name: /Execute quality control/i }));
+
+    await waitFor(() =>
+      expect(queryByText(/loading/i)).not.toBeInTheDocument()
+    );
+    await waitFor(() => expect(queryByText(/loader/i)).not.toBeInTheDocument());
+
+    const modal = queryByText(/Quality controls execution/i).parentElement;
+    userEvent.click(within(modal).getByRole("button", { name: /Create/i }));
+
+    expect(trigger).toHaveBeenCalledWith({
+      score_group: {
+        df_type: "template1",
+        dynamic_content: {},
+      },
+      ids: [13],
+    });
+  });
+});

package/src/components/qualityControls/__tests__/QualityControlsLabelResults.spec.js

@@ -0,0 +1,83 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import { SearchContextProvider } from "@truedat/core/search/SearchContext";
+import { messages } from "@truedat/qx/components/__tests__/__fixtures__/helper";
+import QualityControlsLabelResults from "../QualityControlsLabelResults";
+
+const useFilters = jest.fn(() => ({
+  trigger: jest.fn(() => new Promise(() => {})),
+  isMutating: false,
+}));
+
+const useSearch = () => ({
+  trigger: () => ({
+    then: (callback) =>
+      callback({
+        data: [],
+        headers: { "x-total-count": 22 },
+      }),
+  }),
+});
+
+const searchProps = {
+  initialSortColumn: "updated_at",
+  initialSortDirection: "descending",
+  useSearch: useSearch,
+  useFilters: useFilters,
+};
+
+const renderOpts = { messages };
+
+describe("<QualityControlsLabelResults />", () => {
+  it("matches the latest snapshot", async () => {
+    const executeQualityControlOn = false;
+    const qualityControlsToExecute = 0;
+    const { container, findByText } = render(
+      <SearchContextProvider {...searchProps}>
+        <QualityControlsLabelResults
+          executeQualityControlOn={executeQualityControlOn}
+          qualityControlsToExecute={qualityControlsToExecute}
+        />
+      </SearchContextProvider>,
+      renderOpts
+    );
+
+    expect(await findByText("22 quality controls found")).toBeInTheDocument();
+
+    expect(container).toMatchSnapshot();
+  });
+
+  it("show number of specific executions", async () => {
+    const executeQualityControlOn = true;
+    const qualityControlsToExecute = 10;
+    const { findByText } = render(
+      <SearchContextProvider {...searchProps}>
+        <QualityControlsLabelResults
+          executeQualityControlOn={executeQualityControlOn}
+          qualityControlsToExecute={qualityControlsToExecute}
+        />
+      </SearchContextProvider>,
+      renderOpts
+    );
+    expect(
+      await findByText("10 quality controls to execute")
+    ).toBeInTheDocument();
+  });
+
+  it("show all quality controls to execute ", async () => {
+    const executeQualityControlOn = true;
+    const qualityControlsToExecute = 0;
+    const { findByText } = render(
+      <SearchContextProvider {...searchProps}>
+        <QualityControlsLabelResults
+          executeQualityControlOn={executeQualityControlOn}
+          qualityControlsToExecute={qualityControlsToExecute}
+        />
+      </SearchContextProvider>,
+      renderOpts
+    );
+    expect(
+      await findByText("22 quality controls to execute")
+    ).toBeInTheDocument();
+  });
+});

package/src/components/qualityControls/__tests__/QualityControlsTable.spec.js

@@ -0,0 +1,38 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import { messages } from "@truedat/qx/components/__tests__/__fixtures__/helper";
+import SearchContext from "@truedat/core/search/SearchContext";
+import QualityControlsTable from "../QualityControlsTable";
+import { qualityControlData } from "./__fixtures__/qualityControlHelper";
+
+const data = [qualityControlData(), qualityControlData({ id: 9, name: "Foo" })];
+
+const searchProps = {
+  sortColumn: "updated_at",
+  sortDirection: "descending",
+  handleSortSelection: jest.fn(),
+  searchData: { data },
+};
+
+const renderOpts = { messages };
+
+const props = {
+  addAll: jest.fn(),
+  checkedAll: false,
+  checkRow: jest.fn(),
+  executeQualityControlOn: false,
+  isRowChecked: jest.fn(),
+};
+
+describe("<QualityControlsTable />", () => {
+  it("matches the latest snapshot", () => {
+    const { container } = render(
+      <SearchContext.Provider value={searchProps}>
+        <QualityControlsTable {...props} />
+      </SearchContext.Provider>,
+      renderOpts
+    );
+
+    expect(container).toMatchSnapshot();
+  });
+});