@oneuptime/common 12.0.13 → 12.0.14

package/Tests/Types/AutoRemediation/AutoRemediationSuggestionStatus.test.ts

@@ -0,0 +1,192 @@
+import AutoRemediationSuggestionStatus, {
+  AutoRemediationSuggestionStatusHelper,
+} from "../../../Types/AutoRemediation/AutoRemediationSuggestionStatus";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Contract under test — the lifecycle vocabulary of an auto-remediation
+ * suggestion and the single predicate that splits it into terminal vs open.
+ *
+ * A suggestion is the approvable action object a matched rule attaches to an
+ * incident or alert. isTerminalStatus draws the line between states that can
+ * still be actioned (Planning, Suggested — a human or the executor may yet
+ * move them) and states that are frozen for good (Approved, AutoExecuted,
+ * Dismissed, NoneApplicable). Anything downstream that decides whether to show
+ * an approve/dismiss control, re-run planning, or leave a suggestion alone
+ * relies on this partition being exact — every status classified, none in both
+ * halves.
+ *
+ * The enum is string-valued, so the wire/DB representation of each member is
+ * itself part of the contract: renaming a value would silently orphan rows
+ * persisted under the old string. These tests pin both the string values and
+ * the terminal/open classification.
+ */
+
+/*
+ * The two open (non-terminal) states — still actionable.
+ */
+const OPEN_STATUSES: Array<AutoRemediationSuggestionStatus> = [
+  AutoRemediationSuggestionStatus.Planning,
+  AutoRemediationSuggestionStatus.Suggested,
+];
+
+/*
+ * The four terminal states — frozen, never change again.
+ */
+const TERMINAL_STATUSES: Array<AutoRemediationSuggestionStatus> = [
+  AutoRemediationSuggestionStatus.Approved,
+  AutoRemediationSuggestionStatus.AutoExecuted,
+  AutoRemediationSuggestionStatus.Dismissed,
+  AutoRemediationSuggestionStatus.NoneApplicable,
+];
+
+describe("AutoRemediationSuggestionStatus enum", () => {
+  test("each member's string value matches its name", () => {
+    expect(AutoRemediationSuggestionStatus.Planning).toBe("Planning");
+    expect(AutoRemediationSuggestionStatus.Suggested).toBe("Suggested");
+    expect(AutoRemediationSuggestionStatus.Approved).toBe("Approved");
+    expect(AutoRemediationSuggestionStatus.AutoExecuted).toBe("AutoExecuted");
+    expect(AutoRemediationSuggestionStatus.Dismissed).toBe("Dismissed");
+    expect(AutoRemediationSuggestionStatus.NoneApplicable).toBe(
+      "NoneApplicable",
+    );
+  });
+
+  test("declares exactly six members and no extras", () => {
+    const values: Array<string> = Object.values(
+      AutoRemediationSuggestionStatus,
+    );
+    expect(values).toHaveLength(6);
+    expect(values.slice().sort()).toEqual(
+      [
+        "Approved",
+        "AutoExecuted",
+        "Dismissed",
+        "NoneApplicable",
+        "Planning",
+        "Suggested",
+      ].sort(),
+    );
+  });
+
+  test("all member string values are unique", () => {
+    const values: Array<string> = Object.values(
+      AutoRemediationSuggestionStatus,
+    );
+    const unique: Set<string> = new Set(values);
+    expect(unique.size).toBe(values.length);
+  });
+});
+
+describe("AutoRemediationSuggestionStatusHelper.isTerminalStatus", () => {
+  test.each(TERMINAL_STATUSES)(
+    "returns true for terminal status %s",
+    (status: AutoRemediationSuggestionStatus) => {
+      expect(
+        AutoRemediationSuggestionStatusHelper.isTerminalStatus(status),
+      ).toBe(true);
+    },
+  );
+
+  test.each(OPEN_STATUSES)(
+    "returns false for open status %s",
+    (status: AutoRemediationSuggestionStatus) => {
+      expect(
+        AutoRemediationSuggestionStatusHelper.isTerminalStatus(status),
+      ).toBe(false);
+    },
+  );
+
+  test("terminal and open sets together cover every enum member with no overlap", () => {
+    const allStatuses: Array<AutoRemediationSuggestionStatus> = Object.values(
+      AutoRemediationSuggestionStatus,
+    );
+    const partitioned: Array<AutoRemediationSuggestionStatus> = [
+      ...TERMINAL_STATUSES,
+      ...OPEN_STATUSES,
+    ];
+
+    /*
+     * No status appears in both halves.
+     */
+    expect(new Set(partitioned).size).toBe(partitioned.length);
+
+    /*
+     * Every enum member lands in exactly one half.
+     */
+    expect(partitioned.slice().sort()).toEqual(allStatuses.slice().sort());
+  });
+
+  test("classifies every enum member without leaving any unclassified", () => {
+    const allStatuses: Array<AutoRemediationSuggestionStatus> = Object.values(
+      AutoRemediationSuggestionStatus,
+    );
+
+    for (const status of allStatuses) {
+      const isTerminal: boolean =
+        AutoRemediationSuggestionStatusHelper.isTerminalStatus(status);
+      const expectedTerminal: boolean = TERMINAL_STATUSES.includes(status);
+      expect(isTerminal).toBe(expectedTerminal);
+    }
+  });
+
+  test("is a pure predicate — repeated calls yield the same result", () => {
+    for (const status of Object.values(AutoRemediationSuggestionStatus)) {
+      const first: boolean =
+        AutoRemediationSuggestionStatusHelper.isTerminalStatus(status);
+      const second: boolean =
+        AutoRemediationSuggestionStatusHelper.isTerminalStatus(status);
+      expect(second).toBe(first);
+    }
+  });
+
+  test("returns exactly a boolean, never a truthy/falsy proxy", () => {
+    const terminalResult: boolean =
+      AutoRemediationSuggestionStatusHelper.isTerminalStatus(
+        AutoRemediationSuggestionStatus.Approved,
+      );
+    const openResult: boolean =
+      AutoRemediationSuggestionStatusHelper.isTerminalStatus(
+        AutoRemediationSuggestionStatus.Planning,
+      );
+    expect(typeof terminalResult).toBe("boolean");
+    expect(typeof openResult).toBe("boolean");
+  });
+
+  test("matches the raw string value of each member (DB/wire representation)", () => {
+    /*
+     * The enum is string-backed, so a persisted row carries the string, not the
+     * TS enum reference. Passing the equivalent raw string must classify the
+     * same way — guarding against a future rename that would strand old rows.
+     */
+    expect(
+      AutoRemediationSuggestionStatusHelper.isTerminalStatus(
+        "Dismissed" as AutoRemediationSuggestionStatus,
+      ),
+    ).toBe(true);
+    expect(
+      AutoRemediationSuggestionStatusHelper.isTerminalStatus(
+        "Suggested" as AutoRemediationSuggestionStatus,
+      ),
+    ).toBe(false);
+  });
+
+  test("treats an unknown status as non-terminal (no false freeze)", () => {
+    /*
+     * Defensive edge: a value outside the enum (legacy or corrupt data) is not
+     * one of the four terminal constants, so the predicate reports false. That
+     * keeps an unrecognized suggestion open/actionable rather than silently
+     * frozen.
+     */
+    expect(
+      AutoRemediationSuggestionStatusHelper.isTerminalStatus(
+        "SomethingElse" as AutoRemediationSuggestionStatus,
+      ),
+    ).toBe(false);
+    expect(
+      AutoRemediationSuggestionStatusHelper.isTerminalStatus(
+        "" as AutoRemediationSuggestionStatus,
+      ),
+    ).toBe(false);
+  });
+});

