@oneuptime/common 12.0.7 → 12.0.9

package/Tests/Types/IP/IPv6.test.ts

@@ -2,10 +2,21 @@ import IP from "../../../Types/IP/IPv6";
 
 describe("IPv6()", () => {
   test("should be IPv6", () => {
-    const ip: IP = new IP("2001:0db8:85a3:::8a2e:0370:7334");
+    const ip: IP = new IP("2001:0db8:85a3::8a2e:0370:7334");
     expect(ip.isIPv6()).toBeTruthy();
   });
 
+  /*
+   * This address used to be accepted: a triple colon is not valid IPv6, but
+   * the validator was unanchored and matched the address-shaped substring
+   * inside it.
+   */
+  test("should reject an address with a triple colon", () => {
+    expect(() => {
+      new IP("2001:0db8:85a3:::8a2e:0370:7334");
+    }).toThrow("IP is not a valid address");
+  });
+
   test("should not be IPv4", () => {
     const ip: IP = new IP("2001:0db8:85a3:0000:0000:8a2e:0370:7334");
     expect(ip.isIPv4()).toBeFalsy();

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

@@ -0,0 +1,64 @@
+import SnmpOid, {
+  SnmpOidTemplates,
+} from "../../../Types/Monitor/SnmpMonitor/SnmpOid";
+
+/*
+ * The common-OID list is shipped as the starting point an operator picks from
+ * when building an SNMP monitor, so a typo'd OID or a duplicated entry is a
+ * silently wrong default. These invariants keep the list honest.
+ */
+describe("SnmpOidTemplates.getCommonOids", () => {
+  const oids: Array<SnmpOid> = SnmpOidTemplates.getCommonOids();
+
+  test("returns a non-empty list", () => {
+    expect(oids.length).toBeGreaterThan(0);
+  });
+
+  test("every entry is a dotted numeric OID", () => {
+    for (const entry of oids) {
+      expect(entry.oid).toMatch(/^\d+(\.\d+)+$/);
+    }
+  });
+
+  test("every entry carries a human name and description", () => {
+    for (const entry of oids) {
+      expect(entry.name && entry.name.trim().length).toBeTruthy();
+      expect(entry.description && entry.description.trim().length).toBeTruthy();
+    }
+  });
+
+  test("OIDs are unique", () => {
+    const seen: Set<string> = new Set<string>(
+      oids.map((entry: SnmpOid) => {
+        return entry.oid;
+      }),
+    );
+
+    expect(seen.size).toBe(oids.length);
+  });
+
+  test("names are unique", () => {
+    const names: Array<string> = oids.map((entry: SnmpOid) => {
+      return entry.name as string;
+    });
+
+    expect(new Set<string>(names).size).toBe(names.length);
+  });
+
+  test("includes the system-description OID every SNMP agent exposes", () => {
+    const sysDescr: SnmpOid | undefined = oids.find((entry: SnmpOid) => {
+      return entry.name === "sysDescr";
+    });
+
+    expect(sysDescr?.oid).toBe("1.3.6.1.2.1.1.1.0");
+  });
+
+  test("returns a fresh array each call (callers may mutate their copy)", () => {
+    expect(SnmpOidTemplates.getCommonOids()).not.toBe(
+      SnmpOidTemplates.getCommonOids(),
+    );
+    expect(SnmpOidTemplates.getCommonOids()).toEqual(
+      SnmpOidTemplates.getCommonOids(),
+    );
+  });
+});

package/Tests/Types/NetworkDevice/NetworkDeviceMonitoringMethod.test.ts

@@ -0,0 +1,110 @@
+import NetworkDeviceMonitoringMethod, {
+  NetworkDeviceMonitoringMethodUtil,
+} from "../../../Types/NetworkDevice/NetworkDeviceMonitoringMethod";
+
+/*
+ * The column is free text and pre-existing rows hold NULL, so the whole point
+ * of the util is that anything it does not positively recognise as
+ * monitor-backed reads as SNMP. Getting that default wrong silently stops a
+ * device being polled, which is why it is worth pinning down every branch.
+ */
+describe("NetworkDeviceMonitoringMethod enum", () => {
+  test("Snmp is the string SNMP", () => {
+    expect(NetworkDeviceMonitoringMethod.Snmp).toBe("SNMP");
+  });
+
+  test("Monitor is the string Monitor", () => {
+    expect(NetworkDeviceMonitoringMethod.Monitor).toBe("Monitor");
+  });
+
+  test("has exactly the two known methods", () => {
+    expect(Object.values(NetworkDeviceMonitoringMethod).sort()).toEqual([
+      "Monitor",
+      "SNMP",
+    ]);
+  });
+});
+
+describe("NetworkDeviceMonitoringMethodUtil.parse", () => {
+  test.each([null, undefined, "", "   "])(
+    "reads %p as Snmp (the legacy default)",
+    (value: string | null | undefined) => {
+      expect(NetworkDeviceMonitoringMethodUtil.parse(value)).toBe(
+        NetworkDeviceMonitoringMethod.Snmp,
+      );
+    },
+  );
+
+  test.each(["monitor", "Monitor", "MONITOR", "  monitor  ", "\tMoNiToR\n"])(
+    "reads %p as Monitor, case- and whitespace-insensitively",
+    (value: string) => {
+      expect(NetworkDeviceMonitoringMethodUtil.parse(value)).toBe(
+        NetworkDeviceMonitoringMethod.Monitor,
+      );
+    },
+  );
+
+  test.each(["SNMP", "snmp", "Snmp", " snmp "])(
+    "reads the SNMP spelling %p as Snmp",
+    (value: string) => {
+      expect(NetworkDeviceMonitoringMethodUtil.parse(value)).toBe(
+        NetworkDeviceMonitoringMethod.Snmp,
+      );
+    },
+  );
+
+  test.each(["ping", "unknown", "monitor-backed", "monitors", "SNMPv3", "0"])(
+    "falls back to Snmp for the unrecognised value %p",
+    (value: string) => {
+      expect(NetworkDeviceMonitoringMethodUtil.parse(value)).toBe(
+        NetworkDeviceMonitoringMethod.Snmp,
+      );
+    },
+  );
+
+  test("does not treat a string merely containing 'monitor' as monitor-backed", () => {
+    // Only an exact (trimmed, lowercased) 'monitor' qualifies.
+    expect(NetworkDeviceMonitoringMethodUtil.parse("monitor device")).toBe(
+      NetworkDeviceMonitoringMethod.Snmp,
+    );
+  });
+});
+
+describe("NetworkDeviceMonitoringMethodUtil.isMonitorBacked", () => {
+  test.each(["monitor", "Monitor", "  MONITOR  "])(
+    "is true for %p",
+    (value: string) => {
+      expect(NetworkDeviceMonitoringMethodUtil.isMonitorBacked(value)).toBe(
+        true,
+      );
+    },
+  );
+
+  test.each([null, undefined, "", "SNMP", "snmp", "ping", "monitorish"])(
+    "is false for %p",
+    (value: string | null | undefined) => {
+      expect(NetworkDeviceMonitoringMethodUtil.isMonitorBacked(value)).toBe(
+        false,
+      );
+    },
+  );
+
+  test("agrees with parse for every input", () => {
+    const inputs: Array<string | null | undefined> = [
+      null,
+      undefined,
+      "",
+      "monitor",
+      "Monitor",
+      "SNMP",
+      "ping",
+    ];
+
+    for (const input of inputs) {
+      expect(NetworkDeviceMonitoringMethodUtil.isMonitorBacked(input)).toBe(
+        NetworkDeviceMonitoringMethodUtil.parse(input) ===
+          NetworkDeviceMonitoringMethod.Monitor,
+      );
+    }
+  });
+});

package/Tests/Types/OnCallDutyPolicy/LayerUtilMergeAudit.test.ts

@@ -224,4 +224,110 @@ describe("LayerUtil audit H2: multi-layer merge invariants preserved", () => {
      */
     expect(elapsedMs).toBeLessThan(15000);
   });
+
+  /*
+   * The Dashboard's on-call schedule screen expands the whole coverage window on
+   * the browser's MAIN THREAD (see CoverageWindow.ts — three calendar months),
+   * so this is the shape that decides whether that screen is usable. An hourly
+   * rotation over three months is ~2200 events per layer; with the quadratic
+   * merge this took minutes and hung the tab.
+   *
+   * Two layers, so the priority-trim path is exercised rather than just the
+   * single-layer pass-through.
+   */
+  test("hourly rotation over a 3-month window stays interactive", () => {
+    const primary: LayerProps = {
+      users: [user("A"), user("B"), user("C")],
+      startDateTimeOfLayer: new Date(Date.UTC(2025, 5, 1, 0, 0, 0)),
+      handOffTime: new Date(Date.UTC(2025, 5, 1, 0, 0, 0)),
+      restrictionTimes: businessHoursRestriction(),
+      rotation: rotation(EventInterval.Hour, 1),
+      timezone: "UTC",
+    };
+
+    const fallback: LayerProps = {
+      users: [user("F")],
+      startDateTimeOfLayer: new Date(Date.UTC(2025, 5, 1, 0, 0, 0)),
+      handOffTime: new Date(Date.UTC(2025, 5, 8, 0, 0, 0)),
+      restrictionTimes: RestrictionTimes.getDefault(),
+      rotation: rotation(EventInterval.Week, 1),
+      timezone: "UTC",
+    };
+
+    const start: number = OneUptimeDate.getCurrentDate().getTime();
+    const events: Array<CalendarEvent> = new LayerUtil().getMultiLayerEvents({
+      layers: [primary, fallback],
+      calendarStartDate: new Date(Date.UTC(2025, 5, 1, 0, 0, 0)),
+      calendarEndDate: new Date(Date.UTC(2025, 8, 1, 0, 0, 0)),
+    });
+    const elapsedMs: number = OneUptimeDate.getCurrentDate().getTime() - start;
+
+    /*
+     * ~8 business hours a day over three months, plus the fallback's segments
+     * around them. The floor is here so the test cannot quietly stop exercising
+     * a large merge; it is not an assertion about the exact expansion.
+     */
+    expect(events.length).toBeGreaterThan(700);
+    assertSortedNonOverlappingPositive(events);
+
+    /*
+     * Deliberately far below what a user would notice, and far above the
+     * measured cost, so this fails on a return to quadratic scaling rather than
+     * on CI noise. The quadratic version did not finish this shape in minutes.
+     */
+    expect(elapsedMs).toBeLessThan(10000);
+  });
+
+  /*
+   * A 24/7 fallback under a busy higher-priority layer is the case where the
+   * merge does the most work: every one of the higher-priority layer's events
+   * splits the fallback, so the trailing-tail path runs thousands of times. It
+   * is also the case where a wrong active-set prune would silently delete
+   * fallback coverage, so the gap assertion matters as much as the clock.
+   */
+  test("24/7 fallback split by an hourly layer stays interactive and gapless", () => {
+    const primary: LayerProps = {
+      users: [user("A"), user("B")],
+      startDateTimeOfLayer: new Date(Date.UTC(2025, 5, 1, 0, 0, 0)),
+      handOffTime: new Date(Date.UTC(2025, 5, 1, 0, 0, 0)),
+      restrictionTimes: businessHoursRestriction(),
+      rotation: rotation(EventInterval.Hour, 1),
+      timezone: "UTC",
+    };
+
+    const alwaysOn: LayerProps = {
+      users: [user("F")],
+      startDateTimeOfLayer: new Date(Date.UTC(2025, 5, 1, 0, 0, 0)),
+      handOffTime: new Date(Date.UTC(2025, 6, 1, 0, 0, 0)),
+      restrictionTimes: RestrictionTimes.getDefault(),
+      rotation: rotation(EventInterval.Month, 1),
+      timezone: "UTC",
+    };
+
+    const windowFrom: Date = new Date(Date.UTC(2025, 5, 1, 0, 0, 0));
+    const windowTo: Date = new Date(Date.UTC(2025, 7, 1, 0, 0, 0));
+
+    const start: number = OneUptimeDate.getCurrentDate().getTime();
+    const events: Array<CalendarEvent> = new LayerUtil().getMultiLayerEvents({
+      layers: [primary, alwaysOn],
+      calendarStartDate: windowFrom,
+      calendarEndDate: windowTo,
+    });
+    const elapsedMs: number = OneUptimeDate.getCurrentDate().getTime() - start;
+
+    assertSortedNonOverlappingPositive(events);
+    expect(elapsedMs).toBeLessThan(10000);
+
+    /*
+     * The fallback must still cover everything the primary does not. Segments
+     * are stitched with a 1-second seam, so anything longer than that is a real
+     * hole where an alert would page nobody.
+     */
+    for (let i: number = 1; i < events.length; i++) {
+      const gapMs: number =
+        new Date(events[i]!.start).getTime() -
+        new Date(events[i - 1]!.end).getTime();
+      expect(gapMs).toBeLessThanOrEqual(1000);
+    }
+  });
 });