@oneuptime/common 11.6.2 → 11.7.1

package/Models/AnalyticsModels/SloHistory.ts

@@ -42,8 +42,11 @@ import Permission from "../../Types/Permission";
  * dashboard charts do) or dedupe explicitly via
  * `argMax(value, version) ... GROUP BY <identity>`.
  *
- * `metricName` values: "sli.percent", "error.budget.remaining.percent",
- * "burn.rate", "good.count", "total.count".
+ * `metricName` values written today: "sli.percent",
+ * "error.budget.remaining.percent" and "burn.rate" — the three gauges the
+ * evaluation worker persists per run. "good.count" / "total.count" are
+ * reserved for event-based (Metric) SLIs, which the worker does not
+ * evaluate yet; nothing writes or reads them.
  */
 export default class SloHistory extends AnalyticsBaseModel {
   public constructor() {
@@ -87,7 +90,7 @@ export default class SloHistory extends AnalyticsBaseModel {
       isLowCardinality: true,
       title: "Metric Name",
       description:
-        "Which SLO series this row belongs to: sli.percent, error.budget.remaining.percent, burn.rate, good.count, or total.count.",
+        "Which SLO series this row belongs to: sli.percent, error.budget.remaining.percent, or burn.rate.",
       required: true,
       type: TableColumnType.Text,
       accessControl: {

package/Models/DatabaseModels/ServiceLevelObjective.ts

@@ -12,6 +12,7 @@ import AccessControlColumn from "../../Types/Database/AccessControlColumn";
 import ColumnLength from "../../Types/Database/ColumnLength";
 import ColumnType from "../../Types/Database/ColumnType";
 import CrudApiEndpoint from "../../Types/Database/CrudApiEndpoint";
+import EnableAuditLog from "../../Types/Database/EnableAuditLog";
 import EnableDocumentation from "../../Types/Database/EnableDocumentation";
 import EnableWorkflow from "../../Types/Database/EnableWorkflow";
 import SlugifyColumn from "../../Types/Database/SlugifyColumn";
@@ -72,6 +73,14 @@ const decimalTransformer: ValueTransformer = {
  * an owner of the SLO they just created).
  */
 @OperationalResource()
+/*
+ * An SLO's target, window and monitor set are the definition of what
+ * "reliable enough" means for a service, so a change to any of them
+ * silently rewrites history: budgets recompute against the new
+ * definition on the worker's next tick. Recording those edits is how a
+ * team answers "did the SLO get better, or did someone move the target?".
+ */
+@EnableAuditLog()
 @EnableDocumentation()
 @AccessControlColumn("labels")
 @TenantColumn("projectId")

package/Server/Infrastructure/Postgres/SchemaMigrations/1785066759532-MigrationName.ts

@@ -0,0 +1,30 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1785066759532 implements MigrationInterface {
+  public name = "MigrationName1785066759532";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    /*
+     * 1784200000000 added these two as `text`, but the entity declares them
+     * ColumnType.LongText, which maps to `varchar`. The generator wants to
+     * DROP and re-ADD the columns; an in-place TYPE change reaches the same
+     * schema without discarding the SNMP v3 credentials already stored on
+     * existing discovery scans.
+     */
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ALTER COLUMN "snmpV3AuthKey" TYPE character varying`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ALTER COLUMN "snmpV3PrivKey" TYPE character varying`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ALTER COLUMN "snmpV3PrivKey" TYPE text`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ALTER COLUMN "snmpV3AuthKey" TYPE text`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -469,6 +469,7 @@ import { AddNetworkSiteAlerting1784897317860 } from "./1784897317860-AddNetworkS
 import { AddNetworkDevicePollingColumns1784970388777 } from "./1784970388777-AddNetworkDevicePollingColumns";
 import { AddNetworkSiteTypeTable1784986826214 } from "./1784986826214-AddNetworkSiteTypeTable";
 import { AddServiceLevelObjective1784987015619 } from "./1784987015619-AddServiceLevelObjective";
+import { MigrationName1785066759532 } from "./1785066759532-MigrationName";
 
 export default [
   InitialMigration,
@@ -942,4 +943,5 @@ export default [
   AddNetworkDevicePollingColumns1784970388777,
   AddNetworkSiteTypeTable1784986826214,
   AddServiceLevelObjective1784987015619,
+  MigrationName1785066759532,
 ];

package/Server/Services/ServiceLevelObjectiveService.ts

@@ -650,8 +650,15 @@ export class Service extends DatabaseService<Model> {
   private validateWindowDays(value: unknown): number {
     const windowDays: number = this.normalizeNumericInput(value);
 
-    if (!Number.isFinite(windowDays) || windowDays < 1 || windowDays > 366) {
-      throw new BadDataException("SLO window must be between 1 and 366 days.");
+    /*
+     * The column is a Postgres integer, so a decimal that cleared only the
+     * range check would fail the INSERT with a raw driver error instead of
+     * this message.
+     */
+    if (!Number.isInteger(windowDays) || windowDays < 1 || windowDays > 366) {
+      throw new BadDataException(
+        "SLO window must be a whole number of days between 1 and 366.",
+      );
     }
 
     return windowDays;
@@ -660,13 +667,14 @@ export class Service extends DatabaseService<Model> {
   private validateAtRiskThresholdPercentage(value: unknown): number {
     const atRiskThresholdPercentage: number = this.normalizeNumericInput(value);
 
+    // Integer column — see validateWindowDays.
     if (
-      !Number.isFinite(atRiskThresholdPercentage) ||
+      !Number.isInteger(atRiskThresholdPercentage) ||
       atRiskThresholdPercentage < 0 ||
       atRiskThresholdPercentage > 100
     ) {
       throw new BadDataException(
-        "SLO at-risk threshold must be a percentage between 0 and 100.",
+        "SLO at-risk threshold must be a whole percentage between 0 and 100.",
       );
     }
 

package/Tests/Server/Services/ServiceLevelObjectiveService.test.ts

@@ -62,9 +62,9 @@ const RESOLVED_STATE_ID: ObjectID = new ObjectID(
 const TARGET_PERCENTAGE_ERROR_MESSAGE: string =
   "SLO target must be greater than 0 and at most 99.999. A 100% target leaves no error budget.";
 const WINDOW_DAYS_ERROR_MESSAGE: string =
-  "SLO window must be between 1 and 366 days.";
+  "SLO window must be a whole number of days between 1 and 366.";
 const AT_RISK_THRESHOLD_ERROR_MESSAGE: string =
-  "SLO at-risk threshold must be a percentage between 0 and 100.";
+  "SLO at-risk threshold must be a whole percentage between 0 and 100.";
 
 /*
  * Every column getDueSlos must hand to the evaluation worker. Enumerated here

package/Tests/Types/DateUserTimezone.test.ts

@@ -0,0 +1,205 @@
+/**
+ * The user's profile timezone (User Settings > Timezone) — not the zone the
+ * browser reports — decides which wall clock OneUptimeDate reads and writes.
+ *
+ * The bug these lock in: a user in America/New_York whose browser reported
+ * America/Adak was told "your local timezone - HDT" on every date field, and
+ * had to enter Hawaii-Aleutian times for their events to land correctly. The
+ * profile timezone was stored but never consulted by the UI.
+ *
+ * Every assertion is expressed in explicit-zone wall-clock (or absolute
+ * milliseconds) so it holds under whatever TZ the suite runs in.
+ */
+import OneUptimeDate from "../../Types/Date";
+import Timezone from "../../Types/Timezone";
+import moment from "moment-timezone";
+
+const NY: Timezone = Timezone.AmericaNew_York;
+const ADAK: Timezone = Timezone.AmericaAdak;
+const KOLKATA: Timezone = Timezone.AsiaKolkata;
+
+describe("OneUptimeDate user timezone", () => {
+  afterEach(() => {
+    // Never leak an override into the rest of the suite.
+    OneUptimeDate.setUserTimezone(null);
+  });
+
+  describe("setUserTimezone / getCurrentTimezone", () => {
+    it("falls back to the browser / process zone when no user timezone is set", () => {
+      expect(OneUptimeDate.getUserTimezone()).toBeNull();
+      expect(OneUptimeDate.getCurrentTimezone().toString()).toBe(
+        moment.tz.guess(),
+      );
+    });
+
+    it("prefers the user timezone over the browser / process zone", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      expect(OneUptimeDate.getCurrentTimezone()).toBe(NY);
+      expect(OneUptimeDate.getUserTimezone()).toBe(NY);
+    });
+
+    it("reports the abbreviation of the user timezone, DST aware", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      // The bug reported "HDT" (America/Adak) for a New York user.
+      expect(OneUptimeDate.getCurrentTimezoneString()).not.toBe("HDT");
+      expect(["EST", "EDT"]).toContain(
+        OneUptimeDate.getCurrentTimezoneString(),
+      );
+    });
+
+    it("clears back to the browser / process zone when set to null", () => {
+      OneUptimeDate.setUserTimezone(NY);
+      OneUptimeDate.setUserTimezone(null);
+
+      expect(OneUptimeDate.getUserTimezone()).toBeNull();
+      expect(OneUptimeDate.getCurrentTimezone().toString()).toBe(
+        moment.tz.guess(),
+      );
+    });
+
+    it("ignores a value moment does not recognise as a zone rather than breaking every date", () => {
+      OneUptimeDate.setUserTimezone("Not/AZone" as Timezone);
+
+      expect(OneUptimeDate.getUserTimezone()).toBeNull();
+      expect(OneUptimeDate.getCurrentTimezone().toString()).toBe(
+        moment.tz.guess(),
+      );
+      // Formatting still works.
+      expect(
+        OneUptimeDate.toDateTimeLocalString(new Date("2026-07-09T13:00:00Z")),
+      ).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/);
+    });
+  });
+
+  describe("datetime-local round trip", () => {
+    it("renders a stored instant as its wall-clock in the user timezone", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      // 17:00 UTC on 2026-07-09 is 13:00 in New York (EDT).
+      expect(
+        OneUptimeDate.toDateTimeLocalString(new Date("2026-07-09T17:00:00Z")),
+      ).toBe("2026-07-09T13:00:00");
+    });
+
+    it("resolves a typed wall-clock in the user timezone, not the browser zone", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      const typed: Date =
+        OneUptimeDate.fromDateTimeLocalString("2026-07-09T13:00");
+
+      expect(typed.toISOString()).toBe("2026-07-09T17:00:00.000Z");
+    });
+
+    it("round trips what the user typed back into the picker unchanged", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      const typed: Date =
+        OneUptimeDate.fromDateTimeLocalString("2026-01-15T09:30");
+
+      expect(OneUptimeDate.toDateTimeLocalString(typed)).toBe(
+        "2026-01-15T09:30:00",
+      );
+    });
+
+    it("stores different instants for the same wall-clock in different user timezones", () => {
+      OneUptimeDate.setUserTimezone(NY);
+      const inNY: Date =
+        OneUptimeDate.fromDateTimeLocalString("2026-07-09T13:00");
+
+      OneUptimeDate.setUserTimezone(ADAK);
+      const inAdak: Date =
+        OneUptimeDate.fromDateTimeLocalString("2026-07-09T13:00");
+
+      // Adak is 5 hours behind New York in July.
+      expect(inAdak.getTime() - inNY.getTime()).toBe(5 * 60 * 60 * 1000);
+    });
+
+    it("honours the user timezone's DST offset for a winter instant", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      // 09:00 EST is 14:00 UTC in January.
+      expect(
+        OneUptimeDate.fromDateTimeLocalString("2026-01-15T09:00").toISOString(),
+      ).toBe("2026-01-15T14:00:00.000Z");
+    });
+  });
+
+  describe("display helpers", () => {
+    it("formats an instant in the user timezone with its abbreviation", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      const formatted: string = OneUptimeDate.getDateAsLocalFormattedString(
+        new Date("2026-07-09T17:00:00Z"),
+      );
+
+      expect(formatted).toContain("Jul 09 2026");
+      expect(formatted).toContain("13:00");
+      expect(formatted).toContain("EDT");
+    });
+
+    it("reads the hour and minute of an instant in the user timezone", () => {
+      OneUptimeDate.setUserTimezone(KOLKATA);
+
+      const instant: Date = new Date("2026-07-09T17:00:00Z");
+
+      // 17:00 UTC is 22:30 in Kolkata (UTC+5:30).
+      expect(OneUptimeDate.getLocalHours(instant)).toBe(22);
+      expect(OneUptimeDate.getLocalMinutes(instant)).toBe(30);
+      expect(OneUptimeDate.getLocalTimeString(instant)).toBe("22:30");
+    });
+
+    it("rolls the calendar day when the user timezone puts the instant on another date", () => {
+      OneUptimeDate.setUserTimezone(KOLKATA);
+
+      // 23:00 UTC on Jul 9 is already 04:30 on Jul 10 in Kolkata.
+      const instant: Date = new Date("2026-07-09T23:00:00Z");
+
+      expect(OneUptimeDate.asDateForDatabaseQuery(instant)).toBe("2026-07-10");
+      expect(OneUptimeDate.getDateAsLocalDayMonthString(instant)).toBe(
+        "10 Jul",
+      );
+      expect(OneUptimeDate.getDateAsLocalMonthYearString(instant)).toBe(
+        "Jul 2026",
+      );
+    });
+  });
+
+  describe("schedule-zone wall-clock bridge", () => {
+    it("reads the entered wall-clock in the user timezone before anchoring it to the schedule zone", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      // The admin typed 09:00 while working in New York.
+      const typed: Date =
+        OneUptimeDate.fromDateTimeLocalString("2026-07-09T09:00");
+
+      const stored: Date = OneUptimeDate.getInstantFromLocalWallClockInTimezone(
+        typed,
+        KOLKATA.toString(),
+      );
+
+      // ...and the schedule enforces 09:00 in Kolkata.
+      expect(moment.tz(stored, KOLKATA.toString()).format("HH:mm")).toBe(
+        "09:00",
+      );
+    });
+
+    it("redisplays a stored schedule-zone time as the same wall-clock in the picker", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      const stored: Date = moment
+        .tz("2026-07-09 09:00", KOLKATA.toString())
+        .toDate();
+
+      const forPicker: Date = OneUptimeDate.getLocalDateFromWallClockInTimezone(
+        stored,
+        KOLKATA.toString(),
+      );
+
+      expect(OneUptimeDate.toDateTimeLocalString(forPicker)).toBe(
+        "2026-07-09T09:00:00",
+      );
+    });
+  });
+});

package/Tests/Types/DateUserTimezoneOverridesBrowser.test.ts

@@ -0,0 +1,73 @@
+/** @timezone America/Adak */
+
+/**
+ * Regression test for the reported bug, reproduced exactly: the process (a
+ * stand-in for the customer's browser) reports America/Adak — abbreviated
+ * "HDT" — while the user has picked America/New_York in User Settings.
+ *
+ * Before the fix, every date field labelled itself "your local timezone - HDT"
+ * and resolved what the user typed in Adak's zone, so a New York user had to
+ * enter Hawaii-Aleutian times to get the right instant stored. The profile
+ * timezone must win over whatever the browser reports.
+ */
+import OneUptimeDate from "../../Types/Date";
+import Timezone from "../../Types/Timezone";
+import moment from "moment-timezone";
+
+const NY: Timezone = Timezone.AmericaNew_York;
+
+describe("user timezone overrides a browser reporting a different zone", () => {
+  afterEach(() => {
+    OneUptimeDate.setUserTimezone(null);
+  });
+
+  it("confirms the process really is on the Adak (HDT) clock", () => {
+    // Guards the premise of every assertion below.
+    expect(moment.tz.guess()).toBe("America/Adak");
+    expect(OneUptimeDate.getCurrentTimezoneString()).toBe("HDT");
+  });
+
+  it("labels date fields with the profile timezone, not HDT", () => {
+    OneUptimeDate.setUserTimezone(NY);
+
+    expect(OneUptimeDate.getCurrentTimezoneString()).toBe("EDT");
+    expect(OneUptimeDate.getCurrentTimezone()).toBe(NY);
+  });
+
+  it("stores the wall-clock the user typed as New York time", () => {
+    OneUptimeDate.setUserTimezone(NY);
+
+    /*
+     * The user schedules maintenance for 14:00 on Jul 9. That is 18:00 UTC in
+     * New York; reading it on the Adak clock would have stored 23:00 UTC —
+     * five hours off, which is exactly what the customer worked around.
+     */
+    const startsAt: Date =
+      OneUptimeDate.fromDateTimeLocalString("2026-07-09T14:00");
+
+    expect(startsAt.toISOString()).toBe("2026-07-09T18:00:00.000Z");
+  });
+
+  it("reads a stored event back at the wall-clock the user typed", () => {
+    OneUptimeDate.setUserTimezone(NY);
+
+    const startsAt: Date = new Date("2026-07-09T18:00:00.000Z");
+
+    expect(OneUptimeDate.toDateTimeLocalString(startsAt)).toBe(
+      "2026-07-09T14:00:00",
+    );
+    expect(OneUptimeDate.getDateAsLocalFormattedString(startsAt)).toContain(
+      "EDT",
+    );
+    expect(OneUptimeDate.getLocalTimeString(startsAt)).toBe("14:00");
+  });
+
+  it("still follows the browser zone for a user who has not picked one", () => {
+    OneUptimeDate.setUserTimezone(null);
+
+    // 14:00 HDT (UTC-9) is 23:00 UTC the same day.
+    expect(
+      OneUptimeDate.fromDateTimeLocalString("2026-07-09T14:00").toISOString(),
+    ).toBe("2026-07-09T23:00:00.000Z");
+  });
+});

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

@@ -0,0 +1,155 @@
+import MonitorCriteria from "../../../Types/Monitor/MonitorCriteria";
+import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInstance";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+import { JSONObject, ObjectType } from "../../../Types/JSON";
+import BadDataException from "../../../Types/Exception/BadDataException";
+
+/*
+ * MonitorCriteria wraps the ordered list of MonitorCriteriaInstance that a
+ * monitor step evaluates. These tests lock in the default builder (which
+ * composes the online + offline instances), the validation contract (which
+ * delegates to each instance), and the toJSON/fromJSON round-trip.
+ */
+
+const DEFAULT_ARG: {
+  monitorType: MonitorType;
+  monitorName: string;
+  onlineMonitorStatusId: ObjectID;
+  offlineMonitorStatusId: ObjectID;
+  defaultIncidentSeverityId: ObjectID;
+  defaultAlertSeverityId: ObjectID;
+} = {
+  monitorType: MonitorType.Ping,
+  monitorName: "Gateway",
+  onlineMonitorStatusId: new ObjectID("100000000000000000000011"),
+  offlineMonitorStatusId: new ObjectID("100000000000000000000012"),
+  defaultIncidentSeverityId: new ObjectID("100000000000000000000013"),
+  defaultAlertSeverityId: new ObjectID("100000000000000000000014"),
+};
+
+describe("MonitorCriteria", () => {
+  describe("getDefaultMonitorCriteria", () => {
+    test("composes both an offline and an online instance for Ping", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+
+      // Ping has both an offline (Disallow) and an online criteria instance.
+      expect(criteria.data?.monitorCriteriaInstanceArray).toHaveLength(2);
+      for (const instance of criteria.data!.monitorCriteriaInstanceArray) {
+        expect(instance).toBeInstanceOf(MonitorCriteriaInstance);
+      }
+    });
+
+    test("the default Ping criteria passes validation", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      expect(
+        MonitorCriteria.getValidationError(criteria, MonitorType.Ping),
+      ).toBeNull();
+    });
+  });
+
+  describe("getValidationError", () => {
+    test("errors when data is missing", () => {
+      const criteria: MonitorCriteria = new MonitorCriteria();
+      criteria.data = undefined;
+      expect(
+        MonitorCriteria.getValidationError(criteria, MonitorType.Ping),
+      ).toBe("Monitor Criteria is required");
+    });
+
+    test("errors when the instance array is empty", () => {
+      const criteria: MonitorCriteria = new MonitorCriteria();
+      criteria.data = { monitorCriteriaInstanceArray: [] };
+      expect(
+        MonitorCriteria.getValidationError(criteria, MonitorType.Ping),
+      ).toBe("Monitor Criteria is required");
+    });
+
+    test("propagates a validation error from a contained instance", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      // Corrupt a contained instance: strip its required name.
+      criteria.data!.monitorCriteriaInstanceArray[0]!.data!.name = "";
+      const error: string | null = MonitorCriteria.getValidationError(
+        criteria,
+        MonitorType.Ping,
+      );
+      expect(error).toContain("Name is required");
+    });
+  });
+
+  describe("getNewMonitorCriteriaAsJSON", () => {
+    test("wraps a single default instance", () => {
+      const json: JSONObject = MonitorCriteria.getNewMonitorCriteriaAsJSON();
+      expect(json["_type"]).toBe("MonitorCriteria");
+      const value: JSONObject = json["value"] as JSONObject;
+      expect(Array.isArray(value["monitorCriteriaInstanceArray"])).toBe(true);
+      expect(
+        (value["monitorCriteriaInstanceArray"] as Array<unknown>).length,
+      ).toBe(1);
+    });
+  });
+
+  describe("toJSON / fromJSON round-trip", () => {
+    test("serializes with the MonitorCriteria type wrapper", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      const json: JSONObject = criteria.toJSON();
+      expect(json["_type"]).toBe(ObjectType.MonitorCriteria);
+    });
+
+    test("round-trips the instance count", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      const restored: MonitorCriteria = MonitorCriteria.fromJSON(
+        criteria.toJSON(),
+      );
+      expect(restored.data?.monitorCriteriaInstanceArray).toHaveLength(2);
+      expect(restored.data?.monitorCriteriaInstanceArray[0]).toBeInstanceOf(
+        MonitorCriteriaInstance,
+      );
+    });
+
+    test("toString returns a JSON string of the serialized value", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      const parsed: JSONObject = JSON.parse(criteria.toString()) as JSONObject;
+      expect(parsed["_type"]).toBe(ObjectType.MonitorCriteria);
+    });
+  });
+
+  describe("fromJSON validation", () => {
+    test("returns the same instance when given a MonitorCriteria", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      expect(MonitorCriteria.fromJSON(criteria as unknown as JSONObject)).toBe(
+        criteria,
+      );
+    });
+
+    test("throws on a wrong _type", () => {
+      expect(() => {
+        return MonitorCriteria.fromJSON({ _type: "Nope", value: {} });
+      }).toThrow(BadDataException);
+    });
+
+    test("throws when value is missing", () => {
+      expect(() => {
+        return MonitorCriteria.fromJSON({
+          _type: ObjectType.MonitorCriteria,
+        });
+      }).toThrow(BadDataException);
+    });
+
+    test("throws when monitorCriteriaInstanceArray is missing", () => {
+      expect(() => {
+        return MonitorCriteria.fromJSON({
+          _type: ObjectType.MonitorCriteria,
+          value: {},
+        });
+      }).toThrow(BadDataException);
+    });
+  });
+});