@oneuptime/common 11.7.0 → 11.7.2

package/Tests/Utils/Dashboard/VariableUrlState.test.ts

@@ -0,0 +1,219 @@
+import DashboardVariableUrlState, {
+  VariableUrlSnapshot,
+} from "../../../Utils/Dashboard/VariableUrlState";
+import DashboardVariable, {
+  DashboardVariableType,
+} from "../../../Types/Dashboard/DashboardVariable";
+
+function makeVariable(data: Partial<DashboardVariable>): DashboardVariable {
+  return {
+    id: data.id || "id",
+    name: data.name || "cluster",
+    type: data.type || DashboardVariableType.CustomList,
+    ...data,
+  };
+}
+
+describe("DashboardVariableUrlState", () => {
+  describe("parseFromSearch", () => {
+    test("returns an empty object for an empty search string", () => {
+      expect(DashboardVariableUrlState.parseFromSearch("")).toEqual({});
+    });
+
+    test("ignores params that are not prefixed with var-", () => {
+      const result: Record<string, VariableUrlSnapshot> =
+        DashboardVariableUrlState.parseFromSearch(
+          "?token=abc&filter=on&page=2",
+        );
+      expect(result).toEqual({});
+    });
+
+    test("parses a single-value variable", () => {
+      const result: Record<string, VariableUrlSnapshot> =
+        DashboardVariableUrlState.parseFromSearch("?var-cluster=prod");
+      expect(result).toEqual({ cluster: { selectedValue: "prod" } });
+    });
+
+    test("works whether or not a leading ? is present", () => {
+      expect(
+        DashboardVariableUrlState.parseFromSearch("var-cluster=prod"),
+      ).toEqual({ cluster: { selectedValue: "prod" } });
+    });
+
+    test("parses a comma-separated multi-value variable", () => {
+      const result: Record<string, VariableUrlSnapshot> =
+        DashboardVariableUrlState.parseFromSearch(
+          "?var-region=us-east,us-west,eu",
+        );
+      expect(result).toEqual({
+        region: { selectedValues: ["us-east", "us-west", "eu"] },
+      });
+    });
+
+    test("trims whitespace and drops empty entries in multi-value lists", () => {
+      const result: Record<string, VariableUrlSnapshot> =
+        DashboardVariableUrlState.parseFromSearch("?var-region=a, ,b, c ,");
+      expect(result["region"]?.selectedValues).toEqual(["a", "b", "c"]);
+    });
+
+    test("skips a var- param with an empty name", () => {
+      expect(DashboardVariableUrlState.parseFromSearch("?var-=x")).toEqual({});
+    });
+
+    test("decodes url-encoded values", () => {
+      const result: Record<string, VariableUrlSnapshot> =
+        DashboardVariableUrlState.parseFromSearch(
+          "?var-service=" + encodeURIComponent("my service"),
+        );
+      expect(result["service"]?.selectedValue).toBe("my service");
+    });
+
+    test("parses several variables together", () => {
+      const result: Record<string, VariableUrlSnapshot> =
+        DashboardVariableUrlState.parseFromSearch(
+          "?var-cluster=prod&var-region=a,b&other=1",
+        );
+      expect(result).toEqual({
+        cluster: { selectedValue: "prod" },
+        region: { selectedValues: ["a", "b"] },
+      });
+    });
+  });
+
+  describe("applyUrlToVariables", () => {
+    test("returns the same variable untouched when the url has no entry", () => {
+      const variable: DashboardVariable = makeVariable({ name: "cluster" });
+      const result: Array<DashboardVariable> =
+        DashboardVariableUrlState.applyUrlToVariables([variable], {});
+      expect(result[0]).toBe(variable);
+    });
+
+    test("applies a single selected value from the url", () => {
+      const variable: DashboardVariable = makeVariable({ name: "cluster" });
+      const result: Array<DashboardVariable> =
+        DashboardVariableUrlState.applyUrlToVariables([variable], {
+          cluster: { selectedValue: "prod" },
+        });
+      expect(result[0]?.selectedValue).toBe("prod");
+      expect(result[0]?.selectedValues).toBeUndefined();
+    });
+
+    test("applies multi-selected values from the url", () => {
+      const variable: DashboardVariable = makeVariable({ name: "region" });
+      const result: Array<DashboardVariable> =
+        DashboardVariableUrlState.applyUrlToVariables([variable], {
+          region: { selectedValues: ["a", "b"] },
+        });
+      expect(result[0]?.selectedValues).toEqual(["a", "b"]);
+    });
+
+    test("does not mutate the original variable object", () => {
+      const variable: DashboardVariable = makeVariable({
+        name: "cluster",
+        selectedValue: "old",
+      });
+      DashboardVariableUrlState.applyUrlToVariables([variable], {
+        cluster: { selectedValue: "new" },
+      });
+      expect(variable.selectedValue).toBe("old");
+    });
+
+    test("matches url state to variables by name", () => {
+      const clusterVar: DashboardVariable = makeVariable({ name: "cluster" });
+      const regionVar: DashboardVariable = makeVariable({ name: "region" });
+      const result: Array<DashboardVariable> =
+        DashboardVariableUrlState.applyUrlToVariables([clusterVar, regionVar], {
+          region: { selectedValue: "eu" },
+        });
+      expect(result[0]?.selectedValue).toBeUndefined();
+      expect(result[1]?.selectedValue).toBe("eu");
+    });
+  });
+
+  describe("parse -> apply round trip", () => {
+    test("a shared url reproduces the selection on the variables", () => {
+      const variables: Array<DashboardVariable> = [
+        makeVariable({ name: "cluster" }),
+        makeVariable({ name: "region" }),
+      ];
+
+      const fromUrl: Record<string, VariableUrlSnapshot> =
+        DashboardVariableUrlState.parseFromSearch(
+          "?var-cluster=prod&var-region=us,eu",
+        );
+      const applied: Array<DashboardVariable> =
+        DashboardVariableUrlState.applyUrlToVariables(variables, fromUrl);
+
+      expect(applied[0]?.selectedValue).toBe("prod");
+      expect(applied[1]?.selectedValues).toEqual(["us", "eu"]);
+    });
+  });
+
+  describe("writeToBrowserUrl", () => {
+    /*
+     * The test environment is jsdom, so window/history/location exist. Reset
+     * the URL before each case so assertions don't leak between tests.
+     */
+    beforeEach(() => {
+      window.history.replaceState({}, "", "/dashboard");
+    });
+
+    test("writes a single selected value as a var- param", () => {
+      DashboardVariableUrlState.writeToBrowserUrl([
+        makeVariable({ name: "cluster", selectedValue: "prod" }),
+      ]);
+      expect(window.location.search).toBe("?var-cluster=prod");
+    });
+
+    test("writes multi-selected values joined by commas", () => {
+      DashboardVariableUrlState.writeToBrowserUrl([
+        makeVariable({ name: "region", selectedValues: ["us", "eu"] }),
+      ]);
+      expect(
+        DashboardVariableUrlState.parseFromSearch(window.location.search)[
+          "region"
+        ]?.selectedValues,
+      ).toEqual(["us", "eu"]);
+    });
+
+    test("preserves unrelated query params while replacing var- params", () => {
+      window.history.replaceState({}, "", "/dashboard?token=abc&var-old=gone");
+      DashboardVariableUrlState.writeToBrowserUrl([
+        makeVariable({ name: "cluster", selectedValue: "prod" }),
+      ]);
+      const params: URLSearchParams = new URLSearchParams(
+        window.location.search,
+      );
+      expect(params.get("token")).toBe("abc");
+      expect(params.get("var-cluster")).toBe("prod");
+      // The previously-present var-old must be stripped.
+      expect(params.has("var-old")).toBe(false);
+    });
+
+    test("omits variables that have no selection", () => {
+      DashboardVariableUrlState.writeToBrowserUrl([
+        makeVariable({ name: "cluster" }),
+      ]);
+      expect(window.location.search).toBe("");
+    });
+
+    test("does not push a new history entry (uses replaceState)", () => {
+      const lengthBefore: number = window.history.length;
+      DashboardVariableUrlState.writeToBrowserUrl([
+        makeVariable({ name: "cluster", selectedValue: "prod" }),
+      ]);
+      expect(window.history.length).toBe(lengthBefore);
+    });
+
+    test("write -> parse round trip preserves the selection", () => {
+      DashboardVariableUrlState.writeToBrowserUrl([
+        makeVariable({ name: "cluster", selectedValue: "prod" }),
+        makeVariable({ name: "region", selectedValues: ["us", "eu"] }),
+      ]);
+      const parsed: Record<string, VariableUrlSnapshot> =
+        DashboardVariableUrlState.parseFromSearch(window.location.search);
+      expect(parsed["cluster"]?.selectedValue).toBe("prod");
+      expect(parsed["region"]?.selectedValues).toEqual(["us", "eu"]);
+    });
+  });
+});

