@truedat/dd 8.11.0 → 8.11.2

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

@@ -1,5 +1,7 @@
+import userEvent from "@testing-library/user-event";
 import { render, waitForLoad } from "@truedat/test/render";
 import { GrantRequest } from "../GrantRequest";
+import { createGrantRequestStatus, fetchGrantRequest } from "../../routines";
 
 describe("<GrantRequest />", () => {
   const grantRequest = {
@@ -97,4 +99,439 @@ describe("<GrantRequest />", () => {
     await waitForLoad(rendered);
     expect(rendered.container).toMatchSnapshot();
   });
+
+  it("shows user group alias when grant request is for a group", async () => {
+    const groupGrantRequest = {
+      ...grantRequest,
+      _embedded: {
+        ...grantRequest._embedded,
+        group: {
+          type: "request",
+          _embedded: {
+            user_group: { id: 10, name: "finance", alias: "Fin" },
+          },
+        },
+      },
+    };
+
+    const rendered = render(
+      <GrantRequest {...{ ...props, grantRequest: groupGrantRequest }} />,
+      renderOpts,
+    );
+    await waitForLoad(rendered);
+    expect(rendered.getByText(/fin/i)).toBeInTheDocument();
+  });
+
+  it("shows user group name when alias is empty", async () => {
+    const groupGrantRequest = {
+      ...grantRequest,
+      _embedded: {
+        ...grantRequest._embedded,
+        group: {
+          type: "request",
+          _embedded: {
+            user_group: { id: 11, name: "legal", alias: "" },
+          },
+        },
+      },
+    };
+
+    const rendered = render(
+      <GrantRequest {...{ ...props, grantRequest: groupGrantRequest }} />,
+      renderOpts,
+    );
+    await waitForLoad(rendered);
+    expect(rendered.getByText(/legal/i)).toBeInTheDocument();
+  });
+
+  it("shows cancel when current user created the group grant request", async () => {
+    const groupGrantRequest = {
+      ...grantRequest,
+      _embedded: {
+        ...grantRequest._embedded,
+        group: {
+          created_by_id: 7,
+          type: "request",
+          _embedded: {
+            user_group: { id: 10, name: "finance", alias: "Fin" },
+            created_by: { user_name: "ada" },
+          },
+        },
+      },
+    };
+
+    const rendered = render(
+      <GrantRequest {...{ ...props, grantRequest: groupGrantRequest }} />,
+      {
+        ...renderOpts,
+        state: { authentication: { user_name: "ada" } },
+      },
+    );
+    await waitForLoad(rendered);
+    expect(rendered.getByText(/cancel/i)).toBeInTheDocument();
+  });
+
+  it("does not show cancel when current user is a group member and not the creator", async () => {
+    const groupGrantRequest = {
+      ...grantRequest,
+      _embedded: {
+        ...grantRequest._embedded,
+        group: {
+          created_by_id: 7,
+          type: "request",
+          _embedded: {
+            user_group: { id: 10, name: "finance", alias: "Fin" },
+            created_by: { user_name: "ada" },
+          },
+        },
+      },
+    };
+
+    const rendered = render(
+      <GrantRequest {...{ ...props, grantRequest: groupGrantRequest }} />,
+      {
+        ...renderOpts,
+        state: { authentication: { user_name: "bob" } },
+      },
+    );
+    await waitForLoad(rendered);
+    expect(rendered.queryByText(/cancel/i)).not.toBeInTheDocument();
+  });
+
+  it("shows cancel when grant request is for a user", async () => {
+    const rendered = render(<GrantRequest {...props} />, renderOpts);
+    await waitForLoad(rendered);
+    expect(rendered.getByText(/cancel/i)).toBeInTheDocument();
+  });
+
+  it("shows accordion with group members when grant request is for a group", async () => {
+    const user = userEvent.setup({ delay: null });
+    const groupGrantRequest = {
+      ...grantRequest,
+      _embedded: {
+        ...grantRequest._embedded,
+        group: {
+          type: "request",
+          _embedded: {
+            user_group: {
+              id: 10,
+              name: "finance",
+              alias: "Fin",
+              users: [
+                { id: 1, user_name: "ada", full_name: "Ada Lovelace" },
+                { id: 2, user_name: "bob", full_name: "Bob Smith" },
+              ],
+            },
+          },
+        },
+      },
+    };
+
+    const rendered = render(
+      <GrantRequest {...{ ...props, grantRequest: groupGrantRequest }} />,
+      renderOpts,
+    );
+    await waitForLoad(rendered);
+
+    const item = rendered.getByText(/fin/i).closest(".item");
+    expect(item.querySelector(".angle.right.icon")).toBeInTheDocument();
+    await user.click(item.querySelector(".angle.right.icon"));
+    expect(item.querySelector(".angle.down.icon")).toBeInTheDocument();
+    expect(rendered.getByText(/ada lovelace/i)).toBeInTheDocument();
+    expect(rendered.getByText(/bob smith/i)).toBeInTheDocument();
+  });
+
+  it("shows accordion when grant request is for a group with no members", async () => {
+    const user = userEvent.setup({ delay: null });
+    const groupGrantRequest = {
+      ...grantRequest,
+      _embedded: {
+        ...grantRequest._embedded,
+        group: {
+          type: "request",
+          _embedded: {
+            user_group: { id: 11, name: "legal", alias: "", users: [] },
+          },
+        },
+      },
+    };
+
+    const rendered = render(
+      <GrantRequest {...{ ...props, grantRequest: groupGrantRequest }} />,
+      renderOpts,
+    );
+    await waitForLoad(rendered);
+
+    const item = rendered.getByText(/legal/i).closest(".item");
+    expect(item.querySelector(".angle.right.icon")).toBeInTheDocument();
+    await user.click(item.querySelector(".angle.right.icon"));
+    expect(item.querySelector(".angle.down.icon")).toBeInTheDocument();
+    expect(rendered.queryByText(/ada/i)).not.toBeInTheDocument();
+  });
+
+  it("does not show accordion when grant request is for a user", async () => {
+    const rendered = render(<GrantRequest {...props} />, renderOpts);
+    await waitForLoad(rendered);
+
+    expect(
+      rendered.container.querySelector(".angle.right.icon:not(.divider)"),
+    ).not.toBeInTheDocument();
+    expect(
+      rendered.container.querySelector(".angle.down.icon"),
+    ).not.toBeInTheDocument();
+  });
+
+  it("cancelling from the detail refetches the grant request", async () => {
+    const user = userEvent.setup({ delay: null });
+    const dispatch = jest.fn();
+    const rendered = render(<GrantRequest {...props} />, {
+      ...renderOpts,
+      dispatch,
+    });
+    await waitForLoad(rendered);
+
+    await user.click(rendered.getByText(/cancel_grant_request/i));
+    await user.click(
+      rendered.getByRole("button", { name: /modal-affirmative-action/i }),
+    );
+
+    const cancelAction = dispatch.mock.calls.find(
+      ([action]) => action.type === createGrantRequestStatus().type,
+    );
+    const { onSuccess } = cancelAction[0].payload;
+    onSuccess();
+    expect(dispatch).toHaveBeenLastCalledWith({
+      ...fetchGrantRequest(),
+      payload: { id: grantRequest.id },
+    });
+  });
+
+  it("shows a single translated full name column in the group members accordion", async () => {
+    const user = userEvent.setup({ delay: null });
+    const groupGrantRequest = {
+      ...grantRequest,
+      _embedded: {
+        ...grantRequest._embedded,
+        group: {
+          type: "request",
+          _embedded: {
+            user_group: {
+              id: 10,
+              name: "finance",
+              alias: "Fin",
+              users: [
+                { id: 1, user_name: "foo", full_name: "foo user" },
+                { id: 2, user_name: "bar", full_name: "bar user" },
+              ],
+            },
+          },
+        },
+      },
+    };
+
+    const rendered = render(
+      <GrantRequest {...{ ...props, grantRequest: groupGrantRequest }} />,
+      {
+        ...renderOpts,
+        messages: {
+          en: {
+            "grantRequests.props.user_full_name": "User",
+          },
+        },
+      },
+    );
+    await waitForLoad(rendered);
+
+    const item = rendered.getByText(/fin/i).closest(".item");
+    await user.click(item.querySelector(".angle.right.icon"));
+    const membersTable = item.querySelector("table");
+    expect(membersTable).toBeInTheDocument();
+    expect(rendered.queryByText(/^user_name$/i)).not.toBeInTheDocument();
+    expect(rendered.queryByText(/^full_name$/i)).not.toBeInTheDocument();
+    expect(rendered.getByText(/^user$/i)).toBeInTheDocument();
+    expect(rendered.getByText(/foo user/i)).toBeInTheDocument();
+    expect(rendered.getByText(/bar user/i)).toBeInTheDocument();
+    expect(membersTable.querySelectorAll("th")).toHaveLength(1);
+    expect(membersTable.querySelectorAll("td")).toHaveLength(2);
+  });
+
+  it("shows a compact collapsing small members table in the group accordion", async () => {
+    const user = userEvent.setup({ delay: null });
+    const groupGrantRequest = {
+      ...grantRequest,
+      _embedded: {
+        ...grantRequest._embedded,
+        group: {
+          type: "request",
+          _embedded: {
+            user_group: {
+              id: 10,
+              name: "finance",
+              alias: "Fin",
+              users: [{ id: 1, user_name: "foo", full_name: "foo user" }],
+            },
+          },
+        },
+      },
+    };
+
+    const rendered = render(
+      <GrantRequest {...{ ...props, grantRequest: groupGrantRequest }} />,
+      renderOpts,
+    );
+    await waitForLoad(rendered);
+
+    const item = rendered.getByText(/fin/i).closest(".item");
+    await user.click(item.querySelector(".angle.right.icon"));
+    const membersTable = item.querySelector("table");
+    expect(membersTable).toBeInTheDocument();
+    expect(membersTable).toHaveClass("compact");
+    expect(membersTable).toHaveClass("collapsing");
+    expect(membersTable).toHaveClass("small");
+  });
+
+  it("shows User as the beneficiary field title for a user grant request", async () => {
+    const userGrantRequest = {
+      ...grantRequest,
+      _embedded: {
+        ...grantRequest._embedded,
+        group: {
+          type: "request",
+          _embedded: {
+            user: { user_name: "foo user" },
+          },
+        },
+      },
+    };
+
+    const rendered = render(
+      <GrantRequest {...{ ...props, grantRequest: userGrantRequest }} />,
+      {
+        ...renderOpts,
+        messages: {
+          en: {
+            "grantRequest.header.user": "User",
+            "grantRequest.header.group": "User group",
+          },
+        },
+      },
+    );
+    await waitForLoad(rendered);
+
+    const item = rendered.getByText(/^foo user$/i).closest(".item");
+    expect(item.querySelector(".header")).toHaveTextContent(/^user$/i);
+    expect(item.querySelector(".header")).not.toHaveTextContent(/user group/i);
+  });
+
+  it("shows User group as the beneficiary field title for a group grant request", async () => {
+    const groupGrantRequest = {
+      ...grantRequest,
+      _embedded: {
+        ...grantRequest._embedded,
+        group: {
+          type: "request",
+          _embedded: {
+            user_group: {
+              id: 10,
+              name: "finance",
+              alias: "Fin",
+              users: [{ id: 1, user_name: "foo", full_name: "foo user" }],
+            },
+          },
+        },
+      },
+    };
+
+    const rendered = render(
+      <GrantRequest {...{ ...props, grantRequest: groupGrantRequest }} />,
+      {
+        ...renderOpts,
+        messages: {
+          en: {
+            "grantRequest.header.user": "User/group",
+            "grantRequest.header.group": "User group",
+          },
+        },
+      },
+    );
+    await waitForLoad(rendered);
+
+    const item = rendered.getByText(/fin/i).closest(".item");
+    expect(item.querySelector(".header")).toHaveTextContent(/^user group$/i);
+    expect(item.querySelector(".header")).not.toHaveTextContent(/user\/group/i);
+  });
+
+  it("shows Deleted user when the beneficiary user is missing", async () => {
+    const deletedUserGrantRequest = {
+      ...grantRequest,
+      _embedded: {
+        ...grantRequest._embedded,
+        group: {
+          type: "request",
+          _embedded: {},
+        },
+      },
+    };
+
+    const rendered = render(
+      <GrantRequest {...{ ...props, grantRequest: deletedUserGrantRequest }} />,
+      {
+        ...renderOpts,
+        messages: {
+          en: {
+            "grantRequest.header.user": "User",
+            "grantRequest.header.group": "User group",
+            "grantRequest.deleted.user": "Deleted user",
+            "grantRequest.deleted.group": "Deleted group",
+          },
+        },
+      },
+    );
+    await waitForLoad(rendered);
+
+    const item = rendered.getByText(/^deleted user$/i).closest(".item");
+    expect(item.querySelector(".header")).toHaveTextContent(/^user$/i);
+    expect(item.querySelector(".header")).not.toHaveTextContent(/user group/i);
+    expect(item.querySelector(".angle.right.icon")).not.toBeInTheDocument();
+    expect(item.querySelector(".angle.down.icon")).not.toBeInTheDocument();
+  });
+
+  it("shows Deleted group without accordion when the beneficiary group is missing", async () => {
+    const deletedGroupGrantRequest = {
+      ...grantRequest,
+      _embedded: {
+        ...grantRequest._embedded,
+        group: {
+          type: "request",
+          user_group_id: 10,
+          _embedded: {},
+        },
+      },
+    };
+
+    const rendered = render(
+      <GrantRequest
+        {...{ ...props, grantRequest: deletedGroupGrantRequest }}
+      />,
+      {
+        ...renderOpts,
+        messages: {
+          en: {
+            "grantRequest.header.user": "User",
+            "grantRequest.header.group": "User group",
+            "grantRequest.deleted.user": "Deleted user",
+            "grantRequest.deleted.group": "Deleted group",
+          },
+        },
+      },
+    );
+    await waitForLoad(rendered);
+
+    const item = rendered.getByText(/^deleted group$/i).closest(".item");
+    expect(item.querySelector(".header")).toHaveTextContent(/^user group$/i);
+    expect(item.querySelector(".header")).not.toHaveTextContent(/^user$/i);
+    expect(item.querySelector(".angle.right.icon")).not.toBeInTheDocument();
+    expect(item.querySelector(".angle.down.icon")).not.toBeInTheDocument();
+    expect(item.querySelector("table")).not.toBeInTheDocument();
+  });
 });

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

@@ -1,6 +1,10 @@
 import { Suspense } from "react";
-import { render } from "@truedat/test/render";
-import { GrantRequestHeader } from "../GrantRequestHeader";
+import userEvent from "@testing-library/user-event";
+import { render, waitForLoad } from "@truedat/test/render";
+import ConnectedGrantRequestHeader, {
+  GrantRequestHeader,
+} from "../GrantRequestHeader";
+import { createGrantRequestStatus, fetchGrantRequest } from "../../routines";
 import en from "../../messages/en";
 
 describe("<GrantRequestHeader />", () => {
@@ -31,4 +35,87 @@ describe("<GrantRequestHeader />", () => {
     );
     expect(container).toMatchSnapshot();
   });
+
+  it("cancelling refetches the grant request", async () => {
+    const user = userEvent.setup({ delay: null });
+    const dispatch = jest.fn();
+    const grantRequest = {
+      id: 8,
+      status: "pending",
+      _embedded: { data_structure: { id: 3 } },
+    };
+
+    const rendered = render(<ConnectedGrantRequestHeader />, {
+      ...renderOpts,
+      state: { grantRequest },
+      dispatch,
+    });
+    await waitForLoad(rendered);
+
+    await user.click(rendered.getByText(/cancel request/i));
+    await user.click(
+      rendered.getByRole("button", { name: /modal-affirmative-action/i }),
+    );
+
+    const cancelAction = dispatch.mock.calls.find(
+      ([action]) => action.type === createGrantRequestStatus().type,
+    );
+    const { onSuccess } = cancelAction[0].payload;
+    expect(onSuccess).toBeDefined();
+    onSuccess();
+    expect(dispatch).toHaveBeenLastCalledWith({
+      ...fetchGrantRequest(),
+      payload: { id: grantRequest.id },
+    });
+  });
+
+  it("shows cancel button when status is pending", async () => {
+    const grantRequest = { status: "pending" };
+    const rendered = render(<GrantRequestHeader grantRequest={grantRequest} />);
+    await waitForLoad(rendered);
+    expect(rendered.getByText(/cancel_grant_request/i)).toBeInTheDocument();
+  });
+
+  it("shows cancel button when status is approved", async () => {
+    const grantRequest = { status: "approved" };
+    const rendered = render(<GrantRequestHeader grantRequest={grantRequest} />);
+    await waitForLoad(rendered);
+    expect(rendered.getByText(/cancel_grant_request/i)).toBeInTheDocument();
+  });
+
+  it("does not show cancel button when status is rejected", async () => {
+    const grantRequest = { status: "rejected" };
+    const rendered = render(<GrantRequestHeader grantRequest={grantRequest} />);
+    await waitForLoad(rendered);
+    expect(
+      rendered.queryByText(/cancel_grant_request/i),
+    ).not.toBeInTheDocument();
+  });
+
+  it("does not show cancel button when status is processing", async () => {
+    const grantRequest = { status: "processing" };
+    const rendered = render(<GrantRequestHeader grantRequest={grantRequest} />);
+    await waitForLoad(rendered);
+    expect(
+      rendered.queryByText(/cancel_grant_request/i),
+    ).not.toBeInTheDocument();
+  });
+
+  it("does not show cancel button when status is cancelled", async () => {
+    const grantRequest = { status: "cancelled" };
+    const rendered = render(<GrantRequestHeader grantRequest={grantRequest} />);
+    await waitForLoad(rendered);
+    expect(
+      rendered.queryByText(/cancel_grant_request/i),
+    ).not.toBeInTheDocument();
+  });
+
+  it("does not show cancel button when status is failed", async () => {
+    const grantRequest = { status: "failed" };
+    const rendered = render(<GrantRequestHeader grantRequest={grantRequest} />);
+    await waitForLoad(rendered);
+    expect(
+      rendered.queryByText(/cancel_grant_request/i),
+    ).not.toBeInTheDocument();
+  });
 });

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

