@truedat/dd 8.12.1 → 8.12.4

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

@@ -1,6 +1,7 @@
 import userEvent from "@testing-library/user-event";
 import { render, waitForLoad } from "@truedat/test/render";
 import { singleTemplateMock, domainsMock } from "@truedat/test/mocks";
+import { DOMAINS_QUERY, FUNCTIONS_QUERY } from "@truedat/core/api/queries";
 import { StructureGrantCartCheckout } from "../StructureGrantCartCheckout";
 
 jest.mock("@truedat/core/webContext", () => ({
@@ -23,6 +24,10 @@ jest.mock("@truedat/auth/hooks/useUsers", () => ({
   useGrantRequestableUsers: jest.fn(),
 }));
 
+jest.mock("@truedat/auth/hooks/useRoles", () => ({
+  useRoles: () => ({ data: undefined }),
+}));
+
 jest.mock("react-redux", () => {
   const actual = jest.requireActual("react-redux");
   return {
@@ -177,15 +182,28 @@ const grantRequestsCartSingleDomain = {
 };
 
 describe("StructureGrantCartCheckout", () => {
+  const domainQueryErrorMock = {
+    request: {
+      query: DOMAINS_QUERY,
+      variables: { action: "createForeignGrantRequest" },
+    },
+    error: new Error("Domains are not used by this checkout test"),
+  };
+  const functionsQueryErrorMock = {
+    request: { query: FUNCTIONS_QUERY },
+    error: new Error("Functions are not used by this checkout test"),
+  };
   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,
@@ -206,7 +224,11 @@ describe("StructureGrantCartCheckout", () => {
 
   const variables = { scope: "gr" };
   const renderOpts = {
-    mocks: [singleTemplateMock(variables)],
+    mocks: [
+      singleTemplateMock(variables),
+      functionsQueryErrorMock,
+      domainQueryErrorMock,
+    ],
   };
 
   it("matches snapshot when modification grant (single flow)", async () => {
@@ -220,6 +242,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: [] });
@@ -248,6 +292,8 @@ describe("StructureGrantCartCheckout", () => {
       mocks: [
         singleTemplateMock({ scope: "gr" }),
         domainsMock({ action: "createForeignGrantRequest" }),
+        functionsQueryErrorMock,
+        domainQueryErrorMock,
       ],
     };
     const rendered = render(
@@ -273,6 +319,8 @@ describe("StructureGrantCartCheckout", () => {
       mocks: [
         singleTemplateMock({ scope: "gr" }),
         domainsMock({ action: "createForeignGrantRequest" }),
+        functionsQueryErrorMock,
+        domainQueryErrorMock,
       ],
     };
     const rendered = render(
@@ -300,6 +348,8 @@ describe("StructureGrantCartCheckout", () => {
       mocks: [
         singleTemplateMock({ scope: "gr" }),
         domainsMock({ action: "createForeignGrantRequest" }),
+        functionsQueryErrorMock,
+        domainQueryErrorMock,
       ],
     };
     const rendered = render(
@@ -324,6 +374,8 @@ describe("StructureGrantCartCheckout", () => {
       mocks: [
         singleTemplateMock({ scope: "gr" }),
         domainsMock({ action: "createForeignGrantRequest" }),
+        functionsQueryErrorMock,
+        domainQueryErrorMock,
       ],
     };
     const rendered = render(
@@ -334,7 +386,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 }],
@@ -349,6 +401,8 @@ describe("StructureGrantCartCheckout", () => {
       mocks: [
         singleTemplateMock({ scope: "gr" }),
         domainsMock({ action: "createForeignGrantRequest" }),
+        functionsQueryErrorMock,
+        domainQueryErrorMock,
       ],
     };
     const rendered = render(
@@ -371,15 +425,21 @@ 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" }),
+        functionsQueryErrorMock,
+        domainQueryErrorMock,
       ],
     };
     const rendered = render(
@@ -399,6 +459,49 @@ 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" }),
+        functionsQueryErrorMock,
+        domainQueryErrorMock,
+      ],
+    };
+
+    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 +541,113 @@ 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" }),
+        functionsQueryErrorMock,
+        domainQueryErrorMock,
+      ],
+    };
+    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" }),
+        functionsQueryErrorMock,
+        domainQueryErrorMock,
+      ],
+    };
+
+    const rendered = render(
+      <StructureGrantCartCheckout {...props} />,
+      renderOpts,
+    );
+    await waitForLoad(rendered);
+
+    expect(mockSelectGrantRequestTemplateForGroup).not.toHaveBeenCalledWith({
+      key: "nodomain_others_notype",
+      template: "baz",
+    });
+  });
 });

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

@@ -1,5 +1,5 @@
 import { render, waitForLoad } from "@truedat/test/render";
-import { singleTemplateMock } from "@truedat/test/mocks";
+import { singleTemplateMock, domainsMock } from "@truedat/test/mocks";
 import { StructureGrantCartInformation } from "../StructureGrantCartInformation";
 
 jest.mock("@truedat/auth/hooks/useRoles", () => {
@@ -38,7 +38,10 @@ describe("<StructureGrantCartInformation />", () => {
   };
 
   const renderOpts = {
-    mocks: [singleTemplateMock(variables)],
+    mocks: [
+      singleTemplateMock(variables),
+      domainsMock({ action: "createForeignGrantRequest" }, []),
+    ],
   };
 
   it("matches the latest snapshot", async () => {

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

@@ -4,6 +4,10 @@ import { render, waitForLoad } from "@truedat/test/render";
 import { useGrantRequestableUsers } from "@truedat/auth/hooks/useUsers";
 import StructureGrantCartUserSelector from "../StructureGrantCartUserSelector";
 
+jest.mock("@truedat/auth/hooks/useRoles", () => ({
+  useRoles: () => ({ data: undefined }),
+}));
+
 jest.mock("@truedat/auth/hooks/useUsers", () => ({
   useGrantRequestableUsers: jest.fn(() => ({
     users: [
@@ -179,4 +183,128 @@ describe("<StructureGrantCartUserSelector />", () => {
     );
     expect(payloads.some((payload) => payload?.id === "group:10")).toBe(false);
   });
+
+  it("preselects user group when modificationGrant has user_group_id", async () => {
+    const dispatch = jest.fn();
+    useGrantRequestableUsers.mockImplementation(() => ({
+      users: [{ id: 1, full_name: "foo user" }],
+      groups: [{ id: 10, name: "foo", alias: "bar" }],
+      trigger: jest.fn(),
+    }));
+
+    const rendered = render(<StructureGrantCartUserSelector />, {
+      state: {
+        grantRequestsCart: {
+          modificationGrant: {
+            user_group_id: 10,
+            user_group: { id: 10, name: "foo", alias: "bar" },
+            user_id: null,
+          },
+        },
+      },
+      dispatch,
+    });
+    await waitForLoad(rendered);
+
+    await waitFor(() => {
+      const payloads = dispatch.mock.calls.map(
+        ([action]) => action?.payload ?? action,
+      );
+      expect(payloads.some((payload) => payload?.user_group_id === 10)).toBe(
+        true,
+      );
+    });
+  });
+
+  it("shows group alias in the modification header", async () => {
+    const rendered = render(<StructureGrantCartUserSelector />, {
+      state: {
+        grantRequestsCart: {
+          modificationGrant: {
+            user_group_id: 10,
+            user_group: { id: 10, alias: "bar", name: "foo" },
+            user_id: null,
+          },
+        },
+      },
+      messages: {
+        en: {
+          "grantRequestCart.user.label": "Request for:",
+        },
+      },
+    });
+    await waitForLoad(rendered);
+
+    expect(rendered.getByText(/bar/i)).toBeInTheDocument();
+    expect(rendered.queryByText(/undefined/i)).not.toBeInTheDocument();
+  });
+
+  it("shows group name in the modification header when alias is empty", async () => {
+    const rendered = render(<StructureGrantCartUserSelector />, {
+      state: {
+        grantRequestsCart: {
+          modificationGrant: {
+            user_group_id: 10,
+            user_group: { id: 10, alias: "", name: "foo" },
+            user_id: null,
+          },
+        },
+      },
+      messages: {
+        en: {
+          "grantRequestCart.user.label": "Request for:",
+        },
+      },
+    });
+    await waitForLoad(rendered);
+
+    expect(rendered.getByText(/foo/i)).toBeInTheDocument();
+    expect(rendered.queryByText(/bar/i)).not.toBeInTheDocument();
+    expect(rendered.queryByText(/undefined/i)).not.toBeInTheDocument();
+  });
+
+  it("shows deleted group in the modification header when the group is missing", async () => {
+    const rendered = render(<StructureGrantCartUserSelector />, {
+      state: {
+        grantRequestsCart: {
+          modificationGrant: {
+            user_group_id: 10,
+            user_group: null,
+            user_id: null,
+          },
+        },
+      },
+      messages: {
+        en: {
+          "grantRequestCart.user.label": "Request for:",
+          "deleted.group": "Deleted group",
+        },
+      },
+    });
+    await waitForLoad(rendered);
+
+    expect(rendered.getByText(/deleted group/i)).toBeInTheDocument();
+    expect(rendered.queryByText(/undefined/i)).not.toBeInTheDocument();
+  });
+
+  it("shows user full name in the modification header for a personal grant", async () => {
+    const rendered = render(<StructureGrantCartUserSelector />, {
+      state: {
+        grantRequestsCart: {
+          modificationGrant: {
+            user: { full_name: "foo user" },
+          },
+        },
+      },
+      messages: {
+        en: {
+          "grantRequestCart.user.label": "Request for:",
+        },
+      },
+    });
+    await waitForLoad(rendered);
+
+    expect(rendered.getByText(/foo user/i)).toBeInTheDocument();
+    expect(rendered.queryByText(/undefined/i)).not.toBeInTheDocument();
+  });
 });

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

@@ -276,4 +276,96 @@ describe("<StructureGrantDropdown />", () => {
       rendered.getByText(/grant.actions.viewrequest.confirmation.header/i),
     ).toBeInTheDocument();
   });
+
+  it("shows users icon and change action for active group grant", async () => {
+    const user = userEvent.setup({ delay: null });
+    const grant = {
+      pending_removal: false,
+      user_group_id: 10,
+      user_group: { id: 10, name: "foo", alias: "bar" },
+    };
+    const props = {
+      ...propsBuilder(grant),
+      grantRequest: null,
+      grantRequestStatus: null,
+    };
+    const rendered = render(<StructureGrantDropdown {...props} />);
+    await waitForLoad(rendered);
+
+    expect(
+      rendered.container.querySelector(".button.group-actions .users.icon"),
+    ).not.toBeInTheDocument();
+
+    fireEvent.mouseOver(await rendered.findByRole("listbox"));
+    expect(
+      await rendered.findByText(/structure.grant.has_grant/i),
+    ).toBeInTheDocument();
+    expect(
+      rendered.baseElement.querySelector(".users.icon"),
+    ).toBeInTheDocument();
+
+    await user.click(await rendered.findByRole("listbox"));
+    expect(
+      rendered.getByText(/structure.grant.request_grant_change/i),
+    ).toBeInTheDocument();
+  });
+
+  it("shows users icon in popup for pending group grant request", async () => {
+    const grantRequest = {
+      group: {
+        user_group_id: 10,
+        _embedded: {
+          user_group: { id: 10, name: "foo" },
+        },
+      },
+    };
+    const props = {
+      ...propsBuilder(null),
+      grantRequest,
+      grantRequestStatus: "pending",
+    };
+    const rendered = render(<StructureGrantDropdown {...props} />, {
+      state: { authentication: { user_name: "foo" } },
+    });
+    await waitForLoad(rendered);
+
+    expect(
+      rendered.container.querySelector(".button.group-actions .users.icon"),
+    ).not.toBeInTheDocument();
+
+    fireEvent.mouseOver(await rendered.findByRole("listbox"));
+    expect(
+      await rendered.findByText(/structure.grant.requested_access/i),
+    ).toBeInTheDocument();
+    expect(
+      rendered.baseElement.querySelector(".users.icon"),
+    ).toBeInTheDocument();
+  });
+
+  it("shows users icon in popup for active group grant", async () => {
+    const grant = {
+      pending_removal: false,
+      user_group_id: 10,
+      user_group: { id: 10, name: "foo", alias: "bar" },
+    };
+    const props = {
+      ...propsBuilder(grant),
+      grantRequest: null,
+      grantRequestStatus: null,
+    };
+    const rendered = render(<StructureGrantDropdown {...props} />);
+    await waitForLoad(rendered);
+
+    expect(
+      rendered.container.querySelector(".button.group-actions .users.icon"),
+    ).not.toBeInTheDocument();
+
+    fireEvent.mouseOver(await rendered.findByRole("listbox"));
+    expect(
+      await rendered.findByText(/structure.grant.has_grant/i),
+    ).toBeInTheDocument();
+    expect(
+      rendered.baseElement.querySelector(".users.icon"),
+    ).toBeInTheDocument();
+  });
 });

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

@@ -1,4 +1,5 @@
 import userEvent from "@testing-library/user-event";
+import { fireEvent } from "@testing-library/react";
 import { render, waitForLoad } from "@truedat/test/render";
 import SearchContextWrapper from "@truedat/core/components/common/SearchContextWrapper";
 import StructureGrantListButton from "../StructureGrantListButton";
@@ -117,4 +118,73 @@ describe("<StructureGrantListButton />", () => {
     onSuccess();
     expect(refreshSearch).toHaveBeenCalled();
   });
+
+  it("shows users icon in popup for group grant in my_grants", async () => {
+    const groupStructure = {
+      ...structure,
+      my_grants: [
+        {
+          id: 2,
+          user_group_id: 10,
+          user_group: { id: 10, name: "foo" },
+        },
+      ],
+    };
+
+    const rendered = render(
+      <SearchContextWrapper props={searchProps}>
+        <StructureGrantListButton structure={groupStructure} />
+      </SearchContextWrapper>,
+      renderOpts,
+    );
+    await waitForLoad(rendered);
+
+    expect(
+      rendered.container.querySelector(".button.group-actions .users.icon"),
+    ).not.toBeInTheDocument();
+
+    fireEvent.mouseOver(await rendered.findByRole("listbox"));
+    expect(
+      await rendered.findByText(/structure.grant.has_grant/i),
+    ).toBeInTheDocument();
+    expect(
+      rendered.baseElement.querySelector(".users.icon"),
+    ).toBeInTheDocument();
+  });
+
+  it("shows users icon in popup for pending group grant request in my_grant_request", async () => {
+    const pendingGroupStructure = {
+      ...structure,
+      my_grant_request: {
+        status: "pending",
+        _embedded: { group: { user_group_id: 10 } },
+      },
+    };
+
+    const rendered = render(
+      <SearchContextWrapper props={searchProps}>
+        <StructureGrantListButton structure={pendingGroupStructure} />
+      </SearchContextWrapper>,
+      {
+        ...renderOpts,
+        state: {
+          ...renderOpts.state,
+          authentication: { user_name: "foo" },
+        },
+      },
+    );
+    await waitForLoad(rendered);
+
+    expect(
+      rendered.container.querySelector(".button.group-actions .users.icon"),
+    ).not.toBeInTheDocument();
+
+    fireEvent.mouseOver(await rendered.findByRole("listbox"));
+    expect(
+      await rendered.findByText(/structure.grant.requested_access/i),
+    ).toBeInTheDocument();
+    expect(
+      rendered.baseElement.querySelector(".users.icon"),
+    ).toBeInTheDocument();
+  });
 });