package/Tests/Utils/Incident/IncidentMetricType.test.ts

@@ -0,0 +1,174 @@
+import IncidentMetricTypeUtil from "../../../Utils/Incident/IncidentMetricType";
+import IncidentMetricType from "../../../Types/Incident/IncidentMetricType";
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+
+describe("IncidentMetricTypeUtil", () => {
+  describe("getAggregationTypeByIncidentMetricType", () => {
+    test.each([
+      [IncidentMetricType.IncidentCount, AggregationType.Sum],
+      [IncidentMetricType.SeverityChange, AggregationType.Sum],
+      [IncidentMetricType.TimeToAcknowledge, AggregationType.Avg],
+      [IncidentMetricType.TimeToResolve, AggregationType.Avg],
+      [IncidentMetricType.IncidentDuration, AggregationType.Avg],
+      [IncidentMetricType.TimeInState, AggregationType.Avg],
+      [IncidentMetricType.PostmortemCompletionTime, AggregationType.Avg],
+    ])(
+      "%s aggregates as %s",
+      (metricType: IncidentMetricType, expected: AggregationType) => {
+        expect(
+          IncidentMetricTypeUtil.getAggregationTypeByIncidentMetricType(
+            metricType,
+          ),
+        ).toBe(expected);
+      },
+    );
+
+    test("throws for the unhandled TimeToRootCausePosted metric type", () => {
+      /*
+       * TimeToRootCausePosted is written directly by the investigation
+       * runner and is intentionally not part of the aggregation switch.
+       */
+      expect(() => {
+        return IncidentMetricTypeUtil.getAggregationTypeByIncidentMetricType(
+          IncidentMetricType.TimeToRootCausePosted,
+        );
+      }).toThrow("Invalid IncidentMetricType value");
+    });
+
+    test("throws for an unknown metric type", () => {
+      expect(() => {
+        return IncidentMetricTypeUtil.getAggregationTypeByIncidentMetricType(
+          "not-a-real-metric" as IncidentMetricType,
+        );
+      }).toThrow("Invalid IncidentMetricType value");
+    });
+  });
+
+  describe("getAllIncidentMetricTypes", () => {
+    test("returns the four core metric types", () => {
+      expect(IncidentMetricTypeUtil.getAllIncidentMetricTypes()).toEqual([
+        IncidentMetricType.IncidentCount,
+        IncidentMetricType.TimeToAcknowledge,
+        IncidentMetricType.TimeToResolve,
+        IncidentMetricType.IncidentDuration,
+      ]);
+    });
+
+    test("every returned core type resolves to a valid aggregation type", () => {
+      for (const metricType of IncidentMetricTypeUtil.getAllIncidentMetricTypes()) {
+        expect(() => {
+          return IncidentMetricTypeUtil.getAggregationTypeByIncidentMetricType(
+            metricType,
+          );
+        }).not.toThrow();
+      }
+    });
+  });
+
+  describe("getTitleByIncidentMetricType", () => {
+    test.each([
+      [IncidentMetricType.IncidentCount, "Incident Count"],
+      [IncidentMetricType.TimeToAcknowledge, "Time to Acknowledge"],
+      [IncidentMetricType.TimeToResolve, "Time to Resolve"],
+      [IncidentMetricType.IncidentDuration, "Incident Duration"],
+      [IncidentMetricType.TimeInState, "Time in State"],
+      [IncidentMetricType.SeverityChange, "Severity Changes"],
+      [
+        IncidentMetricType.PostmortemCompletionTime,
+        "Postmortem Completion Time",
+      ],
+    ])("%s -> %s", (metricType: IncidentMetricType, expected: string) => {
+      expect(
+        IncidentMetricTypeUtil.getTitleByIncidentMetricType(metricType),
+      ).toBe(expected);
+    });
+
+    test("returns empty string for an unknown metric type", () => {
+      expect(
+        IncidentMetricTypeUtil.getTitleByIncidentMetricType(
+          "unknown" as IncidentMetricType,
+        ),
+      ).toBe("");
+    });
+  });
+
+  describe("getDescriptionByIncidentMetricType", () => {
+    test.each([
+      IncidentMetricType.IncidentCount,
+      IncidentMetricType.TimeToAcknowledge,
+      IncidentMetricType.TimeToResolve,
+      IncidentMetricType.IncidentDuration,
+      IncidentMetricType.TimeInState,
+      IncidentMetricType.SeverityChange,
+      IncidentMetricType.PostmortemCompletionTime,
+    ])("%s returns a non-empty sentence", (metricType: IncidentMetricType) => {
+      const description: string =
+        IncidentMetricTypeUtil.getDescriptionByIncidentMetricType(metricType);
+      expect(description.length).toBeGreaterThan(0);
+      expect(description.endsWith(".")).toBe(true);
+    });
+
+    test("returns empty string for an unknown metric type", () => {
+      expect(
+        IncidentMetricTypeUtil.getDescriptionByIncidentMetricType(
+          "unknown" as IncidentMetricType,
+        ),
+      ).toBe("");
+    });
+  });
+
+  describe("getLegendByIncidentMetricType", () => {
+    test.each([
+      [IncidentMetricType.IncidentCount, "Incidents"],
+      [IncidentMetricType.TimeToAcknowledge, "Time to Acknowledge"],
+      [IncidentMetricType.TimeToResolve, "Time to Resolve"],
+      [IncidentMetricType.IncidentDuration, "Duration"],
+      [IncidentMetricType.TimeInState, "Time in State"],
+      [IncidentMetricType.SeverityChange, "Severity Changes"],
+      [IncidentMetricType.PostmortemCompletionTime, "Postmortem Time"],
+    ])("%s -> %s", (metricType: IncidentMetricType, expected: string) => {
+      expect(
+        IncidentMetricTypeUtil.getLegendByIncidentMetricType(metricType),
+      ).toBe(expected);
+    });
+
+    test("returns empty string for an unknown metric type", () => {
+      expect(
+        IncidentMetricTypeUtil.getLegendByIncidentMetricType(
+          "unknown" as IncidentMetricType,
+        ),
+      ).toBe("");
+    });
+  });
+
+  describe("getLegendUnitByIncidentMetricType", () => {
+    test.each([
+      IncidentMetricType.IncidentCount,
+      IncidentMetricType.SeverityChange,
+    ])("%s has no unit", (metricType: IncidentMetricType) => {
+      expect(
+        IncidentMetricTypeUtil.getLegendUnitByIncidentMetricType(metricType),
+      ).toBe("");
+    });
+
+    test.each([
+      IncidentMetricType.TimeToAcknowledge,
+      IncidentMetricType.TimeToResolve,
+      IncidentMetricType.IncidentDuration,
+      IncidentMetricType.TimeInState,
+      IncidentMetricType.PostmortemCompletionTime,
+    ])("%s is measured in seconds", (metricType: IncidentMetricType) => {
+      expect(
+        IncidentMetricTypeUtil.getLegendUnitByIncidentMetricType(metricType),
+      ).toBe("s");
+    });
+
+    test("returns empty string for an unknown metric type", () => {
+      expect(
+        IncidentMetricTypeUtil.getLegendUnitByIncidentMetricType(
+          "unknown" as IncidentMetricType,
+        ),
+      ).toBe("");
+    });
+  });
+});