package/Tests/Types/Call/CallRequest.test.ts

@@ -0,0 +1,189 @@
+import Phone from "../../../Types/Phone";
+import { isHighRiskPhoneNumber } from "../../../Types/Call/CallRequest";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * isHighRiskPhoneNumber(phone) stringifies the Phone and returns true when the
+ * resulting string starts with any of a fixed set of high-risk country dialing
+ * codes. The matching is a plain String.prototype.startsWith over the raw
+ * value, so behavior hinges on: the exact leading characters (including the
+ * "+"), the ordering-independent "some" scan, and the boundary between a real
+ * code and a number that merely shares leading digits with one.
+ *
+ * These tests exercise the real branches: every high-risk code (true path),
+ * ordinary countries (false path), near-miss prefixes that share leading digits
+ * but are not a code, the required leading "+", formatting/length boundaries,
+ * and copy-constructed Phone objects.
+ */
+
+/*
+ * The exact high-risk set encoded in CallRequest.ts. Kept as a local literal so
+ * the test asserts against a known expectation rather than re-importing the
+ * private constant.
+ */
+const HIGH_RISK_DIALING_CODES: Array<string> = [
+  "+92",
+  "+27",
+  "+213",
+  "+371",
+  "+370",
+  "+372",
+  "+252",
+  "+232",
+  "+231",
+  "+53",
+  "+960",
+  "+992",
+  "+880",
+  "+62",
+  "+84",
+  "+95",
+];
+
+type MakeValidNumberFunction = (dialingCode: string) => string;
+
+/*
+ * Build a phone string that starts with the given dialing code and satisfies
+ * Phone's constructor regex (3 digits, 3 digits, then 4-7 digits => 10-13 total
+ * digits). Padding with zeros to 12 total digits keeps every generated number
+ * inside the valid range regardless of whether the code has 2 or 3 digits.
+ */
+const makeValidNumber: MakeValidNumberFunction = (
+  dialingCode: string,
+): string => {
+  const digits: string = dialingCode.replace("+", "");
+  const padding: string = "0000000000000".substring(0, 12 - digits.length);
+  return "+" + digits + padding;
+};
+
+describe("isHighRiskPhoneNumber flags every high-risk dialing code", () => {
+  test.each(HIGH_RISK_DIALING_CODES)(
+    "flags a number starting with %s",
+    (dialingCode: string) => {
+      const phone: Phone = new Phone(makeValidNumber(dialingCode));
+      expect(isHighRiskPhoneNumber(phone)).toBe(true);
+    },
+  );
+
+  test("flags Tajikistan (+992) on its own three-digit code, not via +92", () => {
+    /*
+     * +992 does not start with +92, so it can only be flagged by its own
+     * three-digit entry. This guards against a regression where only the
+     * shorter code were present.
+     */
+    const phone: Phone = new Phone(makeValidNumber("+992"));
+    expect(phone.toString().startsWith("+92")).toBe(false);
+    expect(isHighRiskPhoneNumber(phone)).toBe(true);
+  });
+});
+
+describe("isHighRiskPhoneNumber does not flag ordinary / low-risk countries", () => {
+  const lowRiskNumbers: Array<string> = [
+    "+15551234567", // United States / Canada (+1)
+    "+442071234567", // United Kingdom (+44)
+    "+491234567890", // Germany (+49)
+    "+611234567890", // Australia (+61)
+    "+331234567890", // France (+33)
+    "+811234567890", // Japan (+81)
+    "+861234567890", // China (+86)
+    "+551234567890", // Brazil (+55)
+    "+521234567890", // Mexico (+52) sits right next to Cuba (+53)
+    "+919876543210", // India (+91) sits right next to Pakistan (+92)
+  ];
+
+  test.each(lowRiskNumbers)("does not flag %s", (phoneNumber: string) => {
+    const phone: Phone = new Phone(phoneNumber);
+    expect(isHighRiskPhoneNumber(phone)).toBe(false);
+  });
+});
+
+describe("near-miss prefixes that only share leading digits are not flagged", () => {
+  /*
+   * Each entry starts with the same first digits as a real high-risk code but
+   * diverges before the full code, so startsWith must return false. This is the
+   * key discriminating branch: matching is prefix-exact, not "close enough".
+   */
+  const nearMisses: Array<[string, string]> = [
+    ["+254123456789", "Kenya (+254) vs Somalia (+252)"],
+    ["+994123456789", "Azerbaijan (+994) vs Tajikistan (+992)"],
+    ["+886123456789", "Taiwan (+886) vs Bangladesh (+880)"],
+    [
+      "+373123456789",
+      "Moldova (+373) vs Latvia/Lithuania/Estonia (+371/+370/+372)",
+    ],
+    ["+919876543210", "India (+91) vs Pakistan (+92)"],
+    ["+521234567890", "Mexico (+52) vs Cuba (+53)"],
+  ];
+
+  test.each(nearMisses)("does not flag %s", (phoneNumber: string) => {
+    const phone: Phone = new Phone(phoneNumber);
+    expect(isHighRiskPhoneNumber(phone)).toBe(false);
+  });
+});
+
+describe("the leading + is part of the match", () => {
+  test("a high-risk number without the leading + is not flagged", () => {
+    /*
+     * The stored value is exactly what the caller passed. Without the "+", the
+     * string is "920000000000", which does not start with "+92".
+     */
+    const phone: Phone = new Phone("920000000000");
+    expect(phone.toString().startsWith("+")).toBe(false);
+    expect(isHighRiskPhoneNumber(phone)).toBe(false);
+  });
+
+  test("the same digits with the leading + are flagged", () => {
+    const phone: Phone = new Phone("+920000000000");
+    expect(isHighRiskPhoneNumber(phone)).toBe(true);
+  });
+});
+
+describe("formatting and length boundaries", () => {
+  test("flags a high-risk number written with separators after the code", () => {
+    /*
+     * "+232-123-4567" is a valid Phone (3 digits, sep, 3 digits, sep, 4 digits)
+     * whose string still starts with the Sierra Leone code "+232".
+     */
+    const phone: Phone = new Phone("+232-123-4567");
+    expect(isHighRiskPhoneNumber(phone)).toBe(true);
+  });
+
+  test("flags the shortest valid high-risk number (10 digits)", () => {
+    const phone: Phone = new Phone("+9200000000");
+    expect(isHighRiskPhoneNumber(phone)).toBe(true);
+  });
+
+  test("flags the longest valid high-risk number (13 digits)", () => {
+    const phone: Phone = new Phone("+9200000000000");
+    expect(isHighRiskPhoneNumber(phone)).toBe(true);
+  });
+});
+
+describe("Phone construction variants are evaluated identically", () => {
+  test("a Phone copy-constructed from another Phone is still flagged", () => {
+    const original: Phone = new Phone("+920000000000");
+    const copy: Phone = new Phone(original);
+    expect(copy.toString()).toEqual(original.toString());
+    expect(isHighRiskPhoneNumber(copy)).toBe(true);
+  });
+
+  test("mutating a Phone to a high-risk value changes the result", () => {
+    const phone: Phone = new Phone("+15551234567");
+    expect(isHighRiskPhoneNumber(phone)).toBe(false);
+    phone.phone = "+840000000000";
+    expect(isHighRiskPhoneNumber(phone)).toBe(true);
+  });
+});
+
+describe("return value contract", () => {
+  test("always returns a strict boolean", () => {
+    const flagged: boolean = isHighRiskPhoneNumber(new Phone("+920000000000"));
+    const notFlagged: boolean = isHighRiskPhoneNumber(
+      new Phone("+15551234567"),
+    );
+    expect(typeof flagged).toBe("boolean");
+    expect(typeof notFlagged).toBe("boolean");
+    expect(flagged).toBe(true);
+    expect(notFlagged).toBe(false);
+  });
+});

