@truedat/qx 7.0.8 → 7.1.0

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

@@ -0,0 +1,253 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import { waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { QUALITY_CONTROLS } from "@truedat/core/routes";
+import { SOURCE_OPTIONS_QUERY } from "@truedat/cx/sources/api/queries";
+import { REFERENCE_DATASETS_HEADERS_QUERY } from "@truedat/dd/api/queries";
+import { DOMAINS_QUERY } from "@truedat/core/api/queries";
+import { singleTemplateMock } from "@truedat/test/mocks";
+import { messages } from "@truedat/qx/components/__tests__/__fixtures__/helper";
+import {
+  useQualityControlCreateDraft,
+  useQualityControl,
+} from "../../../hooks/useQualityControls";
+import NewDraftQualityControl from "../NewDraftQualityControl";
+import {
+  sources,
+  domains,
+  qualityControlData,
+} from "./__fixtures__/qualityControlHelper";
+
+const mockHistory = { push: jest.fn() };
+
+jest.mock("react-router-dom", () => ({
+  ...jest.requireActual("react-router-dom"),
+  useParams: () => ({ id: "8" }),
+  useHistory: () => mockHistory,
+}));
+
+jest.mock("@truedat/core/hooks/useUserFilters", () => {
+  const originalModule = jest.requireActual(
+    "@truedat/core/hooks/useUserFilters"
+  );
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    useUserFilters: jest.fn(() => ({})),
+  };
+});
+jest.mock("@truedat/qx/hooks/useFunctions", () => {
+  const originalModule = jest.requireActual("@truedat/qx/hooks/useFunctions");
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    useFunctions: jest.fn(() => ({})),
+  };
+});
+jest.mock("@truedat/qx/hooks/useDataViews", () => {
+  const originalModule = jest.requireActual("@truedat/qx/hooks/useDataViews");
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    useDataViews: jest.fn(() => ({})),
+  };
+});
+
+jest.mock("@truedat/qx/hooks/useQualityControls", () => {
+  const { qualityControlData } = jest.requireActual(
+    "./__fixtures__/qualityControlHelper"
+  );
+
+  return {
+    useQualityControl: jest.fn(() => ({
+      data: {
+        data: qualityControlData({
+          versions: [],
+          status: "published",
+        }),
+      },
+      loading: false,
+    })),
+    useQualityControlCreateDraft: jest.fn(() => ({
+      trigger: jest.fn(() => Promise.resolve()),
+      isMutating: false,
+    })),
+  };
+});
+
+const sourcesMock = {
+  request: { query: SOURCE_OPTIONS_QUERY },
+  result: { data: { sources } },
+};
+
+const referenceDatasetsMock = {
+  request: { query: REFERENCE_DATASETS_HEADERS_QUERY },
+  result: {
+    data: {
+      referenceDatasets: [
+        {
+          id: "7",
+          name: "dataset1",
+          headers: ["campo1", "campo2"],
+        },
+      ],
+      loading: false,
+    },
+  },
+};
+
+const publishDomainsMock = {
+  request: {
+    query: DOMAINS_QUERY,
+    variables: { action: "publishQualityControls" },
+  },
+  result: { data: { domains } },
+};
+const createDomainsMock = {
+  request: {
+    query: DOMAINS_QUERY,
+    variables: { action: "createQualityControls" },
+  },
+  result: { data: { domains } },
+};
+
+const variables = { scope: "quality_control", domainIds: [2] };
+
+const renderOpts = {
+  mocks: [
+    singleTemplateMock(variables),
+    sourcesMock,
+    referenceDatasetsMock,
+    publishDomainsMock,
+    createDomainsMock,
+  ],
+  messages,
+  fallback: "loading",
+};
+
+describe("<NewDraftQualityControl />", () => {
+  it("matches the latest snapshot", async () => {
+    const { container, queryByText } = render(
+      <NewDraftQualityControl />,
+      renderOpts
+    );
+
+    await waitFor(() =>
+      expect(queryByText(/loading/i)).not.toBeInTheDocument()
+    );
+    await waitFor(() =>
+      expect(container.querySelector(".loader")).not.toBeInTheDocument()
+    );
+    expect(container).toMatchSnapshot();
+  });
+
+  it("navigates to quality controls when cancel button is cliked", async () => {
+    const { getByText, queryByText } = render(
+      <NewDraftQualityControl />,
+      renderOpts
+    );
+    await waitFor(() =>
+      expect(queryByText(/loading/i)).not.toBeInTheDocument()
+    );
+
+    const cancelButton = getByText(/Cancel/i);
+    expect(cancelButton).toBeInTheDocument();
+
+    userEvent.click(cancelButton);
+
+    expect(mockHistory.push.mock.calls.length).toBe(1);
+    expect(mockHistory.push.mock.calls[0][0]).toBe(QUALITY_CONTROLS);
+  });
+
+  it("test save submit ", async () => {
+    const trigger = jest.fn(() =>
+      Promise.resolve({ data: { data: { id: "9" } } })
+    );
+
+    useQualityControlCreateDraft.mockImplementation(() => ({
+      trigger,
+    }));
+
+    const { getByText, getByPlaceholderText, queryByText, getByRole } = render(
+      <NewDraftQualityControl />,
+      renderOpts
+    );
+
+    await waitFor(() =>
+      expect(queryByText(/loading/i)).not.toBeInTheDocument()
+    );
+    await waitFor(() =>
+      expect(getByRole("button", { name: /Save/ })).toBeDisabled()
+    );
+
+    userEvent.type(getByPlaceholderText("Name"), "_modified");
+
+    await waitFor(() =>
+      expect(getByRole("button", { name: /Save/ })).toBeEnabled()
+    );
+    userEvent.click(getByText(/Save/));
+
+    const qualityControl = qualityControlData({
+      versions: [],
+      status: "draft",
+      name: "test_modified",
+    });
+    await waitFor(() =>
+      expect(trigger).toHaveBeenCalledWith({ quality_control: qualityControl })
+    );
+  });
+
+  it("test publish submit ", async () => {
+    const trigger = jest.fn(() =>
+      Promise.resolve({ data: { data: { id: "9" } } })
+    );
+
+    useQualityControlCreateDraft.mockImplementation(() => ({
+      trigger,
+    }));
+
+    const { getByText, getByPlaceholderText, queryByText, getByRole } = render(
+      <NewDraftQualityControl />,
+      renderOpts
+    );
+
+    await waitFor(() =>
+      expect(queryByText(/loading/i)).not.toBeInTheDocument()
+    );
+    await waitFor(() =>
+      expect(getByRole("button", { name: /Publish/ })).toBeDisabled()
+    );
+
+    userEvent.type(getByPlaceholderText("Name"), "_modified");
+
+    await waitFor(() =>
+      expect(getByRole("button", { name: /Publish/ })).toBeEnabled()
+    );
+    userEvent.click(getByText(/Publish/));
+
+    const qualityControl = qualityControlData({
+      versions: [],
+      status: "published",
+      name: "test_modified",
+    });
+    await waitFor(() =>
+      expect(trigger).toHaveBeenCalledWith({ quality_control: qualityControl })
+    );
+  });
+
+  it("when no quality control is fetched, do not render editor", async () => {
+    useQualityControl.mockImplementation(() => ({ data: undefined }));
+
+    const { queryByText } = render(<NewDraftQualityControl />, renderOpts);
+
+    await waitFor(() =>
+      expect(queryByText(/loading/i)).not.toBeInTheDocument()
+    );
+
+    await waitFor(() => expect(queryByText(/Save/i)).not.toBeInTheDocument());
+  });
+});

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

