@oneuptime/common 12.0.4 → 12.0.5

package/Tests/Types/Monitor/SnmpMonitor/SnmpVendorTemplate.test.ts

@@ -0,0 +1,151 @@
+import SnmpOid from "../../../../Types/Monitor/SnmpMonitor/SnmpOid";
+import SnmpVendorTemplateUtil, {
+  SnmpVendorTemplate,
+  SnmpVendorTemplates,
+} from "../../../../Types/Monitor/SnmpMonitor/SnmpVendorTemplate";
+
+describe("SnmpVendorTemplateUtil", () => {
+  describe("getAll", () => {
+    test("returns every registered template", () => {
+      expect(SnmpVendorTemplateUtil.getAll()).toBe(SnmpVendorTemplates);
+      expect(SnmpVendorTemplateUtil.getAll().length).toBeGreaterThan(0);
+    });
+
+    test("every template has an id, label, description and at least one oid", () => {
+      const seenIds: Set<string> = new Set<string>();
+
+      for (const template of SnmpVendorTemplateUtil.getAll()) {
+        expect(template.id.length).toBeGreaterThan(0);
+        expect(template.label.length).toBeGreaterThan(0);
+        expect(template.description.length).toBeGreaterThan(0);
+        expect(template.oids.length).toBeGreaterThan(0);
+
+        // Ids are unique so getById is unambiguous.
+        expect(seenIds.has(template.id)).toBe(false);
+        seenIds.add(template.id);
+
+        // Each oid within a template carries an OID string.
+        for (const oid of template.oids) {
+          expect(oid.oid.length).toBeGreaterThan(0);
+        }
+      }
+    });
+  });
+
+  describe("getById", () => {
+    test("returns the matching template", () => {
+      const first: SnmpVendorTemplate = SnmpVendorTemplateUtil.getAll()[0]!;
+      expect(SnmpVendorTemplateUtil.getById(first.id)).toBe(first);
+    });
+
+    test("returns undefined for an unknown id", () => {
+      expect(SnmpVendorTemplateUtil.getById("does-not-exist")).toBeUndefined();
+    });
+  });
+
+  describe("mergeOids", () => {
+    test("returns the existing list unchanged for an unknown template id", () => {
+      const existing: Array<SnmpOid> = [{ oid: "1.2.3", name: "custom" }];
+
+      const merged: Array<SnmpOid> = SnmpVendorTemplateUtil.mergeOids(
+        existing,
+        "does-not-exist",
+      );
+
+      expect(merged).toBe(existing);
+    });
+
+    test("appends all of a template's oids onto an empty list", () => {
+      const template: SnmpVendorTemplate = SnmpVendorTemplateUtil.getAll()[0]!;
+
+      const merged: Array<SnmpOid> = SnmpVendorTemplateUtil.mergeOids(
+        [],
+        template.id,
+      );
+
+      expect(
+        merged.map((o: SnmpOid) => {
+          return o.oid;
+        }),
+      ).toEqual(
+        template.oids.map((o: SnmpOid) => {
+          return o.oid;
+        }),
+      );
+    });
+
+    test("does not duplicate an oid that already exists", () => {
+      const template: SnmpVendorTemplate = SnmpVendorTemplateUtil.getAll()[0]!;
+      const firstOid: SnmpOid = template.oids[0]!;
+
+      const merged: Array<SnmpOid> = SnmpVendorTemplateUtil.mergeOids(
+        [{ oid: firstOid.oid, name: "already here" }],
+        template.id,
+      );
+
+      const occurrences: number = merged.filter((o: SnmpOid) => {
+        return o.oid === firstOid.oid;
+      }).length;
+      expect(occurrences).toBe(1);
+
+      // The pre-existing entry is preserved (not overwritten by the template's).
+      expect(merged[0]).toEqual({ oid: firstOid.oid, name: "already here" });
+
+      // The merged list has one entry per distinct oid in existing ∪ template.
+      expect(merged.length).toBe(template.oids.length);
+    });
+
+    test("is idempotent — applying the same template twice adds nothing new", () => {
+      const template: SnmpVendorTemplate = SnmpVendorTemplateUtil.getAll()[0]!;
+
+      const once: Array<SnmpOid> = SnmpVendorTemplateUtil.mergeOids(
+        [],
+        template.id,
+      );
+      const twice: Array<SnmpOid> = SnmpVendorTemplateUtil.mergeOids(
+        once,
+        template.id,
+      );
+
+      expect(
+        twice.map((o: SnmpOid) => {
+          return o.oid;
+        }),
+      ).toEqual(
+        once.map((o: SnmpOid) => {
+          return o.oid;
+        }),
+      );
+    });
+
+    test("preserves the caller's existing oids and appends only new ones", () => {
+      const template: SnmpVendorTemplate = SnmpVendorTemplateUtil.getAll()[0]!;
+      const custom: SnmpOid = { oid: "9.9.9.9", name: "custom metric" };
+
+      const merged: Array<SnmpOid> = SnmpVendorTemplateUtil.mergeOids(
+        [custom],
+        template.id,
+      );
+
+      // Existing custom oid stays first, template oids follow.
+      expect(merged[0]).toEqual(custom);
+      expect(merged.length).toBe(1 + template.oids.length);
+      for (const oid of template.oids) {
+        expect(
+          merged.map((o: SnmpOid) => {
+            return o.oid;
+          }),
+        ).toContain(oid.oid);
+      }
+    });
+
+    test("does not mutate the input array", () => {
+      const template: SnmpVendorTemplate = SnmpVendorTemplateUtil.getAll()[0]!;
+      const existing: Array<SnmpOid> = [{ oid: "9.9.9.9" }];
+
+      SnmpVendorTemplateUtil.mergeOids(existing, template.id);
+
+      expect(existing).toEqual([{ oid: "9.9.9.9" }]);
+    });
+  });
+});

