@truedat/dq 8.4.2 → 8.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dq",
-  "version": "8.4.2",
+  "version": "8.4.4",
   "description": "Truedat Web Data Quality Module",
   "sideEffects": false,
   "module": "src/index.js",
@@ -56,7 +56,7 @@
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.3.0",
     "@testing-library/user-event": "^14.6.1",
-    "@truedat/test": "8.4.2",
+    "@truedat/test": "8.4.4",
     "identity-obj-proxy": "^3.0.0",
     "jest": "^29.7.0",
     "redux-saga-test-plan": "^4.0.6"
@@ -89,5 +89,5 @@
     "semantic-ui-react": "^3.0.0-beta.2",
     "swr": "^2.3.3"
   },
-  "gitHead": "6ce335c57b6311c56828ce132b816322aa79d9ea"
+  "gitHead": "0d8d2a2f4526c425fcef656a6004484cbd755774"
 }

package/src/components/Implementations.js

@@ -49,6 +49,7 @@ export const Implementations = ({ defaultFilters }) => {
     userFiltersType: "user_search_filters",
     userFilterScope: "rule_implementation",
     defaultFilters: filtersWithSubscope,
+    useDomainSearchFilter: true,
   };
 
   return (

package/src/components/RuleSelectedFilters.js

@@ -54,6 +54,7 @@ export const mapStateToProps = (state, ownProps) => {
     activeFilters,
     userFilters,
     userFilterScope: "rule",
+    useDomainSearchFilter: true,
   };
 };
 

package/src/components/RulesLoader.js