@@ -1,4 +1,5 @@
 import { render, waitForLoad } from "@truedat/test/render";
+import userEvent from "@testing-library/user-event";
 import { screen } from "@testing-library/react";
 import SearchContext from "@truedat/core/search/SearchContext";
 import { GrantRequestsDownloadButton } from "../GrantRequestsDownloadButton";
@@ -195,4 +196,55 @@ describe("<GrantRequestsDownloadButton />", () => {
       }),
     );
   });
+
+  it("sends User / Group in header_labels for user_full_name", async () => {
+    const triggerMock = jest.fn();
+    const grantRequestHook = require("@truedat/dd/hooks/useGrantRequest");
+    grantRequestHook.useGrantRequestsDownload.mockReturnValue({
+      trigger: triggerMock,
+      isMutating: false,
+    });
+
+    const props = {
+      hasFilterApplied: true,
+      searchBy: "approve",
+      setDownloading: jest.fn(),
+    };
+
+    const rendered = render(
+      <SearchContext value={buildSearchContext({ status: ["pending"] })}>
+        <GrantRequestsDownloadButton {...props} />
+      </SearchContext>,
+      {
+        messages: {
+          en: {
+            "grantRequest.actions.download.tooltip": "Descargar / Download",
+            "grantRequest.actions.download.popup":
+              "Search or apply a filter to download grant requests",
+            "grantRequests.props.current_status": "Status",
+            "grantRequests.props.user_full_name": "User/group",
+            "grantRequests.props.user_or_group": "User / Group",
+            "grantRequests.props.created_by_full_name": "Created by",
+            "grantRequests.props.structure_external_id": "Structure",
+            "grantRequests.props.domains": "Domains",
+            "grantRequests.props.system_name": "System",
+            "grantRequests.props.structure_path": "Path",
+            "grantRequests.props.request_type": "Request type",
+          },
+        },
+      },
+    );
+
+    await waitForLoad(rendered);
+    const user = userEvent.setup({ delay: null });
+    await user.click(await rendered.findByRole("button"));
+
+    expect(triggerMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        header_labels: expect.objectContaining({
+          user_full_name: "User / Group",
+        }),
+      }),
+    );
+  });
 });

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