package/Tests/Types/Dashboard/DashboardSize.test.ts

@@ -0,0 +1,226 @@
+import DefaultDashboardSize, {
+  GetDashboardComponentWidthInDashboardUnits,
+  SpaceBetweenUnitsInPx,
+} from "../../../Types/Dashboard/DashboardSize";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * GetDashboardComponentWidthInDashboardUnits converts a pixel width into a
+ * count of dashboard grid units. The internal math is:
+ *
+ *   eachUnitSizeInPx = currentTotalDashboardWidthInPx / widthInDashboardUnits
+ *   units            = Math.ceil(componentWidthInPx / eachUnitSizeInPx)
+ *   return units < 1 ? 1 : units
+ *
+ * where widthInDashboardUnits comes from DefaultDashboardSize. The tests below
+ * pin down the ceiling rounding, the floor-to-1 clamp, the absence of any
+ * upper clamp, and the degenerate divide-by-zero behaviour.
+ */
+
+describe("GetDashboardComponentWidthInDashboardUnits", () => {
+  /*
+   * The whole module is calibrated around a 12-unit-wide grid. If that default
+   * ever changes, the hand-computed expectations below would silently drift, so
+   * assert the assumption explicitly and fail loudly here instead.
+   */
+  const GRID_UNITS: number = DefaultDashboardSize.widthInDashboardUnits;
+
+  test("assumes the default grid is 12 units wide", () => {
+    expect(GRID_UNITS).toBe(12);
+  });
+
+  describe("basic conversion", () => {
+    test("returns 1 when the component spans exactly one unit", () => {
+      /*
+       * total 1200px over 12 units => 100px per unit. A 100px component is
+       * exactly one unit and must round to 1 (not 2).
+       */
+      const units: number = GetDashboardComponentWidthInDashboardUnits(
+        1200,
+        100,
+      );
+      expect(units).toBe(1);
+    });
+
+    test("returns 2 when the component spans exactly two units", () => {
+      const units: number = GetDashboardComponentWidthInDashboardUnits(
+        1200,
+        200,
+      );
+      expect(units).toBe(2);
+    });
+
+    test("returns the full grid width when the component fills the dashboard", () => {
+      const units: number = GetDashboardComponentWidthInDashboardUnits(
+        1200,
+        1200,
+      );
+      expect(units).toBe(GRID_UNITS);
+    });
+
+    test("scales the unit size with the total dashboard width", () => {
+      /*
+       * total 600px over 12 units => 50px per unit. A 50px component is one
+       * unit and a 150px component is three units. The unit size is derived
+       * from the total width, so a different total yields a different mapping.
+       */
+      expect(GetDashboardComponentWidthInDashboardUnits(600, 50)).toBe(1);
+      expect(GetDashboardComponentWidthInDashboardUnits(600, 150)).toBe(3);
+    });
+  });
+
+  describe("ceiling / round-up behaviour", () => {
+    test("rounds a partial unit up to the next whole unit", () => {
+      /*
+       * 100px per unit. 150px is 1.5 units and must round up to 2. 250px is
+       * 2.5 units and must round up to 3.
+       */
+      expect(GetDashboardComponentWidthInDashboardUnits(1200, 150)).toBe(2);
+      expect(GetDashboardComponentWidthInDashboardUnits(1200, 250)).toBe(3);
+    });
+
+    test("rounds up even a single pixel over a unit boundary", () => {
+      /*
+       * 101px is 1.01 units; the ceiling makes it consume 2 whole units so the
+       * component is never visually clipped.
+       */
+      expect(GetDashboardComponentWidthInDashboardUnits(1200, 101)).toBe(2);
+    });
+
+    test("does not round up when the width lands exactly on a boundary", () => {
+      /*
+       * ceil(2.0) is 2, not 3. Exact multiples of the unit size stay put.
+       */
+      expect(GetDashboardComponentWidthInDashboardUnits(1200, 200)).toBe(2);
+      expect(GetDashboardComponentWidthInDashboardUnits(1200, 300)).toBe(3);
+    });
+
+    test("rounds a sub-unit width up to a single unit", () => {
+      /*
+       * 50px is half a unit; ceil(0.5) is 1, so a component narrower than one
+       * unit still occupies a whole unit.
+       */
+      expect(GetDashboardComponentWidthInDashboardUnits(1200, 50)).toBe(1);
+    });
+  });
+
+  describe("floor-to-1 clamp", () => {
+    test("returns 1 for a zero-width component", () => {
+      /*
+       * ceil(0) is 0, which is below the minimum, so the clamp forces 1. A
+       * component always occupies at least one grid unit.
+       */
+      expect(GetDashboardComponentWidthInDashboardUnits(1200, 0)).toBe(1);
+    });
+
+    test("returns 1 for a negative component width", () => {
+      /*
+       * ceil(-0.5) is -0, which is below the minimum and clamps to 1 rather
+       * than returning a negative or zero unit count.
+       */
+      expect(GetDashboardComponentWidthInDashboardUnits(1200, -50)).toBe(1);
+    });
+
+    test("returns 1 when the total dashboard width is negative", () => {
+      /*
+       * A negative total flips the sign of the unit size, so a positive
+       * component yields a negative raw unit count that clamps to 1.
+       */
+      expect(GetDashboardComponentWidthInDashboardUnits(-1200, 100)).toBe(1);
+    });
+  });
+
+  describe("no upper clamp", () => {
+    test("returns more than the grid width when the component overflows the dashboard", () => {
+      /*
+       * A 2400px component on a 1200px dashboard is 24 units. The function does
+       * not cap the result at the 12-unit grid width.
+       */
+      const units: number = GetDashboardComponentWidthInDashboardUnits(
+        1200,
+        2400,
+      );
+      expect(units).toBe(24);
+      expect(units).toBeGreaterThan(GRID_UNITS);
+    });
+  });
+
+  describe("degenerate totals (divide by zero)", () => {
+    test("returns Infinity when the total is zero but the component is positive", () => {
+      /*
+       * A zero total makes the per-unit size zero, so a positive component
+       * divides by zero to Infinity. ceil(Infinity) is Infinity, which is above
+       * the minimum and is returned as-is rather than clamped.
+       */
+      const units: number = GetDashboardComponentWidthInDashboardUnits(0, 100);
+      expect(units).toBe(Infinity);
+      expect(Number.isFinite(units)).toBe(false);
+    });
+
+    test("returns NaN when both the total and the component are zero", () => {
+      /*
+       * 0 / 0 is NaN, ceil(NaN) is NaN, and NaN < 1 is false, so NaN passes the
+       * clamp untouched.
+       */
+      const units: number = GetDashboardComponentWidthInDashboardUnits(0, 0);
+      expect(Number.isNaN(units)).toBe(true);
+    });
+  });
+
+  describe("independence from inter-unit spacing", () => {
+    test("ignores SpaceBetweenUnitsInPx when computing the unit count", () => {
+      /*
+       * Unlike GetWidthOfDashboardComponent, this function divides the raw total
+       * width by the unit count and never subtracts SpaceBetweenUnitsInPx. Prove
+       * that by showing the result depends only on total and component width: a
+       * 100px component on a 1200px dashboard is exactly one unit regardless of
+       * the spacing constant's value.
+       */
+      expect(SpaceBetweenUnitsInPx).toBeGreaterThan(0);
+      expect(GetDashboardComponentWidthInDashboardUnits(1200, 100)).toBe(1);
+    });
+  });
+
+  describe("monotonicity", () => {
+    test("never decreases as the component width grows", () => {
+      /*
+       * For a fixed dashboard width, a wider component can only ever require the
+       * same number of units or more. Sweep a range of widths and assert the
+       * unit count is non-decreasing.
+       */
+      const total: number = 1200;
+      let previous: number = GetDashboardComponentWidthInDashboardUnits(
+        total,
+        0,
+      );
+
+      for (
+        let componentWidth: number = 0;
+        componentWidth <= 2400;
+        componentWidth += 37
+      ) {
+        const current: number = GetDashboardComponentWidthInDashboardUnits(
+          total,
+          componentWidth,
+        );
+        expect(current).toBeGreaterThanOrEqual(previous);
+        previous = current;
+      }
+    });
+  });
+
+  describe("output shape", () => {
+    test("always returns a whole number for finite positive inputs", () => {
+      const widths: Array<number> = [1, 49, 50, 99, 100, 101, 599, 1200, 5000];
+
+      for (const componentWidth of widths) {
+        const units: number = GetDashboardComponentWidthInDashboardUnits(
+          1200,
+          componentWidth,
+        );
+        expect(Number.isInteger(units)).toBe(true);
+        expect(units).toBeGreaterThanOrEqual(1);
+      }
+    });
+  });
+});