package/Tests/Types/Permission.test.ts

@@ -1,6 +1,7 @@
 import ObjectID from "../../Types/ObjectID";
 import Permission, {
   PermissionHelper,
+  PermissionProps,
   UserPermission,
 } from "../../Types/Permission";
 import PermissionScope from "../../Types/Database/AccessControl/PermissionScope";
@@ -15,6 +16,142 @@ describe("Permission", () => {
   });
 });
 
+/*
+ * Integrity of the permission catalogue itself.
+ *
+ * Both invariants below were violated in this file for a long time and neither
+ * failure was visible from the outside:
+ *
+ *  - CreateScheduledMaintenanceTemplateOwnerUser and ...OwnerTeam were declared
+ *    with the string values of their non-template counterparts, so two distinct
+ *    capabilities were one permission wearing two names. Granting either
+ *    conferred both, and owner rows feed the Owned permission scope, so it
+ *    widened access to scheduled maintenance events the holder did not own.
+ *
+ *  - Sixteen permissions had their PermissionProps object listed twice, so the
+ *    dashboard's granular picker offered each of them twice.
+ *
+ * A duplicate is silent by construction: TypeScript is happy, every lookup
+ * still resolves, and the only symptom is a picker entry that does not do what
+ * its label says. These tests are the tripwire.
+ */
+describe("Permission catalogue integrity", () => {
+  test("no two enum members share a string value", () => {
+    const seen: Map<string, string> = new Map();
+    const collisions: Array<string> = [];
+
+    for (const [name, value] of Object.entries(Permission)) {
+      const previous: string | undefined = seen.get(value);
+
+      if (previous) {
+        collisions.push(`${previous} and ${name} both = "${value}"`);
+        continue;
+      }
+
+      seen.set(value, name);
+    }
+
+    expect(collisions).toEqual([]);
+  });
+
+  test("getAllPermissionProps has no duplicate permission entries", () => {
+    const counts: Map<Permission, number> = new Map();
+
+    for (const props of PermissionHelper.getAllPermissionProps()) {
+      counts.set(props.permission, (counts.get(props.permission) || 0) + 1);
+    }
+
+    const duplicates: Array<string> = [];
+    for (const [permission, count] of counts) {
+      if (count > 1) {
+        duplicates.push(`${permission} x${count}`);
+      }
+    }
+
+    expect(duplicates).toEqual([]);
+  });
+
+  test("every props entry round-trips through getTitle and getDescription", () => {
+    /*
+     * getTitle/getDescription take the FIRST match while
+     * getAllPermissionPropsAsDictionary is last-wins. With duplicates present
+     * those two disagree, and the dashboard and the API reference then show
+     * different text for the same permission.
+     */
+    for (const props of PermissionHelper.getAllPermissionProps()) {
+      expect(PermissionHelper.getTitle(props.permission)).toBe(props.title);
+      expect(PermissionHelper.getDescription(props.permission)).toBe(
+        props.description,
+      );
+    }
+  });
+
+  test("the props dictionary covers every props entry", () => {
+    const dictionary: Record<string, PermissionProps> =
+      PermissionHelper.getAllPermissionPropsAsDictionary() as Record<
+        string,
+        PermissionProps
+      >;
+
+    for (const props of PermissionHelper.getAllPermissionProps()) {
+      expect(dictionary[props.permission]).toBeDefined();
+      expect(dictionary[props.permission]!.title).toBe(props.title);
+    }
+  });
+
+  test("no props entry is keyed to a permission from another resource family", () => {
+    /*
+     * The template-owner bug was a mis-keyed entry: the title said "Template"
+     * while the permission pointed at the non-template member. Catch the shape
+     * generically — a title containing "Template" must belong to a permission
+     * whose name contains "Template", and vice versa.
+     */
+    const mismatched: Array<string> = [];
+
+    for (const props of PermissionHelper.getAllPermissionProps()) {
+      const titleSaysTemplate: boolean = props.title.includes("Template");
+      const keySaysTemplate: boolean = props.permission
+        .toString()
+        .includes("Template");
+
+      if (titleSaysTemplate !== keySaysTemplate) {
+        mismatched.push(`${props.permission} titled "${props.title}"`);
+      }
+    }
+
+    expect(mismatched).toEqual([]);
+  });
+
+  test("every tenant-assignable permission has a non-empty title and description", () => {
+    const bad: Array<string> = [];
+
+    for (const props of PermissionHelper.getTenantPermissionProps()) {
+      if (!props.title.trim() || !props.description.trim()) {
+        bad.push(props.permission.toString());
+      }
+    }
+
+    expect(bad).toEqual([]);
+  });
+
+  test("roles and granular permissions partition the assignable set", () => {
+    const assignable: Array<PermissionProps> =
+      PermissionHelper.getTenantPermissionProps();
+    const roles: Array<PermissionProps> =
+      PermissionHelper.getRolePermissionProps();
+
+    const granular: Array<PermissionProps> = assignable.filter(
+      (props: PermissionProps) => {
+        return !props.isRolePermission;
+      },
+    );
+
+    expect(roles.length + granular.length).toBe(assignable.length);
+    expect(roles.length).toBeGreaterThan(10);
+    expect(granular.length).toBeGreaterThan(100);
+  });
+});
+
 const makeRow: (
   permission: Permission,
   scope: PermissionScope | undefined,

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/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", () => {
@@ -208,6 +233,20 @@ describe("ErrorBoundary", () => {
         screen.getByTestId("error-boundary-error-message").textContent,
       ).toContain("reading 'queryConfigs'");
     });
+
+    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();
+    });
   });
 
   describe("reporting", () => {
@@ -222,6 +261,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 +334,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">