@oneuptime/common 12.0.4 → 12.0.6

package/Tests/Types/Rum/SessionReplayMaskingMode.test.ts

@@ -0,0 +1,101 @@
+import SessionReplayMaskingMode, {
+  doesMaskingModeRecordReadableContent,
+  parseSessionReplayMaskingMode,
+} from "../../../Types/Rum/SessionReplayMaskingMode";
+import { describe, expect, test } from "@jest/globals";
+
+describe("SessionReplayMaskingMode", () => {
+  const allModes: Array<SessionReplayMaskingMode> = Object.values(
+    SessionReplayMaskingMode,
+  );
+
+  describe("parseSessionReplayMaskingMode", () => {
+    test("returns each valid mode when given its own value", () => {
+      expect(
+        parseSessionReplayMaskingMode(
+          SessionReplayMaskingMode.MaskSensitiveInputsOnly,
+        ),
+      ).toBe(SessionReplayMaskingMode.MaskSensitiveInputsOnly);
+      expect(
+        parseSessionReplayMaskingMode(SessionReplayMaskingMode.MaskInputsOnly),
+      ).toBe(SessionReplayMaskingMode.MaskInputsOnly);
+      expect(
+        parseSessionReplayMaskingMode(SessionReplayMaskingMode.MaskAllText),
+      ).toBe(SessionReplayMaskingMode.MaskAllText);
+    });
+
+    test("round-trips every enum member", () => {
+      for (const mode of allModes) {
+        expect(parseSessionReplayMaskingMode(mode)).toBe(mode);
+      }
+    });
+
+    test("fails closed to MaskAllText for unrecognised values", () => {
+      const unknownValues: Array<unknown> = [
+        undefined,
+        null,
+        "",
+        "maskallText",
+        "MaskEverything",
+        "mask_inputs_only",
+        0,
+        1,
+        true,
+        false,
+        {},
+        [],
+        { mode: SessionReplayMaskingMode.MaskInputsOnly },
+      ];
+      for (const value of unknownValues) {
+        expect(parseSessionReplayMaskingMode(value)).toBe(
+          SessionReplayMaskingMode.MaskAllText,
+        );
+      }
+    });
+
+    test("is case-sensitive and does not coerce near-matches to a relaxed mode", () => {
+      // A relaxed-looking-but-wrong string must NOT downgrade privacy.
+      expect(parseSessionReplayMaskingMode("maskinputsonly")).toBe(
+        SessionReplayMaskingMode.MaskAllText,
+      );
+      expect(parseSessionReplayMaskingMode("MaskSensitiveInputsOnly ")).toBe(
+        SessionReplayMaskingMode.MaskAllText,
+      );
+    });
+  });
+
+  describe("doesMaskingModeRecordReadableContent", () => {
+    test("is true for both relaxed modes", () => {
+      expect(
+        doesMaskingModeRecordReadableContent(
+          SessionReplayMaskingMode.MaskSensitiveInputsOnly,
+        ),
+      ).toBe(true);
+      expect(
+        doesMaskingModeRecordReadableContent(
+          SessionReplayMaskingMode.MaskInputsOnly,
+        ),
+      ).toBe(true);
+    });
+
+    test("is false only for the wireframe mode", () => {
+      expect(
+        doesMaskingModeRecordReadableContent(
+          SessionReplayMaskingMode.MaskAllText,
+        ),
+      ).toBe(false);
+    });
+
+    test("MaskAllText is the single mode that does not record readable content", () => {
+      const recordingModes: Array<SessionReplayMaskingMode> = allModes.filter(
+        (mode: SessionReplayMaskingMode) => {
+          return doesMaskingModeRecordReadableContent(mode);
+        },
+      );
+      expect(recordingModes).not.toContain(
+        SessionReplayMaskingMode.MaskAllText,
+      );
+      expect(recordingModes.length).toBe(allModes.length - 1);
+    });
+  });
+});

package/Tests/UI/Components/AiInvestigationSettingsCard.test.tsx

@@ -152,17 +152,17 @@ const renderCard: RenderCardFunction = (): void => {
           placeholder: "Every severity",
         },
         {
-          field: { aiMaxConcurrentInvestigations: true },
+          field: { incidentAiMaxConcurrentInvestigations: true },
           stepId: "limits",
-          title: "Max Concurrent Investigations",
+          title: "Max Concurrent Incident Investigations",
           required: false,
           fieldType: FormFieldSchemaType.Number,
           placeholder: "3",
         },
         {
-          field: { aiDailyFixTaskLimit: true },
+          field: { incidentAiDailyFixTaskLimit: true },
           stepId: "fix-tasks",
-          title: "Daily AI Fix Task Limit",
+          title: "Daily Incident AI Fix Task Limit",
           required: false,
           fieldType: FormFieldSchemaType.Number,
           placeholder: "25",
@@ -280,6 +280,6 @@ describe("AI investigation settings card", () => {
      * Only the first step's fields are on screen - which is the point of
      * steps, and proves stepId actually took rather than being ignored.
      */
-    expect(screen.queryByText("Daily AI Fix Task Limit")).toBeNull();
+    expect(screen.queryByText("Daily Incident AI Fix Task Limit")).toBeNull();
   });
 });

