@oneuptime/common 11.6.0 → 11.6.2

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

@@ -0,0 +1,151 @@
+import ArpEntry from "../../../Types/Monitor/SnmpMonitor/ArpEntry";
+import FdbEntry from "../../../Types/Monitor/SnmpMonitor/FdbEntry";
+import SnmpMonitorResponse from "../../../Types/Monitor/SnmpMonitor/SnmpMonitorResponse";
+import NetworkTopology, {
+  NetworkTopologyEdge,
+  NetworkTopologyNode,
+} from "../../../Types/Monitor/SnmpMonitor/NetworkTopology";
+
+/*
+ * These types travel over the probe ingest wire and get stored in JSON
+ * columns, so a plain JSON round trip must preserve them exactly — no
+ * class instances, no Dates, no methods.
+ */
+describe("SNMP endpoint discovery types", () => {
+  describe("SnmpMonitorResponse with endpoint data", () => {
+    test("arp and fdb entries survive a JSON wire round trip", () => {
+      const arpEntry: ArpEntry = {
+        ipAddress: "10.20.30.40",
+        macAddress: "aa:bb:cc:dd:ee:ff",
+        interfaceIndex: 3,
+        entryType: "dynamic",
+      };
+      const fdbEntry: FdbEntry = {
+        macAddress: "aa:bb:cc:dd:ee:ff",
+        bridgePort: 7,
+        interfaceIndex: 3,
+        vlanId: 120,
+        status: "learned",
+      };
+      const response: SnmpMonitorResponse = {
+        isOnline: true,
+        responseTimeInMs: 12,
+        failureCause: "",
+        oidResponses: [],
+        arpEntries: [arpEntry],
+        fdbEntries: [fdbEntry],
+      };
+
+      const roundTripped: SnmpMonitorResponse = JSON.parse(
+        JSON.stringify(response),
+      ) as SnmpMonitorResponse;
+
+      expect(roundTripped.arpEntries).toEqual([arpEntry]);
+      expect(roundTripped.fdbEntries).toEqual([fdbEntry]);
+    });
+
+    test("an older probe's payload carries no endpoint keys at all", () => {
+      const response: SnmpMonitorResponse = {
+        isOnline: false,
+        responseTimeInMs: 0,
+        failureCause: "Timed out",
+        oidResponses: [],
+      };
+
+      /*
+       * The server branches on presence, not emptiness (an absent array
+       * means "this probe does not collect endpoints", an empty one means
+       * "collected, found nothing"), so the wire form must not gain the
+       * keys — JSON.stringify has to drop them rather than emit [].
+       */
+      const roundTripped: SnmpMonitorResponse = JSON.parse(
+        JSON.stringify(response),
+      ) as SnmpMonitorResponse;
+
+      expect(Object.keys(roundTripped)).toEqual([
+        "isOnline",
+        "responseTimeInMs",
+        "failureCause",
+        "oidResponses",
+      ]);
+      expect("arpEntries" in roundTripped).toBe(false);
+      expect("fdbEntries" in roundTripped).toBe(false);
+    });
+
+    test("entries carry only their required fields over the wire", () => {
+      const arpEntry: ArpEntry = {
+        ipAddress: "10.0.0.1",
+        macAddress: "00:11:22:33:44:55",
+        interfaceIndex: 1,
+      };
+      const fdbEntry: FdbEntry = {
+        macAddress: "00:11:22:33:44:55",
+        bridgePort: 2,
+      };
+
+      expect(Object.keys(JSON.parse(JSON.stringify(arpEntry)))).toEqual([
+        "ipAddress",
+        "macAddress",
+        "interfaceIndex",
+      ]);
+      expect(Object.keys(JSON.parse(JSON.stringify(fdbEntry)))).toEqual([
+        "macAddress",
+        "bridgePort",
+      ]);
+    });
+  });
+
+  describe("NetworkTopology endpoint nodes and fdb links", () => {
+    test("an endpoint node attached via an fdb edge round-trips", () => {
+      const endpointNode: NetworkTopologyNode = {
+        id: "endpoint:aa:bb:cc:dd:ee:ff",
+        name: "POS Terminal 3",
+        isManaged: false,
+        status: "up",
+        kind: "endpoint",
+        macAddress: "aa:bb:cc:dd:ee:ff",
+        ipAddress: "10.20.30.40",
+        vendor: "Verifone",
+        classification: "pos-terminal",
+      };
+      const edge: NetworkTopologyEdge = {
+        fromNodeId: "device-1",
+        toNodeId: endpointNode.id,
+        protocols: ["fdb"],
+      };
+      const topology: NetworkTopology = {
+        nodes: [endpointNode],
+        edges: [edge],
+      };
+
+      const roundTripped: NetworkTopology = JSON.parse(
+        JSON.stringify(topology),
+      ) as NetworkTopology;
+
+      expect(roundTripped).toEqual(topology);
+      expect(roundTripped.nodes[0]!.kind).toBe("endpoint");
+      expect(roundTripped.edges[0]!.protocols).toEqual(["fdb"]);
+    });
+
+    test("a legacy node round-trips without gaining endpoint keys", () => {
+      const legacyNode: NetworkTopologyNode = {
+        id: "device-1",
+        name: "core-switch",
+        isManaged: true,
+        status: "up",
+      };
+
+      const roundTripped: NetworkTopologyNode = JSON.parse(
+        JSON.stringify(legacyNode),
+      ) as NetworkTopologyNode;
+
+      expect(Object.keys(roundTripped)).toEqual([
+        "id",
+        "name",
+        "isManaged",
+        "status",
+      ]);
+      expect(roundTripped).toEqual(legacyNode);
+    });
+  });
+});

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

