@oneuptime/common 12.0.22 → 12.0.24

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

@@ -0,0 +1,272 @@
+import {
+  MAX_DEVICE_DESCRIPTION_LENGTH,
+  MAX_DEVICE_NAME_LENGTH,
+  buildDeviceName,
+  buildFallbackDeviceName,
+  buildNetworkDeviceFromDiscoveredHost,
+  DiscoveredDeviceScanSource,
+} from "../../../Utils/NetworkDiscovery/DiscoveredDeviceBuilder";
+import NetworkDevice from "../../../Models/DatabaseModels/NetworkDevice";
+import { DiscoveredNetworkDevice } from "../../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import NetworkDeviceMonitoringMethod from "../../../Types/NetworkDevice/NetworkDeviceMonitoringMethod";
+import ObjectID from "../../../Types/ObjectID";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * Contract under test — one discovered host maps to one NetworkDevice the
+ * SAME way everywhere. The builder is the shared recipe behind the
+ * dashboard's Review-dialog import and the server-side auto-import rule
+ * engine, so what these tests pin is the device both paths must agree on:
+ * which host field lands in which device column, which scan credentials ride
+ * along (and when they must NOT), and the length ceilings that keep a
+ * real-world 255-octet sysName from failing the create on the slug.
+ */
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "22222222-2222-4222-8222-222222222222",
+);
+const PROBE_ID: ObjectID = new ObjectID("11111111-1111-4111-8111-111111111111");
+
+function snmpHost(
+  overrides: Partial<DiscoveredNetworkDevice> = {},
+): DiscoveredNetworkDevice {
+  return {
+    ipAddress: "10.0.0.5",
+    sysName: "core-switch-01",
+    sysDescr: "Cisco IOS Software, C2960X",
+    ...overrides,
+  };
+}
+
+// A scan carrying every credential column the builder knows how to copy.
+function fullScanSource(): DiscoveredDeviceScanSource {
+  return {
+    probeId: PROBE_ID,
+    snmpVersion: "V3",
+    snmpCommunityString: "public",
+    snmpPort: 1161,
+    snmpV3SecurityLevel: "authPriv",
+    snmpV3Username: "observer",
+    snmpV3AuthProtocol: "SHA",
+    snmpV3AuthKey: "auth-key-value",
+    snmpV3PrivProtocol: "AES",
+    snmpV3PrivKey: "priv-key-value",
+  };
+}
+
+function build(data: {
+  host?: DiscoveredNetworkDevice | undefined;
+  scan?: DiscoveredDeviceScanSource | undefined;
+  name?: string | undefined;
+}): NetworkDevice {
+  return buildNetworkDeviceFromDiscoveredHost({
+    projectId: PROJECT_ID,
+    host: data.host || snmpHost(),
+    scan: data.scan || fullScanSource(),
+    name: data.name,
+  });
+}
+
+describe("buildNetworkDeviceFromDiscoveredHost - vendor template auto-apply flag", () => {
+  it("is off unless the caller asks for it", () => {
+    expect(build({}).autoApplyVendorHealthTemplate).toBeUndefined();
+  });
+
+  it("is set on an SNMP host when the caller asks (the rule engine does)", () => {
+    const device: NetworkDevice = buildNetworkDeviceFromDiscoveredHost({
+      projectId: PROJECT_ID,
+      host: snmpHost(),
+      scan: fullScanSource(),
+      autoApplyVendorHealthTemplate: true,
+    });
+
+    expect(device.autoApplyVendorHealthTemplate).toBe(true);
+  });
+
+  /*
+   * A ping-only host is never SNMP-polled, so no poll can ever fingerprint
+   * its vendor — the flag would be a dead toggle that reads as a promise.
+   */
+  it("stays off on a ping-only host even when requested", () => {
+    const device: NetworkDevice = buildNetworkDeviceFromDiscoveredHost({
+      projectId: PROJECT_ID,
+      host: snmpHost({ snmpReachable: false }),
+      scan: fullScanSource(),
+      autoApplyVendorHealthTemplate: true,
+    });
+
+    expect(device.autoApplyVendorHealthTemplate).toBeUndefined();
+  });
+});
+
+describe("buildNetworkDeviceFromDiscoveredHost - SNMP host", () => {
+  it("maps identity fields: sysName to name, address to hostname, sysDescr to description", () => {
+    const device: NetworkDevice = build({});
+
+    expect(device.projectId?.toString()).toBe(PROJECT_ID.toString());
+    expect(device.name).toBe("core-switch-01");
+    // The address is both the hostname and the registered-host dedup key.
+    expect(device.hostname).toBe("10.0.0.5");
+    expect(device.description).toBe("Cisco IOS Software, C2960X");
+    expect(device.monitoringMethod).toBe(NetworkDeviceMonitoringMethod.Snmp);
+  });
+
+  /*
+   * Every credential the scan swept with must land on the device, or the
+   * imported device can never poll. The v3 block matters most: a v3 scan
+   * that imported as a credential-less device would sit unreachable with no
+   * error anywhere.
+   */
+  it("copies the probe and every SNMP credential from the scan source", () => {
+    const device: NetworkDevice = build({});
+
+    expect(device.probeId?.toString()).toBe(PROBE_ID.toString());
+    expect(device.snmpVersion).toBe("V3");
+    expect(device.snmpCommunityString).toBe("public");
+    expect(device.snmpPort).toBe(1161);
+    expect(device.snmpV3SecurityLevel).toBe("authPriv");
+    expect(device.snmpV3Username).toBe("observer");
+    expect(device.snmpV3AuthProtocol).toBe("SHA");
+    expect(device.snmpV3AuthKey).toBe("auth-key-value");
+    expect(device.snmpV3PrivProtocol).toBe("AES");
+    expect(device.snmpV3PrivKey).toBe("priv-key-value");
+  });
+
+  /*
+   * The scan row may hold a serialized id rather than an ObjectID instance
+   * (the rule engine selects its scan itself); the builder re-wraps rather
+   * than trusting the shape.
+   */
+  it("re-wraps the probe id so a serialized id still becomes an ObjectID", () => {
+    const device: NetworkDevice = build({
+      scan: {
+        ...fullScanSource(),
+        probeId: PROBE_ID.toString() as unknown as ObjectID,
+      },
+    });
+
+    expect(device.probeId).toBeInstanceOf(ObjectID);
+    expect(device.probeId?.toString()).toBe(PROBE_ID.toString());
+  });
+});
+
+describe("buildNetworkDeviceFromDiscoveredHost - ping-only host", () => {
+  /*
+   * A ping-only host becomes a monitor-backed device: recorded so it can
+   * belong to a site and appear on the topology map, with binding a monitor
+   * to it a separate deliberate step. Credentials it never answered to must
+   * not ride along.
+   */
+  it("builds a monitor-backed device with polling off and no credentials", () => {
+    const device: NetworkDevice = build({
+      host: snmpHost({ snmpReachable: false, sysName: undefined }),
+    });
+
+    expect(device.monitoringMethod).toBe(NetworkDeviceMonitoringMethod.Monitor);
+    expect(device.isPollingEnabled).toBe(false);
+    expect(device.probeId).toBeUndefined();
+    expect(device.snmpVersion).toBeUndefined();
+    expect(device.snmpCommunityString).toBeUndefined();
+    expect(device.snmpPort).toBeUndefined();
+    expect(device.snmpV3SecurityLevel).toBeUndefined();
+    expect(device.snmpV3Username).toBeUndefined();
+    expect(device.snmpV3AuthProtocol).toBeUndefined();
+    expect(device.snmpV3AuthKey).toBeUndefined();
+    expect(device.snmpV3PrivProtocol).toBeUndefined();
+    expect(device.snmpV3PrivKey).toBeUndefined();
+  });
+});
+
+describe("buildDeviceName", () => {
+  it("prefers the sysName", () => {
+    expect(buildDeviceName(snmpHost())).toBe("core-switch-01");
+  });
+
+  // A ping-only host has no SNMP identity; the address is all there is.
+  it("falls back to the address when sysName is missing", () => {
+    expect(buildDeviceName(snmpHost({ sysName: undefined }))).toBe("10.0.0.5");
+  });
+
+  it("falls back to the address when sysName is whitespace", () => {
+    expect(buildDeviceName(snmpHost({ sysName: "   " }))).toBe("10.0.0.5");
+  });
+
+  /*
+   * SNMP sysName is a DisplayString of up to 255 octets, so over-long names
+   * are routine on real gear — and the create path THROWS on an over-long
+   * name (via the slug ceiling) rather than truncating, so the clamp has to
+   * happen here.
+   */
+  it("clamps a 255-character sysName to MAX_DEVICE_NAME_LENGTH", () => {
+    const longSysName: string = "x".repeat(255);
+    const name: string = buildDeviceName(snmpHost({ sysName: longSysName }));
+
+    expect(name.length).toBe(MAX_DEVICE_NAME_LENGTH);
+    expect(name).toBe(longSysName.substring(0, MAX_DEVICE_NAME_LENGTH));
+  });
+});
+
+describe("buildFallbackDeviceName", () => {
+  it("appends the address that tells name-twins apart", () => {
+    expect(buildFallbackDeviceName(snmpHost())).toBe(
+      "core-switch-01 (10.0.0.5)",
+    );
+  });
+
+  /*
+   * The collision fallback must fit under the SAME ceiling as the first
+   * attempt: the widest possible suffix is " (255.255.255.255)", so the base
+   * name is cut down first rather than the composed string overflowing into
+   * the very slug-length failure the ceiling exists to avoid.
+   */
+  it("keeps the composed name within MAX_DEVICE_NAME_LENGTH at the widest address", () => {
+    const name: string = buildFallbackDeviceName(
+      snmpHost({
+        sysName: "y".repeat(255),
+        ipAddress: "255.255.255.255",
+      }),
+    );
+
+    expect(name.length).toBeLessThanOrEqual(MAX_DEVICE_NAME_LENGTH);
+    expect(name.endsWith(" (255.255.255.255)")).toBe(true);
+  });
+});
+
+describe("description clamping", () => {
+  it("clamps an over-long sysDescr to MAX_DEVICE_DESCRIPTION_LENGTH", () => {
+    const longSysDescr: string = "d".repeat(700);
+    const device: NetworkDevice = build({
+      host: snmpHost({ sysDescr: longSysDescr }),
+    });
+
+    expect(device.description?.length).toBe(MAX_DEVICE_DESCRIPTION_LENGTH);
+    expect(device.description).toBe(
+      longSysDescr.substring(0, MAX_DEVICE_DESCRIPTION_LENGTH),
+    );
+  });
+
+  it("sets no description when the host has no sysDescr", () => {
+    const device: NetworkDevice = build({
+      host: snmpHost({ sysDescr: undefined }),
+    });
+
+    expect(device.description).toBeUndefined();
+  });
+});
+
+describe("the name override", () => {
+  /*
+   * The caller supplies the name so the collision retry can rebuild the SAME
+   * device under the fallback name without re-deciding anything else — the
+   * override must therefore be taken verbatim.
+   */
+  it("uses a supplied name verbatim instead of deriving one", () => {
+    const device: NetworkDevice = build({
+      name: "core-switch-01 (10.0.0.5)",
+    });
+
+    expect(device.name).toBe("core-switch-01 (10.0.0.5)");
+    // Everything else is still derived from the host as usual.
+    expect(device.hostname).toBe("10.0.0.5");
+  });
+});

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