@truedat/dd 8.12.1 → 8.12.2

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 }),
+      ],
+    }),
+  });
+});

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

@@ -180,12 +180,14 @@ describe("StructureGrantCartCheckout", () => {
   const mockTrigger = jest.fn().mockResolvedValue({});
   const mockDispatch = jest.fn();
   const mockInitGroupTemplates = jest.fn();
+  const mockSelectGrantRequestTemplate = jest.fn();
   const mockSelectGrantRequestTemplateForGroup = jest.fn();
   const mockUpdateGrantRequestTemplateContentForGroup = jest.fn();
 
   const defaultProps = {
     grantRequestsCart: grantRequestsCartWithModification,
     initGroupTemplates: mockInitGroupTemplates,
+    selectGrantRequestTemplate: mockSelectGrantRequestTemplate,
     selectGrantRequestTemplateForGroup: mockSelectGrantRequestTemplateForGroup,
     updateGrantRequestTemplateContentForGroup:
       mockUpdateGrantRequestTemplateContentForGroup,
@@ -220,6 +222,28 @@ describe("StructureGrantCartCheckout", () => {
     expect(rendered.container).toMatchSnapshot();
   });
 
+  it("applies the default template when an update has no selection", async () => {
+    useWebContext.mockReturnValue({ scopesWithRelations: ["gr"] });
+    useTemplateRelations.mockReturnValue({
+      resource: [],
+      default: { template_id: 3 },
+    });
+    useTemplatesByIds.mockReturnValue({
+      3: { id: 3, name: "Default template", content: [] },
+    });
+
+    const rendered = render(
+      <StructureGrantCartCheckout {...defaultProps} />,
+      renderOpts,
+    );
+    await waitForLoad(rendered);
+
+    expect(useTemplatesByIds).toHaveBeenCalledWith([3]);
+    expect(mockSelectGrantRequestTemplate).toHaveBeenCalledWith(
+      "Default template",
+    );
+  });
+
   it("matches snapshot when single flow without modification and empty cart", async () => {
     useWebContext.mockReturnValue({ scopesWithRelations: [] });
     useTemplateRelations.mockReturnValue({ resource: [] });
@@ -334,7 +358,7 @@ describe("StructureGrantCartCheckout", () => {
     expect(rendered.container).toMatchSnapshot();
   });
 
-  it("matches snapshot with single domain - shows singular domain message", async () => {
+  it("matches snapshot with single domain - uses single-group information panel", async () => {
     useWebContext.mockReturnValue({ scopesWithRelations: ["gr"] });
     useTemplateRelations.mockReturnValue({
       resource: [{ resource_id: 10, template_id: 1, group_by_domain: true }],
@@ -371,12 +395,16 @@ describe("StructureGrantCartCheckout", () => {
       1: { name: "Template A", content: [] },
       2: { name: "Template B", content: [] },
     });
+    const grantRequestsCart = {
+      ...grantRequestsCartMultiGroup,
+      groupTemplates: {},
+    };
     const props = {
       ...defaultProps,
-      grantRequestsCart: grantRequestsCartMultiGroup,
+      grantRequestsCart,
     };
     const renderOpts = {
-      state: { grantRequestsCart: grantRequestsCartMultiGroup },
+      state: { grantRequestsCart },
       mocks: [
         singleTemplateMock({ scope: "gr" }),
         domainsMock({ action: "createForeignGrantRequest" }),
@@ -399,6 +427,47 @@ describe("StructureGrantCartCheckout", () => {
     expect(mockInitGroupTemplates).not.toHaveBeenCalled();
   });
 
+  it("preserves group selections when no automatic template is assigned", async () => {
+    useWebContext.mockReturnValue({ scopesWithRelations: ["gr"] });
+    useTemplateRelations.mockReturnValue({
+      resource: [
+        { resource_id: 10, template_id: null },
+        { resource_id: 20, template_id: null },
+      ],
+    });
+    const grantRequestsCart = {
+      ...grantRequestsCartMultiGroup,
+      groupTemplates: {
+        nodomain_10_notype: {
+          template: "user template A",
+          templateContent: {},
+          valid: true,
+        },
+        nodomain_20_notype: {
+          template: "user template B",
+          templateContent: {},
+          valid: true,
+        },
+      },
+    };
+    const props = { ...defaultProps, grantRequestsCart };
+    const renderOpts = {
+      state: { grantRequestsCart },
+      mocks: [
+        singleTemplateMock({ scope: "gr" }),
+        domainsMock({ action: "createForeignGrantRequest" }),
+      ],
+    };
+
+    const rendered = render(
+      <StructureGrantCartCheckout {...props} />,
+      renderOpts,
+    );
+    await waitForLoad(rendered);
+
+    expect(mockInitGroupTemplates).not.toHaveBeenCalled();
+  });
+
   it("sends user_group_id and not user_id on single checkout", async () => {
     const user = userEvent.setup({ delay: null });
     useWebContext.mockReturnValue({ scopesWithRelations: [] });
@@ -438,4 +507,109 @@ describe("StructureGrantCartCheckout", () => {
     expect(grant_request_group.user_group_id).toBe(10);
     expect(grant_request_group.user_id).toBeUndefined();
   });
+
+  it("preselects default template for groups without a system relation", async () => {
+    useWebContext.mockReturnValue({ scopesWithRelations: ["gr"] });
+    useTemplateRelations.mockReturnValue({
+      resource: [
+        { resource_id: 10, template_id: 1 },
+        { resource_id: 20, template_id: 2 },
+      ],
+      default: { template_id: 3 },
+    });
+    useTemplatesByIds.mockReturnValue({
+      1: { name: "foo", content: [] },
+      2: { name: "bar", content: [] },
+      3: { name: "baz", content: [] },
+    });
+    const grantRequestsCart = {
+      ...grantRequestsCartMultiGroup,
+      structures: [
+        ...grantRequestsCartMultiGroup.structures,
+        {
+          id: 301,
+          system_id: 30,
+          system: { id: 30, name: "foo system" },
+          domain_ids: [3],
+          domains: [{ id: 3, name: "foo domain" }],
+        },
+      ],
+    };
+    const props = {
+      ...defaultProps,
+      grantRequestsCart,
+    };
+    const renderOpts = {
+      state: { grantRequestsCart },
+      mocks: [
+        singleTemplateMock({ scope: "gr" }),
+        domainsMock({ action: "createForeignGrantRequest" }),
+      ],
+    };
+    const rendered = render(
+      <StructureGrantCartCheckout {...props} />,
+      renderOpts,
+    );
+    await waitForLoad(rendered);
+    expect(mockSelectGrantRequestTemplateForGroup).toHaveBeenCalledWith({
+      key: "nodomain_others_notype",
+      template: "baz",
+    });
+  });
+
+  it("preserves a selected template when revisiting a defaulted group", async () => {
+    useWebContext.mockReturnValue({ scopesWithRelations: ["gr"] });
+    useTemplateRelations.mockReturnValue({
+      resource: [
+        { resource_id: 10, template_id: 1 },
+        { resource_id: 20, template_id: 2 },
+      ],
+      default: { template_id: 3 },
+    });
+    useTemplatesByIds.mockReturnValue({
+      1: { name: "foo", content: [] },
+      2: { name: "bar", content: [] },
+      3: { name: "baz", content: [] },
+    });
+    const grantRequestsCart = {
+      ...grantRequestsCartMultiGroup,
+      structures: [
+        ...grantRequestsCartMultiGroup.structures,
+        {
+          id: 301,
+          system_id: 30,
+          system: { id: 30, name: "foo system" },
+          domain_ids: [3],
+          domains: [{ id: 3, name: "foo domain" }],
+        },
+      ],
+      groupTemplates: {
+        ...grantRequestsCartMultiGroup.groupTemplates,
+        nodomain_others_notype: {
+          template: "user selected template",
+          templateContent: {},
+          valid: true,
+        },
+      },
+    };
+    const props = { ...defaultProps, grantRequestsCart };
+    const renderOpts = {
+      state: { grantRequestsCart },
+      mocks: [
+        singleTemplateMock({ scope: "gr" }),
+        domainsMock({ action: "createForeignGrantRequest" }),
+      ],
+    };
+
+    const rendered = render(
+      <StructureGrantCartCheckout {...props} />,
+      renderOpts,
+    );
+    await waitForLoad(rendered);
+
+    expect(mockSelectGrantRequestTemplateForGroup).not.toHaveBeenCalledWith({
+      key: "nodomain_others_notype",
+      template: "baz",
+    });
+  });
 });