@@ -25,7 +25,9 @@ RulesLoader.propTypes = {
 const makeMapStateToProps = () => {
   const searchQuerySelector = makeSearchQuerySelector(
     "ruleQuery",
-    "ruleActiveFilters"
+    "ruleActiveFilters",
+    undefined,
+    { useDomainSearchFilter: true }
   );
   const mapStateToProps = (state, props) => ({
     payload: searchQuerySelector(state, props),

package/src/components/Subscription.js

@@ -124,7 +124,11 @@ export const Subscription = ({
 
   const className = subscribed ? "secondary" : "";
 
-  const handleSubmit = () => {
+  const handleSubmit = (e) => {
+    if (e) {
+      e.preventDefault();
+      e.stopPropagation();
+    }
     const payload = {
       ...{
         subscription: {
@@ -175,7 +179,11 @@ export const Subscription = ({
     }
   };
 
-  const handleDelete = () => {
+  const handleDelete = (e) => {
+    if (e) {
+      e.preventDefault();
+      e.stopPropagation();
+    }
     const payload = {
       ...{
         subscription: subscriptionField,
@@ -191,7 +199,10 @@ export const Subscription = ({
   };
 
   const handleChange = (e, { name, value }) => {
-    e && e.preventDefault() && e.stopPropagation();
+    if (e) {
+      e.preventDefault();
+      e.stopPropagation();
+    }
     setSubscription({ ...subscriptionField, [name]: value });
   };
 

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

@@ -1,7 +1,11 @@
 import userEvent from "@testing-library/user-event";
 import { waitFor } from "@testing-library/react";
 import { render, waitForLoad } from "@truedat/test/render";
-import { Subscription, SubscriptionContent } from "../Subscription";
+import {
+  Subscription,
+  SubscriptionContent,
+  mapStateToProps,
+} from "../Subscription";
 
 describe("<SubscriptionContent />", () => {
   const subscription = {
@@ -43,6 +47,23 @@ describe("<SubscriptionContent />", () => {
     await user.click(rendered.getByText(/subscriptions.status.success/i));
     expect(setSubscription).toHaveBeenCalled();
   });
+
+  it("removes status when selecting an already selected event type", async () => {
+    const props = {
+      subscription,
+      setSubscription,
+    };
+    const rendered = render(<SubscriptionContent {...props} />);
+    await waitForLoad(rendered);
+
+    const user = userEvent.setup({ delay: null });
+    await user.click(rendered.getByText(/subscriptions.status.warn/i));
+
+    expect(setSubscription).toHaveBeenCalledWith({
+      ...subscription,
+      scope: { status: [] },
+    });
+  });
 });
 
 describe("<Subscription />", () => {
@@ -102,4 +123,121 @@ describe("<Subscription />", () => {
       expect(rendered.queryByText(/actions.save/i)).not.toBeInTheDocument()
     );
   });
+
+  it("updates periodicity when selecting another radio option", async () => {
+    const rendered = render(<Subscription {...props} />);
+    await waitForLoad(rendered);
+
+    const user = userEvent.setup({ delay: null });
+    await user.click(rendered.getByRole("button"));
+    await user.click(
+      await rendered.findByText(/subscriptions.periodicity.hourly/i)
+    );
+    await user.click(await rendered.findByText(/actions.save/i));
+
+    expect(updateSubscription).toHaveBeenCalledWith(
+      expect.objectContaining({
+        subscription: expect.objectContaining({ periodicity: "hourly" }),
+      })
+    );
+  });
+
+  it("deletes subscription and closes popup", async () => {
+    const rendered = render(<Subscription {...props} />);
+    await waitForLoad(rendered);
+
+    const user = userEvent.setup({ delay: null });
+    await user.click(rendered.getByRole("button"));
+    await user.click(
+      await rendered.findByText(/ruleSubscription.actions.remove/i)
+    );
+
+    expect(deleteSubscription).toHaveBeenCalledWith(
+      expect.objectContaining({
+        resource_id: 1,
+        resource_type: "rule",
+      })
+    );
+
+    await waitFor(() =>
+      expect(
+        rendered.queryByText(/ruleSubscription.actions.remove/i)
+      ).not.toBeInTheDocument()
+    );
+  });
+
+  it("handles implementation payload fields on save and delete", async () => {
+    const implementationProps = {
+      ...props,
+      resource: {
+        id: 9,
+        implementation_key: "impl-key",
+        implementation_ref: "impl-ref",
+      },
+      resourceType: "implementation",
+      searchSubscription: {
+        ...searchSubscription,
+        scope: { ...searchSubscription.scope, status: ["success"] },
+      },
+    };
+    const rendered = render(<Subscription {...implementationProps} />);
+    await waitForLoad(rendered);
+
+    const user = userEvent.setup({ delay: null });
+    await user.click(rendered.getByRole("button"));
+    await user.click(await rendered.findByText(/actions.save/i));
+
+    expect(updateSubscription).toHaveBeenCalledWith(
+      expect.objectContaining({
+        implementation_id: 9,
+        subscription: expect.objectContaining({
+          scope: expect.objectContaining({
+            resource_id: "impl-ref",
+            resource_name: "impl-key",
+            resource_type: "implementation",
+          }),
+        }),
+      })
+    );
+
+    await user.click(rendered.getByRole("button"));
+    await user.click(
+      await rendered.findByText(/ruleSubscription.actions.remove/i)
+    );
+
+    expect(deleteSubscription).toHaveBeenCalledWith(
+      expect.objectContaining({
+        implementation_id: 9,
+        resource_id: 9,
+        resource_type: "implementation",
+      })
+    );
+  });
+
+  it("closes popup when clicking outside", async () => {
+    const rendered = render(<Subscription {...props} />);
+    await waitForLoad(rendered);
+
+    const user = userEvent.setup({ delay: null });
+    await user.click(rendered.getByRole("button"));
+    expect(await rendered.findByText(/actions.save/i)).toBeInTheDocument();
+
+    await user.click(document.body);
+
+    await waitFor(() =>
+      expect(rendered.queryByText(/actions.save/i)).not.toBeInTheDocument()
+    );
+  });
+
+  it("maps state to props", () => {
+    const state = {
+      searchSubscription: { id: 12 },
+      subscriptionUpdating: true,
+    };
+
+    expect(mapStateToProps(state)).toEqual({
+      searchSubscription: { id: 12 },
+      subscriptionUpdating: true,
+    });
+  });
 });

package/src/reducers/__tests__/ruleImplementationRedirect.spec.js

@@ -1,6 +1,15 @@
-import { clearRedirect } from "@truedat/core/routines";
 import {
+  clearRedirect,
+  createSubscription,
+  deleteSubscription,
+  updateSubscription,
+} from "@truedat/core/routines";
+import { IMPLEMENTATIONS, linkTo } from "@truedat/core/routes";
+import {
+  createExecutionGroup,
+  createImplementationStructure,
   createRuleImplementation,
+  uploadImplementations,
   updateRuleImplementation,
   deleteRuleResult,
 } from "../../routines";
@@ -52,4 +61,92 @@ describe("reducers: ruleImplementationRedirect", () => {
       })
     ).toBe("/implementations/2/results");
   });
+
+  it("should keep current state after createSubscription.SUCCESS action", () => {
+    const payload = { implementation_id: 311 };
+
+    expect(
+      ruleImplementationRedirect(fooState, {
+        type: createSubscription.SUCCESS,
+        payload,
+      })
+    ).toBe(fooState);
+  });
+
+  it("should keep current state after updateSubscription.SUCCESS action", () => {
+    const payload = { implementation_id: 311 };
+
+    expect(
+      ruleImplementationRedirect(fooState, {
+        type: updateSubscription.SUCCESS,
+        payload,
+      })
+    ).toBe(fooState);
+  });
+
+  it("should keep current state after deleteSubscription.SUCCESS action", () => {
+    const payload = { implementation_id: 311 };
+
+    expect(
+      ruleImplementationRedirect(fooState, {
+        type: deleteSubscription.SUCCESS,
+        payload,
+      })
+    ).toBe(fooState);
+  });
+
+  it("should return implementation concepts link after createRuleImplementation.FAILURE action with implementation_id", () => {
+    const payload = { implementation_id: 2 };
+
+    expect(
+      ruleImplementationRedirect(fooState, {
+        type: createRuleImplementation.FAILURE,
+        payload,
+      })
+    ).toBe(
+      linkTo.IMPLEMENTATION_CONCEPT_LINKS({
+        implementation_id: payload.implementation_id,
+      })
+    );
+  });
+
+  it("should keep current state after createRuleImplementation.FAILURE action without implementation_id", () => {
+    expect(
+      ruleImplementationRedirect(fooState, {
+        type: createRuleImplementation.FAILURE,
+        payload: {},
+      })
+    ).toBe(fooState);
+  });
+
+  it("should return redirectUrl after createImplementationStructure.SUCCESS action", () => {
+    const payload = { redirectUrl: "/custom/redirect" };
+
+    expect(
+      ruleImplementationRedirect(fooState, {
+        type: createImplementationStructure.SUCCESS,
+        payload,
+      })
+    ).toBe("/custom/redirect");
+  });
+
+  it("should return execution group link after createExecutionGroup.SUCCESS action", () => {
+    const payload = { data: { id: 10 } };
+
+    expect(
+      ruleImplementationRedirect(fooState, {
+        type: createExecutionGroup.SUCCESS,
+        payload,
+      })
+    ).toBe(linkTo.EXECUTION_GROUP({ id: 10 }));
+  });
+
+  it("should return implementations route after uploadImplementations.SUCCESS action", () => {
+    expect(
+      ruleImplementationRedirect(fooState, {
+        type: uploadImplementations.SUCCESS,
+        payload: {},
+      })
+    ).toBe(IMPLEMENTATIONS);
+  });
 });

package/src/reducers/__tests__/ruleRedirect.spec.js

@@ -1,5 +1,6 @@
 import { linkTo, RULES } from "@truedat/core/routes";
 import {
+  clearRedirect,
   createSubscription,
   deleteSubscription,
   updateSubscription,
@@ -8,6 +9,8 @@ import {
   createRule,
   deleteRule,
   deleteImplementation,
+  updateRule,
+  uploadRules,
   submitImplementation,
   publishImplementation,
   rejectImplementation,
@@ -34,33 +37,51 @@ describe("reducers: ruleImplementationRedirect", () => {
     expect(ruleRedirect(fooState, deleteRule.success(payload))).toBe(RULES);
   });
 
-  it("should return a link to Rule after updateSubscription.SUCCESS action", () => {
+  it("should be true after receiving the clearRedirect.TRIGGER action", () => {
+    expect(ruleRedirect(fooState, { type: clearRedirect.TRIGGER })).toBe(
+      initialState
+    );
+  });
+
+  it("should return redirectUrl after updateRule.SUCCESS action", () => {
+    const redirectUrl = "/rules/22";
+    const action = {
+      type: updateRule.SUCCESS,
+      payload: { data: { id: 22 } },
+      meta: { redirectUrl },
+    };
+    expect(ruleRedirect(fooState, action)).toBe(redirectUrl);
+  });
+
+  it("should return RULES route after uploadRules.SUCCESS action", () => {
+    const payload = {};
+    expect(ruleRedirect(fooState, uploadRules.success(payload))).toBe(RULES);
+  });
+
+  it("should keep current state after updateSubscription.SUCCESS action", () => {
     const rule_id = 2;
     const payload = { rule_id };
-    const url = linkTo.RULE({ id: rule_id });
 
     expect(ruleRedirect(fooState, updateSubscription.success(payload))).toBe(
-      url
+      fooState
     );
   });
 
-  it("should return a link to Rule after deleteSubscription.SUCCESS action", () => {
+  it("should keep current state after deleteSubscription.SUCCESS action", () => {
     const rule_id = 2;
     const payload = { rule_id };
-    const url = linkTo.RULE({ id: rule_id });
 
     expect(ruleRedirect(fooState, deleteSubscription.success(payload))).toBe(
-      url
+      fooState
     );
   });
 
-  it("should return a link to Rule after createSubscription.SUCCESS action", () => {
+  it("should keep current state after createSubscription.SUCCESS action", () => {
     const rule_id = 2;
     const payload = { rule_id };
-    const url = linkTo.RULE({ id: rule_id });
 
     expect(ruleRedirect(fooState, createSubscription.success(payload))).toBe(
-      url
+      fooState
     );
   });
 
@@ -72,6 +93,13 @@ describe("reducers: ruleImplementationRedirect", () => {
     );
   });
 
+  it("should return current state on deleteImplementation.SUCCESS action without redirectUrl", () => {
+    const payload = {};
+    expect(ruleRedirect(fooState, deleteImplementation.success(payload))).toBe(
+      fooState
+    );
+  });
+
   it("should return the current state on submitImplementation.SUCCESS action", () => {
     const payload = { data: {} };
     expect(ruleRedirect(fooState, submitImplementation.success(payload))).toBe(

package/src/reducers/ruleImplementationRedirect.js

@@ -1,4 +1,3 @@
-import _ from "lodash/fp";
 import { IMPLEMENTATIONS, linkTo } from "@truedat/core/routes";
 import {
   clearRedirect,
@@ -61,12 +60,8 @@ export const ruleImplementationRedirect = (
     }
     case createSubscription.SUCCESS:
     case deleteSubscription.SUCCESS:
-    case updateSubscription.SUCCESS: {
-      const { implementation_id } = payload;
-      return _.isNil(implementation_id)
-        ? state
-        : linkTo.IMPLEMENTATION({ implementation_id });
-    }
+    case updateSubscription.SUCCESS:
+      return state;
     default:
       return state;
   }

package/src/reducers/ruleRedirect.js

@@ -1,4 +1,3 @@
-import _ from "lodash/fp";
 import { RULES, linkTo } from "@truedat/core/routes";
 import {
   clearRedirect,
@@ -31,24 +30,17 @@ export const ruleRedirect = (state = initialState, { type, payload, meta }) => {
     case deleteRule.SUCCESS:
       return RULES;
     case updateRule.SUCCESS: {
-      const { redirectUrl } = meta;
+      const redirectUrl = meta?.redirectUrl;
       return redirectUrl;
     }
-    case updateSubscription.SUCCESS: {
-      const { rule_id } = payload;
-      return _.isNil(rule_id) ? state : linkTo.RULE({ id: rule_id });
-    }
+    case updateSubscription.SUCCESS:
+      return state;
     case uploadRules.SUCCESS: {
       return RULES;
     }
-    case deleteSubscription.SUCCESS: {
-      const { rule_id } = payload;
-      return _.isNil(rule_id) ? state : linkTo.RULE({ id: rule_id });
-    }
-    case createSubscription.SUCCESS: {
-      const { rule_id } = payload;
-      return _.isNil(rule_id) ? state : linkTo.RULE({ id: rule_id });
-    }
+    case deleteSubscription.SUCCESS:
+    case createSubscription.SUCCESS:
+      return state;
     case deleteImplementation.SUCCESS:
       return payload?.redirectUrl || state;
     case publishImplementation.SUCCESS: