@oneuptime/common 13.0.1 → 13.0.4

package/Tests/App/Dashboard/InventoryItemSideMenu.test.tsx

@@ -0,0 +1,155 @@
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+import "@testing-library/jest-dom";
+import { cleanup } from "@testing-library/react";
+import * as React from "react";
+import ObjectID from "../../../Types/ObjectID";
+import InventoryItemSideMenu from "../../../../App/FeatureSet/Dashboard/src/Pages/Inventory/View/SideMenu";
+import {
+  DESKTOP_WIDTH,
+  MOBILE_WIDTH,
+  MenuLink,
+  PROJECT_ID,
+  goTo,
+  hrefsInMenu,
+  iconCountIn,
+  isExpanded,
+  linksIn,
+  mobileSummaryText,
+  renderMenu,
+  sectionRoot,
+  sectionTitlesInOrder,
+  setViewportWidth,
+  titlesInMenu,
+} from "./SideMenuHarness";
+
+const ITEM_ID: string = "0193c0de-2222-4aaa-8bbb-000000000002";
+const ITEM_PATH: string = `/dashboard/${PROJECT_ID}/inventory/item/${ITEM_ID}`;
+const AUDIT_LOGS_PATH: string = `${ITEM_PATH}/audit-logs`;
+
+async function renderInventoryItemMenu(): Promise<void> {
+  await renderMenu(<InventoryItemSideMenu modelId={new ObjectID(ITEM_ID)} />);
+}
+
+describe("Inventory item side menu", () => {
+  beforeEach(() => {
+    setViewportWidth(DESKTOP_WIDTH);
+    goTo(AUDIT_LOGS_PATH);
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  test("renders the item sections in their expected order", async () => {
+    await renderInventoryItemMenu();
+
+    expect(sectionTitlesInOrder()).toEqual([
+      "Item",
+      "Telemetry",
+      "Operations",
+      "Advanced",
+    ]);
+  });
+
+  test("keeps the unchanged item and telemetry destinations intact", async () => {
+    await renderInventoryItemMenu();
+
+    expect(linksIn("Item")).toEqual([
+      { title: "Overview", href: ITEM_PATH },
+      { title: "Connections", href: `${ITEM_PATH}/relationships` },
+      { title: "Custom Fields", href: `${ITEM_PATH}/custom-fields` },
+    ]);
+    expect(linksIn("Telemetry")).toEqual([
+      { title: "Logs", href: `${ITEM_PATH}/logs` },
+      { title: "Traces", href: `${ITEM_PATH}/traces` },
+      { title: "Metrics", href: `${ITEM_PATH}/metrics` },
+      { title: "Performance Profiles", href: `${ITEM_PATH}/profiles` },
+      { title: "Exceptions", href: `${ITEM_PATH}/exceptions` },
+    ]);
+  });
+
+  test("Operations contains only live operational activity", async () => {
+    await renderInventoryItemMenu();
+
+    expect(linksIn("Operations")).toEqual([
+      { title: "Incidents", href: `${ITEM_PATH}/incidents` },
+      { title: "Alerts", href: `${ITEM_PATH}/alerts` },
+      {
+        title: "Scheduled Maintenance",
+        href: `${ITEM_PATH}/scheduled-maintenance`,
+      },
+    ]);
+  });
+
+  test("Advanced contains Settings, Audit Logs, and Delete Item in order", async () => {
+    await renderInventoryItemMenu();
+
+    expect(linksIn("Advanced")).toEqual([
+      { title: "Settings", href: `${ITEM_PATH}/settings` },
+      { title: "Audit Logs", href: AUDIT_LOGS_PATH },
+      { title: "Delete Item", href: `${ITEM_PATH}/delete` },
+    ]);
+    expect(iconCountIn("Advanced")).toBe(3);
+  });
+
+  test("lists every destination exactly once and fully populates its route", async () => {
+    await renderInventoryItemMenu();
+
+    const hrefs: Array<string> = hrefsInMenu();
+    const titles: Array<string> = titlesInMenu();
+
+    expect(hrefs).toEqual(Array.from(new Set(hrefs)));
+    expect(titles).toEqual(Array.from(new Set(titles)));
+    expect(
+      hrefs.filter((href: string): boolean => {
+        return href === AUDIT_LOGS_PATH;
+      }),
+    ).toHaveLength(1);
+    expect(
+      titles.filter((title: string): boolean => {
+        return title === "Audit Logs";
+      }),
+    ).toHaveLength(1);
+
+    hrefs.forEach((href: string) => {
+      expect(href).toContain(ITEM_PATH);
+      expect(href).not.toContain(":projectId");
+      expect(href).not.toContain(":modelId");
+    });
+  });
+
+  test("marks Audit Logs active in the expanded Advanced section", async () => {
+    await renderInventoryItemMenu();
+
+    const auditLogAnchor: HTMLAnchorElement | undefined = Array.from(
+      sectionRoot("Advanced").querySelectorAll<HTMLAnchorElement>("a"),
+    ).find((anchor: HTMLAnchorElement): boolean => {
+      return anchor.getAttribute("href") === AUDIT_LOGS_PATH;
+    });
+
+    expect(auditLogAnchor).toBeDefined();
+    expect(auditLogAnchor).toHaveClass("bg-indigo-50", "text-indigo-700");
+    expect(isExpanded("Advanced")).toBe(true);
+  });
+
+  test("the mobile summary names Audit Logs as an Advanced page", async () => {
+    setViewportWidth(MOBILE_WIDTH);
+
+    await renderInventoryItemMenu();
+
+    expect(mobileSummaryText()).toContain("Advanced / Audit Logs");
+  });
+
+  test("all rendered links retain a visible label and icon", async () => {
+    await renderInventoryItemMenu();
+
+    sectionTitlesInOrder().forEach((sectionTitle: string) => {
+      const links: Array<MenuLink> = linksIn(sectionTitle);
+
+      expect(iconCountIn(sectionTitle)).toBe(links.length);
+      links.forEach((link: MenuLink) => {
+        expect(link.title).not.toBe("");
+      });
+    });
+  });
+});

package/Tests/App/Dashboard/InvestigationFeedRefresh.test.tsx

@@ -57,6 +57,8 @@ import IncidentFeed, {
 } from "../../../Models/DatabaseModels/IncidentFeed";
 import IconProp from "../../../Types/Icon/IconProp";
 import ObjectID from "../../../Types/ObjectID";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
+import { DEFAULT_LIMIT } from "../../../Types/Database/LimitMax";
 
 interface RenderedFeedItem {
   key: string;
@@ -86,6 +88,9 @@ interface FeedListRequest {
   modelType: unknown;
   query: Record<string, unknown>;
   select: Record<string, unknown>;
+  skip: number;
+  limit: number;
+  sort: Record<string, SortOrder>;
 }
 
 const INCIDENT_ID: ObjectID = new ObjectID(
@@ -274,6 +279,9 @@ describe("investigation reports in incident and alert feeds", () => {
       .calls[1]![0] as FeedListRequest;
     expect(request.modelType).toBe(IncidentFeed);
     expect(request.query).toEqual({ incidentId: INCIDENT_ID });
+    expect(request.skip).toBe(0);
+    expect(request.limit).toBe(DEFAULT_LIMIT);
+    expect(request.sort).toEqual({ postedAt: SortOrder.Descending });
     expect(request.select).toEqual(
       expect.objectContaining({
         feedInfoInMarkdown: true,
@@ -326,6 +334,9 @@ describe("investigation reports in incident and alert feeds", () => {
       .calls[1]![0] as FeedListRequest;
     expect(request.modelType).toBe(AlertFeed);
     expect(request.query).toEqual({ alertId: ALERT_ID });
+    expect(request.skip).toBe(0);
+    expect(request.limit).toBe(DEFAULT_LIMIT);
+    expect(request.sort).toEqual({ postedAt: SortOrder.Descending });
     expect(request.select).toEqual(
       expect.objectContaining({
         feedInfoInMarkdown: true,

package/Tests/App/Dashboard/PasskeySettings.test.tsx

@@ -31,6 +31,7 @@ import UiAnalytics from "../../../UI/Utils/Analytics";
 import WebAuthnTestUtil, {
   registrationOptions,
 } from "../../Utils/WebAuthnTestUtil";
+import UserProfileSideMenu from "../../../../App/FeatureSet/Dashboard/src/Pages/Global/UserProfile/SideMenu";
 import PasskeySettings from "../../../../App/FeatureSet/Dashboard/src/Pages/Global/UserProfile/Passkeys";
 import TwoFactorSettings from "../../../../App/FeatureSet/Dashboard/src/Pages/Global/UserProfile/TwoFactorAuth";
 import { ComponentProps as ModelTableProps } from "../../../UI/Components/ModelTable/ModelTable";
@@ -348,16 +349,33 @@ describe("Passkey settings registration", () => {
     });
   });
 
+  /*
+   * The two links are the user profile SIDE MENU's, not the page's. The page
+   * used to render its own <Page sideMenu={...}> wrapper; that moved into
+   * Global/UserProfile/Layout so the menu survives navigation between these
+   * pages instead of remounting, which is the whole point of the layout.
+   * Asserting it here, against the component that owns it, keeps the
+   * contract covered without re-rendering a whole page to reach a menu.
+   */
+  test("gives passkeys and two-factor auth their own entries in the security menu", () => {
+    render(
+      <MemoryRouter initialEntries={["/dashboard/user-profile/passkeys"]}>
+        <UserProfileSideMenu />
+      </MemoryRouter>,
+    );
+
+    expect(
+      screen.getByRole("link", { name: "Passkeys", exact: true }),
+    ).toHaveAttribute("href", "/dashboard/user-profile/passkeys");
+    expect(
+      screen.getByRole("link", { name: /Two.factor authentication/i }),
+    ).toHaveAttribute("href", "/dashboard/user-profile/two-factor-auth");
+  });
+
   test.each([true, false])(
-    "provides distinct navigation and removes the old advice panel: passkeys %s",
+    "removes the old advice panel: passkeys %s",
     (isPasskey: boolean) => {
       renderPage(isPasskey);
-      expect(
-        screen.getByRole("link", { name: "Passkeys", exact: true }),
-      ).toHaveAttribute("href", "/dashboard/user-profile/passkeys");
-      expect(
-        screen.getByRole("link", { name: /Two.factor authentication/i }),
-      ).toHaveAttribute("href", "/dashboard/user-profile/two-factor-auth");
       expect(
         screen.queryByText("Keep another way to sign in"),
       ).not.toBeInTheDocument();
@@ -373,13 +391,31 @@ describe("Passkey settings registration", () => {
     },
   );
 
-  test("shows a concise empty state for passkeys", () => {
-    renderPage();
-    expect(screen.getByText("No passkeys added yet.")).toBeVisible();
-    expect(
-      screen.queryByText("No passkeys or security keys found."),
-    ).not.toBeInTheDocument();
-  });
+  test.each([true, false])(
+    "shows a concise empty state without the legacy credential notice: passkeys %s",
+    async (isPasskey: boolean) => {
+      mockPasskeyTable([]);
+      renderPage(isPasskey);
+      expect(
+        await screen.findByText(
+          isPasskey ? "No passkeys added yet." : "No security keys added yet.",
+        ),
+      ).toBeVisible();
+      expect(
+        screen.queryByText("No passkeys or security keys found."),
+      ).not.toBeInTheDocument();
+      expect(
+        screen.queryByText(
+          /Existing credentials appear on both security pages/,
+        ),
+      ).not.toBeInTheDocument();
+      expect(
+        screen.getByRole("button", {
+          name: isPasskey ? "Add Passkey" : "Add Security Key",
+        }),
+      ).toBeEnabled();
+    },
+  );
 
   test.each([false, true])(
     "uses the shared table header and standard add action when a saved passkey is present: %s",
@@ -448,25 +484,81 @@ describe("Passkey settings registration", () => {
   );
 
   test.each([true, false])(
-    "keeps existing credentials manageable when their original purpose is unknown: passkeys %s",
+    "omits legacy notices and badges while keeping mixed saved credentials manageable: passkeys %s",
     async (isPasskey: boolean) => {
       const storedKey: UserWebAuthn = new UserWebAuthn();
       storedKey._id = "44444444-4444-4444-8444-444444444444";
       storedKey.name = "Existing device";
       storedKey.isVerified = true;
-      mockPasskeyTable([storedKey]);
+      const olderKey: UserWebAuthn = UserWebAuthn.fromJSONObject(
+        {
+          _id: "55555555-5555-4555-8555-555555555555",
+          name: "Older device",
+          isVerified: true,
+          isPasskey: null,
+        },
+        UserWebAuthn,
+      );
+      const currentKey: UserWebAuthn = new UserWebAuthn();
+      currentKey._id = "66666666-6666-4666-8666-666666666666";
+      currentKey.name = "New device";
+      currentKey.isVerified = false;
+      currentKey.isPasskey = isPasskey;
+      const namedKey: UserWebAuthn = new UserWebAuthn();
+      namedKey._id = "77777777-7777-4777-8777-777777777777";
+      namedKey.name = "Existing credential";
+      namedKey.isVerified = true;
+      mockPasskeyTable([storedKey, olderKey, currentKey, namedKey]);
       renderPage(isPasskey);
       expect(await screen.findByText("Existing device")).toBeVisible();
-      expect(screen.getByText("Existing credential")).toBeVisible();
       expect(
-        screen.getByText(/Existing credentials appear on both security pages/),
-      ).toBeVisible();
+        screen.queryByText(
+          /Existing credentials appear on both security pages/,
+        ),
+      ).not.toBeInTheDocument();
       expect(
-        screen.getByRole("button", { name: "Rename", exact: true }),
-      ).toBeEnabled();
+        screen.queryByText(/They continue to work as before/),
+      ).not.toBeInTheDocument();
+
+      for (const name of [
+        "Existing device",
+        "Older device",
+        "New device",
+        "Existing credential",
+      ]) {
+        const row: HTMLElement = screen.getByRole("row", {
+          name: new RegExp(name),
+        });
+        expect(within(row).getByText(name)).toBeVisible();
+        expect(
+          within(row).getByRole("button", { name: "Rename", exact: true }),
+        ).toBeEnabled();
+        expect(
+          within(row).getByRole("button", { name: "Delete", exact: true }),
+        ).toBeEnabled();
+        if (name !== "Existing credential") {
+          expect(
+            within(row).queryByText("Existing credential"),
+          ).not.toBeInTheDocument();
+        }
+        if (name === "New device") {
+          expect(within(row).getByText("Setup incomplete")).toBeVisible();
+        } else {
+          expect(within(row).getByText("Ready")).toBeVisible();
+        }
+      }
       expect(
-        screen.getByRole("button", { name: "Delete", exact: true }),
+        screen.getAllByText("Existing credential", { exact: true }),
+      ).toHaveLength(1);
+      expect(
+        screen.getByRole("button", {
+          name: isPasskey ? "Add Passkey" : "Add Security Key",
+        }),
       ).toBeEnabled();
+      expect(mockCredentialTableProps?.query).toEqual({
+        userId: UserUtil.getUserId(),
+        isPasskey: new EqualToOrNull(isPasskey ? "true" : "false"),
+      });
     },
   );
 
@@ -541,16 +633,37 @@ describe("Passkey settings registration", () => {
     ).toHaveTextContent("Passkey added. Use it the next time you sign in.");
   });
 
-  test("registers a security key as a second factor from the two-factor page", async () => {
+  test("registers security keys, closes registration and refreshes the list without a success banner", async () => {
     renderPage(false);
-    await register(false);
-    expect(posted[0]?.data).toEqual({ isPasskey: false });
-    expect(posted[1]?.data).toMatchObject({ name: "My laptop" });
-    expect(
-      screen.getByTestId("passkey-registration-success"),
-    ).toHaveTextContent(
-      "Security key added. It is ready to use for two-factor authentication.",
-    );
+    for (const registrationNumber of [1, 2]) {
+      const refreshBefore: string | null = screen
+        .getByTestId("security-keys-table")
+        .getAttribute("data-refresh");
+      await register(false);
+
+      expect(posted).toHaveLength(registrationNumber * 2);
+      expect(posted[(registrationNumber - 1) * 2]?.data).toEqual({
+        isPasskey: false,
+      });
+      expect(posted[registrationNumber * 2 - 1]?.data).toMatchObject({
+        name: "My laptop",
+      });
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+      expect(
+        screen.getByTestId("security-keys-table").getAttribute("data-refresh"),
+      ).not.toBe(refreshBefore);
+      expect(
+        screen.queryByTestId("passkey-registration-success"),
+      ).not.toBeInTheDocument();
+      expect(
+        screen.queryByText(
+          "Security key added. It is ready to use for two-factor authentication.",
+        ),
+      ).not.toBeInTheDocument();
+      expect(
+        screen.getByRole("button", { name: "Add Security Key" }),
+      ).toBeEnabled();
+    }
   });
 
   test.each([true, false])(
@@ -562,6 +675,16 @@ describe("Passkey settings registration", () => {
       expect(screen.getByTestId("enrolment-backup-codes")).toHaveTextContent(
         "ABCDE-12345,FGHIJ-67890",
       );
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+      if (isPasskey) {
+        expect(
+          screen.getByTestId("passkey-registration-success"),
+        ).toHaveTextContent("Passkey added. Use it the next time you sign in.");
+      } else {
+        expect(
+          screen.queryByTestId("passkey-registration-success"),
+        ).not.toBeInTheDocument();
+      }
     },
   );
 
@@ -597,6 +720,11 @@ describe("Passkey settings registration", () => {
       });
       expect(posted).toHaveLength(3);
       expect(posted[2]?.data).toMatchObject({ name: "My laptop" });
+      if (!isPasskey) {
+        expect(
+          screen.queryByTestId("passkey-registration-success"),
+        ).not.toBeInTheDocument();
+      }
     },
   );
 
@@ -750,49 +878,65 @@ describe("Passkey settings registration", () => {
     ).toHaveTextContent("Passkey added");
   });
 
-  test("keeps verification visible until saving finishes and preserves returned recovery codes", async () => {
-    let finish: ((value: HTTPResponse<JSONObject>) => void) | undefined;
-    jest
-      .spyOn(API, "post")
-      .mockResolvedValueOnce(
-        new HTTPResponse<JSONObject>(200, { options: registrationOptions }, {}),
-      )
-      .mockImplementationOnce(() => {
-        return new Promise<HTTPResponse<JSONObject>>(
-          (resolve: (value: HTTPResponse<JSONObject>) => void) => {
-            finish = resolve;
-          },
+  test.each([true, false])(
+    "keeps verification visible until saving finishes and preserves returned recovery codes: passkey %s",
+    async (isPasskey: boolean) => {
+      let finish: ((value: HTTPResponse<JSONObject>) => void) | undefined;
+      jest
+        .spyOn(API, "post")
+        .mockResolvedValueOnce(
+          new HTTPResponse<JSONObject>(
+            200,
+            { options: registrationOptions },
+            {},
+          ),
+        )
+        .mockImplementationOnce(() => {
+          return new Promise<HTTPResponse<JSONObject>>(
+            (resolve: (value: HTTPResponse<JSONObject>) => void) => {
+              finish = resolve;
+            },
+          );
+        });
+      renderPage(isPasskey);
+      await register(isPasskey);
+      expect(screen.getByRole("status")).toHaveTextContent("Saving your key");
+      expect(
+        screen.queryByRole("button", { name: "Cancel" }),
+      ).not.toBeInTheDocument();
+      expect(
+        screen.queryByRole("button", { name: "Close" }),
+      ).not.toBeInTheDocument();
+      expect(
+        screen.queryByTestId("passkey-registration-success"),
+      ).not.toBeInTheDocument();
+      await keyboard("{Escape}");
+      expect(screen.getByRole("dialog")).toBeInTheDocument();
+      expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+      await act(async () => {
+        finish!(
+          new HTTPResponse<JSONObject>(
+            200,
+            { verified: true, backupCodes: ["ABCDE-12345"] },
+            {},
+          ),
         );
       });
-    renderPage();
-    await register();
-    expect(screen.getByRole("status")).toHaveTextContent("Saving your key");
-    expect(
-      screen.queryByRole("button", { name: "Cancel" }),
-    ).not.toBeInTheDocument();
-    expect(
-      screen.queryByRole("button", { name: "Close" }),
-    ).not.toBeInTheDocument();
-    await keyboard("{Escape}");
-    expect(screen.getByRole("dialog")).toBeInTheDocument();
-    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
-    await act(async () => {
-      finish!(
-        new HTTPResponse<JSONObject>(
-          200,
-          { verified: true, backupCodes: ["ABCDE-12345"] },
-          {},
-        ),
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+      expect(screen.getByTestId("enrolment-backup-codes")).toHaveTextContent(
+        "ABCDE-12345",
       );
-    });
-    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
-    expect(screen.getByTestId("enrolment-backup-codes")).toHaveTextContent(
-      "ABCDE-12345",
-    );
-    expect(
-      screen.getByTestId("passkey-registration-success"),
-    ).toHaveTextContent("Passkey added");
-  });
+      if (isPasskey) {
+        expect(
+          screen.getByTestId("passkey-registration-success"),
+        ).toHaveTextContent("Passkey added");
+      } else {
+        expect(
+          screen.queryByTestId("passkey-registration-success"),
+        ).not.toBeInTheDocument();
+      }
+    },
+  );
 
   test.each([true, false])(
     "lets the owner rename a key without updating credential or verification fields: passkey %s",