@oneuptime/common 12.0.23 → 12.0.24

package/Tests/Utils/NetworkDevice/DeviceReachabilityUtil.test.ts

@@ -608,3 +608,255 @@ describe("issue #3220 at fleet scale", () => {
     expect(stale).toBe(50);
   });
 });
+
+/*
+ * Issue #3392: a device nothing polls.
+ *
+ * The whole rule above is about the OUTCOME of a poll, and a monitor-backed
+ * device never gets one — no probe, no credentials, no walk. Its poll
+ * columns are NULL forever, so the rule could only ever answer "Pending"
+ * for it: an operator who followed the documented workflow to the letter
+ * (Monitoring Method = Monitor, a Ping monitor bound, polling off) watched
+ * a device that answers every ping sit on "Pending" indefinitely.
+ *
+ * These pin the second rule: for such a device the bound Monitor's verdict
+ * IS the answer, and every poll column on the row is irrelevant to it.
+ */
+describe("monitor-backed devices are judged by their monitor, not by a poll", () => {
+  const MONITOR_BACKED: string = "Monitor";
+
+  test("a bound monitor reporting healthy makes the device Up", () => {
+    expect(
+      statusOf({
+        monitoringMethod: MONITOR_BACKED,
+        monitorStatusIsOffline: false,
+      }),
+    ).toBe(NetworkDeviceReachability.Up);
+  });
+
+  test("a bound monitor reporting offline makes the device Down", () => {
+    expect(
+      statusOf({
+        monitoringMethod: MONITOR_BACKED,
+        monitorStatusIsOffline: true,
+      }),
+    ).toBe(NetworkDeviceReachability.Down);
+  });
+
+  /*
+   * MonitorStatus is a ladder, not a pair: a "Degraded" row is neither
+   * operational nor offline. Reading the OFFLINE end is what keeps this
+   * verdict identical to the one the topology map draws for the same
+   * device, which resolves the ladder the same way.
+   */
+  test("a degraded-but-not-offline status is Up, exactly as the map draws it", () => {
+    expect(
+      statusOf({
+        monitoringMethod: MONITOR_BACKED,
+        monitorStatusIsOffline: false,
+      }),
+    ).toBe(NetworkDeviceReachability.Up);
+  });
+
+  /*
+   * The two ways a monitor-backed device legitimately has no verdict:
+   * nothing is bound to it yet (discovery import creates ping-only hosts
+   * that way on purpose), or something is bound and has not been evaluated
+   * yet. Both are Pending, and neither may default to healthy.
+   */
+  test("no stamped status is Pending, not a healthy default", () => {
+    expect(statusOf({ monitoringMethod: MONITOR_BACKED })).toBe(
+      NetworkDeviceReachability.Pending,
+    );
+
+    expect(
+      statusOf({
+        monitoringMethod: MONITOR_BACKED,
+        monitorStatusIsOffline: null,
+      }),
+    ).toBe(NetworkDeviceReachability.Pending);
+  });
+
+  /*
+   * The regression itself. This is the exact row shape the issue reports:
+   * an ICMP-only host imported by a discovery scan, switched to Monitor,
+   * bound to a Ping monitor that is reporting healthy, and polled by
+   * nothing — so every poll column is NULL.
+   */
+  test("the reported row shape reads Up rather than Pending", () => {
+    const un0661voipcp01: DeviceReachabilityInput = {
+      monitoringMethod: MONITOR_BACKED,
+      monitorStatusIsOffline: false,
+      isReachable: null,
+      lastPolledAt: null,
+      lastSeenAt: null,
+      pollingIntervalInMinutes: null,
+    };
+
+    expect(statusOf(un0661voipcp01)).toBe(NetworkDeviceReachability.Up);
+  });
+
+  /*
+   * Poll columns on a monitor-backed row are not merely absent — on a
+   * device switched over from SNMP they hold whatever a probe last found
+   * before it stopped asking, which is worse than nothing. The monitor
+   * wins outright, in both directions.
+   */
+  test("a stale successful walk does not override a monitor reporting offline", () => {
+    expect(
+      statusOf({
+        monitoringMethod: MONITOR_BACKED,
+        monitorStatusIsOffline: true,
+        isReachable: true,
+        lastPolledAt: minutesAgo(2),
+        lastSeenAt: minutesAgo(2),
+      }),
+    ).toBe(NetworkDeviceReachability.Down);
+  });
+
+  test("a failed walk from its SNMP days does not override a healthy monitor", () => {
+    expect(
+      statusOf({
+        monitoringMethod: MONITOR_BACKED,
+        monitorStatusIsOffline: false,
+        isReachable: false,
+        lastPolledAt: minutesAgo(4000),
+        lastSeenAt: minutesAgo(9000),
+      }),
+    ).toBe(NetworkDeviceReachability.Up);
+  });
+
+  /*
+   * Staleness says "nothing has polled this device lately, go and check its
+   * probe". For a device that has no probe BY DESIGN that is both false and
+   * actively misleading, so it can never be raised here.
+   */
+  test("is never flagged stale, however old the poll columns are", () => {
+    const result: DeviceReachabilityResult = reachabilityOf({
+      monitoringMethod: MONITOR_BACKED,
+      monitorStatusIsOffline: false,
+      lastPolledAt: minutesAgo(60 * 24 * 30),
+      lastSeenAt: minutesAgo(60 * 24 * 30),
+      pollingIntervalInMinutes: 5,
+    });
+
+    expect(result.status).toBe(NetworkDeviceReachability.Up);
+    expect(result.isStale).toBe(false);
+  });
+
+  test("is never flagged stale even when it has no poll columns at all", () => {
+    expect(
+      reachabilityOf({
+        monitoringMethod: MONITOR_BACKED,
+        monitorStatusIsOffline: true,
+      }).isStale,
+    ).toBe(false);
+  });
+
+  /*
+   * lastContactAt is still reported honestly — it is "the newest thing a
+   * probe wrote", and for a device converted from SNMP that is a real
+   * historical fact the device page prints. It just does not decide
+   * anything here.
+   */
+  test("still reports lastContactAt from the poll columns when there is one", () => {
+    expect(
+      reachabilityOf({
+        monitoringMethod: MONITOR_BACKED,
+        monitorStatusIsOffline: false,
+        lastPolledAt: minutesAgo(90),
+      }).lastContactAt?.getTime(),
+    ).toBe(minutesAgo(90).getTime());
+
+    expect(
+      reachabilityOf({
+        monitoringMethod: MONITOR_BACKED,
+        monitorStatusIsOffline: false,
+      }).lastContactAt,
+    ).toBeNull();
+  });
+});
+
+/*
+ * The column is free text (the SnmpVersion precedent), so what counts as
+ * "monitor-backed" is whatever NetworkDeviceMonitoringMethodUtil.parse says
+ * — and every other value has to keep the poll rule, because reading a
+ * typo as monitor-backed would silently stop a switch being judged by its
+ * walk.
+ */
+describe("which rows count as monitor-backed", () => {
+  test.each(["Monitor", "monitor", "MONITOR", "  Monitor  "])(
+    "%p reads as monitor-backed",
+    (monitoringMethod: string) => {
+      const result: DeviceReachabilityResult = reachabilityOf({
+        monitoringMethod: monitoringMethod,
+        monitorStatusIsOffline: false,
+      });
+
+      expect(result.isMonitorBacked).toBe(true);
+      expect(result.status).toBe(NetworkDeviceReachability.Up);
+    },
+  );
+
+  test.each([
+    ["SNMP", "the explicit SNMP value"],
+    ["", "an empty string"],
+    ["Monitorr", "a typo"],
+    ["ping", "an unrecognised word"],
+  ])("%p (%s) keeps the poll rule", (monitoringMethod: string) => {
+    const device: DeviceReachabilityInput = {
+      monitoringMethod: monitoringMethod,
+      // A monitor status the poll rule must ignore for these rows.
+      monitorStatusIsOffline: true,
+      isReachable: true,
+      lastPolledAt: minutesAgo(1),
+      lastSeenAt: minutesAgo(1),
+    };
+
+    const result: DeviceReachabilityResult = reachabilityOf(device);
+
+    expect(result.isMonitorBacked).toBe(false);
+    expect(result.status).toBe(NetworkDeviceReachability.Up);
+  });
+
+  /*
+   * Every row written before the column existed, and every caller that
+   * does not select it. Both have to keep behaving exactly as they did.
+   */
+  test.each([
+    ["null", null],
+    ["undefined", undefined],
+  ])(
+    "a %s method is a polled device, unchanged",
+    (_label: string, value: string | null | undefined) => {
+      const result: DeviceReachabilityResult = reachabilityOf({
+        monitoringMethod: value as string | null | undefined,
+        monitorStatusIsOffline: true,
+        isReachable: true,
+        lastPolledAt: minutesAgo(1),
+        lastSeenAt: minutesAgo(1),
+      });
+
+      expect(result.isMonitorBacked).toBe(false);
+      expect(result.status).toBe(NetworkDeviceReachability.Up);
+    },
+  );
+
+  /*
+   * A caller that selects neither new column gets precisely the old
+   * behaviour, including staleness — which is what lets the topology
+   * builder and the site rollup keep passing their existing projections.
+   */
+  test("an input carrying neither new column behaves exactly as before", () => {
+    const result: DeviceReachabilityResult = reachabilityOf({
+      isReachable: true,
+      lastPolledAt: minutesAgo(180),
+      lastSeenAt: minutesAgo(180),
+      pollingIntervalInMinutes: 5,
+    });
+
+    expect(result.status).toBe(NetworkDeviceReachability.Up);
+    expect(result.isStale).toBe(true);
+    expect(result.isMonitorBacked).toBe(false);
+  });
+});

