@truedat/dd 8.12.1 → 8.12.4

package/src/components/__tests__/StructureGrantCartCheckout.grouping.spec.js

@@ -0,0 +1,95 @@
+import { getGroupedStructuresByDomainAndTemplate as groupStructures } from "../StructureGrantCartCheckout";
+
+const structures = [
+  { id: 1, system_id: 10, domain_ids: [1] },
+  { id: 2, system_id: 20, domain_ids: [1] },
+  { id: 3, system_id: 20, domain_ids: [2] },
+];
+
+// These cases capture the grouping policy on main before TD-8477.
+it.each([
+  ["no policy", [], null, false, true, { nodomain_others_notype: [1, 2, 3] }],
+  [
+    "default template only",
+    [],
+    7,
+    false,
+    true,
+    { nodomain_others_notype: [1, 2, 3] },
+  ],
+  [
+    "default domain policy",
+    [],
+    7,
+    true,
+    true,
+    { "1_others_notype": [1, 2], "2_others_notype": [3] },
+  ],
+  [
+    "explicit system policy",
+    [{ resource_id: 10, template_id: 5 }],
+    null,
+    false,
+    true,
+    { nodomain_10_5: [1], nodomain_others_notype: [2, 3] },
+  ],
+  [
+    "unmatched system policy",
+    [{ resource_id: 30, template_id: 5 }],
+    null,
+    false,
+    true,
+    { nodomain_others_notype: [1, 2, 3] },
+  ],
+  [
+    "explicit system domain policy",
+    [{ resource_id: 20, template_id: 5, group_by_domain: true }],
+    null,
+    false,
+    true,
+    { nodomain_others_notype: [1], "1_20_5": [2], "2_20_5": [3] },
+  ],
+  [
+    "explicit false overrides default domain policy",
+    [{ resource_id: 20, template_id: 5, group_by_domain: false }],
+    7,
+    true,
+    true,
+    { "1_others_notype": [1], nodomain_20_5: [2, 3] },
+  ],
+  [
+    "explicit system falls back to default template",
+    [{ resource_id: 20, template_id: null }],
+    7,
+    false,
+    true,
+    { nodomain_others_notype: [1], nodomain_20_7: [2, 3] },
+  ],
+  [
+    "disabled grouping",
+    [{ resource_id: 20, template_id: 5, group_by_domain: true }],
+    7,
+    true,
+    false,
+    { all: [1, 2, 3] },
+  ],
+])(
+  "preserves the original grouping for %s",
+  (_label, relations, defaultId, byDomain, enabled, expected) => {
+    const { grouped } = groupStructures(
+      structures,
+      relations,
+      defaultId,
+      byDomain,
+      enabled,
+    );
+    expect(
+      Object.fromEntries(
+        Object.entries(grouped).map(([key, entries]) => [
+          key,
+          entries.map(({ id }) => id),
+        ]),
+      ),
+    ).toEqual(expected);
+  },
+);

package/src/components/__tests__/StructureGrantCartCheckout.selection.spec.js

