@oneuptime/common 11.6.2 → 11.7.1

package/Tests/Types/Monitor/MonitorSteps.test.ts

@@ -0,0 +1,183 @@
+import MonitorSteps from "../../../Types/Monitor/MonitorSteps";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+import { JSONObject, ObjectType } from "../../../Types/JSON";
+import BadDataException from "../../../Types/Exception/BadDataException";
+
+/*
+ * MonitorSteps is the top-level DatabaseProperty stored on a Monitor: an array
+ * of MonitorStep plus the default monitor status. These tests lock in the
+ * factory shape, toJSON/fromJSON round-trip (including the deliberately lenient
+ * fromJSON(undefined) -> empty instance), and the validation contract.
+ */
+
+const buildDefaultSteps: () => MonitorSteps = (): MonitorSteps => {
+  return MonitorSteps.getDefaultMonitorSteps({
+    defaultMonitorStatusId: new ObjectID("100000000000000000000001"),
+    monitorType: MonitorType.Manual,
+    monitorName: "My Monitor",
+    onlineMonitorStatusId: new ObjectID("100000000000000000000002"),
+    offlineMonitorStatusId: new ObjectID("100000000000000000000003"),
+    defaultIncidentSeverityId: new ObjectID("100000000000000000000004"),
+    defaultAlertSeverityId: new ObjectID("100000000000000000000005"),
+  });
+};
+
+describe("MonitorSteps", () => {
+  describe("getNewMonitorStepsAsJSON", () => {
+    test("wraps a single default step under the MonitorSteps type", () => {
+      const json: JSONObject = MonitorSteps.getNewMonitorStepsAsJSON();
+      expect(json["_type"]).toBe(ObjectType.MonitorSteps);
+      const value: JSONObject = json["value"] as JSONObject;
+      expect(Array.isArray(value["monitorStepsInstanceArray"])).toBe(true);
+      expect(
+        (value["monitorStepsInstanceArray"] as Array<unknown>).length,
+      ).toBe(1);
+      expect(value["defaultMonitorStatusId"]).toBeUndefined();
+    });
+  });
+
+  describe("getDefaultMonitorSteps", () => {
+    test("creates one step and carries the default monitor status id", () => {
+      const steps: MonitorSteps = buildDefaultSteps();
+      expect(steps.data?.monitorStepsInstanceArray).toHaveLength(1);
+      expect(steps.data?.monitorStepsInstanceArray[0]).toBeInstanceOf(
+        MonitorStep,
+      );
+      expect(steps.data?.defaultMonitorStatusId?.toString()).toBe(
+        "100000000000000000000001",
+      );
+    });
+  });
+
+  describe("toJSON / fromJSON round-trip", () => {
+    test("serializes with the MonitorSteps type wrapper", () => {
+      const steps: MonitorSteps = buildDefaultSteps();
+      const json: JSONObject = steps.toJSON();
+      expect(json["_type"]).toBe(ObjectType.MonitorSteps);
+      expect((json["value"] as JSONObject)["defaultMonitorStatusId"]).toBe(
+        "100000000000000000000001",
+      );
+    });
+
+    test("round-trips the default status id and step count", () => {
+      const steps: MonitorSteps = buildDefaultSteps();
+      const restored: MonitorSteps = MonitorSteps.fromJSON(steps.toJSON());
+      expect(restored.data?.defaultMonitorStatusId?.toString()).toBe(
+        "100000000000000000000001",
+      );
+      expect(restored.data?.monitorStepsInstanceArray).toHaveLength(1);
+      expect(restored.data?.monitorStepsInstanceArray[0]).toBeInstanceOf(
+        MonitorStep,
+      );
+    });
+
+    test("toString returns a JSON string of the serialized value", () => {
+      const steps: MonitorSteps = buildDefaultSteps();
+      const asString: string = steps.toString();
+      const parsed: JSONObject = JSON.parse(asString) as JSONObject;
+      expect(parsed["_type"]).toBe(ObjectType.MonitorSteps);
+    });
+  });
+
+  describe("fromJSON leniency and validation", () => {
+    test("returns an empty instance for undefined input", () => {
+      const steps: MonitorSteps = MonitorSteps.fromJSON(undefined);
+      expect(steps).toBeInstanceOf(MonitorSteps);
+    });
+
+    test("returns the same instance when given a MonitorSteps", () => {
+      const steps: MonitorSteps = buildDefaultSteps();
+      expect(MonitorSteps.fromJSON(steps)).toBe(steps);
+    });
+
+    test("throws on a wrong _type", () => {
+      expect(() => {
+        return MonitorSteps.fromJSON({ _type: "Nope", value: {} });
+      }).toThrow(BadDataException);
+    });
+
+    test("throws when value is missing", () => {
+      expect(() => {
+        return MonitorSteps.fromJSON({ _type: "MonitorSteps" });
+      }).toThrow(BadDataException);
+    });
+
+    test("throws when monitorStepsInstanceArray is missing", () => {
+      expect(() => {
+        return MonitorSteps.fromJSON({
+          _type: "MonitorSteps",
+          value: { defaultMonitorStatusId: undefined },
+        });
+      }).toThrow(BadDataException);
+    });
+  });
+
+  describe("getValidationError", () => {
+    test("errors when data is missing", () => {
+      const steps: MonitorSteps = new MonitorSteps();
+      steps.data = undefined;
+      expect(MonitorSteps.getValidationError(steps, MonitorType.Manual)).toBe(
+        "Monitor Steps is required",
+      );
+    });
+
+    test("errors when the step array is empty", () => {
+      const steps: MonitorSteps = new MonitorSteps();
+      steps.data = {
+        monitorStepsInstanceArray: [],
+        defaultMonitorStatusId: new ObjectID("100000000000000000000001"),
+      };
+      expect(MonitorSteps.getValidationError(steps, MonitorType.Manual)).toBe(
+        "Monitor Steps is required",
+      );
+    });
+
+    test("errors when the default monitor status id is missing", () => {
+      const steps: MonitorSteps = buildDefaultSteps();
+      steps.data!.defaultMonitorStatusId = undefined;
+      expect(MonitorSteps.getValidationError(steps, MonitorType.Manual)).toBe(
+        "Default Monitor Status is required",
+      );
+    });
+  });
+
+  describe("clone and setters", () => {
+    test("clone produces an independent copy", () => {
+      const steps: MonitorSteps = buildDefaultSteps();
+      const cloned: MonitorSteps = MonitorSteps.clone(steps);
+      expect(cloned).not.toBe(steps);
+      expect(cloned.data?.defaultMonitorStatusId?.toString()).toBe(
+        steps.data?.defaultMonitorStatusId?.toString(),
+      );
+
+      cloned.setDefaultMonitorStatusId(
+        new ObjectID("200000000000000000000009"),
+      );
+      // Original must be unaffected by the clone's mutation.
+      expect(steps.data?.defaultMonitorStatusId?.toString()).toBe(
+        "100000000000000000000001",
+      );
+    });
+
+    test("setDefaultMonitorStatusId mutates and returns this", () => {
+      const steps: MonitorSteps = new MonitorSteps();
+      const returned: MonitorSteps = steps.setDefaultMonitorStatusId(
+        new ObjectID("300000000000000000000000"),
+      );
+      expect(returned).toBe(steps);
+      expect(steps.data?.defaultMonitorStatusId?.toString()).toBe(
+        "300000000000000000000000",
+      );
+    });
+
+    test("setMonitorStepsInstanceArray replaces the step list", () => {
+      const steps: MonitorSteps = buildDefaultSteps();
+      const newStep: MonitorStep = new MonitorStep();
+      steps.setMonitorStepsInstanceArray([newStep]);
+      expect(steps.data?.monitorStepsInstanceArray).toHaveLength(1);
+      expect(steps.data?.monitorStepsInstanceArray[0]).toBe(newStep);
+    });
+  });
+});

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

