@truedat/dq 4.47.4 → 4.47.7

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

@@ -1,20 +1,29 @@
+import _ from "lodash/fp";
 import React from "react";
-import { waitFor } from "@testing-library/react";
+import { waitFor, within } from "@testing-library/react";
 import { render } from "@truedat/test/render";
 import { multipleTemplatesMock } from "@truedat/test/mocks";
-import { NewRuleImplementation } from "../NewRuleImplementation";
+import userEvent from "@testing-library/user-event";
+import defaultMessages from "@truedat/test/messages";
+import NewRuleImplementation, {
+  NewRuleImplementation as NewRuleImplementationComponent,
+} from "../NewRuleImplementation";
 import { newRuleImplementationProps } from "../__test_samples__/NewRuleImplementationProps";
+import {
+  ruleImplementationLoaderGlobalState,
+  ruleImplementationLoaderActions,
+} from "../__test_samples__/newRuleImplementationHelper";
 
 describe("<NewRuleImplementation />", () => {
   const createRuleImplementation = jest.fn();
   const updateRuleImplementation = jest.fn();
-  const sources = [{ id: 1, external_id: "foo", config: { alias: ["foo"] } }];
+
   const ruleImplementationProps = { id: 1, name: "nn", executable: true };
+
   const props = {
     ruleImplementationProps,
     createRuleImplementation,
     updateRuleImplementation,
-    sources,
   };
   const renderOpts = {
     mocks: [
@@ -32,11 +41,11 @@ describe("<NewRuleImplementation />", () => {
       <NewRuleImplementation {...props} />,
       renderOpts
     );
+
     await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
     await waitFor(() =>
       expect(queryByText(/loading/i)).not.toBeInTheDocument()
     );
-
     expect(container).toMatchSnapshot();
   });
 
@@ -47,7 +56,7 @@ describe("<NewRuleImplementation />", () => {
       applyTemplate: applyTemplate,
     };
     const { container, queryByText } = render(
-      <NewRuleImplementation {...props} />,
+      <NewRuleImplementationComponent {...props} />,
       renderOpts
     );
     await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
@@ -57,3 +66,261 @@ describe("<NewRuleImplementation />", () => {
     expect(container).toMatchSnapshot();
   });
 });
+
+describe("<NewRuleImplementation> NewRuleImplementation doSubmit", () => {
+  const dispatch = jest.fn();
+
+  const renderOptsImplementationEdit = {
+    mocks: [
+      multipleTemplatesMock({
+        scope: "ri",
+        domainIds: [2],
+      }),
+    ],
+    messages: {
+      en: {
+        ...defaultMessages.en,
+        // This is in td-web
+        "filtersGrid.field.modifier.cast_as_date": "Cast as date",
+      },
+    },
+    state: ruleImplementationLoaderGlobalState,
+    fallback: "lazy",
+    dispatch,
+  };
+
+  const props = {
+    ...ruleImplementationLoaderActions,
+    edition: true,
+  };
+
+  const expectedRuleImplementationBase = {
+    dataset: [
+      {
+        alias: { index: 4, text: null },
+        clauses: [],
+        structure: { id: 11127104 },
+      },
+    ],
+    df_content: {},
+    df_name: "template1",
+    domain_id: 2,
+    executable: true,
+    goal: 90,
+    id: 1329 + 1,
+    implementation_key: "oracle_prueba",
+    implementation_type: "default",
+    minimum: 80,
+    populations: [],
+    result_type: "percentage",
+    rule_id: undefined,
+    segments: [],
+    status: undefined,
+  };
+
+  it("doSubmit: is empty operator", async () => {
+    const expectedRuleImplementation = {
+      ...expectedRuleImplementationBase,
+      validations: [
+        {
+          modifier: null,
+          operator: { name: "empty" },
+          population: [],
+          structure: { id: 11127109, parent_index: 4 },
+          value: [],
+          value_modifier: [],
+        },
+      ],
+    };
+
+    const { queryByText, getByRole, findByRole, findByTestId } = render(
+      <NewRuleImplementation {...props} />,
+      renderOptsImplementationEdit
+    );
+
+    // Information Form
+
+    await waitFor(() => {
+      expect(queryByText(/Template/)).toBeTruthy();
+    });
+
+    userEvent.click(await findByRole("option", { name: "template1" }));
+
+    await waitFor(() => {
+      expect(getByRole("button", { name: "Next" })).toBeEnabled();
+    });
+    userEvent.click(await getByRole("button", { name: "Next" }));
+
+    // Dataset Form
+
+    await waitFor(() => {
+      expect(getByRole("button", { name: "Next" })).toBeEnabled();
+    });
+    userEvent.click(await getByRole("button", { name: "Next" }));
+
+    // Population Form
+
+    await waitFor(() => {
+      expect(getByRole("button", { name: "Next" })).toBeEnabled();
+    });
+    userEvent.click(await getByRole("button", { name: "Next" }));
+
+    // Validations Form
+
+    userEvent.click(await findByRole("button", { name: "add-condition-row" }));
+
+    const row = await findByTestId("row-0");
+
+    const field = row.querySelector('div[label="Field"]');
+    const operator = row.querySelector('div[label="Operator"]');
+
+    userEvent.click(field);
+    const fieldOptions = await within(field).findByRole("listbox");
+    const emailFieldOption = within(fieldOptions).getByText("EMAIL");
+    userEvent.click(emailFieldOption);
+    const selectedField = fieldOptions.querySelector(".selected>span");
+    expect(within(selectedField).queryByText(/EMAIL/)).toBeInTheDocument();
+
+    userEvent.click(operator);
+    const operatorOptions = await within(operator).findByRole("listbox");
+    const emptyOperatorOption = within(operatorOptions).getByText("is empty");
+    userEvent.click(emptyOperatorOption);
+    const selectedOperator = operatorOptions.querySelector(".selected>span");
+    expect(
+      within(selectedOperator).queryByText(/is empty/)
+    ).toBeInTheDocument();
+
+    await waitFor(() => {
+      expect(getByRole("button", { name: "Save" })).toBeEnabled();
+    });
+
+    userEvent.click(await getByRole("button", { name: "Save" }));
+
+    expect(dispatch).toHaveBeenCalledWith({
+      ...ruleImplementationLoaderActions.updateRuleImplementation(),
+      payload: { rule_implementation: expectedRuleImplementation },
+    });
+  });
+
+  it("doSubmit: unique across fields operator", async () => {
+    const expectedRuleImplementation = {
+      ...expectedRuleImplementationBase,
+      validations: [
+        {
+          modifier: null,
+          operator: { name: "unique", value_type: "field_list" },
+          population: [],
+          structure: { id: 11127109, parent_index: 4 },
+          value: [
+            {
+              fields: [
+                {
+                  id: 11127109,
+                  name: "EMAIL",
+                  parent_index: 4,
+                  path: undefined,
+                },
+                {
+                  id: 11127116,
+                  name: "PHONE_NUMBER",
+                  parent_index: 4,
+                  path: undefined,
+                },
+              ],
+            },
+          ],
+          value_modifier: [],
+        },
+      ],
+    };
+
+    const { queryByText, getByRole, findByRole, findByTestId } = render(
+      <NewRuleImplementation {...props} />,
+      renderOptsImplementationEdit
+    );
+
+    // Information Form
+
+    await waitFor(() => {
+      expect(queryByText(/Template/)).toBeTruthy();
+    });
+
+    userEvent.click(await findByRole("option", { name: "template1" }));
+
+    await waitFor(() => {
+      expect(getByRole("button", { name: "Next" })).toBeEnabled();
+    });
+    userEvent.click(await getByRole("button", { name: "Next" }));
+
+    // Dataset Form
+
+    await waitFor(() => {
+      expect(getByRole("button", { name: "Next" })).toBeEnabled();
+    });
+    userEvent.click(await getByRole("button", { name: "Next" }));
+
+    // Population Form
+
+    await waitFor(() => {
+      expect(getByRole("button", { name: "Next" })).toBeEnabled();
+    });
+    userEvent.click(await getByRole("button", { name: "Next" }));
+
+    // Validations Form
+
+    userEvent.click(await findByRole("button", { name: "add-condition-row" }));
+
+    const row = await findByTestId("row-0");
+
+    const field = row.querySelector('div[label="Field"]');
+    const operator = row.querySelector('div[label="Operator"]');
+
+    userEvent.click(field);
+    const fieldOptions = await within(field).findByRole("listbox");
+    const emailFieldOption = within(fieldOptions).getByText("EMAIL");
+    userEvent.click(emailFieldOption);
+    const selectedField = fieldOptions.querySelector(".selected>span");
+    expect(within(selectedField).queryByText(/EMAIL/)).toBeInTheDocument();
+
+    userEvent.click(operator);
+    const operatorOptions = await within(operator).findByRole("listbox");
+    const uniqueAcrossFieldsOperatorOption = within(operatorOptions).getByText(
+      "unique across fields"
+    );
+    userEvent.click(uniqueAcrossFieldsOperatorOption);
+    const selectedOperator = operatorOptions.querySelector(".selected>span");
+    expect(
+      within(selectedOperator).queryByText(/unique across fields/)
+    ).toBeInTheDocument();
+
+    const updatedRow = await findByTestId("row-0");
+    const value = updatedRow.querySelector('div[label="Value"]');
+    userEvent.click(value);
+    const valueOptions = await within(value).findByRole("listbox");
+    const valueEmailFieldOption = within(valueOptions).getByText("EMAIL");
+    const valuePhoneNumberFieldOption =
+      within(valueOptions).getByText("PHONE_NUMBER");
+
+    userEvent.click(valueEmailFieldOption);
+    userEvent.click(valuePhoneNumberFieldOption);
+    const selectedFieldValues = updatedRow.querySelectorAll(".label");
+
+    const selectedFieldTexts = [...selectedFieldValues].map(
+      (selectedFieldValue) => selectedFieldValue.text
+    );
+
+    expect(_.difference(selectedFieldTexts, ["EMAIL", "PHONE_NUMBER"])).toEqual(
+      []
+    );
+
+    await waitFor(() => {
+      expect(getByRole("button", { name: "Save" })).toBeEnabled();
+    });
+    userEvent.click(await getByRole("button", { name: "Save" }));
+
+    expect(dispatch).toHaveBeenCalledWith({
+      ...ruleImplementationLoaderActions.updateRuleImplementation(),
+      payload: { rule_implementation: expectedRuleImplementation },
+    });
+  });
+});

package/src/components/ruleImplementationForm/FiltersField.js

@@ -48,6 +48,19 @@ export const FiltersField = ({
   const { value_type, value_type_filter, fixed_values } = operator;
 
   const modifierDef = _.find({ name: modifier?.name })(typeCastModifiers);
+  const pickFromValue = _.pick(["data_structure_id", "name", "parent_index"]);
+
+  const getVal = (value) =>
+    _.isNil(_.prop("parent_index")(value))
+      ? _.prop("id")(value)
+      : `${_.prop("id")(value)}/${_.prop("parent_index")(value)}`;
+
+  const getValue = (valueOrValues, operator) =>
+    operator?.value_type === "field_list"
+      ? (valueOrValues?.fields || []).map((v) => {
+          return getVal(v);
+        })
+      : getVal(valueOrValues);
 
   switch (value_type) {
     case "string":
@@ -89,6 +102,7 @@ export const FiltersField = ({
     case "timestamp":
       return <DateTimeField label={label} value={value} onChange={onChange} />;
     case "field":
+    case "field_list":
       const structureFields = getStructureFields(parentStructures);
       return value_type_filter == "any" ? (
         <StructureSelectorInputField
@@ -111,24 +125,30 @@ export const FiltersField = ({
       ) : (
         <>
           <StructureFieldsDropdown
+            multiple={value_type === "field_list"}
             label={label}
             inline={false}
             parentStructures={parentStructures}
             structureFields={structureFields}
             typeCastModifiers={typeCastModifiers}
-            filters={{ field_type: [fieldType] }}
-            onSelectField={(value, modifier) =>
+            filters={
+              value_type === "field_list" ? null : { field_type: [fieldType] }
+            }
+            onSelectField={(value, modifier) => {
               onChange(
                 null,
-                _.pick(["data_structure_id", "name", "parent_index"])(value),
+                pickFromValue(value),
                 modifier ? { name: modifier.name } : null
-              )
-            }
-            value={
-              _.isNil(_.prop("parent_index")(value))
-                ? _.prop("id")(value)
-                : `${_.prop("id")(value)}/${_.prop("parent_index")(value)}`
-            }
+              );
+            }}
+            onSelectFields={(values) => {
+              onChange(
+                null,
+                values.map((value) => pickFromValue(value)),
+                null
+              );
+            }}
+            value={getValue(value, operator)}
           />
           {modifier && (
             <FieldModifier
@@ -158,7 +178,7 @@ FiltersField.propTypes = {
   parentStructures: PropTypes.array,
   operator: PropTypes.object,
   fieldType: PropTypes.string,
-  value: PropTypes.string,
+  value: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),
   name: PropTypes.string,
   onChange: PropTypes.func,
   modifier: PropTypes.object,

package/src/components/ruleImplementationForm/FiltersFormGroup.js

@@ -162,7 +162,7 @@ FiltersFormGroup.propTypes = {
   parentStructures: PropTypes.array,
   siblings: PropTypes.array,
   scope: PropTypes.string,
-  operators: PropTypes.array,
+  operators: PropTypes.object,
 };
 
 export default FiltersFormGroup;

package/src/components/ruleImplementationForm/FiltersGrid.js

@@ -56,13 +56,21 @@ export const FiltersGrid = ({
     });
   };
 
+  const composeFieldValue = (value) => ({
+    id: value.data_structure_id || value.id,
+    name: value.name,
+    path: value.path,
+    parent_index: value.parent_index,
+  });
+
   const composeValue = (value_type, value) => {
     if (value_type == "field") {
+      return composeFieldValue(value);
+    } else if (value_type === "field_list") {
       return {
-        id: value.data_structure_id || value.id,
-        name: value.name,
-        path: value.path,
-        parent_index: value.parent_index,
+        fields: _.map((v) => {
+          return composeFieldValue(v);
+        })(value),
       };
     } else {
       return { raw: value };
@@ -151,7 +159,11 @@ export const FiltersGrid = ({
           scope={scope}
         />
       </Grid>
-      <Button onClick={onRowAddition} icon="plus circle" />
+      <Button
+        aria-label="add-condition-row"
+        onClick={onRowAddition}
+        icon="plus circle"
+      />
     </>
   );
 };
@@ -161,7 +173,7 @@ FiltersGrid.propTypes = {
   setRowValue: PropTypes.func,
   scope: PropTypes.string,
   structures: PropTypes.array,
-  typeOperators: PropTypes.array,
+  typeOperators: PropTypes.object,
 };
 
 export default FiltersGrid;

package/src/components/ruleImplementationForm/FiltersGroup.js

@@ -50,7 +50,7 @@ const Filter = ({
     _.filter((v) => !_.isNil(v?.id))(row?.value || []);
   return (
     <>
-      <Grid.Row>
+      <Grid.Row data-testid={`row-${index}`}>
         <Grid.Column width={14}>
           <FiltersFormGroup
             clause={clause}
@@ -126,7 +126,7 @@ const Filter = ({
 Filter.propTypes = {
   activeConditionIndex: PropTypes.number,
   allOperators: PropTypes.array,
-  operators: PropTypes.array,
+  operators: PropTypes.object,
   clause: PropTypes.object,
   composeValue: PropTypes.func,
   onConditionChange: PropTypes.func,
@@ -182,7 +182,7 @@ export const FiltersGroup = ({
 FiltersGroup.propTypes = {
   activeConditionIndex: PropTypes.number,
   allOperators: PropTypes.array,
-  operators: PropTypes.array,
+  operators: PropTypes.object,
   composeValue: PropTypes.func,
   onConditionChange: PropTypes.func,
   onOperatorChange: PropTypes.func,

package/src/components/ruleImplementationForm/InformationForm.js

@@ -25,6 +25,7 @@ export const InformationForm = ({
 
   const handleContentChange = ({ content, valid }) => {
     onChange("dfContent", content);
+
     setIsValid(_.isEmpty(valid));
   };
   const domainId = ruleImplementation?.domain_id || rule?.domain_id;
@@ -64,6 +65,7 @@ export const InformationForm = ({
           autoComplete="off"
         />
       </Form.Field>
+
       {_.isEmpty(rule) && !ruleImplementation?.rule_id ? (
         <Form.Field>
           <DomainDropdownSelector

package/src/components/ruleImplementationForm/RuleImplementationForm.js

@@ -350,7 +350,7 @@ RuleImplementationForm.propTypes = {
   addSegments: PropTypes.func,
   authManageSegments: PropTypes.bool,
   isAdmin: PropTypes.bool,
-  isSubmitting: PropTypes.bool.isRequired,
+  isSubmitting: PropTypes.bool,
   onChange: PropTypes.func,
   onSubmit: PropTypes.func.isRequired,
   operators: PropTypes.object,

package/src/components/ruleImplementationForm/RuleImplementationRawForm.js

@@ -4,6 +4,8 @@ import PropTypes from "prop-types";
 import { connect } from "react-redux";
 import { useHistory } from "react-router-dom";
 import { FormattedMessage, useIntl } from "react-intl";
+import { gql, useQuery } from "@apollo/client";
+import { Loading } from "@truedat/core/components";
 import { Button, Form, Icon, Popup } from "semantic-ui-react";
 import { accentInsensitivePathOrder } from "@truedat/core/services/sort";
 import LimitsForm from "./LimitsForm";
@@ -80,6 +82,7 @@ export const RuleImplementationRawForm = ({
     setImplementationRawContent({
       ...rawContent,
       source_id: value,
+      source: _.find({ id: value })(sources),
       database: "",
     });
   };
@@ -334,6 +337,32 @@ RuleImplementationRawForm.propTypes = {
   sourcesLoading: PropTypes.bool,
 };
 
+export const SOURCES_WITH_CONFIG = gql`
+  query SOURCES_WITH_CONFIG($jobTypes: String) {
+    sources(jobTypes: $jobTypes) {
+      id
+      externalId
+      config
+    }
+  }
+`;
+
+export const RuleImplementationRawFormLoader = (props) => {
+  const { data, error, loading } = useQuery(SOURCES_WITH_CONFIG, {
+    variables: { jobTypes: "quality" },
+  });
+  if (error) return null;
+  if (loading) return <Loading />;
+  const sources = data?.sources || [];
+  return (
+    <RuleImplementationRawForm
+      sources={sources}
+      sourcesLoading={loading}
+      {...props}
+    />
+  );
+};
+
 const mapStateToProps = ({
   implementationActions,
   rule,
@@ -344,4 +373,4 @@ const mapStateToProps = ({
   rule,
 });
 
-export default connect(mapStateToProps)(RuleImplementationRawForm);
+export default connect(mapStateToProps)(RuleImplementationRawFormLoader);

package/src/components/ruleImplementationForm/__tests__/RuleImplementationRawForm.spec.js

@@ -4,7 +4,7 @@ import { waitFor } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { render } from "@truedat/test/render";
 import { multipleTemplatesMock } from "@truedat/test/mocks";
-import RuleImplementationRawForm from "../RuleImplementationRawForm";
+import { RuleImplementationRawForm } from "../RuleImplementationRawForm";
 
 jest.setTimeout(30000);
 
@@ -13,6 +13,7 @@ const renderOpts = {
   state: {
     rule: { domain_id: 1 },
     ruleImplementationCreating: false,
+    domains: [{ id: 1, name: "domain1" }],
   },
   fallback: "lazy",
 };
@@ -35,6 +36,7 @@ const props = {
     minimum: "1",
     result_type: "percentage",
   },
+  sourcesLoading: false,
   sources: [
     {
       id: "1",
@@ -56,8 +58,11 @@ const props = {
 
 describe("<RuleImplementationRawForm />", () => {
   it("matches the latest snapshot", async () => {
+    const updatedProps = _.flow(_.set("ruleImplementation.domain_id", 1))(
+      props
+    );
     const { container, queryByText } = render(
-      <RuleImplementationRawForm {...props} />,
+      <RuleImplementationRawForm {...updatedProps} />,
       renderOpts
     );
     await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument(), {
@@ -141,6 +146,7 @@ describe("<RuleImplementationRawForm />", () => {
 
   it("submit button enabled if there is valid content in form with database", async () => {
     const updatedProps = _.flow(
+      _.set("ruleImplementation.domain_id", 1),
       _.set("ruleImplementation.dfName", "template1"),
       _.set("ruleImplementation.dfContent", { field1: "foo" })
     )(props);
@@ -156,13 +162,11 @@ describe("<RuleImplementationRawForm />", () => {
       rule: { id: 5, name: "regla" },
     };
 
-    const { queryByRole } = render(
+    const { findByRole } = render(
       <RuleImplementationRawForm {...customProps} />,
       renderOpts
     );
-    await waitFor(() =>
-      expect(queryByRole("button", { name: /save/i })).toBeEnabled()
-    );
+    expect(await findByRole("button", { name: /save/i })).toBeEnabled();
   });
 
   it("submit button disabled if databases are available and not selected", async () => {
@@ -176,14 +180,10 @@ describe("<RuleImplementationRawForm />", () => {
       },
     };
 
-    const { queryByText, getByRole } = render(
+    const { getByRole } = render(
       <RuleImplementationRawForm {...customProps} />,
       renderOpts
     );
-    await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
-    await waitFor(() =>
-      expect(queryByText(/loading/i)).not.toBeInTheDocument()
-    );
     expect(getByRole("button", { name: "Save" })).toBeDisabled();
   });
 
@@ -221,6 +221,15 @@ describe("<RuleImplementationRawForm />", () => {
       population: "",
       source_id: "2",
       validations: "",
+      source: {
+        id: "2",
+        config: {
+          alias: "source2",
+          job_types: ["quality"],
+          databases: ["db1", "db2"],
+        },
+        externalId: "ext_id_2",
+      },
     });
   });
 
@@ -239,17 +248,12 @@ describe("<RuleImplementationRawForm />", () => {
         validations: "a.city='MADRID'",
       },
     };
-    const { queryByRole, queryByText } = render(
+    const { findByRole } = render(
       <RuleImplementationRawForm {...customProps} />,
       renderOpts
     );
-    await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
-    await waitFor(() =>
-      expect(queryByText(/loading/i)).not.toBeInTheDocument()
-    );
-    await waitFor(() =>
-      expect(queryByRole("button", { name: /save/i })).toBeEnabled()
-    );
+
+    expect(await findByRole("button", { name: /save/i })).toBeEnabled();
   });
 
   it("submit button disabled if there is invalid content in form", async () => {
@@ -266,14 +270,10 @@ describe("<RuleImplementationRawForm />", () => {
         validations: "a.city='MADRID'",
       },
     };
-    const { queryByRole, queryByText } = render(
+    const { queryByRole } = render(
       <RuleImplementationRawForm {...customProps} />,
       renderOpts
     );
-    await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
-    await waitFor(() =>
-      expect(queryByText(/loading/i)).not.toBeInTheDocument()
-    );
     expect(queryByRole("button", { name: /save/i })).toBeDisabled();
   });