@oneuptime/common 11.3.20 → 11.3.21

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

@@ -0,0 +1,280 @@
+import IoTDeviceService, {
+  IoTDeviceLatestMetric,
+  ParsedIoTDevice,
+} from "../../../Server/Services/IoTDeviceService";
+import { IOT_MAX_FUTURE_CLOCK_SKEW_MINUTES } from "../../../Server/Utils/Telemetry/IoTSnapshotScan";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * Malformed-device hardening for the IoTDevice inventory write path.
+ * The service builds raw parameterized SQL against the TypeORM manager
+ * — these tests mock the query runner (no Postgres) and lock in:
+ *
+ *   - ShortText values (externalId and friends) truncate to the
+ *     100-char column limit BEFORE the chunk is built, so one bad
+ *     device can never fail the whole 500-row INSERT and drop the
+ *     other 499 with it,
+ *   - identities that collide after truncation dedupe to the newest
+ *     row (two VALUES rows on one conflict target abort the statement),
+ *   - a future-skewed lastSeenAt / observedAt clamps to ingest time so
+ *     the `>=` dominance guards can't get wedged by one bogus device
+ *     clock,
+ *   - the latest-metric mirror truncates identity the SAME way the
+ *     upsert does, so the UPDATE still finds the row the upsert wrote.
+ */
+
+const PROJECT_ID: ObjectID = ObjectID.generate();
+const FLEET_ID: ObjectID = ObjectID.generate();
+const SHORT_TEXT_LIMIT: number = 100;
+const UPSERT_PARAMS_PER_ROW: number = 11;
+
+type QueryCall = [string, Array<unknown>];
+
+function mockQueryRunner(result: unknown = []): jest.Mock {
+  const query: jest.Mock = jest.fn().mockResolvedValue(result);
+  jest
+    .spyOn(IoTDeviceService, "getRepository")
+    .mockReturnValue({ manager: { query } } as any);
+  return query;
+}
+
+function parsedDevice(
+  overrides: Partial<ParsedIoTDevice> = {},
+): ParsedIoTDevice {
+  return {
+    kind: "Sensor",
+    externalId: "sensor-1",
+    name: "greenhouse-sensor",
+    deviceType: "temperature",
+    firmwareVersion: "1.2.3",
+    isUp: true,
+    uptimeSeconds: 3600,
+    lastSeenAt: new Date("2026-06-13T00:00:00.000Z"),
+    ...overrides,
+  };
+}
+
+function latestMetric(
+  overrides: Partial<IoTDeviceLatestMetric> = {},
+): IoTDeviceLatestMetric {
+  return {
+    kind: "Sensor",
+    externalId: "sensor-1",
+    cpuPercent: 12.5,
+    memoryBytes: 1024,
+    maxMemoryBytes: 4096,
+    memoryPercent: 25,
+    batteryPercent: 88,
+    signalStrengthDbm: -61,
+    temperatureCelsius: 21.4,
+    observedAt: new Date("2026-06-13T00:00:00.000Z"),
+    ...overrides,
+  };
+}
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("IoTDeviceService.bulkUpsert — ShortText sanitation", () => {
+  test("truncates an over-long externalId instead of failing the chunk", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    const longId: string = "x".repeat(150);
+
+    await IoTDeviceService.bulkUpsert({
+      projectId: PROJECT_ID,
+      iotFleetId: FLEET_ID,
+      devices: [
+        parsedDevice({ externalId: longId }),
+        parsedDevice({ externalId: "sensor-good" }),
+      ],
+    });
+
+    expect(query).toHaveBeenCalledTimes(1);
+    const [, params] = query.mock.calls[0] as QueryCall;
+
+    // Both rows made it into the one chunk — the bad id dropped nobody.
+    expect(params).toHaveLength(2 * UPSERT_PARAMS_PER_ROW);
+    expect(params).toContain("x".repeat(SHORT_TEXT_LIMIT));
+    expect(params).toContain("sensor-good");
+    expect(params).not.toContain(longId);
+  });
+
+  test("truncates over-long kind/name/deviceType/firmwareVersion values", async () => {
+    const query: jest.Mock = mockQueryRunner();
+
+    await IoTDeviceService.bulkUpsert({
+      projectId: PROJECT_ID,
+      iotFleetId: FLEET_ID,
+      devices: [
+        parsedDevice({
+          kind: "k".repeat(140),
+          name: "n".repeat(140),
+          deviceType: "t".repeat(140),
+          firmwareVersion: "f".repeat(140),
+        }),
+      ],
+    });
+
+    const [, params] = query.mock.calls[0] as QueryCall;
+    expect(params).toContain("k".repeat(SHORT_TEXT_LIMIT));
+    expect(params).toContain("n".repeat(SHORT_TEXT_LIMIT));
+    expect(params).toContain("t".repeat(SHORT_TEXT_LIMIT));
+    expect(params).toContain("f".repeat(SHORT_TEXT_LIMIT));
+  });
+
+  test("identities colliding after truncation dedupe to the newest row", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    const shared: string = "z".repeat(SHORT_TEXT_LIMIT);
+    const older: Date = new Date("2026-06-13T00:00:00.000Z");
+    const newer: Date = new Date("2026-06-13T00:05:00.000Z");
+
+    await IoTDeviceService.bulkUpsert({
+      projectId: PROJECT_ID,
+      iotFleetId: FLEET_ID,
+      devices: [
+        parsedDevice({
+          externalId: `${shared}-alpha`,
+          name: "older-device",
+          lastSeenAt: older,
+        }),
+        parsedDevice({
+          externalId: `${shared}-bravo`,
+          name: "newer-device",
+          lastSeenAt: newer,
+        }),
+      ],
+    });
+
+    const [, params] = query.mock.calls[0] as QueryCall;
+
+    // One conflict target → exactly one VALUES row, the newest one.
+    expect(params).toHaveLength(UPSERT_PARAMS_PER_ROW);
+    expect(params).toContain(shared);
+    expect(params).toContain("newer-device");
+    expect(params).not.toContain("older-device");
+  });
+
+  test("skips rows whose externalId is empty", async () => {
+    const query: jest.Mock = mockQueryRunner();
+
+    await IoTDeviceService.bulkUpsert({
+      projectId: PROJECT_ID,
+      iotFleetId: FLEET_ID,
+      devices: [parsedDevice({ externalId: "" })],
+    });
+
+    expect(query).not.toHaveBeenCalled();
+  });
+});
+
+describe("IoTDeviceService.bulkUpsert — future clock-skew clamping", () => {
+  test("clamps a lastSeenAt beyond the skew tolerance to ingest time", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    const before: number = Date.now();
+
+    await IoTDeviceService.bulkUpsert({
+      projectId: PROJECT_ID,
+      iotFleetId: FLEET_ID,
+      devices: [
+        parsedDevice({
+          lastSeenAt: new Date(Date.now() + 24 * 60 * 60 * 1000),
+        }),
+      ],
+    });
+
+    const after: number = Date.now();
+    const [, params] = query.mock.calls[0] as QueryCall;
+    const lastSeenAt: Date = params[9] as Date;
+
+    expect(lastSeenAt.getTime()).toBeGreaterThanOrEqual(before);
+    expect(lastSeenAt.getTime()).toBeLessThanOrEqual(after);
+  });
+
+  test("keeps a lastSeenAt within the skew tolerance untouched", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    const slightlyAhead: Date = new Date(
+      Date.now() + (IOT_MAX_FUTURE_CLOCK_SKEW_MINUTES - 1) * 60 * 1000,
+    );
+
+    await IoTDeviceService.bulkUpsert({
+      projectId: PROJECT_ID,
+      iotFleetId: FLEET_ID,
+      devices: [parsedDevice({ lastSeenAt: slightlyAhead })],
+    });
+
+    const [, params] = query.mock.calls[0] as QueryCall;
+    expect(params[9]).toEqual(slightlyAhead);
+  });
+});
+
+describe("IoTDeviceService.bulkUpdateLatestMetrics — sanitation matches the upsert", () => {
+  test("truncates an over-long externalId to the same identity the upsert wrote", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    const longId: string = "x".repeat(150);
+
+    await IoTDeviceService.bulkUpdateLatestMetrics({
+      projectId: PROJECT_ID,
+      iotFleetId: FLEET_ID,
+      metrics: [latestMetric({ externalId: longId })],
+    });
+
+    expect(query).toHaveBeenCalledTimes(1);
+    const [, params] = query.mock.calls[0] as QueryCall;
+
+    // Params: projectId, fleetId, then kind, externalId, ... per row.
+    expect(params[3]).toBe("x".repeat(SHORT_TEXT_LIMIT));
+  });
+
+  test("clamps a future observedAt beyond the skew tolerance", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    const before: number = Date.now();
+
+    await IoTDeviceService.bulkUpdateLatestMetrics({
+      projectId: PROJECT_ID,
+      iotFleetId: FLEET_ID,
+      metrics: [
+        latestMetric({
+          observedAt: new Date(Date.now() + 24 * 60 * 60 * 1000),
+        }),
+      ],
+    });
+
+    const after: number = Date.now();
+    const [, params] = query.mock.calls[0] as QueryCall;
+    const observedAt: Date = params[11] as Date;
+
+    expect(observedAt.getTime()).toBeGreaterThanOrEqual(before);
+    expect(observedAt.getTime()).toBeLessThanOrEqual(after);
+  });
+
+  test("identities colliding after truncation dedupe to the newest observation", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    const shared: string = "z".repeat(SHORT_TEXT_LIMIT);
+
+    await IoTDeviceService.bulkUpdateLatestMetrics({
+      projectId: PROJECT_ID,
+      iotFleetId: FLEET_ID,
+      metrics: [
+        latestMetric({
+          externalId: `${shared}-alpha`,
+          batteryPercent: 10,
+          observedAt: new Date("2026-06-13T00:00:00.000Z"),
+        }),
+        latestMetric({
+          externalId: `${shared}-bravo`,
+          batteryPercent: 90,
+          observedAt: new Date("2026-06-13T00:05:00.000Z"),
+        }),
+      ],
+    });
+
+    const [, params] = query.mock.calls[0] as QueryCall;
+
+    // 2 shared params + one 9-param row (kind..temp) + observedAt.
+    expect(params).toHaveLength(2 + 10);
+    expect(params[3]).toBe(shared);
+    expect(params).toContain(90);
+    expect(params).not.toContain(10);
+  });
+});