@@ -49,4 +49,22 @@ describe("<GrantRequestsTable />", () => {
     );
     expect(container).toMatchSnapshot();
   });
+
+  it("shows User / Group header for the user column", () => {
+    const rendered = render(
+      <SearchContext value={searchContext}>
+        <GrantRequestsTable {...props} />
+      </SearchContext>,
+      {
+        messages: {
+          en: {
+            "grantRequest.current_status.pending": "pending",
+            "grantRequest.header.user": "User/group",
+            "grantRequests.props.user_or_group": "User / Group",
+          },
+        },
+      },
+    );
+    expect(rendered.getByText(/user \/ group/i)).toBeInTheDocument();
+  });
 });

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

@@ -1,3 +1,4 @@
+import userEvent from "@testing-library/user-event";
 import { render, waitForLoad } from "@truedat/test/render";
 import { singleTemplateMock, domainsMock } from "@truedat/test/mocks";
 import { StructureGrantCartCheckout } from "../StructureGrantCartCheckout";
@@ -397,4 +398,44 @@ describe("StructureGrantCartCheckout", () => {
     });
     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: [] });
+    useTemplateRelations.mockReturnValue({ resource: [] });
+
+    const grantRequestsCartUserGroup = {
+      template: "some_template",
+      templateContent: {},
+      modificationGrant: null,
+      validCart: true,
+      user: { id: null, valid: true },
+      user_group_id: 10,
+      structures: [
+        {
+          id: 101,
+          system_id: 10,
+          system: { id: 10, name: "System A" },
+          domain_ids: [1],
+        },
+      ],
+    };
+
+    const props = {
+      ...defaultProps,
+      grantRequestsCart: grantRequestsCartUserGroup,
+    };
+
+    const rendered = render(
+      <StructureGrantCartCheckout {...props} />,
+      renderOpts,
+    );
+    await waitForLoad(rendered);
+    await user.click(rendered.getByText(/save/i));
+
+    expect(mockTrigger).toHaveBeenCalled();
+    const [{ grant_request_group }] = mockTrigger.mock.calls[0];
+    expect(grant_request_group.user_group_id).toBe(10);
+    expect(grant_request_group.user_id).toBeUndefined();
+  });
 });