@truedat/dq 4.47.4 → 4.47.5

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

@@ -1,9 +1,21 @@
+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,
+  SOURCES_WITH_CONFIG,
+} from "../NewRuleImplementation";
+import NewRuleImplementationLoader from "../NewRuleImplementation";
 import { newRuleImplementationProps } from "../__test_samples__/NewRuleImplementationProps";
+import {
+  ruleImplementationLoaderGlobalState,
+  ruleImplementationLoaderActions,
+  sourcesRuleImplementationLoader,
+} from "../__test_samples__/newRuleImplementationLoader";
 
 describe("<NewRuleImplementation />", () => {
   const createRuleImplementation = jest.fn();
@@ -57,3 +69,270 @@ describe("<NewRuleImplementation />", () => {
     expect(container).toMatchSnapshot();
   });
 });
+
+describe("<NewRuleImplementationLoader> NewRuleImplementation doSubmit", () => {
+  const dispatch = jest.fn();
+
+  const sourcesWithConfigMock = {
+    request: {
+      query: SOURCES_WITH_CONFIG,
+      variables: { jobTypes: "quality" },
+    },
+    result: { data: { sources: sourcesRuleImplementationLoader } },
+  };
+
+  const renderOptsImplementationEdit = {
+    mocks: [
+      multipleTemplatesMock({
+        scope: "ri",
+        domainIds: [2],
+      }),
+      sourcesWithConfigMock,
+    ],
+    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(
+      <NewRuleImplementationLoader {...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(
+      <NewRuleImplementationLoader {...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/__tests__/__snapshots__/FiltersFormGroup.spec.js.snap

@@ -50,7 +50,13 @@ exports[`<FiltersFormGroup /> matches the latest snapshot 1`] = `
         <div
           class="menu transition"
           role="listbox"
-        />
+        >
+          <div
+            class="message"
+          >
+            No results found.
+          </div>
+        </div>
       </div>
     </div>
     <div

package/src/components/ruleImplementationForm/__tests__/__snapshots__/FiltersGroup.spec.js.snap

@@ -4,6 +4,7 @@ exports[`<FiltersGroup /> matches the latest snapshot when siblings provided 1`]
 <div>
   <div
     class="row"
+    data-testid="row-0"
     style="display: none;"
   >
     <div
@@ -56,7 +57,13 @@ exports[`<FiltersGroup /> matches the latest snapshot when siblings provided 1`]
             <div
               class="menu transition"
               role="listbox"
-            />
+            >
+              <div
+                class="message"
+              >
+                No results found.
+              </div>
+            </div>
           </div>
         </div>
         <div

package/src/components/ruleImplementationForm/__tests__/__snapshots__/ValueConditions.spec.js.snap

@@ -56,7 +56,13 @@ exports[`<ValueConditions /> matches the latest snapshot when siblings provided
             <div
               class="menu transition"
               role="listbox"
-            />
+            >
+              <div
+                class="message"
+              >
+                No results found.
+              </div>
+            </div>
           </div>
         </div>
         <div

package/src/messages/en.js

@@ -423,7 +423,8 @@ export default {
     "matches regular expression",
   "ruleImplementation.operator.starts_with": "starts with",
   "ruleImplementation.operator.starts_with.string": "starts with",
-  "ruleImplementation.operator.unique": "has unique value",
+  "ruleImplementation.operator.unique": "unique",
+  "ruleImplementation.operator.unique.field_list": "unique across fields",
   "ruleImplementation.operator.variation_on_count": "count variation",
   "ruleImplementation.operator.variation_on_count.string": "count variation",
   "ruleImplementation.props.esquema": "Structure",

package/src/messages/es.js

@@ -435,7 +435,8 @@ export default {
   "ruleImplementation.operator.regex_format": "cumple la expresión regular",
   "ruleImplementation.operator.starts_with.string": "empieza por",
   "ruleImplementation.operator.starts_with": "empieza por",
-  "ruleImplementation.operator.unique": "tiene valor único",
+  "ruleImplementation.operator.unique": "único",
+  "ruleImplementation.operator.unique.field_list": "único en conjunto",
   "ruleImplementation.operator.variation_on_count.string": "variación conteo",
   "ruleImplementation.operator.variation_on_count": "variación conteo",
   "ruleImplementation.props.esquema.placeholder": "añade una estructura",

package/src/selectors/getRuleImplementationOperators.js

@@ -5,6 +5,7 @@ const defaultOperators = {
   any: {
     operators: [
       { name: "unique", scope: "validation" },
+      { name: "unique", value_type: "field_list" },
       { name: "not_empty" },
       { name: "empty" },
       {