package/Tests/Server/Utils/Monitor/Criteria/TelemetryStepMetricAlias.test.ts

@@ -0,0 +1,390 @@
+import MetricMonitorCriteria from "../../../../../Server/Utils/Monitor/Criteria/MetricMonitorCriteria";
+import MonitorCriteriaDataExtractor from "../../../../../Server/Utils/Monitor/MonitorCriteriaDataExtractor";
+import AggregateModel from "../../../../../Types/BaseDatabase/AggregatedModel";
+import AggregatedResult from "../../../../../Types/BaseDatabase/AggregatedResult";
+import {
+  CheckOn,
+  CriteriaFilter,
+  EvaluateOverTimeType,
+  FilterType,
+} from "../../../../../Types/Monitor/CriteriaFilter";
+import MetricFormulaConfigData from "../../../../../Types/Metrics/MetricFormulaConfigData";
+import MetricQueryConfigData from "../../../../../Types/Metrics/MetricQueryConfigData";
+import MetricQueryData from "../../../../../Types/Metrics/MetricQueryData";
+import MetricsViewConfig from "../../../../../Types/Metrics/MetricsViewConfig";
+import MetricMonitorResponse from "../../../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
+import MonitorStep, {
+  MonitorStepType,
+} from "../../../../../Types/Monitor/MonitorStep";
+import { MonitorStepCephMonitorUtil } from "../../../../../Types/Monitor/MonitorStepCephMonitor";
+import { MonitorStepDockerMonitorUtil } from "../../../../../Types/Monitor/MonitorStepDockerMonitor";
+import { MonitorStepDockerSwarmMonitorUtil } from "../../../../../Types/Monitor/MonitorStepDockerSwarmMonitor";
+import { MonitorStepHostMonitorUtil } from "../../../../../Types/Monitor/MonitorStepHostMonitor";
+import { MonitorStepKubernetesMonitorUtil } from "../../../../../Types/Monitor/MonitorStepKubernetesMonitor";
+import { MonitorStepPodmanMonitorUtil } from "../../../../../Types/Monitor/MonitorStepPodmanMonitor";
+import { MonitorStepProxmoxMonitorUtil } from "../../../../../Types/Monitor/MonitorStepProxmoxMonitor";
+import RollingTime from "../../../../../Types/RollingTime/RollingTime";
+import ObjectID from "../../../../../Types/ObjectID";
+
+/*
+ * Criteria evaluation resolves `metricAlias` → result slot via the query
+ * configs on the monitor step. Telemetry monitors other than the plain
+ * Metric monitor (IoT, Kubernetes, Docker, ...) store their query configs
+ * under their own step shape (e.g. `data.iotMonitor.metricViewConfig`), so
+ * alias resolution must read from whichever shape the step carries — not
+ * just `data.metricMonitor`. These tests pin that behavior: a criteria
+ * referencing the second query's alias must evaluate the second result
+ * slot, never silently fall back to slot 0.
+ */
+
+function buildQueryConfig(input: {
+  alias: string;
+  metricName: string;
+}): MetricQueryConfigData {
+  return {
+    metricAliasData: {
+      metricVariable: input.alias,
+      title: input.metricName,
+      description: undefined,
+      legend: undefined,
+      legendUnit: undefined,
+    },
+    metricQueryData: {
+      filterData: {
+        metricName: input.metricName,
+      },
+    } as unknown as MetricQueryData,
+  };
+}
+
+/*
+ * Two queries — "a" (iot_battery_percent) and "b"
+ * (iot_signal_strength_dbm) — plus an optional formula "f" = a + b.
+ * Result slots: 0 → a, 1 → b, 2 → f.
+ */
+function buildViewConfig(input?: { withFormula?: boolean }): MetricsViewConfig {
+  const formulaConfigs: Array<MetricFormulaConfigData> = input?.withFormula
+    ? [
+        {
+          metricAliasData: {
+            metricVariable: "f",
+            title: "Battery + Signal",
+            description: undefined,
+            legend: undefined,
+            legendUnit: undefined,
+          },
+          metricFormulaData: {
+            metricFormula: "a + b",
+          },
+        },
+      ]
+    : [];
+
+  return {
+    queryConfigs: [
+      buildQueryConfig({ alias: "a", metricName: "iot_battery_percent" }),
+      buildQueryConfig({ alias: "b", metricName: "iot_signal_strength_dbm" }),
+    ],
+    formulaConfigs,
+  };
+}
+
+/*
+ * Bare step whose telemetry shape is attached by `assignShape` — the
+ * point of these tests is that `data.metricMonitor` stays undefined.
+ */
+function buildStep(
+  assignShape: (data: MonitorStepType, viewConfig: MetricsViewConfig) => void,
+  viewConfig: MetricsViewConfig,
+): MonitorStep {
+  const monitorStep: MonitorStep = new MonitorStep();
+  monitorStep.data = {
+    id: ObjectID.generate().toString(),
+    monitorCriteria: { data: undefined } as never,
+  } as unknown as MonitorStep["data"];
+  assignShape(monitorStep.data!, viewConfig);
+  return monitorStep;
+}
+
+function buildIoTStep(viewConfig: MetricsViewConfig): MonitorStep {
+  return buildStep((data: MonitorStepType, v: MetricsViewConfig) => {
+    data.iotMonitor = {
+      fleetIdentifier: "plant-a-fleet",
+      resourceFilters: {},
+      metricViewConfig: v,
+      rollingTime: RollingTime.Past1Minute,
+    };
+  }, viewConfig);
+}
+
+/*
+ * One aggregated result per result slot, in query/formula order.
+ */
+function buildResponse(input: {
+  viewConfig: MetricsViewConfig;
+  resultSlots: Array<Array<number>>;
+}): MetricMonitorResponse {
+  const metricResult: Array<AggregatedResult> = input.resultSlots.map(
+    (values: Array<number>) => {
+      return {
+        data: values.map((v: number) => {
+          return {
+            timestamp: new Date(),
+            value: v,
+          } as AggregateModel;
+        }),
+      };
+    },
+  );
+
+  return {
+    projectId: ObjectID.generate(),
+    metricResult,
+    metricViewConfig: input.viewConfig,
+    monitorId: ObjectID.generate(),
+  };
+}
+
+function greaterThanFilter(input: {
+  alias: string;
+  threshold: string;
+}): CriteriaFilter {
+  return {
+    checkOn: CheckOn.MetricValue,
+    filterType: FilterType.GreaterThan,
+    value: input.threshold,
+    metricMonitorOptions: {
+      metricAlias: input.alias,
+      metricAggregationType: EvaluateOverTimeType.AnyValue,
+    },
+  };
+}
+
+describe("MetricMonitorCriteria — IoT monitor step alias resolution", () => {
+  test("criteria on the second alias evaluates the second series", async () => {
+    const viewConfig: MetricsViewConfig = buildViewConfig();
+    const criteriaFilter: CriteriaFilter = greaterThanFilter({
+      alias: "b",
+      threshold: "30",
+    });
+
+    // Slot 0 (alias a) stays under the threshold; slot 1 (alias b) breaches.
+    const message: string | null =
+      await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+        dataToProcess: buildResponse({
+          viewConfig,
+          resultSlots: [[10, 12], [55]],
+        }),
+        criteriaFilter,
+        monitorStep: buildIoTStep(viewConfig),
+      });
+
+    expect(message).toBeTruthy();
+    expect(message).toContain("55");
+    expect(criteriaFilter.metricCriteriaContext?.metricName).toBe(
+      "iot_signal_strength_dbm",
+    );
+    expect(criteriaFilter.metricCriteriaContext?.breachingSample?.value).toBe(
+      55,
+    );
+  });
+
+  test("criteria on the second alias ignores a breach in the first series", async () => {
+    const viewConfig: MetricsViewConfig = buildViewConfig();
+
+    // Slot 0 (alias a) breaches, but the criteria targets alias b.
+    const message: string | null =
+      await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+        dataToProcess: buildResponse({
+          viewConfig,
+          resultSlots: [[90], [10]],
+        }),
+        criteriaFilter: greaterThanFilter({ alias: "b", threshold: "30" }),
+        monitorStep: buildIoTStep(viewConfig),
+      });
+
+    expect(message).toBeNull();
+  });
+
+  test("formula alias resolves to the formula result slot", async () => {
+    const viewConfig: MetricsViewConfig = buildViewConfig({
+      withFormula: true,
+    });
+    const criteriaFilter: CriteriaFilter = greaterThanFilter({
+      alias: "f",
+      threshold: "100",
+    });
+
+    // Slots: a → 10, b → 20, f (formula) → 150. Only the formula breaches.
+    const message: string | null =
+      await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+        dataToProcess: buildResponse({
+          viewConfig,
+          resultSlots: [[10], [20], [150]],
+        }),
+        criteriaFilter,
+        monitorStep: buildIoTStep(viewConfig),
+      });
+
+    expect(message).toBeTruthy();
+    expect(message).toContain("150");
+    expect(criteriaFilter.metricCriteriaContext?.isFormula).toBe(true);
+  });
+});
+
+describe("MonitorCriteriaDataExtractor — IoT monitor step alias resolution", () => {
+  test("extractMetricValues returns the aliased series, not slot 0", () => {
+    const viewConfig: MetricsViewConfig = buildViewConfig();
+
+    const extracted: { alias: string | null; values: Array<number> } | null =
+      MonitorCriteriaDataExtractor.extractMetricValues({
+        criteriaFilter: greaterThanFilter({ alias: "b", threshold: "30" }),
+        dataToProcess: buildResponse({
+          viewConfig,
+          resultSlots: [
+            [10, 12],
+            [55, 60],
+          ],
+        }),
+        monitorStep: buildIoTStep(viewConfig),
+      });
+
+    expect(extracted).not.toBeNull();
+    expect(extracted?.alias).toBe("b");
+    expect(extracted?.values).toEqual([55, 60]);
+  });
+});
+
+describe("MetricMonitorCriteria — other telemetry step shapes", () => {
+  type ShapeCase = {
+    name: string;
+    assignShape: (data: MonitorStepType, viewConfig: MetricsViewConfig) => void;
+  };
+
+  const shapeCases: Array<ShapeCase> = [
+    {
+      name: "kubernetesMonitor",
+      assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {
+        data.kubernetesMonitor = {
+          ...MonitorStepKubernetesMonitorUtil.getDefault(),
+          metricViewConfig: v,
+        };
+      },
+    },
+    {
+      name: "dockerMonitor",
+      assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {
+        data.dockerMonitor = {
+          ...MonitorStepDockerMonitorUtil.getDefault(),
+          metricViewConfig: v,
+        };
+      },
+    },
+    {
+      name: "dockerSwarmMonitor",
+      assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {
+        data.dockerSwarmMonitor = {
+          ...MonitorStepDockerSwarmMonitorUtil.getDefault(),
+          metricViewConfig: v,
+        };
+      },
+    },
+    {
+      name: "hostMonitor",
+      assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {
+        data.hostMonitor = {
+          ...MonitorStepHostMonitorUtil.getDefault(),
+          metricViewConfig: v,
+        };
+      },
+    },
+    {
+      name: "podmanMonitor",
+      assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {
+        data.podmanMonitor = {
+          ...MonitorStepPodmanMonitorUtil.getDefault(),
+          metricViewConfig: v,
+        };
+      },
+    },
+    {
+      name: "proxmoxMonitor",
+      assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {
+        data.proxmoxMonitor = {
+          ...MonitorStepProxmoxMonitorUtil.getDefault(),
+          metricViewConfig: v,
+        };
+      },
+    },
+    {
+      name: "cephMonitor",
+      assignShape: (data: MonitorStepType, v: MetricsViewConfig) => {
+        data.cephMonitor = {
+          ...MonitorStepCephMonitorUtil.getDefault(),
+          metricViewConfig: v,
+        };
+      },
+    },
+  ];
+
+  test.each(shapeCases)(
+    "$name: criteria on the second alias evaluates the second series",
+    async (shapeCase: ShapeCase) => {
+      const viewConfig: MetricsViewConfig = buildViewConfig();
+      const criteriaFilter: CriteriaFilter = greaterThanFilter({
+        alias: "b",
+        threshold: "30",
+      });
+
+      const message: string | null =
+        await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: buildResponse({
+            viewConfig,
+            resultSlots: [[10, 12], [55]],
+          }),
+          criteriaFilter,
+          monitorStep: buildStep(shapeCase.assignShape, viewConfig),
+        });
+
+      expect(message).toBeTruthy();
+      expect(message).toContain("55");
+      expect(criteriaFilter.metricCriteriaContext?.metricName).toBe(
+        "iot_signal_strength_dbm",
+      );
+    },
+  );
+});
+
+describe("MetricMonitorCriteria — metric monitor step (regression)", () => {
+  test("alias resolution still reads data.metricMonitor", async () => {
+    const viewConfig: MetricsViewConfig = buildViewConfig();
+    const criteriaFilter: CriteriaFilter = greaterThanFilter({
+      alias: "b",
+      threshold: "30",
+    });
+
+    const message: string | null =
+      await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+        dataToProcess: buildResponse({
+          viewConfig,
+          resultSlots: [[10, 12], [55]],
+        }),
+        criteriaFilter,
+        monitorStep: buildStep(
+          (data: MonitorStepType, v: MetricsViewConfig) => {
+            data.metricMonitor = {
+              metricViewConfig: v,
+              rollingTime: RollingTime.Past1Minute,
+            };
+          },
+          viewConfig,
+        ),
+      });
+
+    expect(message).toBeTruthy();
+    expect(message).toContain("55");
+    expect(criteriaFilter.metricCriteriaContext?.metricName).toBe(
+      "iot_signal_strength_dbm",
+    );
+  });
+});