@@ -0,0 +1,384 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import { waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { singleTemplateMock } from "@truedat/test/mocks";
+import { DOMAINS_QUERY } from "@truedat/core/api/queries";
+import { SOURCE_OPTIONS_QUERY } from "@truedat/cx/sources/api/queries";
+import { REFERENCE_DATASETS_HEADERS_QUERY } from "@truedat/dd/api/queries";
+import { messages } from "@truedat/qx/components/__tests__/__fixtures__/helper";
+import { useQualityControlCreate } from "@truedat/qx/hooks/useQualityControls";
+import NewQualityControl from "../NewQualityControl";
+import { sources, domains } from "./__fixtures__/qualityControlHelper";
+
+const mockHistory = { push: jest.fn() };
+
+jest.mock("react-router-dom", () => ({
+  ...jest.requireActual("react-router-dom"),
+  useHistory: () => mockHistory,
+}));
+
+jest.mock("@truedat/qx/hooks/useQualityControls", () => ({
+  useQualityControlCreate: jest.fn(() => ({
+    trigger: jest.fn(() => new Promise(() => {})),
+    isMutating: false,
+  })),
+}));
+
+jest.mock("@truedat/qx/hooks/useFunctions", () => ({
+  useFunctions: jest.fn(() => ({
+    data: {
+      data: [
+        {
+          name: "eq",
+          type: "boolean",
+          params: [
+            { name: "arg1", type: "any" },
+            { name: "arg2", type: "any" },
+          ],
+        },
+      ],
+    },
+    loading: false,
+  })),
+}));
+
+jest.mock("@truedat/qx/hooks/useDataViews", () => ({
+  useDataViews: jest.fn(() => ({
+    data: { data: [] },
+    loading: false,
+  })),
+}));
+
+const sourcesMock = {
+  request: { query: SOURCE_OPTIONS_QUERY },
+  result: { data: { sources } },
+};
+
+const referenceDatasetsMock = {
+  request: { query: REFERENCE_DATASETS_HEADERS_QUERY },
+  result: {
+    data: {
+      referenceDatasets: [
+        {
+          id: "7",
+          name: "dataset1",
+          headers: ["campo1", "campo2"],
+        },
+      ],
+      loading: false,
+    },
+  },
+};
+
+const domainsMock = {
+  request: {
+    query: DOMAINS_QUERY,
+    variables: { action: "publishQualityControls" },
+  },
+  result: { data: { domains: domains } },
+};
+const createDomainsMock = {
+  request: {
+    query: DOMAINS_QUERY,
+    variables: { action: "createQualityControls" },
+  },
+  result: { data: { domains } },
+};
+
+const renderOpts = {
+  mocks: [
+    singleTemplateMock({ scope: "quality_control", domainIds: [] }),
+    singleTemplateMock({ scope: "quality_control", domainIds: ["2"] }),
+    sourcesMock,
+    referenceDatasetsMock,
+    createDomainsMock,
+    domainsMock,
+  ],
+  messages,
+  fallback: "loading",
+};
+
+describe("<NewQualityControl />", () => {
+  it("matches the latest snapshot", async () => {
+    const { container, queryByText } = render(
+      <NewQualityControl />,
+
+      renderOpts
+    );
+
+    await waitFor(() =>
+      expect(container.querySelector(".loader")).not.toBeInTheDocument()
+    );
+    await waitFor(() =>
+      expect(queryByText(/loading/i)).not.toBeInTheDocument()
+    );
+    expect(container).toMatchSnapshot();
+  });
+
+  it("navigates to qulity controls when cancel button is cliked", async () => {
+    const { container, getByText, queryByText } = render(
+      <NewQualityControl />,
+      renderOpts
+    );
+    await waitFor(() =>
+      expect(queryByText(/loading/i)).not.toBeInTheDocument()
+    );
+    await waitFor(() =>
+      expect(container.querySelector(".loader")).not.toBeInTheDocument()
+    );
+    userEvent.click(getByText(/Cancel/));
+    userEvent.click(getByText(/confirm_yes/));
+    await waitFor(() => expect(mockHistory.push.mock.calls.length).toBe(1));
+    expect(mockHistory.push.mock.calls[0][0]).toBe("/qualityControls");
+  });
+
+  it("test save submit ", async () => {
+    const trigger = jest.fn(() =>
+      Promise.resolve({ data: { data: { id: "9" } } })
+    );
+
+    useQualityControlCreate.mockImplementation(() => ({
+      trigger,
+    }));
+
+    const {
+      container,
+      getByText,
+      getByPlaceholderText,
+      queryByText,
+      getByRole,
+      getAllByRole,
+    } = render(<NewQualityControl />, renderOpts);
+
+    await waitFor(() =>
+      expect(queryByText(/loading/i)).not.toBeInTheDocument()
+    );
+    await waitFor(() =>
+      expect(getByRole("button", { name: /Save/ })).toBeDisabled()
+    );
+
+    // Fill in the 'Name' field
+    userEvent.type(getByPlaceholderText("Name"), "test_modified");
+
+    // Select a domain
+    userEvent.click(getByText(/Select domains/));
+    userEvent.click(getByText(/barDomain/));
+
+    // Select a source
+    userEvent.click(getByText(/Select source/));
+    userEvent.click(getByRole("option", { name: /external_source_id/i }));
+
+    // Select a control mode
+    userEvent.click(getByRole("option", { name: /Percentage/i }));
+
+    // Fill in the 'Threshold' field
+    userEvent.type(getByPlaceholderText("Threshold"), "10");
+
+    // Fill in the 'Goal' field
+    userEvent.type(getByPlaceholderText("Goal"), "20");
+
+    await waitFor(() =>
+      expect(queryByText(/loading/i)).not.toBeInTheDocument()
+    );
+    await waitFor(() =>
+      expect(container.querySelector(".loader")).not.toBeInTheDocument()
+    );
+
+    // Select the 'Reference datasets' for the resource type
+    userEvent.click(getByText(/Resource type/));
+    userEvent.click(getByText(/Reference datasets/));
+    userEvent.click(getByRole("option", { name: /dataset1/i }));
+
+    userEvent.click(getAllByRole("option", { name: /campo1/i })[0]);
+    userEvent.click(getByRole("option", { name: /eq/i }));
+    userEvent.click(getAllByRole("option", { name: /campo2/i })[1]);
+
+    await waitFor(() =>
+      expect(getByRole("button", { name: /Save/ })).toBeEnabled()
+    );
+    userEvent.click(getByText(/Save/));
+
+    await waitFor(() =>
+      expect(trigger).toHaveBeenCalledWith({
+        quality_control: {
+          name: "test_modified",
+          active: true,
+          domain_ids: ["2"],
+          df_type: "template1",
+          source_id: 181,
+          control_mode: "percentage",
+          dynamic_content: {},
+          control_properties: {
+            resource: {
+              type: "reference_dataset",
+              id: 7,
+              embedded: {
+                id: 7,
+                name: "dataset1",
+                headers: ["campo1", "campo2"],
+                fields: [
+                  {
+                    id: 0,
+                    name: "campo1",
+                    type: "string",
+                    parent_name: "dataset1",
+                  },
+                  {
+                    id: 1,
+                    name: "campo2",
+                    type: "string",
+                    parent_name: "dataset1",
+                  },
+                ],
+              },
+            },
+            validation: [
+              {
+                expressions: [
+                  {
+                    shape: "function",
+                    value: {
+                      isCondition: true,
+                      args: {
+                        arg1: {
+                          shape: "field",
+                          value: {
+                            id: 0,
+                            name: "campo1",
+                            type: "string",
+                            parent_name: "dataset1",
+                            alias: "dataset1",
+                            parent_id: 0,
+                            color: "blue",
+                          },
+                        },
+                        arg2: {
+                          shape: "field",
+                          value: {
+                            id: 1,
+                            name: "campo2",
+                            type: "string",
+                            parent_name: "dataset1",
+                            alias: "dataset1",
+                            parent_id: 0,
+                            color: "blue",
+                          },
+                        },
+                      },
+                      name: "eq",
+                      type: "boolean",
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+          score_criteria: { goal: "20", minimum: "10" },
+          status: "draft",
+        },
+      })
+    );
+  });
+
+  it("test publish submit ", async () => {
+    const trigger = jest.fn(() =>
+      Promise.resolve({ data: { data: { id: "9" } } })
+    );
+
+    useQualityControlCreate.mockImplementation(() => ({
+      trigger,
+    }));
+
+    const {
+      container,
+      getByText,
+      getByPlaceholderText,
+      queryByText,
+      getByRole,
+    } = render(<NewQualityControl />, renderOpts);
+
+    await waitFor(() =>
+      expect(queryByText(/loading/i)).not.toBeInTheDocument()
+    );
+    await waitFor(() =>
+      expect(getByRole("button", { name: /Publish/ })).toBeDisabled()
+    );
+
+    // Fill in the 'Name' field
+    userEvent.type(getByPlaceholderText("Name"), "test_modified");
+
+    // Select a domain
+    userEvent.click(getByText(/Select domains/));
+    userEvent.click(getByText(/barDomain/));
+
+    // Select a source
+    userEvent.click(getByText(/Select source/));
+    userEvent.click(getByRole("option", { name: /external_source_id/i }));
+
+    userEvent.click(getByRole("option", { name: /Error count/i }));
+
+    // Fill in the 'Goal' field
+    userEvent.type(getByPlaceholderText("Goal"), "25");
+    // Fill in the 'Threshold' field
+    userEvent.type(getByPlaceholderText("Threshold"), "50");
+
+    await waitFor(() =>
+      expect(queryByText(/loading/i)).not.toBeInTheDocument()
+    );
+    await waitFor(() =>
+      expect(container.querySelector(".loader")).not.toBeInTheDocument()
+    );
+
+    // // Select the 'Reference datasets' for the resource type
+    userEvent.click(getByText(/Resource type/));
+    userEvent.click(getByText(/Reference datasets/));
+    userEvent.click(getByRole("option", { name: /dataset1/i }));
+
+    await waitFor(() =>
+      expect(getByRole("button", { name: /Publish/i })).toBeEnabled()
+    );
+    userEvent.click(getByText(/Publish/i));
+
+    await waitFor(() =>
+      expect(trigger).toHaveBeenCalledWith({
+        quality_control: {
+          name: "test_modified",
+          active: true,
+          domain_ids: ["2"],
+          df_type: "template1",
+          source_id: 181,
+          control_mode: "error_count",
+          dynamic_content: {},
+          control_properties: {
+            errors_resource: {
+              type: "reference_dataset",
+              id: 7,
+              embedded: {
+                id: 7,
+                name: "dataset1",
+                headers: ["campo1", "campo2"],
+                fields: [
+                  {
+                    id: 0,
+                    name: "campo1",
+                    type: "string",
+                    parent_name: "dataset1",
+                  },
+                  {
+                    id: 1,
+                    name: "campo2",
+                    type: "string",
+                    parent_name: "dataset1",
+                  },
+                ],
+              },
+            },
+          },
+          score_criteria: { goal: "25", maximum: "50" },
+          status: "published",
+        },
+      })
+    );
+  });
+});

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

@@ -0,0 +1,30 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import { messages } from "@truedat/qx/components/__tests__/__fixtures__/helper";
+import { scoreData } from "@truedat/qx/components/scores/__tests__/__fixtures__/scoreHelper";
+import QualityBadge from "../QualityBadge";
+
+const renderOpts = { messages };
+
+describe("<QualityBadge />", () => {
+  it("matches the latest snapshot", () => {
+    const score = scoreData();
+    const { container } = render(<QualityBadge score={score} />, renderOpts);
+
+    expect(container).toMatchSnapshot();
+  });
+
+  it("show status failed", () => {
+    const score = scoreData({ status: "FAILED" });
+    const { queryByText } = render(<QualityBadge score={score} />, renderOpts);
+
+    expect(queryByText(/Failed/i)).toBeInTheDocument();
+  });
+
+  it("show no results", () => {
+    const score = scoreData({ score_content: undefined });
+    const { queryByText } = render(<QualityBadge score={score} />, renderOpts);
+
+    expect(queryByText(/No results/i)).toBeInTheDocument();
+  });
+});