@oneuptime/common 11.7.2 → 11.7.4

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);
+    });
+  });
+});

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

@@ -0,0 +1,386 @@
+import { JSONObject } from "../../../Types/JSON";
+import MetricFormulaConfigData from "../../../Types/Metrics/MetricFormulaConfigData";
+import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
+import MetricsViewConfig from "../../../Types/Metrics/MetricsViewConfig";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorStepMetricMonitor, {
+  MonitorStepMetricMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepMetricMonitor";
+import RollingTime from "../../../Types/RollingTime/RollingTime";
+
+/*
+ * Regression coverage for the blank-screen crash on the monitor view page.
+ *
+ * MetricMonitorPreview read `monitorStepMetricMonitor?.metricViewConfig.queryConfigs`.
+ * The optional chain stops at `monitorStepMetricMonitor`, so a step that HAS a
+ * metricMonitor but no metricViewConfig threw
+ *
+ *     TypeError: Cannot read properties of undefined (reading 'queryConfigs')
+ *
+ * during render. Nothing above it caught the throw, so React unmounted the whole
+ * tree and the dashboard went blank white — nav, sidebar and all.
+ *
+ * That shape is reachable because monitor steps are persisted as free-form JSON
+ * and rehydrated with a cast: nothing at runtime enforces that metricViewConfig
+ * is present. These tests lock in that resolving the config NEVER throws and
+ * always yields array-shaped queryConfigs / formulaConfigs, whatever garbage the
+ * database hands back.
+ */
+
+function queryConfig(metricVariable: string): MetricQueryConfigData {
+  return {
+    metricAliasData: {
+      metricVariable,
+      title: metricVariable,
+      description: metricVariable,
+      legend: metricVariable,
+      legendUnit: undefined,
+    },
+    metricQueryData: {
+      filterData: {},
+    },
+  } as unknown as MetricQueryConfigData;
+}
+
+function formulaConfig(metricVariable: string): MetricFormulaConfigData {
+  return {
+    metricAliasData: {
+      metricVariable,
+      title: metricVariable,
+      description: metricVariable,
+      legend: metricVariable,
+      legendUnit: undefined,
+    },
+    metricFormulaData: {
+      formula: "a + b",
+    },
+  } as unknown as MetricFormulaConfigData;
+}
+
+describe("MonitorStepMetricMonitorUtil.getMetricViewConfig", () => {
+  test("returns the config untouched when the step is well formed", () => {
+    const queryConfigs: Array<MetricQueryConfigData> = [queryConfig("a")];
+    const formulaConfigs: Array<MetricFormulaConfigData> = [formulaConfig("b")];
+
+    const config: MetricsViewConfig =
+      MonitorStepMetricMonitorUtil.getMetricViewConfig({
+        metricViewConfig: {
+          queryConfigs,
+          formulaConfigs,
+        },
+        rollingTime: RollingTime.Past1Hour,
+      });
+
+    expect(config.queryConfigs).toEqual(queryConfigs);
+    expect(config.formulaConfigs).toEqual(formulaConfigs);
+  });
+
+  test("returns empty arrays when the whole monitor is undefined", () => {
+    const config: MetricsViewConfig =
+      MonitorStepMetricMonitorUtil.getMetricViewConfig(undefined);
+
+    expect(config).toEqual({ queryConfigs: [], formulaConfigs: [] });
+  });
+
+  test("returns empty arrays when the whole monitor is null", () => {
+    const config: MetricsViewConfig =
+      MonitorStepMetricMonitorUtil.getMetricViewConfig(null);
+
+    expect(config).toEqual({ queryConfigs: [], formulaConfigs: [] });
+  });
+
+  test("THE CRASH: monitor present but metricViewConfig missing entirely", () => {
+    /*
+     * The exact shape from the bug report: a persisted metricMonitor that only
+     * carries rollingTime. Reading .metricViewConfig.queryConfigs off this is
+     * what threw and blanked the page.
+     */
+    const malformed: MonitorStepMetricMonitor = {
+      rollingTime: RollingTime.Past1Minute,
+    } as unknown as MonitorStepMetricMonitor;
+
+    expect(() => {
+      return MonitorStepMetricMonitorUtil.getMetricViewConfig(malformed);
+    }).not.toThrow();
+
+    expect(MonitorStepMetricMonitorUtil.getMetricViewConfig(malformed)).toEqual(
+      {
+        queryConfigs: [],
+        formulaConfigs: [],
+      },
+    );
+  });
+
+  test("returns empty arrays when metricViewConfig is explicitly null", () => {
+    const malformed: MonitorStepMetricMonitor = {
+      metricViewConfig: null,
+      rollingTime: RollingTime.Past1Minute,
+    } as unknown as MonitorStepMetricMonitor;
+
+    expect(MonitorStepMetricMonitorUtil.getMetricViewConfig(malformed)).toEqual(
+      { queryConfigs: [], formulaConfigs: [] },
+    );
+  });
+
+  test("fills in queryConfigs when only formulaConfigs was persisted", () => {
+    const formulaConfigs: Array<MetricFormulaConfigData> = [formulaConfig("b")];
+
+    const config: MetricsViewConfig =
+      MonitorStepMetricMonitorUtil.getMetricViewConfig({
+        metricViewConfig: { formulaConfigs },
+        rollingTime: RollingTime.Past1Minute,
+      } as unknown as MonitorStepMetricMonitor);
+
+    expect(config.queryConfigs).toEqual([]);
+    expect(config.formulaConfigs).toEqual(formulaConfigs);
+  });
+
+  test("fills in formulaConfigs when only queryConfigs was persisted", () => {
+    const queryConfigs: Array<MetricQueryConfigData> = [queryConfig("a")];
+
+    const config: MetricsViewConfig =
+      MonitorStepMetricMonitorUtil.getMetricViewConfig({
+        metricViewConfig: { queryConfigs },
+        rollingTime: RollingTime.Past1Minute,
+      } as unknown as MonitorStepMetricMonitor);
+
+    expect(config.queryConfigs).toEqual(queryConfigs);
+    expect(config.formulaConfigs).toEqual([]);
+  });
+
+  test.each([
+    ["null", null],
+    ["undefined", undefined],
+    ["a string", "not-an-array"],
+    ["a number", 42],
+    ["an object", { length: 2 }],
+    ["a boolean", true],
+  ])(
+    "coerces non-array queryConfigs (%s) to an empty array",
+    (_label: string, value: unknown) => {
+      const config: MetricsViewConfig =
+        MonitorStepMetricMonitorUtil.getMetricViewConfig({
+          metricViewConfig: {
+            queryConfigs: value,
+            formulaConfigs: value,
+          },
+          rollingTime: RollingTime.Past1Minute,
+        } as unknown as MonitorStepMetricMonitor);
+
+      expect(config.queryConfigs).toEqual([]);
+      expect(config.formulaConfigs).toEqual([]);
+      // Callers immediately call .length / .map / .some on these.
+      expect(Array.isArray(config.queryConfigs)).toBe(true);
+      expect(Array.isArray(config.formulaConfigs)).toBe(true);
+    },
+  );
+
+  test("the result is always safe for the array reads MetricView performs", () => {
+    const malformed: MonitorStepMetricMonitor =
+      {} as unknown as MonitorStepMetricMonitor;
+
+    const config: MetricsViewConfig =
+      MonitorStepMetricMonitorUtil.getMetricViewConfig(malformed);
+
+    // These are the exact operations MetricView runs on the data it is given.
+    expect(() => {
+      return [
+        config.queryConfigs.length,
+        config.queryConfigs.map((q: MetricQueryConfigData) => {
+          return q;
+        }),
+        config.queryConfigs.some(() => {
+          return true;
+        }),
+        config.formulaConfigs.length,
+        config.formulaConfigs.map((f: MetricFormulaConfigData) => {
+          return f;
+        }),
+      ];
+    }).not.toThrow();
+  });
+
+  test("does not mutate the monitor it was given", () => {
+    const malformed: MonitorStepMetricMonitor = {
+      rollingTime: RollingTime.Past1Minute,
+    } as unknown as MonitorStepMetricMonitor;
+
+    MonitorStepMetricMonitorUtil.getMetricViewConfig(malformed);
+
+    expect(
+      (malformed as unknown as JSONObject)["metricViewConfig"],
+    ).toBeUndefined();
+  });
+
+  test("hands back the same array references when they are already valid", () => {
+    const queryConfigs: Array<MetricQueryConfigData> = [queryConfig("a")];
+    const formulaConfigs: Array<MetricFormulaConfigData> = [formulaConfig("b")];
+
+    const config: MetricsViewConfig =
+      MonitorStepMetricMonitorUtil.getMetricViewConfig({
+        metricViewConfig: { queryConfigs, formulaConfigs },
+        rollingTime: RollingTime.Past1Minute,
+      });
+
+    // No defensive copy: the preview passes these straight into MetricView.
+    expect(config.queryConfigs).toBe(queryConfigs);
+    expect(config.formulaConfigs).toBe(formulaConfigs);
+  });
+});
+
+describe("MonitorStepMetricMonitorUtil.getDefault", () => {
+  test("produces a config that resolves to itself", () => {
+    const defaultMonitor: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.getDefault();
+
+    expect(
+      MonitorStepMetricMonitorUtil.getMetricViewConfig(defaultMonitor),
+    ).toEqual({
+      queryConfigs: [],
+      formulaConfigs: [],
+    });
+    expect(defaultMonitor.rollingTime).toBe(RollingTime.Past1Minute);
+  });
+});
+
+describe("MonitorStepMetricMonitorUtil.fromJSON", () => {
+  test("normalizes JSON that is missing metricViewConfig", () => {
+    const monitor: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.fromJSON({
+        rollingTime: RollingTime.Past1Hour,
+      });
+
+    expect(monitor.metricViewConfig).toEqual({
+      queryConfigs: [],
+      formulaConfigs: [],
+    });
+    expect(monitor.rollingTime).toBe(RollingTime.Past1Hour);
+  });
+
+  test("normalizes JSON that is missing everything", () => {
+    const monitor: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.fromJSON({});
+
+    expect(monitor.metricViewConfig).toEqual({
+      queryConfigs: [],
+      formulaConfigs: [],
+    });
+    // rollingTime backs off to the same default a fresh step gets.
+    expect(monitor.rollingTime).toBe(RollingTime.Past1Minute);
+  });
+
+  test("preserves a well formed config", () => {
+    const json: JSONObject = {
+      metricViewConfig: {
+        queryConfigs: [queryConfig("a")],
+        formulaConfigs: [formulaConfig("b")],
+      },
+      rollingTime: RollingTime.Past7Days,
+    } as unknown as JSONObject;
+
+    const monitor: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.fromJSON(json);
+
+    expect(monitor.metricViewConfig.queryConfigs).toHaveLength(1);
+    expect(monitor.metricViewConfig.formulaConfigs).toHaveLength(1);
+    expect(monitor.rollingTime).toBe(RollingTime.Past7Days);
+  });
+
+  test("keeps unknown keys so forward-compatible fields are not dropped", () => {
+    const monitor: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.fromJSON({
+        rollingTime: RollingTime.Past1Minute,
+        someFutureField: "keep-me",
+      } as unknown as JSONObject);
+
+    expect((monitor as unknown as JSONObject)["someFutureField"]).toBe(
+      "keep-me",
+    );
+  });
+
+  test("round trips through toJSON without losing the normalization", () => {
+    const monitor: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.fromJSON({
+        rollingTime: RollingTime.Past1Minute,
+      });
+
+    const roundTripped: MonitorStepMetricMonitor =
+      MonitorStepMetricMonitorUtil.fromJSON(
+        MonitorStepMetricMonitorUtil.toJSON(monitor),
+      );
+
+    expect(roundTripped.metricViewConfig).toEqual({
+      queryConfigs: [],
+      formulaConfigs: [],
+    });
+  });
+});
+
+describe("MonitorStep.fromJSON normalizes persisted metric monitors", () => {
+  function monitorStepJSON(metricMonitor: JSONObject | undefined): JSONObject {
+    return {
+      _type: "MonitorStep",
+      value: {
+        id: "step-1",
+        monitorCriteria: {
+          _type: "MonitorCriteria",
+          value: {
+            monitorCriteriaInstanceArray: [],
+          },
+        },
+        metricMonitor: metricMonitor,
+      },
+    } as unknown as JSONObject;
+  }
+
+  test("a step whose metricMonitor has no metricViewConfig loads with one", () => {
+    const step: MonitorStep = MonitorStep.fromJSON(
+      monitorStepJSON({
+        rollingTime: RollingTime.Past1Minute,
+      } as unknown as JSONObject),
+    );
+
+    expect(step.data?.metricMonitor?.metricViewConfig).toEqual({
+      queryConfigs: [],
+      formulaConfigs: [],
+    });
+  });
+
+  test("the loaded step is safe to hand to the metric preview", () => {
+    const step: MonitorStep = MonitorStep.fromJSON(
+      monitorStepJSON({} as unknown as JSONObject),
+    );
+
+    expect(() => {
+      const config: MetricsViewConfig =
+        MonitorStepMetricMonitorUtil.getMetricViewConfig(
+          step.data?.metricMonitor,
+        );
+
+      return [config.queryConfigs.length, config.formulaConfigs.length];
+    }).not.toThrow();
+  });
+
+  test("a step with no metricMonitor at all stays undefined", () => {
+    const step: MonitorStep = MonitorStep.fromJSON(monitorStepJSON(undefined));
+
+    expect(step.data?.metricMonitor).toBeUndefined();
+  });
+
+  test("a well formed metricMonitor survives the load unchanged", () => {
+    const step: MonitorStep = MonitorStep.fromJSON(
+      monitorStepJSON({
+        metricViewConfig: {
+          queryConfigs: [queryConfig("a")],
+          formulaConfigs: [],
+        },
+        rollingTime: RollingTime.Past1Hour,
+      } as unknown as JSONObject),
+    );
+
+    expect(
+      step.data?.metricMonitor?.metricViewConfig.queryConfigs,
+    ).toHaveLength(1);
+    expect(step.data?.metricMonitor?.rollingTime).toBe(RollingTime.Past1Hour);
+  });
+});