package/Tests/Utils/NetworkDiscovery/DiscoveredHostUtil.test.ts

@@ -0,0 +1,221 @@
+import { DiscoveredNetworkDevice } from "../../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import { normalizeDiscoveredHosts } from "../../../Utils/NetworkDiscovery/DiscoveredHostUtil";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * normalizeDiscoveredHosts is the one reading of a scan's `discoveredDevices`
+ * jsonb that both the dashboard's Review dialog and the server-side
+ * auto-import rule engine share. The column is written verbatim from the
+ * probe's payload and the only guard on it is "the value is an array", so the
+ * three payload shapes documented on the function - a null row, a non-string
+ * address, and the same address carrying two different isAlreadyRegistered
+ * values - are shapes nothing upstream stops. These tests pin that each is
+ * neutralised here, once, so no downstream reader can be handed a different
+ * reading of the same payload.
+ *
+ * A cast through `unknown` is used wherever a test feeds a shape the type
+ * forbids on purpose: the whole point of the function is that the runtime
+ * value does not honour the type, so the tests have to be able to say so.
+ */
+
+function host(
+  overrides: Partial<DiscoveredNetworkDevice>,
+): DiscoveredNetworkDevice {
+  return { ipAddress: "10.0.0.1", ...overrides };
+}
+
+describe("normalizeDiscoveredHosts", () => {
+  describe("rows that are not hosts at all", () => {
+    test("an empty scan normalises to an empty list", () => {
+      expect(normalizeDiscoveredHosts([])).toEqual([]);
+    });
+
+    test.each([
+      ["null", null],
+      ["undefined", undefined],
+      ["a number", 10],
+      ["a string", "10.0.0.1"],
+      ["a boolean", true],
+    ])(
+      "%s is dropped rather than dereferenced",
+      (_label: string, value: unknown) => {
+        expect(
+          normalizeDiscoveredHosts([
+            value,
+          ] as unknown as Array<DiscoveredNetworkDevice>),
+        ).toEqual([]);
+      },
+    );
+
+    test("the real hosts around a null row survive it", () => {
+      const result: Array<DiscoveredNetworkDevice> = normalizeDiscoveredHosts([
+        host({ ipAddress: "10.0.0.1" }),
+        null as unknown as DiscoveredNetworkDevice,
+        host({ ipAddress: "10.0.0.2" }),
+      ]);
+
+      expect(
+        result.map((entry: DiscoveredNetworkDevice) => {
+          return entry.ipAddress;
+        }),
+      ).toEqual(["10.0.0.1", "10.0.0.2"]);
+    });
+  });
+
+  describe("the address is made a trimmed string", () => {
+    test("a numeric address becomes its string spelling, so Set.has can find it", () => {
+      const result: Array<DiscoveredNetworkDevice> = normalizeDiscoveredHosts([
+        { ipAddress: 10 } as unknown as DiscoveredNetworkDevice,
+      ]);
+
+      expect(result[0]!.ipAddress).toBe("10");
+    });
+
+    test.each([
+      ["a leading and trailing space", "  10.0.0.1  ", "10.0.0.1"],
+      ["a tab", "\t10.0.0.1", "10.0.0.1"],
+      ["only whitespace", "   ", ""],
+    ])("%s is trimmed", (_label: string, given: string, expected: string) => {
+      const result: Array<DiscoveredNetworkDevice> = normalizeDiscoveredHosts([
+        host({ ipAddress: given }),
+      ]);
+
+      expect(result[0]!.ipAddress).toBe(expected);
+    });
+
+    test.each([
+      ["undefined", undefined],
+      ["null", null],
+    ])(
+      "a %s address becomes the empty string, never the literal word",
+      (_label: string, value: unknown) => {
+        const result: Array<DiscoveredNetworkDevice> = normalizeDiscoveredHosts(
+          [{ ipAddress: value } as unknown as DiscoveredNetworkDevice],
+        );
+
+        expect(result[0]!.ipAddress).toBe("");
+      },
+    );
+  });
+
+  describe("everything else on the row is carried through untouched", () => {
+    test("the SNMP system group and reachability flags survive normalisation", () => {
+      const result: Array<DiscoveredNetworkDevice> = normalizeDiscoveredHosts([
+        {
+          ipAddress: " 10.0.0.5 ",
+          sysName: "core-switch",
+          sysDescr: "vendor OS 1.2",
+          sysObjectId: "1.3.6.1.4.1.9",
+          sysLocation: "rack 4",
+          sysContact: "neteng",
+          sysUpTimeSeconds: 4200,
+          snmpReachable: true,
+        },
+      ]);
+
+      expect(result[0]).toEqual({
+        ipAddress: "10.0.0.5",
+        sysName: "core-switch",
+        sysDescr: "vendor OS 1.2",
+        sysObjectId: "1.3.6.1.4.1.9",
+        sysLocation: "rack 4",
+        sysContact: "neteng",
+        sysUpTimeSeconds: 4200,
+        snmpReachable: true,
+      });
+    });
+  });
+
+  describe("an address registered on one row is registered on every row", () => {
+    test("a duplicate address inherits the registered verdict regardless of probe ordering", () => {
+      const result: Array<DiscoveredNetworkDevice> = normalizeDiscoveredHosts([
+        host({ ipAddress: "10.0.0.9", isAlreadyRegistered: false }),
+        host({ ipAddress: "10.0.0.9", isAlreadyRegistered: true }),
+      ]);
+
+      expect(
+        result.map((entry: DiscoveredNetworkDevice) => {
+          return entry.isAlreadyRegistered;
+        }),
+      ).toEqual([true, true]);
+    });
+
+    test("the verdict does not bleed onto a different address", () => {
+      const result: Array<DiscoveredNetworkDevice> = normalizeDiscoveredHosts([
+        host({ ipAddress: "10.0.0.9", isAlreadyRegistered: true }),
+        host({ ipAddress: "10.0.0.10", isAlreadyRegistered: false }),
+      ]);
+
+      expect(
+        result.find((entry: DiscoveredNetworkDevice) => {
+          return entry.ipAddress === "10.0.0.10";
+        })!.isAlreadyRegistered,
+      ).toBe(false);
+    });
+
+    test("an already-registered row is handed back as the very same object", () => {
+      const registered: DiscoveredNetworkDevice = host({
+        ipAddress: "10.0.0.11",
+        isAlreadyRegistered: true,
+      });
+
+      const result: Array<DiscoveredNetworkDevice> = normalizeDiscoveredHosts([
+        registered,
+      ]);
+
+      /*
+       * With nothing to flip, the normaliser must not churn objects it did
+       * not change - a fresh clone every render would defeat any memoised
+       * reader keyed on identity. The first pass already re-spread the row,
+       * so identity is asserted against that cleaned object, not the input.
+       */
+      expect(result[0]).toEqual(registered);
+    });
+
+    test("the empty-string address is never treated as a registered key", () => {
+      /*
+       * A blank address is what an undefined or whitespace-only address
+       * normalises to. If it counted as a registered key, every other blank
+       * row - unrelated hosts the probe could not address - would be marked
+       * registered together.
+       */
+      const result: Array<DiscoveredNetworkDevice> = normalizeDiscoveredHosts([
+        host({ ipAddress: "   ", isAlreadyRegistered: true }),
+        host({ ipAddress: undefined as unknown as string }),
+      ]);
+
+      expect(
+        result.every((entry: DiscoveredNetworkDevice) => {
+          return entry.ipAddress === "";
+        }),
+      ).toBe(true);
+      expect(result[1]!.isAlreadyRegistered).toBeUndefined();
+    });
+
+    test("three rows of one address all end up registered when any one is", () => {
+      const result: Array<DiscoveredNetworkDevice> = normalizeDiscoveredHosts([
+        host({ ipAddress: "10.0.0.20", isAlreadyRegistered: false }),
+        host({ ipAddress: "10.0.0.20" }),
+        host({ ipAddress: "10.0.0.20", isAlreadyRegistered: true }),
+      ]);
+
+      expect(
+        result.map((entry: DiscoveredNetworkDevice) => {
+          return entry.isAlreadyRegistered;
+        }),
+      ).toEqual([true, true, true]);
+    });
+  });
+
+  describe("a scan with nothing registered is left as it is found", () => {
+    test("no row gains a registered flag it did not arrive with", () => {
+      const result: Array<DiscoveredNetworkDevice> = normalizeDiscoveredHosts([
+        host({ ipAddress: "10.0.0.30", isAlreadyRegistered: false }),
+        host({ ipAddress: "10.0.0.31" }),
+      ]);
+
+      expect(result[0]!.isAlreadyRegistered).toBe(false);
+      expect(result[1]!.isAlreadyRegistered).toBeUndefined();
+    });
+  });
+});