@truedat/auth 8.14.3 → 8.14.4

package/src/users/components/__tests__/Password.spec.js

@@ -1,158 +1,65 @@
-import { waitFor } from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
-import { MemoryRouter } from "react-router";
-import { renderWithIntl } from "@truedat/test/renderWithIntl";
-import { Password } from "../Password";
-
-const render = (component) =>
-  renderWithIntl(<MemoryRouter>{component}</MemoryRouter>);
+import { fireEvent, waitFor } from "@testing-library/react";
+import { Routes, Route } from "react-router";
+import { render } from "@truedat/test/render";
+import Password from "../Password";
+import { updatePassword } from "../../routines";
 
 describe("<Password />", () => {
-  beforeEach(() => jest.useRealTimers());
-
-  const updatePassword = jest.fn();
-
-  it("matches the latest snapshot", async () => {
-    const props = {};
-    const rendered = render(<Password {...props} />);
-    await waitFor(() => expect(rendered.container).toMatchSnapshot());
-  });
-
-  it("calls updatePassword for non admin user", async () => {
-    const props = { userName: "joe", authUserName: "joe", updatePassword };
-    const rendered = render(<Password {...props} />);
-    const user = userEvent.setup({ delay: null });
-
-    // Submit button should initially be disabled
-    await waitFor(() =>
-      expect(rendered.getByRole("button", { name: /save/i })).toBeDisabled(),
-    );
-
-    await user.type(
-      rendered.getByLabelText(/user.password.current/i, { selector: "input" }),
-      "oldPassword",
-    );
-    await user.type(
-      rendered.getByLabelText(/user.password.new_password/i, {
-        selector: "input",
-      }),
-      "Va1id.pa$$w0rd!",
-    );
-    await user.type(
-      rendered.getByLabelText(/login.form.re_password.label/i, {
-        selector: "input",
-      }),
-      "Va1id.pa$$w0rd!",
-    );
-
-    await waitFor(() =>
-      expect(
-        rendered.getByRole("button", { name: /save/i }),
-      ).not.toBeDisabled(),
-    );
-
-    // Submit
-    await user.click(await rendered.findByRole("button", { name: /save/i }));
-
-    await waitFor(() =>
-      expect(updatePassword).toHaveBeenCalledWith({
-        user: {
-          old_password: "oldPassword",
-          new_password: "Va1id.pa$$w0rd!",
-        },
-      }),
-    );
-  });
-
-  it("calls updatePassword for admin user", async () => {
-    const props = {
-      id: 42,
-      userName: "joe",
-      authUserName: "bob",
-      updatePassword,
-    };
-    const rendered = render(<Password {...props} />);
-    const user = userEvent.setup({ delay: null });
-
-    // Submit button should initially be disabled
-    await waitFor(() =>
-      expect(rendered.getByRole("button", { name: /save/i })).toBeDisabled(),
-    );
-
-    // No current password id needed for admin users
-    expect(
-      await rendered.queryByLabelText(/user.password.current/i, {
-        selector: "input",
-      }),
-    ).toBeNull();
-
-    await user.type(
-      rendered.getByLabelText(/user.password.new_password/i, {
-        selector: "input",
-      }),
-      "Va1id.pa$$w0rd!",
+  it("uses the shared modal for the authenticated user without an account ID", async () => {
+    const dispatch = jest.fn();
+    const rendered = render(<Password />, {
+      state: { authentication: { user_name: "test.user" } },
+      dispatch,
+    });
+    expect(rendered.getByRole("dialog")).toHaveClass("user-modal--password");
+    expect(document.getElementById("currentPassword")).toHaveAttribute(
+      "autocomplete",
+      "current-password",
     );
-    await user.type(
-      rendered.getByLabelText(/login.form.re_password.label/i, {
-        selector: "input",
-      }),
-      "Va1id.pa$$w0rd!",
+    Object.entries({
+      currentPassword: "old-example123",
+      password: "new-example123",
+      passwordConfirmation: "new-example123",
+    }).forEach(([id, value]) =>
+      fireEvent.change(document.getElementById(id), { target: { value } }),
     );
-
+    fireEvent.submit(document.getElementById("password-modal-form"));
     await waitFor(() =>
-      expect(
-        rendered.getByRole("button", { name: /save/i }),
-      ).not.toBeDisabled(),
-    );
-
-    // Submit
-    await user.click(await rendered.findByRole("button", { name: /save/i }));
-
-    await waitFor(() =>
-      expect(updatePassword).toHaveBeenCalledWith({
-        user: {
-          id: 42,
-          new_password: "Va1id.pa$$w0rd!",
-        },
-      }),
+      expect(dispatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: updatePassword.TRIGGER,
+          payload: {
+            user: {
+              old_password: "old-example123",
+              new_password: "new-example123",
+            },
+          },
+        }),
+      ),
     );
   });
 
-  it("requires current password to have min length", async () => {
-    const props = { userName: "joe", authUserName: "joe", updatePassword };
-    const rendered = render(<Password {...props} />);
-    const user = userEvent.setup({ delay: null });
-
-    await user.type(
-      rendered.getByLabelText(/user.password.current/i, { selector: "input" }),
-      "short",
+  it("returns to the previous page on cancel without submitting", async () => {
+    const dispatch = jest.fn();
+    const rendered = render(
+      <Routes>
+        <Route path="/previous" element={<div>Previous page</div>} />
+        <Route path="/password" element={<Password />} />
+      </Routes>,
+      {
+        routes: ["/previous", "/password"],
+        routeIndex: 1,
+        state: { authentication: { user_name: "test.user" } },
+        dispatch,
+      },
     );
-
-    expect(
-      await rendered.findByText(/form.validation.minLength/i),
-    ).not.toBeNull();
-  });
-
-  it("requires new password to password confirmation to be the same", async () => {
-    const props = { userName: "joe", authUserName: "joe", updatePassword };
-    const rendered = render(<Password {...props} />);
-    const user = userEvent.setup({ delay: null });
-
-    await user.type(
-      rendered.getByLabelText(/user.password.new_password/i, {
-        selector: "input",
-      }),
-      "Va1id.pa$$w0rd!",
+    fireEvent.change(document.getElementById("password"), {
+      target: { value: "discard-example" },
+    });
+    fireEvent.click(rendered.getByRole("button", { name: "actions.cancel" }));
+    expect(await rendered.findByText("Previous page")).toBeVisible();
+    expect(dispatch).not.toHaveBeenCalledWith(
+      expect.objectContaining({ type: updatePassword.TRIGGER }),
     );
-    await user.type(
-      rendered.getByLabelText(/login.form.re_password.label/i, {
-        selector: "input",
-      }),
-      "different",
-    );
-
-    expect(
-      await rendered.findByText(/user.password.must.match/i),
-    ).not.toBeNull();
   });
 });

package/src/users/components/__tests__/UserAcls.spec.js

@@ -1,6 +1,6 @@
-import { waitFor } from "@testing-library/react";
+import { screen, waitFor, within } from "@testing-library/react";
 import { render } from "@truedat/test/render";
-import UserAcls from "../UserAcls";
+import UserAcls, { UserAcls as UserAclsTable } from "../UserAcls";
 
 const renderOpts = {
   messages: {
@@ -32,3 +32,24 @@ describe("<UserAcls />", () => {
     await waitFor(() => expect(container).toMatchSnapshot());
   });
 });
+
+it("groups roles by domain identity and deduplicates repeated assignments", () => {
+  const first = { id: 1, name: "Domain", type: "domain" };
+  const second = { id: 2, name: "Domain", type: "domain" };
+  const acls = [
+    { resource: first, role: "Reader" },
+    { resource: first, role: "Editor" },
+    { resource: first, role: "Reader" },
+    { resource: second, role: "Reader" },
+  ];
+  const rendered = render(<UserAclsTable acls={acls} groupBy="domain" />);
+  expect(screen.getAllByRole("row")).toHaveLength(3);
+  expect(
+    within(screen.getAllByRole("row")[1]).getAllByRole("listitem"),
+  ).toHaveLength(2);
+  rendered.rerender(<UserAclsTable acls={acls} groupBy="role" />);
+  expect(screen.getAllByRole("row")).toHaveLength(3);
+  expect(
+    within(screen.getAllByRole("row")[2]).getAllByRole("listitem"),
+  ).toHaveLength(2);
+});

package/src/users/components/__tests__/UserCard.spec.js

@@ -1,6 +1,11 @@
 import { render } from "@truedat/test/render";
+import userEvent from "@testing-library/user-event";
+import { fireEvent, waitFor } from "@testing-library/react";
+import { useLocation } from "react-router";
 import { UserCard } from "../UserCard";
 
+const CurrentRoute = () => <output>{useLocation().pathname}</output>;
+
 describe("<UserCard />", () => {
   const deleteUser = jest.fn();
   const user = {
@@ -12,15 +17,116 @@ describe("<UserCard />", () => {
     uid: "uID00001",
   };
 
-  it("matches the latest snapshot when showing full name", () => {
-    const props = { user, deleteUser, showFullname: true };
+  it("matches the latest snapshot", () => {
+    const props = { user, deleteUser };
     const rendered = render(<UserCard {...props} />);
     expect(rendered.container).toMatchSnapshot();
   });
 
-  it("matches the latest snapshot when showing UID", () => {
-    const props = { user, deleteUser, showFullname: false };
+  it("shows the trimmed external ID without replacing user metadata", () => {
+    const rendered = render(
+      <UserCard user={{ ...user, external_id: "  employee-123  " }} />,
+    );
+    expect(rendered.getByText("employee-123")).toHaveAttribute(
+      "title",
+      "ID externo: employee-123",
+    );
+    expect(rendered.getByText(user.user_name)).toBeInTheDocument();
+    expect(rendered.getByText(user.email)).toBeInTheDocument();
+  });
+
+  it("shows groups in the badge popup", async () => {
+    const props = {
+      user: { ...user, groups: ["admins", { alias: "Quality" }] },
+      deleteUser,
+    };
     const rendered = render(<UserCard {...props} />);
-    expect(rendered.container).toMatchSnapshot();
+
+    expect(rendered.container.querySelector(".mail.icon")).toBeInTheDocument();
+    fireEvent.mouseOver(rendered.getByText("2"));
+
+    await waitFor(() => expect(rendered.getByRole("list")).toBeInTheDocument());
+    expect(rendered.getByText("admins")).toBeInTheDocument();
+    expect(rendered.getByText("Quality")).toBeInTheDocument();
+  });
+
+  it("omits rows with missing or blank optional data", () => {
+    const props = {
+      user: {
+        id: "2",
+        user_name: "jhon.doe",
+        email: "   ",
+        external_id: "   ",
+        groups: [],
+      },
+      deleteUser,
+    };
+    const rendered = render(<UserCard {...props} />);
+
+    expect(rendered.getByText("jhon.doe")).toBeInTheDocument();
+    expect(
+      rendered.container.querySelector(".user.icon"),
+    ).not.toBeInTheDocument();
+    expect(
+      rendered.container.querySelector(".mail.icon"),
+    ).not.toBeInTheDocument();
+    expect(
+      rendered.container.querySelector(".groups-badge"),
+    ).not.toBeInTheDocument();
+    expect(
+      rendered.container.querySelector(".uc-meta-grid"),
+    ).toBeEmptyDOMElement();
+  });
+
+  it("does not render meta tooltips on hover", () => {
+    const longUserName = "very.long.user.name";
+    const props = {
+      user: {
+        ...user,
+        user_name: longUserName,
+        full_name: "Very Long User",
+      },
+      deleteUser,
+    };
+    const rendered = render(<UserCard {...props} />);
+
+    fireEvent.mouseOver(rendered.getByText(longUserName));
+
+    expect(rendered.getAllByText(longUserName)).toHaveLength(1);
+    expect(rendered.container.querySelector(".inverted.popup")).toBeNull();
+  });
+
+  it("keeps card navigation separate from edit and password actions", async () => {
+    const rendered = render(
+      <>
+        <UserCard user={{ ...user, groups: ["Data"] }} />
+        <CurrentRoute />
+      </>,
+      { routes: ["/users"] },
+    );
+    const keyboard = userEvent.setup({ delay: null });
+    await keyboard.tab();
+    expect(
+      rendered.getByRole("link", { name: "user.info.open" }),
+    ).toHaveFocus();
+    await keyboard.keyboard("{Enter}");
+    expect(rendered.getByRole("status")).toHaveTextContent(/^\/users\/1$/);
+    await keyboard.tab();
+    expect(
+      rendered.getByRole("link", { name: "users.actions.edit" }),
+    ).toHaveFocus();
+    await keyboard.keyboard("{Enter}");
+    expect(rendered.getByRole("status")).toHaveTextContent("/users/1/edit");
+    await keyboard.click(
+      rendered.getByRole("link", { name: "user.actions.edit_password" }),
+    );
+    expect(rendered.getByRole("status")).toHaveTextContent("/users/1/password");
+    expect(
+      rendered.queryByRole("button", {
+        name: "user.actions.delete.confirmation.header",
+      }),
+    ).not.toBeInTheDocument();
+    await keyboard.click(rendered.getByRole("link", { name: "1" }));
+    expect(rendered.getByRole("status")).toHaveTextContent(/^\/users\/1$/);
   });
 });

package/src/users/components/__tests__/UserCards.spec.js

@@ -1,8 +1,11 @@
+import { screen, within } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { render, waitForLoad } from "@truedat/test/render";
 import { UserCards } from "../UserCards";
 
 describe("<UserCards />", () => {
+  beforeEach(() => localStorage.clear());
+  afterEach(() => jest.restoreAllMocks());
   const users = [
     {
       id: "1",
@@ -68,3 +71,194 @@ describe("<UserCards />", () => {
     expect(rendered.getByText(/user.search.no_results/i)).toBeInTheDocument();
   });
 });
+
+it("retains search when switching views and remembers the selected view", async () => {
+  const user = userEvent.setup({ delay: null });
+  const rendered = render(
+    <UserCards
+      users={[
+        {
+          id: 1,
+          full_name: "Alpha",
+          user_name: "a",
+          role: "user",
+          external_id: "EXT-1",
+        },
+        { id: 2, full_name: "Beta", user_name: "b", role: "admin" },
+      ]}
+    />,
+  );
+  await user.type(
+    screen.getByPlaceholderText(/user.search.placeholder/),
+    "ext-1",
+  );
+  await user.click(screen.getByRole("button", { name: "users.view.table" }));
+  expect(screen.getAllByRole("row")).toHaveLength(2);
+  expect(screen.getByRole("link", { name: "Alpha" })).toHaveAttribute(
+    "href",
+    "/users/1",
+  );
+  expect(localStorage.getItem("truedat.users.view")).toBe("table");
+  expect(
+    screen.getByRole("button", { name: "users.view.table" }),
+  ).toHaveAttribute("aria-pressed", "true");
+  await user.click(screen.getByRole("button", { name: "users.view.cards" }));
+  expect(rendered.container.querySelectorAll(".card")).toHaveLength(1);
+  await user.click(screen.getByRole("button", { name: "users.view.table" }));
+  await user.click(screen.getByRole("button", { name: "users.filter.clear" }));
+  expect(screen.getAllByRole("row")).toHaveLength(3);
+  await user.click(screen.getByRole("button", { name: /users.table.name/ }));
+  expect(
+    within(screen.getAllByRole("row")[1]).getByRole("link", { name: "Beta" }),
+  ).toBeInTheDocument();
+  rendered.unmount();
+  render(<UserCards users={[]} />);
+  expect(screen.getByRole("table")).toBeInTheDocument();
+  localStorage.clear();
+});
+
+it("works when storage is unavailable and reuses the delete confirmation", async () => {
+  const get = jest
+    .spyOn(Storage.prototype, "getItem")
+    .mockImplementation(() => {
+      throw new Error("unavailable");
+    });
+  const set = jest
+    .spyOn(Storage.prototype, "setItem")
+    .mockImplementation(() => {
+      throw new Error("unavailable");
+    });
+  const user = userEvent.setup({ delay: null });
+  render(
+    <UserCards
+      users={[
+        {
+          id: 1,
+          user_name: "Alpha",
+          role: "user",
+          groups: ["Data"],
+          acls: [
+            { role: { id: 7, name: "Reader" } },
+            { role: { id: 7, name: "Reader" }, group: { name: "Data" } },
+          ],
+        },
+      ]}
+    />,
+  );
+  await user.click(screen.getByRole("button", { name: "users.view.table" }));
+  expect(screen.getByLabelText("users.table.roles: 1")).toBeInTheDocument();
+  expect(
+    screen.getByRole("link", { name: "users.table.edit" }),
+  ).toHaveAttribute("href", "/users/1/edit");
+  await user.click(screen.getByRole("button", { name: "users.table.delete" }));
+  expect(screen.getByRole("dialog")).toBeInTheDocument();
+  await user.click(screen.getByRole("button", { name: "actions.cancel" }));
+  expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+  expect(screen.getByRole("table")).toBeInTheDocument();
+  get.mockRestore();
+  set.mockRestore();
+});
+
+it("combines type and group filters and keeps all group options available", async () => {
+  localStorage.clear();
+  const user = userEvent.setup({ delay: null });
+  render(
+    <UserCards
+      users={[
+        { id: 1, user_name: "Alpha", role: "user", groups: ["Data"], acls: [] },
+        {
+          id: 2,
+          user_name: "Beta",
+          role: "admin",
+          groups: [{ name: "quality", alias: "Quality" }],
+        },
+        {
+          id: 3,
+          user_name: "Gamma",
+          role: "user",
+          groups: ["Data"],
+          acls: [{ role: {} }],
+        },
+      ]}
+    />,
+  );
+  await user.click(screen.getByRole("button", { name: "users.view.table" }));
+  await user.click(screen.getByText("Filters", { exact: true }));
+  await user.click(screen.getByRole("option", { name: "type", exact: true }));
+  await user.click(screen.getByRole("option", { name: "user.type.user" }));
+  await user.keyboard("{Escape}");
+  await user.click(screen.getByText("Filters", { exact: true }));
+  await user.click(screen.getByRole("option", { name: "groups", exact: true }));
+  expect(screen.getByRole("option", { name: "Quality" })).toBeInTheDocument();
+  await user.click(screen.getByRole("option", { name: "Data" }));
+  await user.keyboard("{Escape}");
+  expect(screen.getAllByRole("row")).toHaveLength(3);
+  expect(screen.getAllByText("users.table.unknown")).toHaveLength(1);
+  await user.type(
+    screen.getByPlaceholderText(/user.search.placeholder/),
+    "alpha",
+  );
+  expect(screen.getAllByRole("row")).toHaveLength(2);
+  await user.click(screen.getByRole("button", { name: "users.filter.clear" }));
+  expect(screen.getAllByRole("row")).toHaveLength(4);
+  localStorage.clear();
+});
+
+describe("<UserCards /> role sections", () => {
+  beforeEach(() => localStorage.clear());
+  const users = [
+    { id: 1, user_name: "alpha", full_name: "Alpha", role: "admin" },
+    { id: 2, user_name: "beta", full_name: "Beta", role: "user" },
+  ];
+
+  it("exposes each role section as a button with its expanded state", async () => {
+    const rendered = render(<UserCards users={users} />);
+    await waitForLoad(rendered);
+
+    const adminToggle = screen.getByRole("button", { name: /user.type.admin/ });
+    expect(adminToggle).toHaveAttribute("aria-expanded", "true");
+    const panelId = adminToggle.getAttribute("aria-controls");
+    expect(panelId).toBeTruthy();
+    expect(document.getElementById(panelId)).toHaveClass("users-role-content");
+  });
+
+  it.each([["{Enter}"], [" "]])(
+    "collapses and expands a role section with the keyboard (%j)",
+    async (key) => {
+      const user = userEvent.setup({ delay: null });
+      const rendered = render(<UserCards users={users} />);
+      await waitForLoad(rendered);
+
+      await user.tab();
+      const toggles = screen
+        .getAllByRole("button")
+        .filter((button) => button.hasAttribute("aria-expanded"));
+      const adminToggle = toggles.find((button) =>
+        /user.type.admin/.test(button.textContent),
+      );
+      adminToggle.focus();
+      expect(adminToggle).toHaveFocus();
+
+      await user.keyboard(key);
+      expect(adminToggle).toHaveAttribute("aria-expanded", "false");
+      expect(adminToggle).toHaveFocus();
+
+      await user.keyboard(key);
+      expect(adminToggle).toHaveAttribute("aria-expanded", "true");
+    },
+  );
+
+  it("keeps the other role sections open when one is collapsed", async () => {
+    const user = userEvent.setup({ delay: null });
+    const rendered = render(<UserCards users={users} />);
+    await waitForLoad(rendered);
+
+    await user.click(screen.getByRole("button", { name: /user.type.admin/ }));
+    expect(
+      screen.getByRole("button", { name: /user.type.admin/ }),
+    ).toHaveAttribute("aria-expanded", "false");
+    expect(
+      screen.getByRole("button", { name: /user.type.user/ }),
+    ).toHaveAttribute("aria-expanded", "true");
+  });
+});

package/src/users/components/__tests__/UserGroupAclRow.spec.js

@@ -1,5 +1,5 @@
 import { waitFor } from "@testing-library/react";
-import { renderWithIntl as render } from "@truedat/test/renderWithIntl";
+import { render } from "@truedat/test/render";
 import UserGroupAclRow from "../UserGroupAclRow";
 
 describe("<UserGroupAclRow />", () => {
@@ -20,4 +20,22 @@ describe("<UserGroupAclRow />", () => {
     );
     await waitFor(() => expect(container).toMatchSnapshot());
   });
+
+  it("renders group, domain and role in order with a new-tab group link", () => {
+    const rendered = render(
+      <table>
+        <tbody>
+          <UserGroupAclRow {...props} groupId={6} />
+        </tbody>
+      </table>,
+      {},
+    );
+    expect(
+      rendered.getAllByRole("cell").map((cell) => cell.textContent),
+    ).toEqual(["grupo1", "resource1", "role1"]);
+    const link = rendered.getByRole("link", { name: "grupo1" });
+    expect(link).toHaveAttribute("href", "/groups/6");
+    expect(link).toHaveAttribute("target", "_blank");
+    expect(link).toHaveAttribute("rel", "noopener noreferrer");
+  });
 });