@@ -18,6 +18,15 @@ const CISCO_SYS_OBJECT_ID: string = "1.3.6.1.4.1.9.1.1208"; // Catalyst 2960X
 const MIKROTIK_SYS_OBJECT_ID: string = "1.3.6.1.4.1.14988.1";
 const UBIQUITI_SYS_OBJECT_ID: string = "1.3.6.1.4.1.41112.1.4";
 const JUNIPER_SYS_OBJECT_ID: string = "1.3.6.1.4.1.2636.1.1.1.2.29"; // EX2200
+const ARISTA_SYS_OBJECT_ID: string = "1.3.6.1.4.1.30065.1.3011.7048";
+const HPE_SYS_OBJECT_ID: string = "1.3.6.1.4.1.11.2.3.7.11.87"; // ProCurve
+const FORTINET_SYS_OBJECT_ID: string = "1.3.6.1.4.1.12356.101.1.60";
+const PALO_ALTO_SYS_OBJECT_ID: string = "1.3.6.1.4.1.25461.2.3.36";
+const HUAWEI_SYS_OBJECT_ID: string = "1.3.6.1.4.1.2011.2.23.92";
+const FORCE10_SYS_OBJECT_ID: string = "1.3.6.1.4.1.6027.1.3.4"; // S-series
+// Ubiquiti EdgeSwitch firmware reports Broadcom's FASTPATH arc, not 41112.
+const EDGESWITCH_SYS_OBJECT_ID: string = "1.3.6.1.4.1.4413";
+const DELL_SYS_OBJECT_ID: string = "1.3.6.1.4.1.674.10895.3031"; // PowerConnect
 
 describe("SnmpVendorTemplateUtil.getEnterpriseNumber", () => {
   test("extracts the enterprise number from a Cisco sysObjectID", () => {
@@ -82,6 +91,14 @@ describe("SnmpVendorTemplateUtil.getVendorNameBySysObjectId", () => {
     [MIKROTIK_SYS_OBJECT_ID, "MikroTik"],
     [UBIQUITI_SYS_OBJECT_ID, "Ubiquiti"],
     [JUNIPER_SYS_OBJECT_ID, "Juniper"],
+    [ARISTA_SYS_OBJECT_ID, "Arista"],
+    [HPE_SYS_OBJECT_ID, "HPE"],
+    [FORTINET_SYS_OBJECT_ID, "Fortinet"],
+    [PALO_ALTO_SYS_OBJECT_ID, "Palo Alto Networks"],
+    [HUAWEI_SYS_OBJECT_ID, "Huawei"],
+    [FORCE10_SYS_OBJECT_ID, "Force10"],
+    [EDGESWITCH_SYS_OBJECT_ID, "Broadcom"],
+    [DELL_SYS_OBJECT_ID, "Dell"],
   ])("%s resolves to vendor %s", (sysObjectId: string, vendor: string) => {
     expect(SnmpVendorTemplateUtil.getVendorNameBySysObjectId(sysObjectId)).toBe(
       vendor,
@@ -130,17 +147,42 @@ describe("SnmpVendorTemplateUtil.matchBySysObjectId", () => {
     ).toBe("ubiquiti-edgeos");
   });
 
+  test.each([
+    [JUNIPER_SYS_OBJECT_ID, "juniper-junos"],
+    [ARISTA_SYS_OBJECT_ID, "arista-eos"],
+    [HPE_SYS_OBJECT_ID, "hpe-procurve"],
+    [FORTINET_SYS_OBJECT_ID, "fortinet-fortigate"],
+    [PALO_ALTO_SYS_OBJECT_ID, "paloalto-panos"],
+    [HUAWEI_SYS_OBJECT_ID, "huawei-vrp"],
+    [FORCE10_SYS_OBJECT_ID, "dell-force10"],
+    /*
+     * EdgeSwitch reports Broadcom's FASTPATH arc but still gets the
+     * standard-MIB Ubiquiti template.
+     */
+    [EDGESWITCH_SYS_OBJECT_ID, "ubiquiti-edgeos"],
+  ])(
+    "%s is routed to the %s template",
+    (sysObjectId: string, templateId: string) => {
+      const template: SnmpVendorTemplate | undefined =
+        SnmpVendorTemplateUtil.matchBySysObjectId(sysObjectId);
+
+      expect(template?.id).toBe(templateId);
+      expect(template).toBe(SnmpVendorTemplateUtil.getById(templateId));
+    },
+  );
+
   /*
-   * Juniper has a vendor name in the enterprise map but no vendor-specific
-   * template — the match must come back empty so callers fall back to the
+   * Dell enterprise 674 (PowerConnect and friends) has a vendor name in the
+   * enterprise map but no vendor-specific template — only Force10 (6027) is
+   * routed. The match must come back empty so callers fall back to the
    * generic Host Resources template rather than mislabeling the device.
    */
-  test("a Juniper device has a vendor name but no template", () => {
+  test("a Dell PowerConnect device has a vendor name but no template", () => {
     expect(
-      SnmpVendorTemplateUtil.getVendorNameBySysObjectId(JUNIPER_SYS_OBJECT_ID),
-    ).toBe("Juniper");
+      SnmpVendorTemplateUtil.getVendorNameBySysObjectId(DELL_SYS_OBJECT_ID),
+    ).toBe("Dell");
     expect(
-      SnmpVendorTemplateUtil.matchBySysObjectId(JUNIPER_SYS_OBJECT_ID),
+      SnmpVendorTemplateUtil.matchBySysObjectId(DELL_SYS_OBJECT_ID),
     ).toBeUndefined();
   });
 
@@ -169,6 +211,68 @@ describe("SnmpVendorTemplateUtil.getAll / getById", () => {
   });
 });
 
+/*
+ * Catalog hygiene: every shipped template must contain OIDs a poller can
+ * actually GET (dotted-numeric instance OIDs, no symbolic names or trailing
+ * dots) and enough metadata for the dashboard to render a useful row.
+ */
+describe("SnmpVendorTemplates catalog", () => {
+  // Absolute numeric OID: digits separated by single dots, at least two arcs.
+  const OID_REGEX: RegExp = /^[0-9]+(\.[0-9]+)+$/;
+
+  test("template ids are unique", () => {
+    const ids: Array<string> = SnmpVendorTemplates.map(
+      (template: SnmpVendorTemplate) => {
+        return template.id;
+      },
+    );
+
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  test.each(
+    SnmpVendorTemplates.map((template: SnmpVendorTemplate) => {
+      return [template.id, template] as [string, SnmpVendorTemplate];
+    }),
+  )(
+    "%s has valid OIDs and non-empty metadata",
+    (_id: string, template: SnmpVendorTemplate) => {
+      expect(template.label.trim()).not.toHaveLength(0);
+      expect(template.description.trim()).not.toHaveLength(0);
+      expect(template.oids.length).toBeGreaterThan(0);
+
+      for (const oid of template.oids) {
+        expect(oid.oid).toMatch(OID_REGEX);
+        expect(oid.name?.trim()).toBeTruthy();
+        expect(oid.description?.trim()).toBeTruthy();
+      }
+
+      // No template should list the same OID twice.
+      const values: Array<string> = template.oids.map((oid: SnmpOid) => {
+        return oid.oid;
+      });
+      expect(new Set(values).size).toBe(values.length);
+    },
+  );
+
+  /*
+   * The Cisco env-mon states are enums where 1 = normal — users build
+   * "not equal to 1" alert criteria on them, so the template must keep
+   * shipping these exact instance OIDs.
+   */
+  test("the Cisco template includes fan and PSU state OIDs", () => {
+    const cisco: SnmpVendorTemplate | undefined =
+      SnmpVendorTemplateUtil.getById("cisco-ios");
+
+    const oidValues: Array<string> = (cisco?.oids || []).map((oid: SnmpOid) => {
+      return oid.oid;
+    });
+
+    expect(oidValues).toContain("1.3.6.1.4.1.9.9.13.1.4.1.3.1"); // fan state
+    expect(oidValues).toContain("1.3.6.1.4.1.9.9.13.1.5.1.3.1"); // PSU state
+  });
+});
+
 describe("SnmpVendorTemplateUtil.mergeOids", () => {
   function oidValues(oids: Array<SnmpOid>): Array<string> {
     return oids.map((oid: SnmpOid) => {

package/Tests/Types/NetworkSite/DefaultNetworkSiteType.test.ts

@@ -0,0 +1,129 @@
+import DefaultNetworkSiteType from "../../../Types/NetworkSite/DefaultNetworkSiteType";
+import Permission, {
+  PermissionHelper,
+  PermissionProps,
+} from "../../../Types/Permission";
+
+describe("DefaultNetworkSiteType", () => {
+  /*
+   * These values are the names seeded into every project's NetworkSiteType
+   * table (and the names the backfill migration matches legacy site type
+   * strings against), so they are data, not just labels - renaming a member
+   * value here would leave existing sites pointing at a type that no longer
+   * gets seeded.
+   */
+  test("contains every hierarchy level with its display value", () => {
+    expect(DefaultNetworkSiteType.AccountType).toBe("Account Type");
+    expect(DefaultNetworkSiteType.Region).toBe("Region");
+    expect(DefaultNetworkSiteType.Franchisee).toBe("Franchisee");
+    expect(DefaultNetworkSiteType.Market).toBe("Market");
+    expect(DefaultNetworkSiteType.Unit).toBe("Unit");
+    expect(DefaultNetworkSiteType.DataCenter).toBe("Data Center");
+    expect(DefaultNetworkSiteType.Other).toBe("Other");
+  });
+
+  test("has exactly the expected members", () => {
+    expect(Object.keys(DefaultNetworkSiteType).sort()).toEqual(
+      [
+        "AccountType",
+        "DataCenter",
+        "Franchisee",
+        "Market",
+        "Other",
+        "Region",
+        "Unit",
+      ].sort(),
+    );
+  });
+});
+
+describe("NetworkSite permissions", () => {
+  /*
+   * Keyed by the enum member name on purpose: the VALUE is what gets
+   * persisted in team/API-key permission rows and compared as a raw string
+   * across services, so a value that drifts from its key is a silent
+   * authorization break. Referencing the members by symbol also keeps this
+   * a compile error if one is ever removed.
+   */
+  const permissionsByName: Record<string, Permission> = {
+    CreateNetworkSite: Permission.CreateNetworkSite,
+    DeleteNetworkSite: Permission.DeleteNetworkSite,
+    EditNetworkSite: Permission.EditNetworkSite,
+    ReadNetworkSite: Permission.ReadNetworkSite,
+    CreateNetworkEndpoint: Permission.CreateNetworkEndpoint,
+    DeleteNetworkEndpoint: Permission.DeleteNetworkEndpoint,
+    EditNetworkEndpoint: Permission.EditNetworkEndpoint,
+    ReadNetworkEndpoint: Permission.ReadNetworkEndpoint,
+    CreateNetworkSiteStatusTimeline: Permission.CreateNetworkSiteStatusTimeline,
+    DeleteNetworkSiteStatusTimeline: Permission.DeleteNetworkSiteStatusTimeline,
+    EditNetworkSiteStatusTimeline: Permission.EditNetworkSiteStatusTimeline,
+    ReadNetworkSiteStatusTimeline: Permission.ReadNetworkSiteStatusTimeline,
+    CreateNetworkSiteLink: Permission.CreateNetworkSiteLink,
+    DeleteNetworkSiteLink: Permission.DeleteNetworkSiteLink,
+    EditNetworkSiteLink: Permission.EditNetworkSiteLink,
+    ReadNetworkSiteLink: Permission.ReadNetworkSiteLink,
+    CreateNetworkSiteAssignmentRule: Permission.CreateNetworkSiteAssignmentRule,
+    DeleteNetworkSiteAssignmentRule: Permission.DeleteNetworkSiteAssignmentRule,
+    EditNetworkSiteAssignmentRule: Permission.EditNetworkSiteAssignmentRule,
+    ReadNetworkSiteAssignmentRule: Permission.ReadNetworkSiteAssignmentRule,
+    CreateNetworkSiteType: Permission.CreateNetworkSiteType,
+    DeleteNetworkSiteType: Permission.DeleteNetworkSiteType,
+    EditNetworkSiteType: Permission.EditNetworkSiteType,
+    ReadNetworkSiteType: Permission.ReadNetworkSiteType,
+  };
+
+  const permissions: Array<Permission> = Object.values(permissionsByName);
+
+  test.each(Object.keys(permissionsByName))(
+    "%s has an enum value identical to its key",
+    (name: string) => {
+      expect(permissionsByName[name]).toBe(name);
+    },
+  );
+
+  test("the enum values are exactly the twenty four expected strings", () => {
+    expect(permissions).toEqual([
+      "CreateNetworkSite",
+      "DeleteNetworkSite",
+      "EditNetworkSite",
+      "ReadNetworkSite",
+      "CreateNetworkEndpoint",
+      "DeleteNetworkEndpoint",
+      "EditNetworkEndpoint",
+      "ReadNetworkEndpoint",
+      "CreateNetworkSiteStatusTimeline",
+      "DeleteNetworkSiteStatusTimeline",
+      "EditNetworkSiteStatusTimeline",
+      "ReadNetworkSiteStatusTimeline",
+      "CreateNetworkSiteLink",
+      "DeleteNetworkSiteLink",
+      "EditNetworkSiteLink",
+      "ReadNetworkSiteLink",
+      "CreateNetworkSiteAssignmentRule",
+      "DeleteNetworkSiteAssignmentRule",
+      "EditNetworkSiteAssignmentRule",
+      "ReadNetworkSiteAssignmentRule",
+      "CreateNetworkSiteType",
+      "DeleteNetworkSiteType",
+      "EditNetworkSiteType",
+      "ReadNetworkSiteType",
+    ]);
+  });
+
+  test.each(permissions)(
+    "%s has permission props with a title and description",
+    (permission: Permission) => {
+      const props: PermissionProps | undefined =
+        PermissionHelper.getAllPermissionProps().find(
+          (item: PermissionProps) => {
+            return item.permission === permission;
+          },
+        );
+
+      expect(props).toBeDefined();
+      expect(props?.title.length).toBeGreaterThan(0);
+      expect(props?.description.length).toBeGreaterThan(0);
+      expect(props?.isAssignableToTenant).toBe(true);
+    },
+  );
+});

package/Tests/Types/SerializableObjectDictionary.test.ts

@@ -0,0 +1,166 @@
+import SerializableObjectDictionary from "../../Types/SerializableObjectDictionary";
+import Color from "../../Types/Color";
+import Email from "../../Types/Email";
+import { JSONValue, ObjectType } from "../../Types/JSON";
+import JSONFunctions from "../../Types/JSONFunctions";
+import ObjectID from "../../Types/ObjectID";
+import Phone from "../../Types/Phone";
+import Port from "../../Types/Port";
+import Version from "../../Types/Version";
+
+/*
+ * SerializableObjectDictionary is the registry JSONFunctions.deserializeValue
+ * looks a `_type` up in. A missing or wrong entry does not throw — the value
+ * just silently stays a plain `{ _type, value }` object and surfaces much
+ * later as a "x.toString is not a function" somewhere else entirely. These
+ * tests make that failure mode loud.
+ */
+
+/*
+ * ObjectTypes that deliberately have no registry entry, with the reason.
+ * Adding a new ObjectType without deciding which side of this line it falls
+ * on will fail the completeness test below.
+ */
+const INTENTIONALLY_UNREGISTERED: Array<ObjectType> = [
+  // Handled by its own branch in deserializeValue, before the registry lookup.
+  ObjectType.Buffer,
+  // Plain numeric wrappers that serialize as bare values.
+  ObjectType.Decimal,
+  ObjectType.PositiveNumber,
+  // Not a database property: permissions serialize as plain enum strings.
+  ObjectType.Permission,
+  // Nested inside Recurring / dashboard configs, never deserialized standalone.
+  ObjectType.RestrictionTimes,
+  ObjectType.DashboardComponent,
+  ObjectType.DashboardViewConfig,
+];
+
+describe("SerializableObjectDictionary", () => {
+  test("every key should be a known ObjectType", () => {
+    const objectTypes: Array<string> = Object.values(ObjectType);
+
+    for (const key of Object.keys(SerializableObjectDictionary)) {
+      expect(objectTypes).toContain(key);
+    }
+  });
+
+  test("every registered class should expose a static fromJSON", () => {
+    const withoutFromJson: Array<string> = Object.entries(
+      SerializableObjectDictionary,
+    )
+      .filter(([, value]: [string, any]) => {
+        return !value || typeof value.fromJSON !== "function";
+      })
+      .map(([key]: [string, any]) => {
+        return key;
+      });
+
+    // Listing the offenders makes a failure name the broken entry directly.
+    expect(withoutFromJson).toEqual([]);
+  });
+
+  test("every ObjectType should be registered or explicitly exempt", () => {
+    const registered: Array<string> = Object.keys(SerializableObjectDictionary);
+    const exempt: Array<string> = INTENTIONALLY_UNREGISTERED.map(
+      (type: ObjectType) => {
+        return type.toString();
+      },
+    );
+
+    const unaccounted: Array<string> = Object.values(ObjectType).filter(
+      (type: string) => {
+        return !registered.includes(type) && !exempt.includes(type);
+      },
+    );
+
+    /*
+     * A non-empty list here means a new ObjectType was added without deciding
+     * whether it needs a registry entry: either add it to
+     * SerializableObjectDictionary or list it in INTENTIONALLY_UNREGISTERED
+     * with the reason.
+     */
+    expect(unaccounted).toEqual([]);
+  });
+
+  test("no exempt ObjectType should also be registered", () => {
+    // Keeps the exemption list honest as entries get added to the registry.
+    const exemptButRegistered: Array<string> =
+      INTENTIONALLY_UNREGISTERED.filter((type: ObjectType) => {
+        return Boolean(SerializableObjectDictionary[type.toString()]);
+      }).map((type: ObjectType) => {
+        return type.toString();
+      });
+
+    expect(exemptButRegistered).toEqual([]);
+  });
+
+  describe("deserializeValue should hydrate registered types", () => {
+    test("should hydrate an ObjectID", () => {
+      const id: ObjectID = ObjectID.generate();
+      const hydrated: JSONValue = JSONFunctions.deserializeValue(id.toJSON());
+
+      expect(hydrated).toBeInstanceOf(ObjectID);
+      expect((hydrated as ObjectID).toString()).toEqual(id.toString());
+    });
+
+    test("should hydrate an Email", () => {
+      const email: Email = new Email("registry@example.com");
+      const hydrated: JSONValue = JSONFunctions.deserializeValue(
+        email.toJSON(),
+      );
+
+      expect(hydrated).toBeInstanceOf(Email);
+      expect((hydrated as Email).toString()).toEqual("registry@example.com");
+    });
+
+    test("should hydrate a Color", () => {
+      const color: Color = new Color("#ab12cd");
+      const hydrated: JSONValue = JSONFunctions.deserializeValue(
+        color.toJSON(),
+      );
+
+      expect(hydrated).toBeInstanceOf(Color);
+      expect((hydrated as Color).toString()).toEqual("#ab12cd");
+    });
+
+    test("should hydrate a Port", () => {
+      const port: Port = new Port(8080);
+      const hydrated: JSONValue = JSONFunctions.deserializeValue(port.toJSON());
+
+      expect(hydrated).toBeInstanceOf(Port);
+      expect((hydrated as Port).toNumber()).toEqual(8080);
+    });
+
+    test("should hydrate a Version", () => {
+      const version: Version = new Version("1.2.3");
+      const hydrated: JSONValue = JSONFunctions.deserializeValue(
+        version.toJSON(),
+      );
+
+      expect(hydrated).toBeInstanceOf(Version);
+      expect((hydrated as Version).toString()).toEqual("1.2.3");
+    });
+
+    test("should hydrate a Phone", () => {
+      const phone: Phone = new Phone("+15551234567");
+      const hydrated: JSONValue = JSONFunctions.deserializeValue(
+        phone.toJSON(),
+      );
+
+      expect(hydrated).toBeInstanceOf(Phone);
+      expect((hydrated as Phone).toString()).toEqual("+15551234567");
+    });
+
+    test("should leave an unknown _type as a plain object", () => {
+      const unknown: JSONValue = JSONFunctions.deserializeValue({
+        _type: "NotARegisteredType",
+        value: "whatever",
+      });
+
+      expect(unknown).toEqual({
+        _type: "NotARegisteredType",
+        value: "whatever",
+      });
+    });
+  });
+});

package/Tests/Types/Time/RangeStartAndEndDateTime.test.ts

@@ -0,0 +1,98 @@
+import InBetween from "../../../Types/BaseDatabase/InBetween";
+import OneUptimeDate from "../../../Types/Date";
+import { RangeStartAndEndDateTimeUtil } from "../../../Types/Time/RangeStartAndEndDateTime";
+import TimeRange from "../../../Types/Time/TimeRange";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * RangeStartAndEndDateTimeUtil turns a relative TimeRange (last 5 mins, last
+ * hour, ...) into a concrete [start, end] window ending "now". Because both
+ * bounds are captured from the same `now`, the window's *width* is
+ * deterministic even though its absolute position moves — so these tests assert
+ * the exact width for the fixed-duration ranges without freezing the clock, and
+ * a sane ordering/magnitude for the calendar-variable month ranges.
+ */
+
+function widthMs(range: TimeRange): number {
+  const between: InBetween<Date> =
+    RangeStartAndEndDateTimeUtil.getStartAndEndDate({ range });
+  return between.endValue.getTime() - between.startValue.getTime();
+}
+
+const MIN: number = 60 * 1000;
+const HOUR: number = 60 * MIN;
+const DAY: number = 24 * HOUR;
+
+describe("RangeStartAndEndDateTimeUtil.getStartAndEndDate - fixed durations", () => {
+  const cases: Array<[TimeRange, number]> = [
+    [TimeRange.PAST_FIVE_MINS, 5 * MIN],
+    [TimeRange.PAST_FIFTEEN_MINS, 15 * MIN],
+    [TimeRange.PAST_THIRTY_MINS, 30 * MIN],
+    [TimeRange.PAST_ONE_HOUR, HOUR],
+    [TimeRange.PAST_TWO_HOURS, 2 * HOUR],
+    [TimeRange.PAST_THREE_HOURS, 3 * HOUR],
+    [TimeRange.PAST_ONE_DAY, DAY],
+    [TimeRange.PAST_TWO_DAYS, 2 * DAY],
+    [TimeRange.PAST_ONE_WEEK, 7 * DAY],
+    [TimeRange.PAST_TWO_WEEKS, 14 * DAY],
+  ];
+
+  for (const [range, expectedWidth] of cases) {
+    test(`${range} spans exactly ${expectedWidth / MIN} minutes`, () => {
+      // Allow a tiny tolerance for the two now() reads inside the util.
+      expect(Math.abs(widthMs(range) - expectedWidth)).toBeLessThan(2000);
+    });
+  }
+
+  test("end bound is at (or a hair before) now, start is earlier", () => {
+    const between: InBetween<Date> =
+      RangeStartAndEndDateTimeUtil.getStartAndEndDate({
+        range: TimeRange.PAST_ONE_HOUR,
+      });
+    expect(between.startValue.getTime()).toBeLessThan(
+      between.endValue.getTime(),
+    );
+    expect(between.endValue.getTime()).toBeLessThanOrEqual(Date.now() + 2000);
+  });
+});
+
+describe("RangeStartAndEndDateTimeUtil.getStartAndEndDate - calendar ranges", () => {
+  test("one month is between 27 and 32 days wide", () => {
+    const width: number = widthMs(TimeRange.PAST_ONE_MONTH);
+    expect(width).toBeGreaterThan(27 * DAY);
+    expect(width).toBeLessThan(32 * DAY);
+  });
+
+  test("three months is wider than one month", () => {
+    expect(widthMs(TimeRange.PAST_THREE_MONTHS)).toBeGreaterThan(
+      widthMs(TimeRange.PAST_ONE_MONTH),
+    );
+  });
+});
+
+describe("RangeStartAndEndDateTimeUtil.getStartAndEndDate - custom", () => {
+  test("returns the caller-supplied window for CUSTOM", () => {
+    const start: Date = OneUptimeDate.fromString("2026-01-01T00:00:00.000Z");
+    const end: Date = OneUptimeDate.fromString("2026-01-02T00:00:00.000Z");
+    const custom: InBetween<Date> = new InBetween<Date>(start, end);
+
+    const result: InBetween<Date> =
+      RangeStartAndEndDateTimeUtil.getStartAndEndDate({
+        range: TimeRange.CUSTOM,
+        startAndEndDate: custom,
+      });
+
+    expect(result).toBe(custom);
+  });
+
+  test("falls back to a zero-width now window when CUSTOM has no dates", () => {
+    const result: InBetween<Date> =
+      RangeStartAndEndDateTimeUtil.getStartAndEndDate({
+        range: TimeRange.CUSTOM,
+      });
+    // start === end within tolerance -> effectively zero width.
+    expect(
+      Math.abs(result.endValue.getTime() - result.startValue.getTime()),
+    ).toBeLessThan(2000);
+  });
+});