package/Tests/UI/Components/CardModelDetailEdit.test.tsx

@@ -283,7 +283,7 @@ describe("CardModelDetail edit modal", () => {
     expect(submitted.model.shouldAutoEnableProbeOnNewMonitors).toBe(false);
   });
 
-  it("confirms the save so a successful edit is not just a modal that vanished", async () => {
+  it("closes the editor without showing a toast after a successful edit", async () => {
     getItemMock.mockResolvedValue(loadedProbe());
 
     renderProbeCard();
@@ -303,13 +303,11 @@ describe("CardModelDetail edit modal", () => {
 
     await waitFor(
       () => {
-        expect(showToastMock).toHaveBeenCalled();
+        expect(screen.queryByText("Save Changes")).toBeNull();
       },
       { timeout: WAIT_TIMEOUT },
     );
 
-    const toast: any = (showToastMock.mock.calls[0] as Array<any>)[0];
-
-    expect(toast.title).toEqual("Changes saved");
+    expect(showToastMock).not.toHaveBeenCalled();
   });
 });

package/Tests/UI/Components/ConfirmModal.test.tsx

@@ -3,6 +3,13 @@ import ConfirmModal, {
   ComponentProps,
 } from "../../../UI/Components/Modal/ConfirmModal";
 import { describe, expect, it, jest, beforeEach } from "@jest/globals";
+/*
+ * The main entry, not "/extend-expect": the latter no longer ships type
+ * declarations. Without this import the jest-dom matchers below have no types
+ * of their own, and the suite only compiled when it happened to share a
+ * program with a file that did import them.
+ */
+import "@testing-library/jest-dom";
 import { fireEvent, render, screen } from "@testing-library/react";
 import React from "react";
 

package/Tests/UI/Components/ErrorBoundary.test.tsx

@@ -6,9 +6,21 @@ import ErrorBoundary, {
   isChunkLoadError,
   markChunkLoadErrorReload,
 } from "../../../UI/Components/ErrorBoundary";
+import downloadFile from "../../../UI/Utils/DownloadFile";
+import { ErrorSupportBundle } from "../../../UI/Utils/ErrorSupportBundle";
 import { fireEvent, render, screen } from "@testing-library/react";
 import React, { FunctionComponent, ReactElement, useEffect } from "react";
 
+jest.mock("../../../UI/Utils/DownloadFile", () => {
+  return {
+    __esModule: true,
+    default: jest.fn(),
+  };
+});
+
+const downloadFileMock: jest.MockedFunction<typeof downloadFile> =
+  downloadFile as jest.MockedFunction<typeof downloadFile>;
+
 /*
  * The blank white screen users hit is React unmounting the entire tree when a
  * render throws and nothing catches it. These tests pin down the containment
@@ -70,6 +82,7 @@ describe("ErrorBoundary", () => {
 
   beforeEach(() => {
     consoleErrorSpy.mockClear();
+    downloadFileMock.mockReset();
     window.sessionStorage.clear();
     mockReload();
   });
@@ -115,6 +128,18 @@ describe("ErrorBoundary", () => {
 
       expect(reloadMock).not.toHaveBeenCalled();
     });
+
+    test("does not show support-bundle controls when the page is healthy", () => {
+      render(
+        <ErrorBoundary>
+          <div>Child Component</div>
+        </ErrorBoundary>,
+      );
+
+      expect(
+        screen.queryByRole("button", { name: "Download support bundle" }),
+      ).toBeNull();
+    });
   });
 
   describe("containment", () => {
@@ -197,6 +222,18 @@ describe("ErrorBoundary", () => {
       expect(screen.queryByRole("alert")).not.toBeNull();
     });
 
+    test("leads with a plain-language heading", () => {
+      render(
+        <ErrorBoundary>
+          <ThrowOnRender />
+        </ErrorBoundary>,
+      );
+
+      expect(
+        screen.queryByRole("heading", { name: "Something went wrong" }),
+      ).not.toBeNull();
+    });
+
     test("shows the underlying error message for support", () => {
       render(
         <ErrorBoundary>
@@ -208,6 +245,61 @@ describe("ErrorBoundary", () => {
         screen.getByTestId("error-boundary-error-message").textContent,
       ).toContain("reading 'queryConfigs'");
     });
+
+    /*
+     * The stack-shaped message is for support, not for the person who just hit
+     * the error. It stays in the DOM (so it can be read and copied) but behind
+     * a closed disclosure so the recovery actions lead.
+     */
+    test("keeps the raw error message behind a closed disclosure", () => {
+      render(
+        <ErrorBoundary>
+          <ThrowOnRender message="Cannot read properties of undefined (reading 'queryConfigs')" />
+        </ErrorBoundary>,
+      );
+
+      const disclosure: HTMLDetailsElement | null = screen
+        .getByTestId("error-boundary-error-message")
+        .closest("details");
+
+      expect(disclosure).not.toBeNull();
+      expect(disclosure!.open).toBe(false);
+    });
+
+    test("offers a support bundle and explains what it contains", () => {
+      render(
+        <ErrorBoundary>
+          <ThrowOnRender />
+        </ErrorBoundary>,
+      );
+
+      expect(
+        screen.queryByRole("button", { name: "Download support bundle" }),
+      ).not.toBeNull();
+      expect(screen.queryByText(/scrubbed page URL/)).not.toBeNull();
+      expect(screen.queryByText(/never reads cookies/)).not.toBeNull();
+    });
+
+    /*
+     * A downloaded bundle is only useful if the user knows where to send it,
+     * so the address is on the fallback rather than a page they have to find.
+     */
+    test("says where to send the support bundle", () => {
+      render(
+        <ErrorBoundary>
+          <ThrowOnRender />
+        </ErrorBoundary>,
+      );
+
+      const supportEmailLink: HTMLAnchorElement = screen.getByTestId(
+        "error-boundary-support-email",
+      ) as HTMLAnchorElement;
+
+      expect(supportEmailLink.textContent).toBe("support@oneuptime.com");
+      expect(supportEmailLink.getAttribute("href")).toBe(
+        "mailto:support@oneuptime.com",
+      );
+    });
   });
 
   describe("reporting", () => {
@@ -222,6 +314,9 @@ describe("ErrorBoundary", () => {
 
       expect(onError).toHaveBeenCalledTimes(1);
       expect((onError.mock.calls[0]![0] as Error).message).toBe("Boom");
+      expect(onError.mock.calls[0]![1].componentStack).toContain(
+        "ThrowOnRender",
+      );
     });
 
     test("logs the error so it still reaches the console and RUM", () => {
@@ -292,6 +387,122 @@ describe("ErrorBoundary", () => {
       expect(reloadMock).toHaveBeenCalledTimes(1);
     });
 
+    test("downloads the caught error and React component stack", () => {
+      render(
+        <ErrorBoundary>
+          <ThrowOnRender message="Trace chart render exploded" />
+        </ErrorBoundary>,
+      );
+
+      fireEvent.click(
+        screen.getByTestId("error-boundary-download-support-bundle"),
+      );
+
+      expect(downloadFileMock).toHaveBeenCalledTimes(1);
+      expect(reloadMock).not.toHaveBeenCalled();
+      expect(screen.queryByTestId("error-boundary-fallback")).not.toBeNull();
+
+      const download: Parameters<typeof downloadFile>[0] =
+        downloadFileMock.mock.calls[0]![0];
+      const bundle: ErrorSupportBundle = JSON.parse(
+        download.content as string,
+      ) as ErrorSupportBundle;
+
+      expect(download.filename).toMatch(
+        /^oneuptime-error-support-bundle-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.json$/,
+      );
+      expect(download.mimeType).toBe("application/json;charset=utf-8;");
+      expect(bundle.error.message).toBe("Trace chart render exploded");
+      expect(bundle.error.stack).toContain("ThrowOnRender");
+      expect(bundle.react.component).toBe("ThrowOnRender");
+      expect(bundle.react.componentStack).toContain("ThrowOnRender");
+      expect(Date.parse(bundle.errorCapturedAt)).toBeLessThanOrEqual(
+        Date.parse(bundle.generatedAt),
+      );
+      expect(
+        screen.getByTestId("error-boundary-support-bundle-status").textContent,
+      ).toContain("Support bundle downloaded");
+    });
+
+    test("keeps component diagnostics when a component throws NaN", () => {
+      const ThrowNaN: FunctionComponent = (): ReactElement => {
+        throw Number.NaN;
+      };
+
+      render(
+        <ErrorBoundary>
+          <ThrowNaN />
+        </ErrorBoundary>,
+      );
+
+      fireEvent.click(
+        screen.getByTestId("error-boundary-download-support-bundle"),
+      );
+
+      const bundle: ErrorSupportBundle = JSON.parse(
+        downloadFileMock.mock.calls[0]![0].content as string,
+      ) as ErrorSupportBundle;
+
+      expect(bundle.error.message).toBe("NaN");
+      expect(bundle.react.componentStack).toContain("ThrowNaN");
+    });
+
+    test("shows a recoverable message if the browser blocks the download", () => {
+      downloadFileMock.mockImplementation(() => {
+        throw new Error("Downloads disabled");
+      });
+
+      render(
+        <ErrorBoundary>
+          <ThrowOnRender />
+        </ErrorBoundary>,
+      );
+
+      fireEvent.click(
+        screen.getByTestId("error-boundary-download-support-bundle"),
+      );
+
+      expect(
+        screen.getByTestId("error-boundary-support-bundle-status").textContent,
+      ).toContain("could not be downloaded");
+      expect(screen.queryByTestId("error-boundary-fallback")).not.toBeNull();
+      expect(reloadMock).not.toHaveBeenCalled();
+    });
+
+    test("downloads fresh diagnostics after recovering and crashing again", () => {
+      let errorMessage: string = "First render failure";
+
+      const ThrowsCurrentError: FunctionComponent = (): ReactElement => {
+        throw new Error(errorMessage);
+      };
+
+      render(
+        <ErrorBoundary>
+          <ThrowsCurrentError />
+        </ErrorBoundary>,
+      );
+
+      fireEvent.click(
+        screen.getByTestId("error-boundary-download-support-bundle"),
+      );
+      const firstBundle: ErrorSupportBundle = JSON.parse(
+        downloadFileMock.mock.calls[0]![0].content as string,
+      ) as ErrorSupportBundle;
+
+      errorMessage = "Second render failure";
+      fireEvent.click(screen.getByTestId("error-boundary-try-again"));
+      fireEvent.click(
+        screen.getByTestId("error-boundary-download-support-bundle"),
+      );
+      const secondBundle: ErrorSupportBundle = JSON.parse(
+        downloadFileMock.mock.calls[1]![0].content as string,
+      ) as ErrorSupportBundle;
+
+      expect(firstBundle.error.message).toBe("First render failure");
+      expect(secondBundle.error.message).toBe("Second render failure");
+      expect(secondBundle.react.componentStack).toContain("ThrowsCurrentError");
+    });
+
     test("changing the resetKey clears the error (navigating away)", () => {
       const { rerender } = render(
         <ErrorBoundary resetKey="/dashboard/monitors/broken">

package/Tests/UI/Components/FeedItemSafeMode.test.tsx

@@ -0,0 +1,74 @@
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+import "@testing-library/jest-dom";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import * as React from "react";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+const markdownViewerMock: MockFunction = getJestMockFunction();
+
+jest.mock("../../../UI/Components/Markdown.tsx/MarkdownViewer", () => {
+  return {
+    __esModule: true,
+    default: (props: MarkdownViewerProps): React.ReactElement => {
+      markdownViewerMock(props);
+      return React.createElement("div", {}, props.text);
+    },
+  };
+});
+
+jest.mock("../../../UI/Components/Modal/ConfirmModal", () => {
+  return {
+    __esModule: true,
+    default: (props: ConfirmModalProps): React.ReactElement => {
+      return React.createElement("div", { role: "dialog" }, props.description);
+    },
+  };
+});
+
+import FeedItem from "../../../UI/Components/Feed/FeedItem";
+import { Blue500 } from "../../../Types/BrandColors";
+import IconProp from "../../../Types/Icon/IconProp";
+
+interface MarkdownViewerProps {
+  text: string;
+  safeMode?: boolean | undefined;
+}
+
+interface ConfirmModalProps {
+  description: React.ReactElement;
+}
+
+afterEach(() => {
+  cleanup();
+  markdownViewerMock.mockReset();
+});
+
+describe("FeedItem safe markdown", () => {
+  test("applies safe mode to both the feed body and More Information modal", () => {
+    render(
+      <FeedItem
+        key="ai-root-cause"
+        textInMarkdown="[Primary link](https://example.com/primary)"
+        moreTextInMarkdown="![Secondary image](https://example.com/image.png)"
+        itemDateTime={new Date("2026-08-07T12:00:00.000Z")}
+        icon={IconProp.Sparkles}
+        color={Blue500}
+        safeMode={true}
+        isLastItem={true}
+      />,
+    );
+
+    expect(markdownViewerMock).toHaveBeenCalledWith({
+      text: "[Primary link](https://example.com/primary)",
+      safeMode: true,
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: "More Information" }));
+
+    expect(screen.getByRole("dialog")).toBeVisible();
+    expect(markdownViewerMock).toHaveBeenCalledWith({
+      text: "![Secondary image](https://example.com/image.png)",
+      safeMode: true,
+    });
+  });
+});