@oneuptime/common 12.0.3 → 12.0.5

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();
   });
 });