@oneuptime/common 11.7.3 → 11.7.4

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

@@ -0,0 +1,105 @@
+import { JSONObject } from "../../../Types/JSON";
+import DnsRecordType from "../../../Types/Monitor/DnsMonitor/DnsRecordType";
+import MonitorStepDnsMonitor, {
+  MonitorStepDnsMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepDnsMonitor";
+
+describe("MonitorStepDnsMonitorUtil", () => {
+  describe("getDefault", () => {
+    test("returns an empty query on port 53 with an A record", () => {
+      const def: MonitorStepDnsMonitor = MonitorStepDnsMonitorUtil.getDefault();
+
+      expect(def.queryName).toBe("");
+      expect(def.recordType).toBe(DnsRecordType.A);
+      expect(def.hostname).toBe("");
+      expect(def.port).toBe(53);
+      expect(def.timeout).toBe(5000);
+      expect(def.retries).toBe(3);
+    });
+  });
+
+  describe("fromJSON", () => {
+    test("reads through explicit values", () => {
+      const parsed: MonitorStepDnsMonitor = MonitorStepDnsMonitorUtil.fromJSON({
+        queryName: "oneuptime.com",
+        recordType: DnsRecordType.MX,
+        hostname: "8.8.8.8",
+        port: 5353,
+        timeout: 2000,
+        retries: 5,
+      });
+
+      expect(parsed.queryName).toBe("oneuptime.com");
+      expect(parsed.recordType).toBe(DnsRecordType.MX);
+      expect(parsed.hostname).toBe("8.8.8.8");
+      expect(parsed.port).toBe(5353);
+      expect(parsed.timeout).toBe(2000);
+      expect(parsed.retries).toBe(5);
+    });
+
+    test("falls back to defaults for missing or falsy fields", () => {
+      const parsed: MonitorStepDnsMonitor = MonitorStepDnsMonitorUtil.fromJSON(
+        {},
+      );
+
+      expect(parsed.queryName).toBe("");
+      expect(parsed.recordType).toBe(DnsRecordType.A);
+      // An empty hostname collapses to undefined (system-default resolver).
+      expect(parsed.hostname).toBeUndefined();
+      expect(parsed.port).toBe(53);
+      expect(parsed.timeout).toBe(5000);
+      expect(parsed.retries).toBe(3);
+    });
+
+    test("treats an empty hostname as the system default resolver", () => {
+      const parsed: MonitorStepDnsMonitor = MonitorStepDnsMonitorUtil.fromJSON({
+        queryName: "oneuptime.com",
+        hostname: "",
+      });
+
+      expect(parsed.hostname).toBeUndefined();
+    });
+  });
+
+  describe("toJSON / round-trip", () => {
+    test("serializes every field", () => {
+      const monitor: MonitorStepDnsMonitor = {
+        queryName: "example.com",
+        recordType: DnsRecordType.AAAA,
+        hostname: "1.1.1.1",
+        port: 53,
+        timeout: 7000,
+        retries: 2,
+      };
+
+      const json: JSONObject = MonitorStepDnsMonitorUtil.toJSON(monitor);
+
+      expect(json).toEqual({
+        queryName: "example.com",
+        recordType: DnsRecordType.AAAA,
+        hostname: "1.1.1.1",
+        port: 53,
+        timeout: 7000,
+        retries: 2,
+      });
+    });
+
+    test("fromJSON(toJSON(x)) preserves a populated monitor", () => {
+      const monitor: MonitorStepDnsMonitor = {
+        queryName: "example.com",
+        recordType: DnsRecordType.TXT,
+        hostname: "9.9.9.9",
+        port: 5300,
+        timeout: 4000,
+        retries: 4,
+      };
+
+      const roundTripped: MonitorStepDnsMonitor =
+        MonitorStepDnsMonitorUtil.fromJSON(
+          MonitorStepDnsMonitorUtil.toJSON(monitor),
+        );
+
+      expect(roundTripped).toEqual(monitor);
+    });
+  });
+});

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

@@ -0,0 +1,131 @@
+import { JSONObject } from "../../../Types/JSON";
+import MonitorStepDnssecMonitor, {
+  MonitorStepDnssecMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepDnssecMonitor";
+
+describe("MonitorStepDnssecMonitorUtil", () => {
+  describe("getDefault", () => {
+    test("returns three public resolvers and nameserver consistency on", () => {
+      const def: MonitorStepDnssecMonitor =
+        MonitorStepDnssecMonitorUtil.getDefault();
+
+      expect(def.domainName).toBe("");
+      expect(def.resolvers).toEqual(["1.1.1.1", "8.8.8.8", "9.9.9.9"]);
+      expect(def.checkNameserverConsistency).toBe(true);
+      expect(def.signatureExpiryWarningDays).toBe(7);
+      expect(def.timeout).toBe(10000);
+      expect(def.retries).toBe(3);
+    });
+  });
+
+  describe("fromJSON resolvers handling", () => {
+    test("keeps only non-empty string resolvers", () => {
+      const parsed: MonitorStepDnssecMonitor =
+        MonitorStepDnssecMonitorUtil.fromJSON({
+          domainName: "oneuptime.com",
+          resolvers: ["1.1.1.1", "", "8.8.4.4", 123, null],
+        });
+
+      expect(parsed.resolvers).toEqual(["1.1.1.1", "8.8.4.4"]);
+    });
+
+    test("restores default resolvers when the provided list filters down to empty", () => {
+      const parsed: MonitorStepDnssecMonitor =
+        MonitorStepDnssecMonitorUtil.fromJSON({
+          domainName: "oneuptime.com",
+          resolvers: ["", 5, null],
+        });
+
+      expect(parsed.resolvers).toEqual(["1.1.1.1", "8.8.8.8", "9.9.9.9"]);
+    });
+
+    test("restores default resolvers when resolvers is not an array", () => {
+      const parsed: MonitorStepDnssecMonitor =
+        MonitorStepDnssecMonitorUtil.fromJSON({
+          domainName: "oneuptime.com",
+          resolvers: "1.1.1.1" as unknown as Array<string>,
+        });
+
+      expect(parsed.resolvers).toEqual(["1.1.1.1", "8.8.8.8", "9.9.9.9"]);
+    });
+  });
+
+  describe("fromJSON checkNameserverConsistency handling", () => {
+    test("honors an explicit false", () => {
+      const parsed: MonitorStepDnssecMonitor =
+        MonitorStepDnssecMonitorUtil.fromJSON({
+          domainName: "oneuptime.com",
+          checkNameserverConsistency: false,
+        });
+
+      expect(parsed.checkNameserverConsistency).toBe(false);
+    });
+
+    test("defaults to true when the field is absent or non-boolean", () => {
+      expect(
+        MonitorStepDnssecMonitorUtil.fromJSON({ domainName: "oneuptime.com" })
+          .checkNameserverConsistency,
+      ).toBe(true);
+
+      expect(
+        MonitorStepDnssecMonitorUtil.fromJSON({
+          domainName: "oneuptime.com",
+          checkNameserverConsistency: "yes" as unknown as boolean,
+        }).checkNameserverConsistency,
+      ).toBe(true);
+    });
+  });
+
+  describe("fromJSON numeric defaults", () => {
+    test("falls back for falsy numeric fields", () => {
+      const parsed: MonitorStepDnssecMonitor =
+        MonitorStepDnssecMonitorUtil.fromJSON({
+          domainName: "oneuptime.com",
+          signatureExpiryWarningDays: 0,
+          timeout: 0,
+          retries: 0,
+        });
+
+      expect(parsed.signatureExpiryWarningDays).toBe(7);
+      expect(parsed.timeout).toBe(10000);
+      expect(parsed.retries).toBe(3);
+    });
+  });
+
+  describe("round-trip", () => {
+    test("fromJSON(toJSON(x)) preserves a populated monitor", () => {
+      const monitor: MonitorStepDnssecMonitor = {
+        domainName: "example.com",
+        resolvers: ["8.8.8.8"],
+        checkNameserverConsistency: false,
+        signatureExpiryWarningDays: 14,
+        timeout: 20000,
+        retries: 5,
+      };
+
+      const roundTripped: MonitorStepDnssecMonitor =
+        MonitorStepDnssecMonitorUtil.fromJSON(
+          MonitorStepDnssecMonitorUtil.toJSON(monitor),
+        );
+
+      expect(roundTripped).toEqual(monitor);
+    });
+
+    test("toJSON emits every field", () => {
+      const json: JSONObject = MonitorStepDnssecMonitorUtil.toJSON(
+        MonitorStepDnssecMonitorUtil.getDefault(),
+      );
+
+      expect(Object.keys(json).sort()).toEqual(
+        [
+          "checkNameserverConsistency",
+          "domainName",
+          "resolvers",
+          "retries",
+          "signatureExpiryWarningDays",
+          "timeout",
+        ].sort(),
+      );
+    });
+  });
+});

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

@@ -0,0 +1,60 @@
+import { JSONObject } from "../../../Types/JSON";
+import MonitorStepDomainMonitor, {
+  MonitorStepDomainMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepDomainMonitor";
+
+describe("MonitorStepDomainMonitorUtil", () => {
+  describe("getDefault", () => {
+    test("returns an empty domain with 10s timeout and 3 retries", () => {
+      const def: MonitorStepDomainMonitor =
+        MonitorStepDomainMonitorUtil.getDefault();
+
+      expect(def.domainName).toBe("");
+      expect(def.timeout).toBe(10000);
+      expect(def.retries).toBe(3);
+    });
+  });
+
+  describe("fromJSON", () => {
+    test("reads through explicit values", () => {
+      const parsed: MonitorStepDomainMonitor =
+        MonitorStepDomainMonitorUtil.fromJSON({
+          domainName: "oneuptime.com",
+          timeout: 3000,
+          retries: 7,
+        });
+
+      expect(parsed.domainName).toBe("oneuptime.com");
+      expect(parsed.timeout).toBe(3000);
+      expect(parsed.retries).toBe(7);
+    });
+
+    test("falls back to defaults for missing or falsy fields", () => {
+      const parsed: MonitorStepDomainMonitor =
+        MonitorStepDomainMonitorUtil.fromJSON({
+          domainName: "",
+          timeout: 0,
+          retries: 0,
+        });
+
+      expect(parsed.domainName).toBe("");
+      expect(parsed.timeout).toBe(10000);
+      expect(parsed.retries).toBe(3);
+    });
+  });
+
+  describe("round-trip", () => {
+    test("toJSON emits every field and fromJSON restores it", () => {
+      const monitor: MonitorStepDomainMonitor = {
+        domainName: "example.com",
+        timeout: 5000,
+        retries: 2,
+      };
+
+      const json: JSONObject = MonitorStepDomainMonitorUtil.toJSON(monitor);
+      expect(json).toEqual(monitor);
+
+      expect(MonitorStepDomainMonitorUtil.fromJSON(json)).toEqual(monitor);
+    });
+  });
+});

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

@@ -0,0 +1,82 @@
+import { JSONObject } from "../../../Types/JSON";
+import ExternalStatusPageProviderType from "../../../Types/Monitor/ExternalStatusPageProviderType";
+import MonitorStepExternalStatusPageMonitor, {
+  MonitorStepExternalStatusPageMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepExternalStatusPageMonitor";
+
+describe("MonitorStepExternalStatusPageMonitorUtil", () => {
+  describe("getDefault", () => {
+    test("returns an auto-detected provider with no component filters", () => {
+      const def: MonitorStepExternalStatusPageMonitor =
+        MonitorStepExternalStatusPageMonitorUtil.getDefault();
+
+      expect(def.statusPageUrl).toBe("");
+      expect(def.provider).toBe(ExternalStatusPageProviderType.Auto);
+      expect(def.componentGroupName).toBeUndefined();
+      expect(def.componentName).toBeUndefined();
+      expect(def.timeout).toBe(10000);
+      expect(def.retries).toBe(3);
+    });
+  });
+
+  describe("fromJSON", () => {
+    test("reads through explicit values", () => {
+      const parsed: MonitorStepExternalStatusPageMonitor =
+        MonitorStepExternalStatusPageMonitorUtil.fromJSON({
+          statusPageUrl: "https://status.example.com",
+          provider: ExternalStatusPageProviderType.AtlassianStatuspage,
+          componentGroupName: "APIs",
+          componentName: "Ingest",
+          timeout: 4000,
+          retries: 1,
+        });
+
+      expect(parsed.statusPageUrl).toBe("https://status.example.com");
+      expect(parsed.provider).toBe(
+        ExternalStatusPageProviderType.AtlassianStatuspage,
+      );
+      expect(parsed.componentGroupName).toBe("APIs");
+      expect(parsed.componentName).toBe("Ingest");
+      expect(parsed.timeout).toBe(4000);
+      expect(parsed.retries).toBe(1);
+    });
+
+    test("falls back to defaults for missing or falsy fields", () => {
+      const parsed: MonitorStepExternalStatusPageMonitor =
+        MonitorStepExternalStatusPageMonitorUtil.fromJSON({
+          statusPageUrl: "",
+          componentGroupName: "",
+          componentName: "",
+          timeout: 0,
+          retries: 0,
+        });
+
+      expect(parsed.statusPageUrl).toBe("");
+      expect(parsed.provider).toBe(ExternalStatusPageProviderType.Auto);
+      expect(parsed.componentGroupName).toBeUndefined();
+      expect(parsed.componentName).toBeUndefined();
+      expect(parsed.timeout).toBe(10000);
+      expect(parsed.retries).toBe(3);
+    });
+  });
+
+  describe("round-trip", () => {
+    test("fromJSON(toJSON(x)) preserves a populated monitor", () => {
+      const monitor: MonitorStepExternalStatusPageMonitor = {
+        statusPageUrl: "https://status.incident.io/x",
+        provider: ExternalStatusPageProviderType.IncidentIo,
+        componentGroupName: "Core",
+        componentName: "Dashboard",
+        timeout: 15000,
+        retries: 5,
+      };
+
+      const json: JSONObject =
+        MonitorStepExternalStatusPageMonitorUtil.toJSON(monitor);
+      const roundTripped: MonitorStepExternalStatusPageMonitor =
+        MonitorStepExternalStatusPageMonitorUtil.fromJSON(json);
+
+      expect(roundTripped).toEqual(monitor);
+    });
+  });
+});

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

@@ -0,0 +1,268 @@
+import { JSONObject } from "../../../Types/JSON";
+import MonitorStepCephMonitor, {
+  CephResourceScope,
+  MonitorStepCephMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepCephMonitor";
+import MonitorStepDockerMonitor, {
+  MonitorStepDockerMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepDockerMonitor";
+import MonitorStepDockerSwarmMonitor, {
+  MonitorStepDockerSwarmMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepDockerSwarmMonitor";
+import MonitorStepHostMonitor, {
+  MonitorStepHostMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepHostMonitor";
+import MonitorStepIoTMonitor, {
+  IoTResourceScope,
+  MonitorStepIoTMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepIoTMonitor";
+import MonitorStepKubernetesMonitor, {
+  KubernetesResourceScope,
+  MonitorStepKubernetesMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepKubernetesMonitor";
+import MonitorStepMetricMonitor, {
+  MonitorStepMetricMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepMetricMonitor";
+import MonitorStepPodmanMonitor, {
+  MonitorStepPodmanMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepPodmanMonitor";
+import MonitorStepProxmoxMonitor, {
+  MonitorStepProxmoxMonitorUtil,
+  ProxmoxResourceScope,
+} from "../../../Types/Monitor/MonitorStepProxmoxMonitor";
+import RollingTime from "../../../Types/RollingTime/RollingTime";
+
+/*
+ * The infrastructure MonitorStep utils share one shape: getDefault() returns
+ * an empty-scope config on a Past1Minute rolling window with an empty metric
+ * view config, and fromJSON/toJSON are structural pass-throughs. This suite
+ * locks in that contract for each of them so a future refactor cannot quietly
+ * change a default or drop a field on the wire.
+ */
+
+describe("Infrastructure MonitorStep utils", () => {
+  describe("MonitorStepMetricMonitorUtil", () => {
+    test("getDefault has an empty metric view config on a 1-minute window", () => {
+      const def: MonitorStepMetricMonitor =
+        MonitorStepMetricMonitorUtil.getDefault();
+
+      expect(def.metricViewConfig).toEqual({
+        queryConfigs: [],
+        formulaConfigs: [],
+      });
+      expect(def.rollingTime).toBe(RollingTime.Past1Minute);
+    });
+
+    test("fromJSON/toJSON are pass-through and round-trip", () => {
+      const monitor: MonitorStepMetricMonitor = {
+        metricViewConfig: { queryConfigs: [], formulaConfigs: [] },
+        rollingTime: RollingTime.Past1Minute,
+      };
+      const json: JSONObject = MonitorStepMetricMonitorUtil.toJSON(monitor);
+      expect(MonitorStepMetricMonitorUtil.fromJSON(json)).toEqual(monitor);
+    });
+  });
+
+  describe("MonitorStepHostMonitorUtil", () => {
+    test("getDefault has an empty host identifier", () => {
+      const def: MonitorStepHostMonitor =
+        MonitorStepHostMonitorUtil.getDefault();
+
+      expect(def.hostIdentifier).toBe("");
+      expect(def.rollingTime).toBe(RollingTime.Past1Minute);
+    });
+
+    test("round-trips through JSON", () => {
+      const monitor: MonitorStepHostMonitor = {
+        hostIdentifier: "web-1",
+        metricViewConfig: { queryConfigs: [], formulaConfigs: [] },
+        rollingTime: RollingTime.Past1Minute,
+      };
+      expect(
+        MonitorStepHostMonitorUtil.fromJSON(
+          MonitorStepHostMonitorUtil.toJSON(monitor),
+        ),
+      ).toEqual(monitor);
+    });
+  });
+
+  describe("MonitorStepDockerMonitorUtil", () => {
+    test("getDefault has empty container filters", () => {
+      const def: MonitorStepDockerMonitor =
+        MonitorStepDockerMonitorUtil.getDefault();
+
+      expect(def.hostIdentifier).toBe("");
+      expect(def.containerFilters).toEqual({});
+      expect(def.rollingTime).toBe(RollingTime.Past1Minute);
+    });
+
+    test("round-trips container filters", () => {
+      const monitor: MonitorStepDockerMonitor = {
+        hostIdentifier: "docker-host",
+        containerFilters: { containerName: "api", containerImage: "nginx" },
+        metricViewConfig: { queryConfigs: [], formulaConfigs: [] },
+        rollingTime: RollingTime.Past1Minute,
+      };
+      expect(
+        MonitorStepDockerMonitorUtil.fromJSON(
+          MonitorStepDockerMonitorUtil.toJSON(monitor),
+        ),
+      ).toEqual(monitor);
+    });
+  });
+
+  describe("MonitorStepPodmanMonitorUtil", () => {
+    test("getDefault has empty container filters", () => {
+      const def: MonitorStepPodmanMonitor =
+        MonitorStepPodmanMonitorUtil.getDefault();
+
+      expect(def.hostIdentifier).toBe("");
+      expect(def.containerFilters).toEqual({});
+      expect(def.rollingTime).toBe(RollingTime.Past1Minute);
+    });
+
+    test("round-trips container filters", () => {
+      const monitor: MonitorStepPodmanMonitor = {
+        hostIdentifier: "podman-host",
+        containerFilters: { hostName: "node-1" },
+        metricViewConfig: { queryConfigs: [], formulaConfigs: [] },
+        rollingTime: RollingTime.Past1Minute,
+      };
+      expect(
+        MonitorStepPodmanMonitorUtil.fromJSON(
+          MonitorStepPodmanMonitorUtil.toJSON(monitor),
+        ),
+      ).toEqual(monitor);
+    });
+  });
+
+  describe("MonitorStepKubernetesMonitorUtil", () => {
+    test("getDefault scopes to the whole cluster", () => {
+      const def: MonitorStepKubernetesMonitor =
+        MonitorStepKubernetesMonitorUtil.getDefault();
+
+      expect(def.clusterIdentifier).toBe("");
+      expect(def.resourceScope).toBe(KubernetesResourceScope.Cluster);
+      expect(def.resourceFilters).toEqual({});
+    });
+
+    test("round-trips a namespace-scoped monitor", () => {
+      const monitor: MonitorStepKubernetesMonitor = {
+        clusterIdentifier: "prod",
+        resourceScope: KubernetesResourceScope.Namespace,
+        resourceFilters: { namespace: "payments" },
+        metricViewConfig: { queryConfigs: [], formulaConfigs: [] },
+        rollingTime: RollingTime.Past1Minute,
+      };
+      expect(
+        MonitorStepKubernetesMonitorUtil.fromJSON(
+          MonitorStepKubernetesMonitorUtil.toJSON(monitor),
+        ),
+      ).toEqual(monitor);
+    });
+  });
+
+  describe("MonitorStepCephMonitorUtil", () => {
+    test("getDefault has no OSD/pool filters", () => {
+      const def: MonitorStepCephMonitor =
+        MonitorStepCephMonitorUtil.getDefault();
+
+      expect(def.clusterIdentifier).toBe("");
+      expect(def.resourceFilters).toEqual({});
+    });
+
+    test("round-trips an OSD-scoped monitor", () => {
+      const monitor: MonitorStepCephMonitor = {
+        clusterIdentifier: "ceph-1",
+        resourceFilters: { osdId: "osd.3", poolId: "2" },
+        metricViewConfig: { queryConfigs: [], formulaConfigs: [] },
+        rollingTime: RollingTime.Past1Minute,
+      };
+      expect(
+        MonitorStepCephMonitorUtil.fromJSON(
+          MonitorStepCephMonitorUtil.toJSON(monitor),
+        ),
+      ).toEqual(monitor);
+      // Scope enum sanity.
+      expect(CephResourceScope.Osd).toBe("OSD");
+    });
+  });
+
+  describe("MonitorStepProxmoxMonitorUtil", () => {
+    test("getDefault has no resource filters", () => {
+      const def: MonitorStepProxmoxMonitor =
+        MonitorStepProxmoxMonitorUtil.getDefault();
+
+      expect(def.clusterIdentifier).toBe("");
+      expect(def.resourceFilters).toEqual({});
+    });
+
+    test("round-trips a guest-scoped monitor", () => {
+      const monitor: MonitorStepProxmoxMonitor = {
+        clusterIdentifier: "pve-cluster",
+        resourceFilters: {
+          scope: ProxmoxResourceScope.Guest,
+          guestId: "qemu/100",
+        },
+        metricViewConfig: { queryConfigs: [], formulaConfigs: [] },
+        rollingTime: RollingTime.Past1Minute,
+      };
+      expect(
+        MonitorStepProxmoxMonitorUtil.fromJSON(
+          MonitorStepProxmoxMonitorUtil.toJSON(monitor),
+        ),
+      ).toEqual(monitor);
+    });
+  });
+
+  describe("MonitorStepDockerSwarmMonitorUtil", () => {
+    test("getDefault has no resource filters", () => {
+      const def: MonitorStepDockerSwarmMonitor =
+        MonitorStepDockerSwarmMonitorUtil.getDefault();
+
+      expect(def.clusterIdentifier).toBe("");
+      expect(def.resourceFilters).toEqual({});
+    });
+
+    test("round-trips a service-scoped monitor", () => {
+      const monitor: MonitorStepDockerSwarmMonitor = {
+        clusterIdentifier: "swarm-1",
+        resourceFilters: { serviceName: "web", nodeName: "node-2" },
+        metricViewConfig: { queryConfigs: [], formulaConfigs: [] },
+        rollingTime: RollingTime.Past1Minute,
+      };
+      expect(
+        MonitorStepDockerSwarmMonitorUtil.fromJSON(
+          MonitorStepDockerSwarmMonitorUtil.toJSON(monitor),
+        ),
+      ).toEqual(monitor);
+    });
+  });
+
+  describe("MonitorStepIoTMonitorUtil", () => {
+    test("getDefault scopes to the whole fleet", () => {
+      const def: MonitorStepIoTMonitor = MonitorStepIoTMonitorUtil.getDefault();
+
+      expect(def.fleetIdentifier).toBe("");
+      expect(def.resourceFilters).toEqual({});
+    });
+
+    test("round-trips a device-scoped monitor", () => {
+      const monitor: MonitorStepIoTMonitor = {
+        fleetIdentifier: "fleet-1",
+        resourceFilters: {
+          scope: IoTResourceScope.Device,
+          deviceId: "sensor-42",
+          deviceType: "temperature",
+        },
+        metricViewConfig: { queryConfigs: [], formulaConfigs: [] },
+        rollingTime: RollingTime.Past1Minute,
+      };
+      expect(
+        MonitorStepIoTMonitorUtil.fromJSON(
+          MonitorStepIoTMonitorUtil.toJSON(monitor),
+        ),
+      ).toEqual(monitor);
+    });
+  });
+});