@@ -89,6 +89,17 @@ jest.mock("../../../../Types/Date", () => {
           return base;
         },
       ),
+      /*
+       * The picker reads the wall-clock through OneUptimeDate so it resolves in
+       * the user's configured timezone; the stubbed dates above already carry
+       * the hour/minute the test intends.
+       */
+      getLocalHours: jest.fn((d: HourMinuteMock) => {
+        return d.getHours();
+      }),
+      getLocalMinutes: jest.fn((d: HourMinuteMock) => {
+        return d.getMinutes();
+      }),
       getCurrentTimezoneString: jest.fn(() => {
         return "UTC";
       }),

package/Tests/Utils/Memory.test.ts

@@ -0,0 +1,44 @@
+import MemoryUtil from "../../Utils/Memory";
+
+/*
+ * MemoryUtil.convertToGb turns a raw byte count into gibibytes (bytes / 1024^3)
+ * rounded to two decimal places. These tests pin the unit (GiB, not GB), the
+ * rounding, and the boundary/edge behaviour.
+ */
+describe("MemoryUtil.convertToGb", () => {
+  const GIB: number = 1024 * 1024 * 1024;
+
+  test("converts exactly one GiB to 1", () => {
+    expect(MemoryUtil.convertToGb(GIB)).toBe(1);
+  });
+
+  test("converts whole GiB multiples", () => {
+    expect(MemoryUtil.convertToGb(4 * GIB)).toBe(4);
+    expect(MemoryUtil.convertToGb(16 * GIB)).toBe(16);
+  });
+
+  test("returns 0 for 0 bytes", () => {
+    expect(MemoryUtil.convertToGb(0)).toBe(0);
+  });
+
+  test("rounds to two decimal places", () => {
+    // 1.5 GiB -> 1.5
+    expect(MemoryUtil.convertToGb(1.5 * GIB)).toBe(1.5);
+    // 1.234 GiB rounds to 1.23
+    expect(MemoryUtil.convertToGb(1.234 * GIB)).toBe(1.23);
+    // 1.235 GiB rounds up to 1.24 (round-half-up)
+    expect(MemoryUtil.convertToGb(1.235 * GIB)).toBe(1.24);
+  });
+
+  test("handles sub-GiB values", () => {
+    // 512 MiB is half a GiB.
+    expect(MemoryUtil.convertToGb(512 * 1024 * 1024)).toBe(0.5);
+    // A single byte rounds down to 0.
+    expect(MemoryUtil.convertToGb(1)).toBe(0);
+  });
+
+  test("uses GiB (1024^3), not GB (1000^3)", () => {
+    // One billion bytes is < 1 GiB, so it must not round to 1.
+    expect(MemoryUtil.convertToGb(1_000_000_000)).toBe(0.93);
+  });
+});

