@oneuptime/common 11.6.1 → 11.7.0

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

@@ -1,17 +1,44 @@
 import { JSONObject } from "../../../Types/JSON";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
 import MonitorStepNetworkDeviceMonitor, {
   MonitorStepNetworkDeviceMonitorUtil,
 } from "../../../Types/Monitor/MonitorStepNetworkDeviceMonitor";
+import MonitorType from "../../../Types/Monitor/MonitorType";
 import SnmpOid from "../../../Types/Monitor/SnmpMonitor/SnmpOid";
+import ObjectID from "../../../Types/ObjectID";
+
+const getNetworkDeviceMonitorStep: (
+  overrides?: Partial<MonitorStepNetworkDeviceMonitor>,
+) => MonitorStep = (
+  overrides: Partial<MonitorStepNetworkDeviceMonitor> = {},
+): MonitorStep => {
+  const id: ObjectID = ObjectID.generate();
+  const monitorStep: MonitorStep = MonitorStep.getDefaultMonitorStep({
+    monitorName: "Network device monitor",
+    monitorType: MonitorType.NetworkDevice,
+    onlineMonitorStatusId: id,
+    offlineMonitorStatusId: id,
+    defaultIncidentSeverityId: id,
+    defaultAlertSeverityId: id,
+  });
+
+  return monitorStep.setNetworkDeviceMonitor({
+    ...MonitorStepNetworkDeviceMonitorUtil.getDefault(),
+    networkDeviceId: "device-1",
+    ...overrides,
+  });
+};
 
 describe("MonitorStepNetworkDeviceMonitorUtil", () => {
   describe("getDefault", () => {
-    test("returns no device, interface monitoring on, and no oids", () => {
+    test("returns no device, interface monitoring on, endpoint collection OFF, and no oids", () => {
       const def: MonitorStepNetworkDeviceMonitor =
         MonitorStepNetworkDeviceMonitorUtil.getDefault();
 
       expect(def.networkDeviceId).toBeUndefined();
       expect(def.monitorInterfaces).toBe(true);
+      // Endpoint collection is strictly opt-in, so a new step starts off.
+      expect(def.collectEndpoints).toBe(false);
       expect(def.oids).toEqual([]);
     });
   });
@@ -22,6 +49,7 @@ describe("MonitorStepNetworkDeviceMonitorUtil", () => {
         MonitorStepNetworkDeviceMonitorUtil.fromJSON({
           networkDeviceId: "device-1",
           monitorInterfaces: false,
+          collectEndpoints: false,
           oids: [
             {
               oid: "1.3.6.1.2.1.1.1.0",
@@ -33,6 +61,7 @@ describe("MonitorStepNetworkDeviceMonitorUtil", () => {
 
       expect(monitor.networkDeviceId).toBe("device-1");
       expect(monitor.monitorInterfaces).toBe(false);
+      expect(monitor.collectEndpoints).toBe(false);
       expect(monitor.oids.length).toBe(1);
       expect(monitor.oids[0]!.oid).toBe("1.3.6.1.2.1.1.1.0");
       expect(monitor.oids[0]!.name).toBe("sysDescr");
@@ -58,6 +87,37 @@ describe("MonitorStepNetworkDeviceMonitorUtil", () => {
       ).toBe(false);
     });
 
+    test("defaults collectEndpoints to false unless it is explicitly true", () => {
+      // Missing -> false: steps saved before the flag existed stay opted out.
+      expect(
+        MonitorStepNetworkDeviceMonitorUtil.fromJSON({}).collectEndpoints,
+      ).toBe(false);
+      // Explicit true -> true: the only way to opt in.
+      expect(
+        MonitorStepNetworkDeviceMonitorUtil.fromJSON({
+          collectEndpoints: true,
+        }).collectEndpoints,
+      ).toBe(true);
+      // Explicit false -> false.
+      expect(
+        MonitorStepNetworkDeviceMonitorUtil.fromJSON({
+          collectEndpoints: false,
+        }).collectEndpoints,
+      ).toBe(false);
+      // null (a JSON round trip of undefined) -> false, not "not false".
+      expect(
+        MonitorStepNetworkDeviceMonitorUtil.fromJSON({
+          collectEndpoints: null,
+        }).collectEndpoints,
+      ).toBe(false);
+      // A truthy non-true value is NOT an opt-in.
+      expect(
+        MonitorStepNetworkDeviceMonitorUtil.fromJSON({
+          collectEndpoints: "true",
+        }).collectEndpoints,
+      ).toBe(false);
+    });
+
     test("coerces a missing networkDeviceId to undefined and missing oids to []", () => {
       const monitor: MonitorStepNetworkDeviceMonitor =
         MonitorStepNetworkDeviceMonitorUtil.fromJSON({});
@@ -85,6 +145,7 @@ describe("MonitorStepNetworkDeviceMonitorUtil", () => {
       const monitor: MonitorStepNetworkDeviceMonitor = {
         networkDeviceId: "device-42",
         monitorInterfaces: false,
+        collectEndpoints: false,
         oids: [{ oid: "1.2.3", name: "n", description: "d" }],
       };
 
@@ -93,10 +154,22 @@ describe("MonitorStepNetworkDeviceMonitorUtil", () => {
 
       expect(json["networkDeviceId"]).toBe("device-42");
       expect(json["monitorInterfaces"]).toBe(false);
+      expect(json["collectEndpoints"]).toBe(false);
       expect(json["oids"]).toEqual([
         { oid: "1.2.3", name: "n", description: "d" },
       ]);
     });
+
+    test("passes collectEndpoints through untouched (true stays true)", () => {
+      const json: JSONObject = MonitorStepNetworkDeviceMonitorUtil.toJSON({
+        networkDeviceId: undefined,
+        monitorInterfaces: true,
+        collectEndpoints: true,
+        oids: [],
+      });
+
+      expect(json["collectEndpoints"]).toBe(true);
+    });
   });
 
   describe("round trip", () => {
@@ -104,6 +177,7 @@ describe("MonitorStepNetworkDeviceMonitorUtil", () => {
       const original: MonitorStepNetworkDeviceMonitor = {
         networkDeviceId: "device-7",
         monitorInterfaces: false,
+        collectEndpoints: false,
         oids: [
           { oid: "1.3.6.1.2.1.1.1.0", name: "sysDescr", description: "desc" },
           {
@@ -134,6 +208,26 @@ describe("MonitorStepNetworkDeviceMonitorUtil", () => {
       expect(roundTripped).toEqual(def);
     });
 
+    test("a legacy step without collectEndpoints round-trips to endpoint collection OFF", () => {
+      // Steps saved before the flag existed serialize without it…
+      const legacy: MonitorStepNetworkDeviceMonitor = {
+        networkDeviceId: "device-legacy",
+        monitorInterfaces: true,
+        oids: [],
+      };
+
+      const roundTripped: MonitorStepNetworkDeviceMonitor =
+        MonitorStepNetworkDeviceMonitorUtil.fromJSON(
+          MonitorStepNetworkDeviceMonitorUtil.toJSON(legacy),
+        );
+
+      /*
+       * …and must deserialize opted OUT: an upgrade cannot silently enrol
+       * an existing monitor into extra SNMP walks and per-MAC writes.
+       */
+      expect(roundTripped.collectEndpoints).toBe(false);
+    });
+
     test("preserves oids with only an oid string across a round trip", () => {
       const original: MonitorStepNetworkDeviceMonitor = {
         networkDeviceId: undefined,
@@ -152,4 +246,50 @@ describe("MonitorStepNetworkDeviceMonitorUtil", () => {
       expect(oid.description).toBeUndefined();
     });
   });
+
+  /*
+   * Under device-owned polling a Network Device monitor is a pure alerting
+   * layer: WHAT to collect (interface walks, endpoint discovery, OIDs) lives
+   * on the NetworkDevice resource itself. Step validation therefore only
+   * requires the device reference — the old "enable interface monitoring or
+   * configure at least one OID" rule is gone.
+   */
+  describe("MonitorStep validation", () => {
+    test("accepts a step with only a device reference (interfaces off, zero oids)", () => {
+      const monitorStep: MonitorStep = getNetworkDeviceMonitorStep({
+        monitorInterfaces: false,
+        oids: [],
+      });
+
+      expect(
+        MonitorStep.getValidationError(monitorStep, MonitorType.NetworkDevice),
+      ).toBeNull();
+    });
+
+    test("still rejects a step with no device reference", () => {
+      const monitorStep: MonitorStep = getNetworkDeviceMonitorStep({
+        networkDeviceId: undefined,
+      });
+
+      expect(
+        MonitorStep.getValidationError(monitorStep, MonitorType.NetworkDevice),
+      ).toBe("Network Device is required");
+    });
+
+    test("rejects a step that has no networkDeviceMonitor block at all", () => {
+      const id: ObjectID = ObjectID.generate();
+      const monitorStep: MonitorStep = MonitorStep.getDefaultMonitorStep({
+        monitorName: "Network device monitor",
+        monitorType: MonitorType.NetworkDevice,
+        onlineMonitorStatusId: id,
+        offlineMonitorStatusId: id,
+        defaultIncidentSeverityId: id,
+        defaultAlertSeverityId: id,
+      });
+
+      expect(
+        MonitorStep.getValidationError(monitorStep, MonitorType.NetworkDevice),
+      ).toBe("Network Device is required");
+    });
+  });
 });

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

@@ -0,0 +1,183 @@
+import MonitorSteps from "../../../Types/Monitor/MonitorSteps";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+import { JSONObject, ObjectType } from "../../../Types/JSON";
+import BadDataException from "../../../Types/Exception/BadDataException";
+
+/*
+ * MonitorSteps is the top-level DatabaseProperty stored on a Monitor: an array
+ * of MonitorStep plus the default monitor status. These tests lock in the
+ * factory shape, toJSON/fromJSON round-trip (including the deliberately lenient
+ * fromJSON(undefined) -> empty instance), and the validation contract.
+ */
+
+const buildDefaultSteps: () => MonitorSteps = (): MonitorSteps => {
+  return MonitorSteps.getDefaultMonitorSteps({
+    defaultMonitorStatusId: new ObjectID("100000000000000000000001"),
+    monitorType: MonitorType.Manual,
+    monitorName: "My Monitor",
+    onlineMonitorStatusId: new ObjectID("100000000000000000000002"),
+    offlineMonitorStatusId: new ObjectID("100000000000000000000003"),
+    defaultIncidentSeverityId: new ObjectID("100000000000000000000004"),
+    defaultAlertSeverityId: new ObjectID("100000000000000000000005"),
+  });
+};
+
+describe("MonitorSteps", () => {
+  describe("getNewMonitorStepsAsJSON", () => {
+    test("wraps a single default step under the MonitorSteps type", () => {
+      const json: JSONObject = MonitorSteps.getNewMonitorStepsAsJSON();
+      expect(json["_type"]).toBe(ObjectType.MonitorSteps);
+      const value: JSONObject = json["value"] as JSONObject;
+      expect(Array.isArray(value["monitorStepsInstanceArray"])).toBe(true);
+      expect(
+        (value["monitorStepsInstanceArray"] as Array<unknown>).length,
+      ).toBe(1);
+      expect(value["defaultMonitorStatusId"]).toBeUndefined();
+    });
+  });
+
+  describe("getDefaultMonitorSteps", () => {
+    test("creates one step and carries the default monitor status id", () => {
+      const steps: MonitorSteps = buildDefaultSteps();
+      expect(steps.data?.monitorStepsInstanceArray).toHaveLength(1);
+      expect(steps.data?.monitorStepsInstanceArray[0]).toBeInstanceOf(
+        MonitorStep,
+      );
+      expect(steps.data?.defaultMonitorStatusId?.toString()).toBe(
+        "100000000000000000000001",
+      );
+    });
+  });
+
+  describe("toJSON / fromJSON round-trip", () => {
+    test("serializes with the MonitorSteps type wrapper", () => {
+      const steps: MonitorSteps = buildDefaultSteps();
+      const json: JSONObject = steps.toJSON();
+      expect(json["_type"]).toBe(ObjectType.MonitorSteps);
+      expect((json["value"] as JSONObject)["defaultMonitorStatusId"]).toBe(
+        "100000000000000000000001",
+      );
+    });
+
+    test("round-trips the default status id and step count", () => {
+      const steps: MonitorSteps = buildDefaultSteps();
+      const restored: MonitorSteps = MonitorSteps.fromJSON(steps.toJSON());
+      expect(restored.data?.defaultMonitorStatusId?.toString()).toBe(
+        "100000000000000000000001",
+      );
+      expect(restored.data?.monitorStepsInstanceArray).toHaveLength(1);
+      expect(restored.data?.monitorStepsInstanceArray[0]).toBeInstanceOf(
+        MonitorStep,
+      );
+    });
+
+    test("toString returns a JSON string of the serialized value", () => {
+      const steps: MonitorSteps = buildDefaultSteps();
+      const asString: string = steps.toString();
+      const parsed: JSONObject = JSON.parse(asString) as JSONObject;
+      expect(parsed["_type"]).toBe(ObjectType.MonitorSteps);
+    });
+  });
+
+  describe("fromJSON leniency and validation", () => {
+    test("returns an empty instance for undefined input", () => {
+      const steps: MonitorSteps = MonitorSteps.fromJSON(undefined);
+      expect(steps).toBeInstanceOf(MonitorSteps);
+    });
+
+    test("returns the same instance when given a MonitorSteps", () => {
+      const steps: MonitorSteps = buildDefaultSteps();
+      expect(MonitorSteps.fromJSON(steps)).toBe(steps);
+    });
+
+    test("throws on a wrong _type", () => {
+      expect(() => {
+        return MonitorSteps.fromJSON({ _type: "Nope", value: {} });
+      }).toThrow(BadDataException);
+    });
+
+    test("throws when value is missing", () => {
+      expect(() => {
+        return MonitorSteps.fromJSON({ _type: "MonitorSteps" });
+      }).toThrow(BadDataException);
+    });
+
+    test("throws when monitorStepsInstanceArray is missing", () => {
+      expect(() => {
+        return MonitorSteps.fromJSON({
+          _type: "MonitorSteps",
+          value: { defaultMonitorStatusId: undefined },
+        });
+      }).toThrow(BadDataException);
+    });
+  });
+
+  describe("getValidationError", () => {
+    test("errors when data is missing", () => {
+      const steps: MonitorSteps = new MonitorSteps();
+      steps.data = undefined;
+      expect(MonitorSteps.getValidationError(steps, MonitorType.Manual)).toBe(
+        "Monitor Steps is required",
+      );
+    });
+
+    test("errors when the step array is empty", () => {
+      const steps: MonitorSteps = new MonitorSteps();
+      steps.data = {
+        monitorStepsInstanceArray: [],
+        defaultMonitorStatusId: new ObjectID("100000000000000000000001"),
+      };
+      expect(MonitorSteps.getValidationError(steps, MonitorType.Manual)).toBe(
+        "Monitor Steps is required",
+      );
+    });
+
+    test("errors when the default monitor status id is missing", () => {
+      const steps: MonitorSteps = buildDefaultSteps();
+      steps.data!.defaultMonitorStatusId = undefined;
+      expect(MonitorSteps.getValidationError(steps, MonitorType.Manual)).toBe(
+        "Default Monitor Status is required",
+      );
+    });
+  });
+
+  describe("clone and setters", () => {
+    test("clone produces an independent copy", () => {
+      const steps: MonitorSteps = buildDefaultSteps();
+      const cloned: MonitorSteps = MonitorSteps.clone(steps);
+      expect(cloned).not.toBe(steps);
+      expect(cloned.data?.defaultMonitorStatusId?.toString()).toBe(
+        steps.data?.defaultMonitorStatusId?.toString(),
+      );
+
+      cloned.setDefaultMonitorStatusId(
+        new ObjectID("200000000000000000000009"),
+      );
+      // Original must be unaffected by the clone's mutation.
+      expect(steps.data?.defaultMonitorStatusId?.toString()).toBe(
+        "100000000000000000000001",
+      );
+    });
+
+    test("setDefaultMonitorStatusId mutates and returns this", () => {
+      const steps: MonitorSteps = new MonitorSteps();
+      const returned: MonitorSteps = steps.setDefaultMonitorStatusId(
+        new ObjectID("300000000000000000000000"),
+      );
+      expect(returned).toBe(steps);
+      expect(steps.data?.defaultMonitorStatusId?.toString()).toBe(
+        "300000000000000000000000",
+      );
+    });
+
+    test("setMonitorStepsInstanceArray replaces the step list", () => {
+      const steps: MonitorSteps = buildDefaultSteps();
+      const newStep: MonitorStep = new MonitorStep();
+      steps.setMonitorStepsInstanceArray([newStep]);
+      expect(steps.data?.monitorStepsInstanceArray).toHaveLength(1);
+      expect(steps.data?.monitorStepsInstanceArray[0]).toBe(newStep);
+    });
+  });
+});

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

@@ -120,7 +120,6 @@ describe("MonitorTypeHelper", () => {
       MonitorType.SSLCertificate,
       MonitorType.SyntheticMonitor,
       MonitorType.CustomJavaScriptCode,
-      MonitorType.NetworkDevice,
       MonitorType.DNS,
       MonitorType.DNSSEC,
       MonitorType.Domain,
@@ -134,6 +133,8 @@ describe("MonitorTypeHelper", () => {
       MonitorType.Logs,
       MonitorType.Server,
       MonitorType.IncomingRequest,
+      // Device-owned polling: the NetworkDevice resource polls itself.
+      MonitorType.NetworkDevice,
     ])("returns false for %s", (monitorType: MonitorType) => {
       expect(MonitorTypeHelper.isProbableMonitor(monitorType)).toBe(false);
     });
@@ -195,6 +196,63 @@ describe("MonitorTypeHelper", () => {
     });
   });
 
+  /*
+   * NetworkDevice is a pure alerting layer under device-owned polling: the
+   * NetworkDevice resource's assigned probe walks it on the device's own
+   * schedule, and the monitor is evaluated server-side against each walk.
+   * It must therefore never appear probeable (no MonitorProbe rows, no
+   * interval) while keeping its full monitor surface: criteria, graphs,
+   * documentation, creatability, and its place in the Network category.
+   */
+  describe("NetworkDevice under device-owned polling", () => {
+    test("is not probeable and has no interval", () => {
+      expect(
+        MonitorTypeHelper.isProbableMonitor(MonitorType.NetworkDevice),
+      ).toBe(false);
+      expect(
+        MonitorTypeHelper.doesMonitorTypeHaveInterval(
+          MonitorType.NetworkDevice,
+        ),
+      ).toBe(false);
+    });
+
+    test("still has criteria, graphs, and documentation", () => {
+      expect(
+        MonitorTypeHelper.doesMonitorTypeHaveCriteria(
+          MonitorType.NetworkDevice,
+        ),
+      ).toBe(true);
+      expect(
+        MonitorTypeHelper.doesMonitorTypeHaveGraphs(MonitorType.NetworkDevice),
+      ).toBe(true);
+      expect(
+        MonitorTypeHelper.doesMonitorTypeHaveDocumentation(
+          MonitorType.NetworkDevice,
+        ),
+      ).toBe(true);
+    });
+
+    test("is still an active (creatable) monitor type", () => {
+      expect(MonitorTypeHelper.getActiveMonitorTypes()).toContain(
+        MonitorType.NetworkDevice,
+      );
+    });
+
+    test("is still listed under the Network category", () => {
+      const networkCategory: MonitorTypeCategory | undefined =
+        MonitorTypeHelper.getMonitorTypeCategories().find(
+          (category: MonitorTypeCategory) => {
+            return category.label === "Network";
+          },
+        );
+
+      expect(networkCategory).toBeDefined();
+      expect(networkCategory?.monitorTypes).toContain(
+        MonitorType.NetworkDevice,
+      );
+    });
+  });
+
   describe("doesMonitorTypeHaveGraphs", () => {
     test("returns true for graphable types and false otherwise", () => {
       expect(

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

@@ -0,0 +1,97 @@
+import NetworkDeviceAlertPackUtil, {
+  NetworkDeviceAlertPackItem,
+} from "../../../Types/Monitor/SnmpMonitor/NetworkDeviceAlertPack";
+import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInstance";
+import ObjectID from "../../../Types/ObjectID";
+
+describe("NetworkDeviceAlertPackUtil.getPackItems", () => {
+  test("every pack item has a name, a description and at least one filter", () => {
+    const items: Array<NetworkDeviceAlertPackItem> =
+      NetworkDeviceAlertPackUtil.getPackItems();
+
+    expect(items.length).toBeGreaterThan(0);
+
+    for (const item of items) {
+      expect(item.name).toBeTruthy();
+      expect(item.description).toBeTruthy();
+      expect(item.filters.length).toBeGreaterThan(0);
+    }
+  });
+});
+
+describe("NetworkDeviceAlertPackUtil.buildCriteriaInstances", () => {
+  test("builds one enabled instance per pack item with unique ids", () => {
+    const instances: Array<MonitorCriteriaInstance> =
+      NetworkDeviceAlertPackUtil.buildCriteriaInstances();
+
+    expect(instances.length).toBe(
+      NetworkDeviceAlertPackUtil.getPackItems().length,
+    );
+
+    const ids: Set<string> = new Set<string>();
+    for (const instance of instances) {
+      expect(instance.data?.isEnabled).toBe(true);
+      expect(instance.data?.id).toBeTruthy();
+      ids.add(instance.data!.id);
+    }
+    expect(ids.size).toBe(instances.length);
+  });
+
+  test("with a downMonitorStatusId context, incident-creating criteria carry that status id", () => {
+    const downStatusId: ObjectID = ObjectID.generate();
+
+    const instances: Array<MonitorCriteriaInstance> =
+      NetworkDeviceAlertPackUtil.buildCriteriaInstances({
+        downMonitorStatusId: downStatusId,
+      });
+
+    for (const instance of instances) {
+      expect(instance.data?.monitorStatusId?.toString()).toBe(
+        downStatusId.toString(),
+      );
+
+      /*
+       * changeMonitorStatus must never be true while the target status id
+       * is missing — that combination produces a criteria that "changes"
+       * the monitor to no status at all.
+       */
+      if (instance.data?.changeMonitorStatus) {
+        expect(instance.data?.monitorStatusId).toBeTruthy();
+      }
+    }
+  });
+
+  test("without context, no instance claims to change monitor status to an undefined id", () => {
+    const instances: Array<MonitorCriteriaInstance> =
+      NetworkDeviceAlertPackUtil.buildCriteriaInstances();
+
+    for (const instance of instances) {
+      expect(instance.data?.monitorStatusId).toBeUndefined();
+      /*
+       * Legacy call sites (no context) still exist in principle; the pack
+       * must not produce a status change pointing at nothing.
+       */
+      expect(instance.data?.changeMonitorStatus).toBe(false);
+    }
+  });
+
+  test("only incident-creating pack items request a monitor status change", () => {
+    const downStatusId: ObjectID = ObjectID.generate();
+    const items: Array<NetworkDeviceAlertPackItem> =
+      NetworkDeviceAlertPackUtil.getPackItems();
+    const instances: Array<MonitorCriteriaInstance> =
+      NetworkDeviceAlertPackUtil.buildCriteriaInstances({
+        downMonitorStatusId: downStatusId,
+      });
+
+    for (let i: number = 0; i < items.length; i++) {
+      expect(instances[i]!.data?.createIncidents).toBe(
+        items[i]!.createIncidents,
+      );
+      expect(instances[i]!.data?.createAlerts).toBe(items[i]!.createAlerts);
+      expect(instances[i]!.data?.changeMonitorStatus).toBe(
+        items[i]!.createIncidents,
+      );
+    }
+  });
+});