@oneuptime/common 12.0.3 → 12.0.5

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

@@ -0,0 +1,249 @@
+import {
+  HostAlertTemplate,
+  HostAlertTemplateArgs,
+  HostAlertTemplateCategory,
+  getAllHostAlertTemplates,
+  getHostAlertTemplateById,
+  getHostAlertTemplatesByCategory,
+} from "../../../Types/Monitor/HostAlertTemplates";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorStepHostMonitor from "../../../Types/Monitor/MonitorStepHostMonitor";
+import MetricsAggregationType from "../../../Types/Metrics/MetricsAggregationType";
+import { FilterType } from "../../../Types/Monitor/CriteriaFilter";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * Host resource templates. The regression-prone details these tests pin:
+ *
+ *   1. The OTel metric name each template reads (system.cpu.utilization,
+ *      system.memory.utilization, ...). A rename in the host receiver would
+ *      make the template match nothing while staying "registered".
+ *
+ *   2. Ratio metrics are on a [0, 1] scale, so a "90%" threshold is the
+ *      literal 0.9 — NOT 90. A slip to 90 makes the utilization templates
+ *      unreachable (utilization never exceeds 1). Load average and process
+ *      count are raw counts, so their thresholds (4, 2000) are literal.
+ *
+ *   3. Aggregation: filesystem usage and process count use `Max` so a single
+ *      full mount / one runaway host trips the alert instead of being averaged
+ *      away; the rest use `Avg` for a representative sustained reading.
+ *
+ *   4. The unhealthy/healthy criteria partition the range at the threshold
+ *      with `>` / `<=` — no gap, no overlap.
+ */
+
+interface HostTemplateCase {
+  id: string;
+  category: HostAlertTemplateCategory;
+  severity: "Critical" | "Warning";
+  metricName: string;
+  metricAlias: string;
+  aggregation: MetricsAggregationType;
+  threshold: number;
+}
+
+const HOST_TEMPLATES: Array<HostTemplateCase> = [
+  {
+    id: "host-high-cpu",
+    category: "Resource",
+    severity: "Warning",
+    metricName: "system.cpu.utilization",
+    metricAlias: "host_cpu",
+    aggregation: MetricsAggregationType.Avg,
+    threshold: 0.8,
+  },
+  {
+    id: "host-high-memory",
+    category: "Resource",
+    severity: "Warning",
+    metricName: "system.memory.utilization",
+    metricAlias: "host_memory",
+    aggregation: MetricsAggregationType.Avg,
+    threshold: 0.85,
+  },
+  {
+    id: "host-high-filesystem",
+    category: "Resource",
+    severity: "Critical",
+    metricName: "system.filesystem.utilization",
+    metricAlias: "host_filesystem",
+    // Max so a single full filesystem is not diluted by averaging mounts.
+    aggregation: MetricsAggregationType.Max,
+    threshold: 0.9,
+  },
+  {
+    id: "host-high-load-average",
+    category: "Resource",
+    severity: "Warning",
+    metricName: "system.cpu.load_average.1m",
+    metricAlias: "host_load_1m",
+    aggregation: MetricsAggregationType.Avg,
+    // Load average is a raw count, not a ratio — threshold is literal 4.
+    threshold: 4,
+  },
+  {
+    id: "host-high-processes",
+    category: "Host",
+    severity: "Warning",
+    metricName: "system.processes.count",
+    metricAlias: "host_processes",
+    aggregation: MetricsAggregationType.Max,
+    threshold: 2000,
+  },
+];
+
+function buildArgs(): HostAlertTemplateArgs {
+  return {
+    hostIdentifier: "host-01",
+    onlineMonitorStatusId: ObjectID.generate(),
+    offlineMonitorStatusId: ObjectID.generate(),
+    defaultIncidentSeverityId: ObjectID.generate(),
+    defaultAlertSeverityId: ObjectID.generate(),
+    monitorName: "Test Host Monitor",
+  };
+}
+
+function getHostMonitor(step: MonitorStep): MonitorStepHostMonitor {
+  const hostMonitor: MonitorStepHostMonitor | undefined =
+    step.data?.hostMonitor;
+  if (!hostMonitor) {
+    throw new Error("hostMonitor missing from monitor step");
+  }
+  return hostMonitor;
+}
+
+describe("HostAlertTemplates", () => {
+  test("every documented template id is registered and the suite is exhaustive", () => {
+    const ids: Array<string> = getAllHostAlertTemplates().map(
+      (t: HostAlertTemplate) => {
+        return t.id;
+      },
+    );
+    for (const tc of HOST_TEMPLATES) {
+      expect(ids).toContain(tc.id);
+    }
+    expect(ids.sort()).toEqual(
+      HOST_TEMPLATES.map((t: HostTemplateCase) => {
+        return t.id;
+      }).sort(),
+    );
+  });
+
+  test("every template id is unique", () => {
+    const ids: Array<string> = getAllHostAlertTemplates().map(
+      (t: HostAlertTemplate) => {
+        return t.id;
+      },
+    );
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  test("getHostAlertTemplateById returns undefined for an unknown id", () => {
+    expect(getHostAlertTemplateById("host-nothing")).toBeUndefined();
+  });
+
+  test("getHostAlertTemplatesByCategory returns only that category and covers the catalog", () => {
+    const all: Array<HostAlertTemplate> = getAllHostAlertTemplates();
+    const categories: Array<HostAlertTemplateCategory> = ["Resource", "Host"];
+
+    let total: number = 0;
+    for (const category of categories) {
+      const inCategory: Array<HostAlertTemplate> =
+        getHostAlertTemplatesByCategory(category);
+      for (const template of inCategory) {
+        expect(template.category).toBe(category);
+      }
+      total += inCategory.length;
+    }
+    expect(total).toBe(all.length);
+  });
+
+  test.each(HOST_TEMPLATES)(
+    "$id is a $severity $category template with populated copy",
+    (tc: HostTemplateCase) => {
+      const template: HostAlertTemplate | undefined = getHostAlertTemplateById(
+        tc.id,
+      );
+      expect(template).toBeDefined();
+      expect(template!.category).toBe(tc.category);
+      expect(template!.severity).toBe(tc.severity);
+      expect(template!.name.length).toBeGreaterThan(0);
+      expect(template!.description.length).toBeGreaterThan(0);
+    },
+  );
+
+  test.each(HOST_TEMPLATES)(
+    "$id queries $metricName with the intended aggregation",
+    (tc: HostTemplateCase) => {
+      const template: HostAlertTemplate = getHostAlertTemplateById(tc.id)!;
+      const step: MonitorStep = template.getMonitorStep(buildArgs());
+      const monitor: MonitorStepHostMonitor = getHostMonitor(step);
+
+      expect(monitor.hostIdentifier).toBe("host-01");
+
+      const queryConfigs: Array<any> = monitor.metricViewConfig
+        .queryConfigs as Array<any>;
+      expect(queryConfigs).toHaveLength(1);
+      expect(monitor.metricViewConfig.formulaConfigs).toHaveLength(0);
+
+      const filterData: any = queryConfigs[0].metricQueryData.filterData;
+      expect(filterData.metricName).toBe(tc.metricName);
+      expect(filterData.aggegationType).toBe(tc.aggregation);
+    },
+  );
+
+  test.each(HOST_TEMPLATES)(
+    "$id unhealthy/healthy criteria partition the range at $threshold with > / <=",
+    (tc: HostTemplateCase) => {
+      const template: HostAlertTemplate = getHostAlertTemplateById(tc.id)!;
+      const step: MonitorStep = template.getMonitorStep(buildArgs());
+
+      const instances: Array<any> = step.data?.monitorCriteria.data
+        ?.monitorCriteriaInstanceArray as Array<any>;
+      expect(instances).toHaveLength(2);
+      const [offline, online] = instances;
+
+      const offlineFilter: any = offline.data.filters[0];
+      const onlineFilter: any = online.data.filters[0];
+
+      expect(offlineFilter.metricMonitorOptions.metricAlias).toBe(
+        tc.metricAlias,
+      );
+      expect(onlineFilter.metricMonitorOptions.metricAlias).toBe(
+        tc.metricAlias,
+      );
+      expect(offlineFilter.value).toBe(tc.threshold);
+      expect(onlineFilter.value).toBe(tc.threshold);
+
+      // Host ceilings are all "> threshold" unhealthy / "<= threshold" healthy.
+      expect(offlineFilter.filterType).toBe(FilterType.GreaterThan);
+      expect(onlineFilter.filterType).toBe(FilterType.LessThanOrEqualTo);
+
+      expect(offline.data.createIncidents).toBe(true);
+      expect(offline.data.createAlerts).toBe(true);
+      expect(online.data.createIncidents).toBe(false);
+      expect(online.data.createAlerts).toBe(false);
+    },
+  );
+
+  test("ratio-metric thresholds stay on the 0-1 scale, not 0-100", () => {
+    /*
+     * A "90%" threshold written as 90 would make a utilization ([0,1])
+     * template unreachable. Lock the utilization templates below 1.
+     */
+    const ratioIds: Array<string> = [
+      "host-high-cpu",
+      "host-high-memory",
+      "host-high-filesystem",
+    ];
+    for (const id of ratioIds) {
+      const tc: HostTemplateCase = HOST_TEMPLATES.find(
+        (t: HostTemplateCase) => {
+          return t.id === id;
+        },
+      )!;
+      expect(tc.threshold).toBeGreaterThan(0);
+      expect(tc.threshold).toBeLessThanOrEqual(1);
+    }
+  });
+});

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

@@ -0,0 +1,104 @@
+import {
+  HostMetricCategory,
+  HostMetricDefinition,
+  getAllHostMetricCategories,
+  getAllHostMetrics,
+  getHostMetricById,
+  getHostMetricByMetricName,
+  getHostMetricsByCategory,
+} from "../../../Types/Monitor/HostMetricCatalog";
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import { describe, expect, test } from "@jest/globals";
+
+describe("HostMetricCatalog", () => {
+  const allMetrics: Array<HostMetricDefinition> = getAllHostMetrics();
+  const allCategories: Array<HostMetricCategory> = getAllHostMetricCategories();
+  const validAggregations: Array<string> = Object.values(AggregationType);
+
+  test("returns a non-empty catalog", () => {
+    expect(Array.isArray(allMetrics)).toBe(true);
+    expect(allMetrics.length).toBeGreaterThan(0);
+  });
+
+  test("every metric definition has all required non-empty fields", () => {
+    for (const metric of allMetrics) {
+      expect(typeof metric.id).toBe("string");
+      expect(metric.id.length).toBeGreaterThan(0);
+      expect(metric.friendlyName.length).toBeGreaterThan(0);
+      expect(metric.description.length).toBeGreaterThan(0);
+      expect(metric.metricName.length).toBeGreaterThan(0);
+      expect(metric.category.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("every metric uses a valid aggregation type", () => {
+    for (const metric of allMetrics) {
+      expect(validAggregations).toContain(metric.defaultAggregation);
+    }
+  });
+
+  test("metric ids are unique", () => {
+    const ids: Array<string> = allMetrics.map((m: HostMetricDefinition) => {
+      return m.id;
+    });
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  test("metric names are unique", () => {
+    const names: Array<string> = allMetrics.map((m: HostMetricDefinition) => {
+      return m.metricName;
+    });
+    expect(new Set(names).size).toBe(names.length);
+  });
+
+  test("every metric category is a declared category", () => {
+    for (const metric of allMetrics) {
+      expect(allCategories).toContain(metric.category);
+    }
+  });
+
+  test("declared categories are unique and non-empty", () => {
+    expect(allCategories.length).toBeGreaterThan(0);
+    expect(new Set(allCategories).size).toBe(allCategories.length);
+  });
+
+  test("every declared category has at least one metric", () => {
+    for (const category of allCategories) {
+      expect(getHostMetricsByCategory(category).length).toBeGreaterThan(0);
+    }
+  });
+
+  test("getHostMetricsByCategory returns only metrics of that category", () => {
+    for (const category of allCategories) {
+      for (const metric of getHostMetricsByCategory(category)) {
+        expect(metric.category).toBe(category);
+      }
+    }
+  });
+
+  test("getHostMetricById round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getHostMetricById(metric.id)).toEqual(metric);
+    }
+  });
+
+  test("getHostMetricById returns undefined for an unknown id", () => {
+    expect(getHostMetricById("does-not-exist")).toBeUndefined();
+    expect(getHostMetricById("")).toBeUndefined();
+  });
+
+  test("getHostMetricByMetricName round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getHostMetricByMetricName(metric.metricName)).toEqual(metric);
+    }
+  });
+
+  test("getHostMetricByMetricName returns undefined for an unknown name", () => {
+    expect(getHostMetricByMetricName("nope.nope")).toBeUndefined();
+  });
+
+  test("known host metrics are present", () => {
+    expect(getHostMetricByMetricName("system.cpu.utilization")).toBeDefined();
+    expect(getHostMetricByMetricName("system.memory.usage")).toBeDefined();
+  });
+});

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

@@ -0,0 +1,320 @@
+import {
+  IoTAlertTemplate,
+  IoTAlertTemplateArgs,
+  IoTAlertTemplateCategory,
+  getAllIoTAlertTemplates,
+  getIoTAlertTemplateById,
+  getIoTAlertTemplatesByCategory,
+} from "../../../Types/Monitor/IotAlertTemplates";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorStepIoTMonitor from "../../../Types/Monitor/MonitorStepIoTMonitor";
+import MetricsAggregationType from "../../../Types/Metrics/MetricsAggregationType";
+import {
+  FilterType,
+  NoDataPolicy,
+} from "../../../Types/Monitor/CriteriaFilter";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * The IoT templates carry two decisions the container templates don't, and
+ * both are the point of this suite:
+ *
+ *   1. INVERTED thresholds. "Bad" for a device is a value that is too LOW —
+ *      no heartbeat (iot_device_up < 1), a draining battery (< 20%), a fading
+ *      radio (< -100 dBm). So the unhealthy criterion is `<` and the healthy
+ *      one is `>=`, the opposite direction from a CPU/memory ceiling. A
+ *      copy-paste of a `>`/`<=` pair from the ceiling templates would make the
+ *      monitor alert exactly when the device is fine. Temperature and CPU are
+ *      genuine ceilings and keep the `>`/`<=` direction — the mix is what makes
+ *      pinning each direction per template worthwhile.
+ *
+ *   2. Per-device grouping. Every template groups by the `device.id` datapoint
+ *      label (NOT `resource.`-prefixed — it is a datapoint attribute, not a
+ *      resource attribute) so one incident fires per device rather than one
+ *      collapsed series for the whole fleet.
+ *
+ *   3. The Device Offline template — and ONLY it — opts into TreatAsZero so a
+ *      registered device that goes completely silent (an empty series) folds
+ *      to 0 and trips `Min(iot_device_up) < 1`. Enabling that on a battery or
+ *      temperature threshold would false-alarm for any silent device, so the
+ *      other templates must NOT carry it.
+ */
+
+interface IoTTemplateCase {
+  id: string;
+  category: IoTAlertTemplateCategory;
+  severity: "Critical" | "Warning";
+  metricName: string;
+  metricAlias: string;
+  aggregation: MetricsAggregationType;
+  offlineFilterType: FilterType;
+  onlineFilterType: FilterType;
+  threshold: number;
+  treatNoDataAsZero: boolean;
+}
+
+const IOT_TEMPLATES: Array<IoTTemplateCase> = [
+  {
+    id: "iot-device-offline",
+    category: "Availability",
+    severity: "Critical",
+    metricName: "iot_device_up",
+    metricAlias: "device_up",
+    // Min: a single down push in the window must win over healthy pushes.
+    aggregation: MetricsAggregationType.Min,
+    offlineFilterType: FilterType.LessThan,
+    onlineFilterType: FilterType.GreaterThanOrEqualTo,
+    threshold: 1,
+    treatNoDataAsZero: true,
+  },
+  {
+    id: "iot-low-battery",
+    category: "Power",
+    severity: "Warning",
+    metricName: "iot_battery_percent",
+    metricAlias: "battery_percent",
+    aggregation: MetricsAggregationType.Avg,
+    offlineFilterType: FilterType.LessThan,
+    onlineFilterType: FilterType.GreaterThanOrEqualTo,
+    threshold: 20,
+    treatNoDataAsZero: false,
+  },
+  {
+    id: "iot-weak-signal",
+    category: "Connectivity",
+    severity: "Warning",
+    metricName: "iot_signal_strength_dbm",
+    metricAlias: "signal_strength",
+    aggregation: MetricsAggregationType.Avg,
+    offlineFilterType: FilterType.LessThan,
+    onlineFilterType: FilterType.GreaterThanOrEqualTo,
+    // dBm is negative; -100 is a real threshold, not a placeholder.
+    threshold: -100,
+    treatNoDataAsZero: false,
+  },
+  {
+    id: "iot-high-temperature",
+    category: "Environment",
+    severity: "Critical",
+    metricName: "iot_temperature_celsius",
+    metricAlias: "temperature_celsius",
+    // Max: a single hot reading must win over cooler ones in the minute.
+    aggregation: MetricsAggregationType.Max,
+    offlineFilterType: FilterType.GreaterThan,
+    onlineFilterType: FilterType.LessThanOrEqualTo,
+    threshold: 70,
+    treatNoDataAsZero: false,
+  },
+  {
+    id: "iot-high-cpu",
+    category: "System",
+    severity: "Warning",
+    metricName: "iot_cpu_usage_ratio",
+    metricAlias: "cpu_usage",
+    aggregation: MetricsAggregationType.Avg,
+    offlineFilterType: FilterType.GreaterThan,
+    onlineFilterType: FilterType.LessThanOrEqualTo,
+    // iot_cpu_usage_ratio is a 0-1 ratio, so 0.9 == 90%.
+    threshold: 0.9,
+    treatNoDataAsZero: false,
+  },
+];
+
+function buildArgs(): IoTAlertTemplateArgs {
+  return {
+    fleetIdentifier: "field-fleet-a",
+    onlineMonitorStatusId: ObjectID.generate(),
+    offlineMonitorStatusId: ObjectID.generate(),
+    defaultIncidentSeverityId: ObjectID.generate(),
+    defaultAlertSeverityId: ObjectID.generate(),
+    monitorName: "Test IoT Monitor",
+  };
+}
+
+function getIoTMonitor(step: MonitorStep): MonitorStepIoTMonitor {
+  const iotMonitor: MonitorStepIoTMonitor | undefined = step.data?.iotMonitor;
+  if (!iotMonitor) {
+    throw new Error("iotMonitor missing from monitor step");
+  }
+  return iotMonitor;
+}
+
+describe("IotAlertTemplates", () => {
+  test("every documented template id is registered and the suite is exhaustive", () => {
+    const ids: Array<string> = getAllIoTAlertTemplates().map(
+      (t: IoTAlertTemplate) => {
+        return t.id;
+      },
+    );
+    for (const tc of IOT_TEMPLATES) {
+      expect(ids).toContain(tc.id);
+    }
+    expect(ids.sort()).toEqual(
+      IOT_TEMPLATES.map((t: IoTTemplateCase) => {
+        return t.id;
+      }).sort(),
+    );
+  });
+
+  test("every template id is unique", () => {
+    const ids: Array<string> = getAllIoTAlertTemplates().map(
+      (t: IoTAlertTemplate) => {
+        return t.id;
+      },
+    );
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  test("getIoTAlertTemplateById returns undefined for an unknown id", () => {
+    expect(getIoTAlertTemplateById("nope")).toBeUndefined();
+  });
+
+  test("getIoTAlertTemplatesByCategory returns only that category and covers the catalog", () => {
+    const all: Array<IoTAlertTemplate> = getAllIoTAlertTemplates();
+    const categories: Array<IoTAlertTemplateCategory> = [
+      "Availability",
+      "Power",
+      "Connectivity",
+      "Environment",
+      "System",
+    ];
+
+    let total: number = 0;
+    for (const category of categories) {
+      const inCategory: Array<IoTAlertTemplate> =
+        getIoTAlertTemplatesByCategory(category);
+      for (const template of inCategory) {
+        expect(template.category).toBe(category);
+      }
+      total += inCategory.length;
+    }
+    expect(total).toBe(all.length);
+  });
+
+  test.each(IOT_TEMPLATES)(
+    "$id is a $severity $category template with populated copy",
+    (tc: IoTTemplateCase) => {
+      const template: IoTAlertTemplate | undefined = getIoTAlertTemplateById(
+        tc.id,
+      );
+      expect(template).toBeDefined();
+      expect(template!.category).toBe(tc.category);
+      expect(template!.severity).toBe(tc.severity);
+      expect(template!.name.length).toBeGreaterThan(0);
+      expect(template!.description.length).toBeGreaterThan(0);
+    },
+  );
+
+  test.each(IOT_TEMPLATES)(
+    "$id queries $metricName grouped per device with the intended aggregation",
+    (tc: IoTTemplateCase) => {
+      const template: IoTAlertTemplate = getIoTAlertTemplateById(tc.id)!;
+      const step: MonitorStep = template.getMonitorStep(buildArgs());
+      const monitor: MonitorStepIoTMonitor = getIoTMonitor(step);
+
+      expect(monitor.fleetIdentifier).toBe("field-fleet-a");
+
+      const queryConfigs: Array<any> = monitor.metricViewConfig
+        .queryConfigs as Array<any>;
+      expect(queryConfigs).toHaveLength(1);
+      expect(monitor.metricViewConfig.formulaConfigs).toHaveLength(0);
+
+      const queryData: any = queryConfigs[0].metricQueryData;
+      expect(queryData.filterData.metricName).toBe(tc.metricName);
+      expect(queryData.filterData.aggegationType).toBe(tc.aggregation);
+
+      /*
+       * Decision (2): one incident per device — group by the raw datapoint
+       * label, which is NOT resource-prefixed.
+       */
+      expect(queryData.groupByAttributeKeys).toEqual(["device.id"]);
+      expect(queryData.groupByAttributeKeys[0].startsWith("resource.")).toBe(
+        false,
+      );
+    },
+  );
+
+  test.each(IOT_TEMPLATES)(
+    "$id unhealthy/healthy criteria partition the range at $threshold",
+    (tc: IoTTemplateCase) => {
+      const template: IoTAlertTemplate = getIoTAlertTemplateById(tc.id)!;
+      const step: MonitorStep = template.getMonitorStep(buildArgs());
+
+      const instances: Array<any> = step.data?.monitorCriteria.data
+        ?.monitorCriteriaInstanceArray as Array<any>;
+      expect(instances).toHaveLength(2);
+      const [offline, online] = instances;
+
+      const offlineFilter: any = offline.data.filters[0];
+      const onlineFilter: any = online.data.filters[0];
+
+      expect(offlineFilter.metricMonitorOptions.metricAlias).toBe(
+        tc.metricAlias,
+      );
+      expect(onlineFilter.metricMonitorOptions.metricAlias).toBe(
+        tc.metricAlias,
+      );
+      expect(offlineFilter.value).toBe(tc.threshold);
+      expect(onlineFilter.value).toBe(tc.threshold);
+
+      /*
+       * Decision (1): pin the exact comparison direction per template — the
+       * low-value alerts invert relative to the ceiling alerts.
+       */
+      expect(offlineFilter.filterType).toBe(tc.offlineFilterType);
+      expect(onlineFilter.filterType).toBe(tc.onlineFilterType);
+
+      expect(offline.data.createIncidents).toBe(true);
+      expect(offline.data.createAlerts).toBe(true);
+      expect(online.data.createIncidents).toBe(false);
+      expect(online.data.createAlerts).toBe(false);
+    },
+  );
+
+  test.each(IOT_TEMPLATES)(
+    "$id applies TreatAsZero only when it is the Device Offline template",
+    (tc: IoTTemplateCase) => {
+      const template: IoTAlertTemplate = getIoTAlertTemplateById(tc.id)!;
+      const step: MonitorStep = template.getMonitorStep(buildArgs());
+
+      const offline: any = (
+        step.data?.monitorCriteria.data
+          ?.monitorCriteriaInstanceArray as Array<any>
+      )[0];
+      const online: any = (
+        step.data?.monitorCriteria.data
+          ?.monitorCriteriaInstanceArray as Array<any>
+      )[1];
+
+      const offlineNoDataPolicy: NoDataPolicy | undefined =
+        offline.data.filters[0].metricMonitorOptions.onNoDataPolicy;
+
+      if (tc.treatNoDataAsZero) {
+        // Decision (3): a silent registered device must fold to 0 and alert.
+        expect(offlineNoDataPolicy).toBe(NoDataPolicy.TreatAsZero);
+      } else {
+        // Everything else leaves no-data untouched to avoid false alarms.
+        expect(offlineNoDataPolicy).toBeUndefined();
+      }
+
+      // The healthy criterion never overrides the no-data policy.
+      expect(
+        online.data.filters[0].metricMonitorOptions.onNoDataPolicy,
+      ).toBeUndefined();
+    },
+  );
+
+  test("exactly one template opts into TreatAsZero", () => {
+    /*
+     * Guards decision (3) at the catalog level: if a second template ever
+     * enables TreatAsZero, this fails and forces a deliberate review.
+     */
+    const withTreatAsZero: Array<IoTTemplateCase> = IOT_TEMPLATES.filter(
+      (tc: IoTTemplateCase) => {
+        return tc.treatNoDataAsZero;
+      },
+    );
+    expect(withTreatAsZero).toHaveLength(1);
+    expect(withTreatAsZero[0]!.id).toBe("iot-device-offline");
+  });
+});