package/Tests/Utils/Monitor/MonitorProbeSelectionUtil.test.ts

@@ -0,0 +1,145 @@
+import MonitorProbeSelectionUtil, {
+  ProbeSelectionCandidate,
+} from "../../../Utils/Monitor/MonitorProbeSelectionUtil";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * The monitor create form pre-selects the probe picker with the set the server
+ * would have attached on its own (MonitorService.addDefaultProbesToMonitor).
+ * If these two ever disagree, opening the form and pressing Create silently
+ * changes which probes watch the monitor - so the rule is pinned here:
+ *
+ *   - only probes that opted in via shouldAutoEnableProbeOnNewMonitors,
+ *   - minus every global probe when the project turned global probes off,
+ *   - deduplicated, because MonitorProbe has no unique index and the second
+ *     insert is rejected with "Probe is already added to this monitor."
+ */
+
+const GLOBAL_PROBE: ProbeSelectionCandidate = {
+  id: "11111111-1111-4111-8111-111111111111",
+  isGlobalProbe: true,
+  shouldAutoEnableProbeOnNewMonitors: true,
+};
+
+const CUSTOM_PROBE: ProbeSelectionCandidate = {
+  id: "22222222-2222-4222-8222-222222222222",
+  isGlobalProbe: false,
+  shouldAutoEnableProbeOnNewMonitors: true,
+};
+
+const OPTED_OUT_CUSTOM_PROBE: ProbeSelectionCandidate = {
+  id: "33333333-3333-4333-8333-333333333333",
+  isGlobalProbe: false,
+  shouldAutoEnableProbeOnNewMonitors: false,
+};
+
+const OPTED_OUT_GLOBAL_PROBE: ProbeSelectionCandidate = {
+  id: "44444444-4444-4444-8444-444444444444",
+  isGlobalProbe: true,
+  shouldAutoEnableProbeOnNewMonitors: false,
+};
+
+describe("MonitorProbeSelectionUtil.getDefaultSelectedProbeIds", () => {
+  it("selects every probe flagged to auto-enable on new monitors", () => {
+    expect(
+      MonitorProbeSelectionUtil.getDefaultSelectedProbeIds({
+        probes: [GLOBAL_PROBE, CUSTOM_PROBE],
+      }),
+    ).toEqual([GLOBAL_PROBE.id, CUSTOM_PROBE.id]);
+  });
+
+  it("leaves out probes that did not opt in, global or custom", () => {
+    expect(
+      MonitorProbeSelectionUtil.getDefaultSelectedProbeIds({
+        probes: [
+          GLOBAL_PROBE,
+          OPTED_OUT_GLOBAL_PROBE,
+          CUSTOM_PROBE,
+          OPTED_OUT_CUSTOM_PROBE,
+        ],
+      }),
+    ).toEqual([GLOBAL_PROBE.id, CUSTOM_PROBE.id]);
+  });
+
+  it("drops global probes when the project disabled them for new monitors", () => {
+    expect(
+      MonitorProbeSelectionUtil.getDefaultSelectedProbeIds({
+        probes: [GLOBAL_PROBE, CUSTOM_PROBE],
+        doNotAddGlobalProbesByDefaultOnNewMonitors: true,
+      }),
+    ).toEqual([CUSTOM_PROBE.id]);
+  });
+
+  it("keeps global probes when the project setting is false or unset", () => {
+    expect(
+      MonitorProbeSelectionUtil.getDefaultSelectedProbeIds({
+        probes: [GLOBAL_PROBE],
+        doNotAddGlobalProbesByDefaultOnNewMonitors: false,
+      }),
+    ).toEqual([GLOBAL_PROBE.id]);
+
+    expect(
+      MonitorProbeSelectionUtil.getDefaultSelectedProbeIds({
+        probes: [GLOBAL_PROBE],
+        doNotAddGlobalProbesByDefaultOnNewMonitors: undefined,
+      }),
+    ).toEqual([GLOBAL_PROBE.id]);
+  });
+
+  it("returns an empty list when nothing opted in", () => {
+    expect(
+      MonitorProbeSelectionUtil.getDefaultSelectedProbeIds({
+        probes: [OPTED_OUT_GLOBAL_PROBE, OPTED_OUT_CUSTOM_PROBE],
+      }),
+    ).toEqual([]);
+  });
+
+  it("returns an empty list for an empty probe list", () => {
+    expect(
+      MonitorProbeSelectionUtil.getDefaultSelectedProbeIds({
+        probes: [],
+      }),
+    ).toEqual([]);
+  });
+
+  it("deduplicates a probe that appears in more than one source list", () => {
+    expect(
+      MonitorProbeSelectionUtil.getDefaultSelectedProbeIds({
+        probes: [GLOBAL_PROBE, { ...GLOBAL_PROBE }, CUSTOM_PROBE],
+      }),
+    ).toEqual([GLOBAL_PROBE.id, CUSTOM_PROBE.id]);
+  });
+
+  it("ignores probes with no id rather than sending an empty id to the server", () => {
+    expect(
+      MonitorProbeSelectionUtil.getDefaultSelectedProbeIds({
+        probes: [
+          {
+            id: "",
+            isGlobalProbe: false,
+            shouldAutoEnableProbeOnNewMonitors: true,
+          },
+          CUSTOM_PROBE,
+        ],
+      }),
+    ).toEqual([CUSTOM_PROBE.id]);
+  });
+});
+
+describe("MonitorProbeSelectionUtil.dedupeProbeIds", () => {
+  it("keeps the first occurrence and preserves order", () => {
+    expect(
+      MonitorProbeSelectionUtil.dedupeProbeIds(["a", "b", "a", "c", "b"]),
+    ).toEqual(["a", "b", "c"]);
+  });
+
+  it("drops empty ids", () => {
+    expect(MonitorProbeSelectionUtil.dedupeProbeIds(["", "a", ""])).toEqual([
+      "a",
+    ]);
+  });
+
+  it("handles an empty list", () => {
+    expect(MonitorProbeSelectionUtil.dedupeProbeIds([])).toEqual([]);
+  });
+});