package/Tests/Utils/Slo/SloBurnRateRuleState.test.ts

@@ -0,0 +1,124 @@
+import SloStatus from "../../../Types/ServiceLevelObjective/SloStatus";
+import {
+  canSloFireBurnRateAlerts,
+  isBurnRateRuleFiring,
+} from "../../../Utils/Slo/SloBurnRateRuleState";
+
+const FIRED_AT: Date = new Date("2026-07-25T10:00:00.000Z");
+
+describe("SloBurnRateRuleState", () => {
+  describe("isBurnRateRuleFiring", () => {
+    it("is false for a rule that has never fired", () => {
+      expect(isBurnRateRuleFiring({})).toBe(false);
+      expect(
+        isBurnRateRuleFiring({
+          lastAlertCreatedAt: null,
+          lastAlertResolvedAt: null,
+        }),
+      ).toBe(false);
+    });
+
+    it("is true when a fire has never been resolved", () => {
+      expect(isBurnRateRuleFiring({ lastAlertCreatedAt: FIRED_AT })).toBe(true);
+    });
+
+    it("is false when the resolve is newer than the fire", () => {
+      expect(
+        isBurnRateRuleFiring({
+          lastAlertCreatedAt: FIRED_AT,
+          lastAlertResolvedAt: new Date("2026-07-25T10:30:00.000Z"),
+        }),
+      ).toBe(false);
+    });
+
+    it("is true when the rule re-fired after an older resolve", () => {
+      expect(
+        isBurnRateRuleFiring({
+          lastAlertCreatedAt: FIRED_AT,
+          lastAlertResolvedAt: new Date("2026-07-25T09:00:00.000Z"),
+        }),
+      ).toBe(true);
+    });
+
+    it("treats an equal-timestamp pair as resolved, not firing", () => {
+      /*
+       * The worker always writes the resolve strictly after the fire, so
+       * an equal pair can only be one lifecycle — leaving a red "Firing"
+       * pill on a rule with nothing open would be the worse error.
+       */
+      expect(
+        isBurnRateRuleFiring({
+          lastAlertCreatedAt: FIRED_AT,
+          lastAlertResolvedAt: new Date(FIRED_AT.getTime()),
+        }),
+      ).toBe(false);
+    });
+
+    it("is false when only a resolve is recorded", () => {
+      // Defensive: a resolve with no fire is not a firing state.
+      expect(isBurnRateRuleFiring({ lastAlertResolvedAt: FIRED_AT })).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("canSloFireBurnRateAlerts", () => {
+    it("is true for a healthy, enabled SLO", () => {
+      expect(
+        canSloFireBurnRateAlerts({
+          isEnabled: true,
+          sloStatus: SloStatus.Healthy,
+        }),
+      ).toBe(true);
+    });
+
+    it("is true while the budget is at risk or exhausted — that is when rules fire", () => {
+      expect(
+        canSloFireBurnRateAlerts({
+          isEnabled: true,
+          sloStatus: SloStatus.AtRisk,
+        }),
+      ).toBe(true);
+      expect(
+        canSloFireBurnRateAlerts({
+          isEnabled: true,
+          sloStatus: SloStatus.BudgetExhausted,
+        }),
+      ).toBe(true);
+    });
+
+    it("is false for a disabled SLO", () => {
+      /*
+       * Disabling resolves every open alert without stamping the rule's
+       * lastAlertResolvedAt, so the rule columns alone would still read as
+       * firing.
+       */
+      expect(
+        canSloFireBurnRateAlerts({
+          isEnabled: false,
+          sloStatus: SloStatus.AtRisk,
+        }),
+      ).toBe(false);
+    });
+
+    it("is false for the two guard statuses that resolve without stamping", () => {
+      expect(
+        canSloFireBurnRateAlerts({
+          isEnabled: true,
+          sloStatus: SloStatus.Misconfigured,
+        }),
+      ).toBe(false);
+      expect(
+        canSloFireBurnRateAlerts({
+          isEnabled: true,
+          sloStatus: SloStatus.Paused,
+        }),
+      ).toBe(false);
+    });
+
+    it("stays optimistic when the fields were not loaded", () => {
+      // Never hide a genuinely firing rule because a fetch has not landed.
+      expect(canSloFireBurnRateAlerts({})).toBe(true);
+    });
+  });
+});

package/Tests/Utils/Slo/SloDuration.test.ts

@@ -0,0 +1,148 @@
+import {
+  formatDurationCompact,
+  formatErrorBudgetRemaining,
+  formatErrorBudgetRemainingOfTotal,
+} from "../../../Utils/Slo/SloDuration";
+
+const MINUS_SIGN: string = "−";
+
+describe("SloDuration", () => {
+  describe("formatDurationCompact", () => {
+    it("renders seconds under a minute", () => {
+      expect(formatDurationCompact(45)).toBe("45s");
+      expect(formatDurationCompact(1)).toBe("1s");
+    });
+
+    it("renders zero as 0s rather than an empty string", () => {
+      expect(formatDurationCompact(0)).toBe("0s");
+    });
+
+    it("renders minutes and seconds", () => {
+      // 99.9% over 30 days — the canonical error budget.
+      expect(formatDurationCompact(2592)).toBe("43m 12s");
+    });
+
+    it("drops a zero remainder instead of padding it", () => {
+      expect(formatDurationCompact(120)).toBe("2m");
+      expect(formatDurationCompact(7200)).toBe("2h");
+      expect(formatDurationCompact(172800)).toBe("2d");
+    });
+
+    it("renders hours and minutes", () => {
+      // 99% over 90 days.
+      expect(formatDurationCompact(77760)).toBe("21h 36m");
+      expect(formatDurationCompact(7860)).toBe("2h 11m");
+    });
+
+    it("renders days and hours", () => {
+      expect(formatDurationCompact(190800)).toBe("2d 5h");
+    });
+
+    it("shows at most the two most significant units", () => {
+      // 2d 5h 13m 7s — the minutes and seconds are dropped.
+      expect(formatDurationCompact(191587)).toBe("2d 5h");
+    });
+
+    it("skips leading zero units", () => {
+      // 0d 0h 5m 3s.
+      expect(formatDurationCompact(303)).toBe("5m 3s");
+    });
+
+    it("skips an interior zero unit and moves on to the next", () => {
+      /*
+       * Exactly 2 days + 30 seconds: hours and minutes are both zero, so
+       * the second slot is filled by seconds rather than padded with "0h".
+       */
+      expect(formatDurationCompact(172830)).toBe("2d 30s");
+    });
+
+    it("floors fractional seconds instead of rounding up", () => {
+      // A 59.9s budget must never read as a full minute it does not have.
+      expect(formatDurationCompact(59.9)).toBe("59s");
+      expect(formatDurationCompact(0.4)).toBe("0s");
+    });
+
+    it("renders the magnitude of a negative input (sign is the caller's job)", () => {
+      expect(formatDurationCompact(-2592)).toBe("43m 12s");
+    });
+  });
+
+  describe("formatErrorBudgetRemaining", () => {
+    it("labels a positive remainder as left", () => {
+      expect(formatErrorBudgetRemaining(2592)).toBe("43m 12s left");
+    });
+
+    it("renders an exhausted-but-not-overspent budget as 0s left", () => {
+      expect(formatErrorBudgetRemaining(0)).toBe("0s left");
+    });
+
+    it("renders an overspent budget with a minus sign and over budget", () => {
+      expect(formatErrorBudgetRemaining(-750)).toBe(
+        `${MINUS_SIGN}12m 30s over budget`,
+      );
+    });
+
+    it("returns null when the SLO has not been evaluated", () => {
+      expect(formatErrorBudgetRemaining(null)).toBeNull();
+      expect(formatErrorBudgetRemaining(undefined)).toBeNull();
+    });
+
+    it("returns null for non-finite values", () => {
+      expect(formatErrorBudgetRemaining(Number.NaN)).toBeNull();
+      expect(formatErrorBudgetRemaining(Number.POSITIVE_INFINITY)).toBeNull();
+    });
+
+    it("rejects a numeric string rather than coercing it", () => {
+      expect(
+        formatErrorBudgetRemaining("2592" as unknown as number),
+      ).toBeNull();
+    });
+  });
+
+  describe("formatErrorBudgetRemainingOfTotal", () => {
+    it("renders remaining alongside the total", () => {
+      expect(
+        formatErrorBudgetRemainingOfTotal({
+          remainingSeconds: 750,
+          totalSeconds: 2592,
+        }),
+      ).toBe("12m 30s left of 43m 12s");
+    });
+
+    it("keeps the total visible when the budget is overspent", () => {
+      expect(
+        formatErrorBudgetRemainingOfTotal({
+          remainingSeconds: -750,
+          totalSeconds: 2592,
+        }),
+      ).toBe(`${MINUS_SIGN}12m 30s over budget of 43m 12s`);
+    });
+
+    it("omits the total when it is unknown", () => {
+      expect(
+        formatErrorBudgetRemainingOfTotal({
+          remainingSeconds: 750,
+          totalSeconds: null,
+        }),
+      ).toBe("12m 30s left");
+    });
+
+    it("omits a zero total — a brand-new SLO has no elapsed window yet", () => {
+      expect(
+        formatErrorBudgetRemainingOfTotal({
+          remainingSeconds: 0,
+          totalSeconds: 0,
+        }),
+      ).toBe("0s left");
+    });
+
+    it("returns null when the SLO has not been evaluated", () => {
+      expect(
+        formatErrorBudgetRemainingOfTotal({
+          remainingSeconds: null,
+          totalSeconds: 2592,
+        }),
+      ).toBeNull();
+    });
+  });
+});