@@ -0,0 +1,416 @@
+import { waitFor, within } from "@testing-library/react";
+import PropTypes from "prop-types";
+import userEvent from "@testing-library/user-event";
+import { useSelector, useDispatch } from "react-redux";
+import { render } from "@truedat/test/render";
+import { TEMPLATES_QUERY, DOMAINS_QUERY } from "@truedat/core/api/queries";
+import { useTemplateRelations } from "@truedat/df/hooks/useTemplateRelations";
+import {
+  addGrantRequestToCart,
+  removeGrantRequestFromCart,
+} from "../../routines";
+import {
+  grantRequestsCart,
+  initialState,
+} from "../../reducers/grantRequestsCart";
+import StructureGrantCartCheckout from "../StructureGrantCartCheckout";
+import { useTemplatesByIds } from "../../hooks/useTemplatesByIds";
+import { useCheckoutGrantRequest } from "../../hooks/useCheckoutGrantRequest";
+
+jest.mock("@truedat/core/webContext", () => ({
+  useWebContext: () => ({ scopesWithRelations: ["gr"] }),
+}));
+jest.mock("@truedat/df/hooks/useTemplateRelations", () => ({
+  useTemplateRelations: jest.fn(),
+}));
+jest.mock("../../hooks/useTemplatesByIds", () => ({
+  useTemplatesByIds: jest.fn(),
+}));
+jest.mock("../../hooks/useCheckoutGrantRequest", () => ({
+  useCheckoutGrantRequest: jest.fn(),
+}));
+jest.mock("../StructureGrantCart", () => () => <div>Structures</div>);
+jest.mock("../StructureGrantCartUserSelector", () => () => (
+  <div data-testid="user-selector" />
+));
+
+const makeTemplate = (id, name) => ({
+  id,
+  name,
+  label: name,
+  scope: "gr",
+  content: [
+    {
+      name: "details",
+      fields: [
+        {
+          name: "reason",
+          label: "Reason",
+          type: "string",
+          placeholder: "Reason",
+        },
+      ],
+    },
+  ],
+});
+const assigned = makeTemplate("1", "Assigned");
+const fallback = makeTemplate("2", "Default");
+const alternative = makeTemplate("3", "Alternative");
+const templates = [assigned, fallback, alternative];
+const structure = (id, systemId) => ({
+  id,
+  system_id: systemId,
+  system: { id: systemId, name: `System ${systemId}` },
+  domain_ids: [1],
+});
+const trigger = jest.fn().mockResolvedValue({});
+
+function CheckoutView({ visible = true }) {
+  const cart = useSelector((state) => state.grantRequestsCart);
+  const dispatch = useDispatch();
+  return (
+    <>
+      <button
+        onClick={() => dispatch(addGrantRequestToCart(structure(201, 20)))}
+      >
+        Add system
+      </button>
+      <button onClick={() => dispatch(removeGrantRequestFromCart({ id: 201 }))}>
+        Remove system
+      </button>
+      <output data-testid="cart">{JSON.stringify(cart)}</output>
+      {visible && <StructureGrantCartCheckout />}
+    </>
+  );
+}
+
+CheckoutView.propTypes = { visible: PropTypes.bool };
+
+const openCheckout = (structures, extra = {}) =>
+  render(<CheckoutView />, {
+    reducer: { grantRequestsCart },
+    state: { grantRequestsCart: { ...initialState, structures, ...extra } },
+    mocks: [
+      {
+        request: { query: TEMPLATES_QUERY, variables: { scope: "gr" } },
+        result: { data: { templates } },
+        maxUsageCount: 20,
+      },
+      {
+        request: {
+          query: DOMAINS_QUERY,
+          variables: { action: "createForeignGrantRequest" },
+        },
+        result: {
+          data: {
+            domains: [
+              {
+                id: "1",
+                name: "Domain",
+                externalId: "domain",
+                parentId: null,
+                actions: [],
+              },
+            ],
+          },
+        },
+        maxUsageCount: 20,
+      },
+    ],
+  });
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  useTemplateRelations.mockReturnValue({
+    resource: [],
+    default: { template_id: 2 },
+    loading: false,
+  });
+  useTemplatesByIds.mockReturnValue({ 1: assigned, 2: fallback });
+  useCheckoutGrantRequest.mockReturnValue({ trigger, isMutating: false });
+});
+
+it("restores a selected template and edited content after leaving and reentering single checkout", async () => {
+  const view = openCheckout([structure(101, 10)]);
+  const user = userEvent.setup({ delay: null });
+  await view.findByPlaceholderText("Reason");
+  const userSelector = await view.findByTestId("user-selector");
+  expect(userSelector.closest("form")).toContainElement(
+    view.getByPlaceholderText("Reason"),
+  );
+  expect(
+    view.container.querySelectorAll(".grant-cart-group-form"),
+  ).toHaveLength(0);
+  await user.click(await view.findByRole("option", { name: "Alternative" }));
+  await user.type(view.getByPlaceholderText("Reason"), "My draft");
+  view.rerender(<CheckoutView visible={false} />);
+  view.rerender(<CheckoutView />);
+  await waitFor(() =>
+    expect(view.getByPlaceholderText("Reason")).toHaveValue("My draft"),
+  );
+  expect(
+    JSON.parse(view.getByTestId("cart").textContent).groupTemplates
+      .nodomain_others_notype.template,
+  ).toBe("Alternative");
+  await user.click(view.getByRole("button", { name: "actions.save" }));
+  expect(trigger).toHaveBeenCalledWith(
+    expect.objectContaining({
+      grant_request_group: expect.objectContaining({
+        type: "Alternative",
+        requests: [
+          expect.objectContaining({
+            metadata: { reason: { value: "My draft", origin: "user" } },
+          }),
+        ],
+      }),
+    }),
+  );
+});
+
+it("keeps assigned and selectable system drafts separate across a remount", async () => {
+  useTemplateRelations.mockReturnValue({
+    resource: [{ resource_id: 10, template_id: 1 }],
+    default: { template_id: 2 },
+    loading: false,
+  });
+  const view = openCheckout([structure(101, 10), structure(201, 20)]);
+  const user = userEvent.setup({ delay: null });
+  await waitFor(() =>
+    expect(view.getAllByPlaceholderText("Reason")).toHaveLength(2),
+  );
+  const groups = view.container.querySelectorAll(".grant-cart-group-form");
+  expect(within(groups[0]).queryByRole("listbox")).not.toBeInTheDocument();
+  await user.click(
+    await within(groups[1]).findByRole("option", { name: "Alternative" }),
+  );
+  await user.type(
+    within(groups[1]).getByPlaceholderText("Reason"),
+    "Group draft",
+  );
+  view.rerender(<CheckoutView visible={false} />);
+  view.rerender(<CheckoutView />);
+  await waitFor(() =>
+    expect(view.getAllByPlaceholderText("Reason")[1]).toHaveValue(
+      "Group draft",
+    ),
+  );
+  await user.click(view.getByRole("button", { name: "actions.save" }));
+  expect(trigger).toHaveBeenCalledWith({
+    grant_request_groups: [
+      expect.objectContaining({ type: "Assigned" }),
+      expect.objectContaining({
+        type: "Alternative",
+        requests: [
+          expect.objectContaining({
+            data_structure_id: 201,
+            metadata: { reason: { value: "Group draft", origin: "user" } },
+          }),
+        ],
+      }),
+    ],
+  });
+});
+
+it("waits for relations and restores a saved selection when definitions arrive later", async () => {
+  useTemplateRelations.mockReturnValue({ resource: [], loading: true });
+  useTemplatesByIds.mockReturnValue({});
+  const view = openCheckout([structure(101, 10)], {
+    groupTemplates: {
+      nodomain_others_notype: {
+        template: "Alternative",
+        templateContent: { reason: { value: "Saved", origin: "user" } },
+      },
+    },
+  });
+  expect(view.queryByPlaceholderText("Reason")).not.toBeInTheDocument();
+  expect(view.getByRole("button", { name: "actions.save" })).toBeDisabled();
+  useTemplateRelations.mockReturnValue({
+    resource: [],
+    default: { template_id: 2 },
+    loading: false,
+  });
+  view.rerender(<CheckoutView />);
+  await waitFor(() =>
+    expect(view.getByPlaceholderText("Reason")).toHaveValue("Saved"),
+  );
+  useTemplatesByIds.mockReturnValue({ 2: { ...fallback } });
+  view.rerender(<CheckoutView />);
+  expect(view.getByPlaceholderText("Reason")).toHaveValue("Saved");
+  expect(
+    JSON.parse(view.getByTestId("cart").textContent).groupTemplates
+      .nodomain_others_notype.template,
+  ).toBe("Alternative");
+});
+
+it("shares all grant templates across systems without a matching relation", async () => {
+  useTemplateRelations.mockReturnValue({
+    resource: [{ resource_id: 30, template_id: 1 }],
+    loading: false,
+  });
+  const view = openCheckout([structure(101, 10), structure(201, 20)]);
+  await waitFor(() =>
+    expect(view.getAllByRole("option", { name: "Assigned" })).toHaveLength(1),
+  );
+  expect(
+    view.queryByText("grantRequest.cart.group.others"),
+  ).not.toBeInTheDocument();
+  expect(view.getByText("structure.grant.cart.template")).toBeInTheDocument();
+  expect(view.queryByPlaceholderText("Reason")).not.toBeInTheDocument();
+  expect(view.getByRole("button", { name: "actions.save" })).toBeDisabled();
+});
+
+it("preserves the draft when adding and removing another system", async () => {
+  useTemplateRelations.mockReturnValue({
+    resource: [{ resource_id: 20, template_id: 1 }],
+    default: { template_id: 2 },
+    loading: false,
+  });
+  const view = openCheckout([structure(101, 10)]);
+  const user = userEvent.setup({ delay: null });
+  await view.findByPlaceholderText("Reason");
+  await user.click(await view.findByRole("option", { name: "Alternative" }));
+  await user.type(view.getByPlaceholderText("Reason"), "First system");
+  expect(view.getByText("structure.grant.cart.template")).toBeInTheDocument();
+  expect(
+    view.container.querySelectorAll(".grant-cart-group-form"),
+  ).toHaveLength(0);
+  await user.click(view.getByText("Add system"));
+  await waitFor(() =>
+    expect(view.getAllByPlaceholderText("Reason")).toHaveLength(2),
+  );
+  expect(view.getAllByPlaceholderText("Reason")[0]).toHaveValue("First system");
+  expect(
+    view.container.querySelectorAll(".grant-cart-group-form"),
+  ).toHaveLength(2);
+  expect(
+    view.queryByText("structure.grant.cart.template"),
+  ).not.toBeInTheDocument();
+  await user.click(view.getByText("Remove system"));
+  expect(view.getByPlaceholderText("Reason")).toHaveValue("First system");
+  expect(view.getByText("structure.grant.cart.template")).toBeInTheDocument();
+  expect(
+    view.container.querySelectorAll(".grant-cart-group-form"),
+  ).toHaveLength(0);
+  await user.click(view.getByRole("button", { name: "actions.save" }));
+  expect(trigger).toHaveBeenCalledWith(
+    expect.objectContaining({
+      grant_request_group: expect.objectContaining({ type: "Alternative" }),
+    }),
+  );
+});
+
+it("restores a grant modification draft without reapplying its default", async () => {
+  const view = openCheckout([structure(101, 10)], {
+    modificationGrant: { id: 7, detail: {} },
+  });
+  const user = userEvent.setup({ delay: null });
+  await view.findByPlaceholderText("Reason");
+  await user.click(await view.findByRole("option", { name: "Alternative" }));
+  await user.type(view.getByPlaceholderText("Reason"), "Updated draft");
+  view.rerender(<CheckoutView visible={false} />);
+  view.rerender(<CheckoutView />);
+  await waitFor(() =>
+    expect(view.getByPlaceholderText("Reason")).toHaveValue("Updated draft"),
+  );
+  await user.click(view.getByRole("button", { name: "actions.save" }));
+  expect(trigger).toHaveBeenCalledWith(
+    expect.objectContaining({
+      grant_request_group: expect.objectContaining({
+        type: "Alternative",
+        modification_grant_id: 7,
+      }),
+    }),
+  );
+});
+
+it("retains the default assignment for an explicit system relation with no template", async () => {
+  useTemplateRelations.mockReturnValue({
+    resource: [{ resource_id: 10, template_id: null }],
+    default: { template_id: 2 },
+    loading: false,
+  });
+  const view = openCheckout([structure(101, 10)]);
+  await view.findByPlaceholderText("Reason");
+  expect(view.queryByRole("combobox")).not.toBeInTheDocument();
+  expect(
+    JSON.parse(view.getByTestId("cart").textContent).groupTemplates
+      .nodomain_10_2.template,
+  ).toBe("Default");
+});
+
+it("preserves domain grouping for assigned templates", async () => {
+  useTemplateRelations.mockReturnValue({
+    resource: [{ resource_id: 10, template_id: 1, group_by_domain: true }],
+    loading: false,
+  });
+  const view = openCheckout([
+    structure(101, 10),
+    { ...structure(102, 10), domain_ids: [2] },
+  ]);
+  await waitFor(() =>
+    expect(view.getAllByPlaceholderText("Reason")).toHaveLength(2),
+  );
+  expect(view.queryByRole("combobox")).not.toBeInTheDocument();
+  const cart = JSON.parse(view.getByTestId("cart").textContent);
+  expect(Object.keys(cart.groupTemplates)).toEqual(["1_10_1", "2_10_1"]);
+});
+
+it("renders a late default after the template list loads and preserves edits on refresh", async () => {
+  useTemplatesByIds.mockReturnValue({});
+  const view = openCheckout([structure(101, 10)]);
+  await view.findByRole("option", { name: "Alternative" });
+  expect(view.queryByPlaceholderText("Reason")).not.toBeInTheDocument();
+  useTemplatesByIds.mockReturnValue({ 2: fallback });
+  view.rerender(<CheckoutView />);
+  const user = userEvent.setup({ delay: null });
+  await user.type(await view.findByPlaceholderText("Reason"), "Default draft");
+  useTemplatesByIds.mockReturnValue({ 2: { ...fallback } });
+  view.rerender(<CheckoutView />);
+  expect(view.getByPlaceholderText("Reason")).toHaveValue("Default draft");
+});
+
+it("retains a single draft created before per-group storage", async () => {
+  const view = openCheckout([structure(101, 10)], {
+    template: "Alternative",
+    templateContent: { reason: { value: "Existing draft", origin: "user" } },
+    validCart: true,
+  });
+  await waitFor(() =>
+    expect(view.getByPlaceholderText("Reason")).toHaveValue("Existing draft"),
+  );
+  expect(
+    JSON.parse(view.getByTestId("cart").textContent).groupTemplates
+      .nodomain_others_notype.template,
+  ).toBe("Alternative");
+});
+
+it("submits all systems and domains in one group when no grouping policy exists", async () => {
+  useTemplateRelations.mockReturnValue({
+    resource: [],
+    default: null,
+    loading: false,
+  });
+  const view = openCheckout([
+    structure(101, 10),
+    { ...structure(201, 20), domain_ids: [2] },
+  ]);
+  const user = userEvent.setup({ delay: null });
+  expect(await view.findAllByRole("combobox")).toHaveLength(1);
+  await user.click(await view.findByRole("option", { name: "Alternative" }));
+  await user.type(view.getByPlaceholderText("Reason"), "Shared draft");
+  view.rerender(<CheckoutView visible={false} />);
+  view.rerender(<CheckoutView />);
+  await waitFor(() =>
+    expect(view.getByPlaceholderText("Reason")).toHaveValue("Shared draft"),
+  );
+  await user.click(view.getByRole("button", { name: "actions.save" }));
+  expect(trigger).toHaveBeenCalledWith({
+    grant_request_group: expect.objectContaining({
+      type: "Alternative",
+      requests: [
+        expect.objectContaining({ data_structure_id: 101 }),
+        expect.objectContaining({ data_structure_id: 201 }),
+      ],
+    }),
+  });
+});