@oneuptime/common 12.0.24 → 12.0.26

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

@@ -320,6 +320,65 @@ describe("tallies", () => {
     });
   });
 
+  /*
+   * The count defaults to one, and every caller written before the rollups
+   * moved into the database depends on that — the topology filter and every
+   * other place that still walks devices one at a time calls this with two
+   * arguments. A default that stopped being 1 would rescale those tallies
+   * without any of them mentioning a count at all.
+   */
+  test("the count defaults to one", () => {
+    const counts: DeviceHealthCounts = emptyDeviceHealthCounts();
+    addDeviceHealth(counts, "healthy");
+    expect(counts).toEqual({
+      total: 1,
+      down: 0,
+      degraded: 0,
+      healthy: 1,
+      unknown: 0,
+    });
+  });
+
+  /*
+   * And the reason the parameter exists: a bucket arrives already standing
+   * for a hundred devices, so one call has to move the tally by the whole
+   * count — total and exactly one state, exactly as a hundred single calls
+   * would have.
+   */
+  test("a count above one moves total and exactly one state by that much", () => {
+    const counts: DeviceHealthCounts = emptyDeviceHealthCounts();
+    addDeviceHealth(counts, "down", 37);
+    expect(counts).toEqual({
+      total: 37,
+      down: 37,
+      degraded: 0,
+      healthy: 0,
+      unknown: 0,
+    });
+    addDeviceHealth(counts, "healthy", 41169);
+    expect(counts).toEqual({
+      total: 41206,
+      down: 37,
+      degraded: 0,
+      healthy: 41169,
+      unknown: 0,
+    });
+    expect(
+      counts.down + counts.degraded + counts.healthy + counts.unknown,
+    ).toBe(counts.total);
+  });
+
+  /*
+   * A grouped aggregate over a filtered set can answer with a combination
+   * and a count of zero. Treating that as one device would invent a switch
+   * nobody owns — and a "down" one at that.
+   */
+  test("a count of zero is a no-op, not an increment", () => {
+    const counts: DeviceHealthCounts = emptyDeviceHealthCounts();
+    addDeviceHealth(counts, "unknown", 0);
+    expect(counts).toEqual(emptyDeviceHealthCounts());
+  });
+
   test("the four states always sum to the total", () => {
     const counts: DeviceHealthCounts = emptyDeviceHealthCounts();
     const states: Array<NetworkDeviceHealthState> = [

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

@@ -10,6 +10,7 @@ import NetworkDevice from "../../../Models/DatabaseModels/NetworkDevice";
 import { DiscoveredNetworkDevice } from "../../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
 import NetworkDeviceMonitoringMethod from "../../../Types/NetworkDevice/NetworkDeviceMonitoringMethod";
 import ObjectID from "../../../Types/ObjectID";
+import { DiscoveryScanSnmpConfig } from "../../../Utils/NetworkDiscovery/SnmpScanConfigUtil";
 import { describe, expect, it } from "@jest/globals";
 
 /*
@@ -20,6 +21,14 @@ import { describe, expect, it } from "@jest/globals";
  * 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.
+ *
+ * Since OneUptime issue #3458 a scan carries an ORDERED LIST of credential
+ * sets rather than one, the probe stamps each discovered host with the id of
+ * the set that answered it, and "which scan credentials ride along" therefore
+ * has a per-host answer. That is the guarantee most of the new cases below
+ * pin, because getting it wrong is invisible: the device is created, it
+ * carries a perfectly valid-looking community string belonging to a DIFFERENT
+ * config, and it simply never polls.
  */
 
 const PROJECT_ID: ObjectID = new ObjectID(
@@ -38,7 +47,16 @@ function snmpHost(
   };
 }
 
-// A scan carrying every credential column the builder knows how to copy.
+/*
+ * A LEGACY scan: every credential column the builder knows how to copy, in
+ * the flattened columns, and NO `snmpConfigs` list.
+ *
+ * It deliberately stays that shape. Every scan created before issue #3458 is
+ * stored exactly like this, as is every scan written by an API client that
+ * only knows the old fields, and their imports must keep producing the device
+ * they always did — which is what makes this fixture the back-compat half of
+ * the suite. The multi-config half is `multiConfigScanSource()` below.
+ */
 function fullScanSource(): DiscoveredDeviceScanSource {
   return {
     probeId: PROBE_ID,
@@ -54,6 +72,103 @@ function fullScanSource(): DiscoveredDeviceScanSource {
   };
 }
 
+/*
+ * The three credential sets a mixed subnet realistically needs — v2c access
+ * switches, a v3 core, a vendor block on a community of its own — with values
+ * chosen so that NO two configs share a single credential. Any leakage
+ * between them therefore shows up as a wrong value rather than as a coincidence
+ * that still passes.
+ *
+ * The ids are opaque literals because that is how they are really used: minted
+ * by the form into the scan's jsonb, copied onto a discovered host by the
+ * probe, and looked up again by the importer in another process, possibly days
+ * later. Nothing may treat them as positions.
+ */
+const ACCESS_CONFIG_ID: string = "access-switches-v2c";
+const CORE_CONFIG_ID: string = "core-routers-v3";
+const PRINTER_CONFIG_ID: string = "printers-v1";
+
+const ACCESS_CONFIG: DiscoveryScanSnmpConfig = {
+  id: ACCESS_CONFIG_ID,
+  name: "Access switches",
+  snmpVersion: "V2c",
+  snmpCommunityString: "access-community",
+  snmpPort: 161,
+};
+
+const CORE_CONFIG: DiscoveryScanSnmpConfig = {
+  id: CORE_CONFIG_ID,
+  name: "Core routers",
+  snmpVersion: "V3",
+  snmpPort: 1161,
+  snmpV3SecurityLevel: "authPriv",
+  snmpV3Username: "core-observer",
+  snmpV3AuthProtocol: "SHA",
+  snmpV3AuthKey: "core-auth-key",
+  snmpV3PrivProtocol: "AES",
+  snmpV3PrivKey: "core-priv-key",
+};
+
+const PRINTER_CONFIG: DiscoveryScanSnmpConfig = {
+  id: PRINTER_CONFIG_ID,
+  name: "Printers - factory default",
+  snmpVersion: "V1",
+  snmpCommunityString: "printer-community",
+  snmpPort: 3161,
+};
+
+/*
+ * A scan configured the NEW way, in the exact shape one is actually stored:
+ * the ordered list AND the flattened mirror of its FIRST entry.
+ *
+ * The mirror is not decoration. NetworkDeviceDiscoveryScanService writes it on
+ * every save so that a probe deployed a version behind — one that has never
+ * heard of `snmpConfigs` — still has credentials to sweep with. It is also
+ * what makes these tests sharp: a builder that read the flattened columns (or
+ * simply `snmpConfigs[0]`) instead of the host's own config would still
+ * produce a fully credentialed device, so only a fixture carrying BOTH halves
+ * can tell the correct device from the plausible one.
+ */
+function multiConfigScanSource(
+  configs: Array<DiscoveryScanSnmpConfig> = [
+    ACCESS_CONFIG,
+    CORE_CONFIG,
+    PRINTER_CONFIG,
+  ],
+): DiscoveredDeviceScanSource {
+  const first: DiscoveryScanSnmpConfig = configs[0]!;
+
+  return {
+    probeId: PROBE_ID,
+    snmpConfigs: configs,
+    snmpVersion: first.snmpVersion,
+    snmpCommunityString: first.snmpCommunityString,
+    snmpPort: first.snmpPort,
+    snmpV3SecurityLevel: first.snmpV3SecurityLevel,
+    snmpV3Username: first.snmpV3Username,
+    snmpV3AuthProtocol: first.snmpV3AuthProtocol,
+    snmpV3AuthKey: first.snmpV3AuthKey,
+    snmpV3PrivProtocol: first.snmpV3PrivProtocol,
+    snmpV3PrivKey: first.snmpV3PrivKey,
+  };
+}
+
+/*
+ * Asserts a device carries NONE of the SNMP v3 block. Used where the point is
+ * that a v2c config answered on a scan whose OTHER config is v3: the six v3
+ * columns are the ones that would arrive from the flattened mirror if the
+ * per-host lookup were skipped, and listing them one by one at every call site
+ * would bury the assertion that matters.
+ */
+function expectNoV3Credentials(device: NetworkDevice): void {
+  expect(device.snmpV3SecurityLevel).toBeUndefined();
+  expect(device.snmpV3Username).toBeUndefined();
+  expect(device.snmpV3AuthProtocol).toBeUndefined();
+  expect(device.snmpV3AuthKey).toBeUndefined();
+  expect(device.snmpV3PrivProtocol).toBeUndefined();
+  expect(device.snmpV3PrivKey).toBeUndefined();
+}
+
 function build(data: {
   host?: DiscoveredNetworkDevice | undefined;
   scan?: DiscoveredDeviceScanSource | undefined;
@@ -116,10 +231,19 @@ describe("buildNetworkDeviceFromDiscoveredHost - SNMP host", () => {
    * 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.
+   *
+   * THE BACK-COMPAT GUARANTEE. This scan has no `snmpConfigs` — its flattened
+   * columns ARE its one credential set, which is the state every scan created
+   * before issue #3458 is in. Resolving a host's credentials through the new
+   * list must therefore still land on exactly these values, or the feature
+   * silently un-credentials the entire existing estate on its first import.
    */
-  it("copies the probe and every SNMP credential from the scan source", () => {
+  it("copies the probe and every SNMP credential from a legacy scan's flattened columns", () => {
     const device: NetworkDevice = build({});
 
+    // Anti-vacuity: this case is only the legacy one while there is no list.
+    expect(fullScanSource().snmpConfigs).toBeUndefined();
+
     expect(device.probeId?.toString()).toBe(PROBE_ID.toString());
     expect(device.snmpVersion).toBe("V3");
     expect(device.snmpCommunityString).toBe("public");
@@ -150,6 +274,137 @@ describe("buildNetworkDeviceFromDiscoveredHost - SNMP host", () => {
   });
 });
 
+/*
+ * The point of issue #3458, from the import side.
+ *
+ * The sweep tries a scan's credential sets in order against each host, stops
+ * at the first that answers, and records WHICH one that was on the host row.
+ * If the import then copies the scan's first config regardless, every device
+ * found by anything but config #1 is created with credentials its agent will
+ * reject — and the failure is mute. There is no error at import time, the
+ * device looks completely ordinary on the form, and the only symptom is a
+ * poll that times out forever with nothing anywhere saying the scan holds the
+ * right credential two entries further down its own list.
+ */
+describe("buildNetworkDeviceFromDiscoveredHost - a scan with several SNMP configs", () => {
+  /*
+   * The core case, and the one that would pass on the old code by accident if
+   * the configs were not deliberately different: a v2c-first scan whose SECOND
+   * config is v3, with a host the v3 config answered. Copying config #1 (or
+   * the flattened mirror of it, which holds the same values) would produce a
+   * v2c device with the access switches' community string.
+   */
+  it("imports a host stamped with the second config using that config's credentials, not the first's", () => {
+    const device: NetworkDevice = build({
+      host: snmpHost({ snmpConfigId: CORE_CONFIG_ID }),
+      scan: multiConfigScanSource(),
+    });
+
+    expect(device.snmpVersion).toBe("V3");
+    expect(device.snmpPort).toBe(1161);
+    expect(device.snmpV3SecurityLevel).toBe("authPriv");
+    expect(device.snmpV3Username).toBe("core-observer");
+    expect(device.snmpV3AuthProtocol).toBe("SHA");
+    expect(device.snmpV3AuthKey).toBe("core-auth-key");
+    expect(device.snmpV3PrivProtocol).toBe("AES");
+    expect(device.snmpV3PrivKey).toBe("core-priv-key");
+    /*
+     * The v3 config carries no community string, so the device must not have
+     * one either — this is the assertion that catches the first config
+     * leaking in through the flattened mirror, which holds "access-community".
+     */
+    expect(device.snmpCommunityString).toBeUndefined();
+    // The probe still rides along; only the credentials are per-host.
+    expect(device.probeId?.toString()).toBe(PROBE_ID.toString());
+  });
+
+  /*
+   * And the reverse, which is the shape that leaks most easily: a v3-FIRST
+   * scan whose second config is v2c. Every v3 column is populated on the scan
+   * row (the mirror), so a builder that fell back to the row would hand the
+   * device a full v3 identity it never authenticated with — a device that
+   * cannot poll AND whose form claims a security level nobody configured.
+   */
+  it("imports a host found by a v2c config on a v3-first scan with no v3 credentials at all", () => {
+    const device: NetworkDevice = build({
+      host: snmpHost({ snmpConfigId: ACCESS_CONFIG_ID }),
+      scan: multiConfigScanSource([CORE_CONFIG, ACCESS_CONFIG, PRINTER_CONFIG]),
+    });
+
+    expect(device.snmpVersion).toBe("V2c");
+    expect(device.snmpCommunityString).toBe("access-community");
+    expect(device.snmpPort).toBe(161);
+    expectNoV3Credentials(device);
+  });
+
+  /*
+   * The third entry, pinned so the lookup can never be "the first, or the one
+   * after it". Configs are found by ID; their position in the list is the
+   * operator's ordering preference and nothing else.
+   */
+  it("imports a host found by the third config with the third config's credentials", () => {
+    const device: NetworkDevice = build({
+      host: snmpHost({ snmpConfigId: PRINTER_CONFIG_ID }),
+      scan: multiConfigScanSource(),
+    });
+
+    expect(device.snmpVersion).toBe("V1");
+    expect(device.snmpCommunityString).toBe("printer-community");
+    expect(device.snmpPort).toBe(3161);
+    expectNoV3Credentials(device);
+  });
+
+  /*
+   * A host with no stamp at all. That is every result stored before this
+   * feature existed and every result from a probe that is a version behind —
+   * neither is an error, and both must import as something that can poll, so
+   * the first config (the one such a probe was actually given, through the
+   * mirror) is the answer.
+   */
+  it("falls back to the first config for a host that carries no config id", () => {
+    const device: NetworkDevice = build({
+      host: snmpHost(),
+      scan: multiConfigScanSource(),
+    });
+
+    expect(device.snmpVersion).toBe("V2c");
+    expect(device.snmpCommunityString).toBe("access-community");
+    expect(device.snmpPort).toBe(161);
+    expectNoV3Credentials(device);
+  });
+
+  /*
+   * A host stamped with an id that is no longer in the list — the operator
+   * deleted that credential set (or renamed the scan's configs wholesale)
+   * between the sweep and the import, which is an entirely ordinary sequence
+   * of events.
+   *
+   * The requirement is that this degrades rather than fails. A throw here
+   * would take down the Review dialog mid-list, and a credential-LESS device
+   * is strictly worse than a wrong one: a wrong credential is visible on the
+   * device form and fixable in a click, whereas a device with no credentials
+   * can never poll and gives the operator nothing to correct.
+   */
+  it("falls back to the first config for a host whose config id is no longer in the list", () => {
+    const buildWithADeletedConfigId: () => NetworkDevice =
+      (): NetworkDevice => {
+        return build({
+          host: snmpHost({ snmpConfigId: "a-config-that-was-deleted" }),
+          scan: multiConfigScanSource(),
+        });
+      };
+
+    expect(buildWithADeletedConfigId).not.toThrow();
+
+    const device: NetworkDevice = buildWithADeletedConfigId();
+
+    expect(device.snmpVersion).toBe("V2c");
+    expect(device.snmpCommunityString).toBe("access-community");
+    expect(device.snmpPort).toBe(161);
+    expectNoV3Credentials(device);
+  });
+});
+
 describe("buildNetworkDeviceFromDiscoveredHost - ping-only host", () => {
   /*
    * A ping-only host becomes a monitor-backed device: recorded so it can
@@ -175,6 +430,36 @@ describe("buildNetworkDeviceFromDiscoveredHost - ping-only host", () => {
     expect(device.snmpV3PrivProtocol).toBeUndefined();
     expect(device.snmpV3PrivKey).toBeUndefined();
   });
+
+  /*
+   * The same guarantee against the multi-config path, with the host carrying
+   * a config id it has no business carrying.
+   *
+   * Defensive on purpose. `snmpConfigId` and `snmpReachable` are two fields of
+   * the same probe-written jsonb row, and nothing in the database enforces
+   * that a ping-only row leaves the first one unset — an older result, a
+   * partially-rewritten row, or a probe bug is enough. The builder must decide
+   * on the monitoring method and return BEFORE it ever looks a config up, so
+   * that a stray id can never conjure credentials onto a device that answered
+   * nothing but a ping.
+   */
+  it("gives a ping-only host no credentials even when it carries an snmpConfigId", () => {
+    const device: NetworkDevice = build({
+      host: snmpHost({
+        snmpReachable: false,
+        snmpConfigId: CORE_CONFIG_ID,
+      }),
+      scan: multiConfigScanSource(),
+    });
+
+    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();
+    expectNoV3Credentials(device);
+  });
 });
 
 describe("buildDeviceName", () => {

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

@@ -0,0 +1,73 @@
+import {
+  isImportableDiscoveredHost,
+  monitoringMethodForDiscoveredHost,
+} from "../../../Utils/NetworkDiscovery/DiscoveryImportEligibility";
+import NetworkDeviceMonitoringMethod from "../../../Types/NetworkDevice/NetworkDeviceMonitoringMethod";
+import type { DiscoveredNetworkDevice } from "../../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * monitoringMethodForDiscoveredHost is the single decision, shared by the
+ * dashboard's Review dialog and the server-side auto-import rule engine, for
+ * HOW a discovered host imports. The two must never disagree: the group a
+ * host is shown under and the method a rule imports it with are the same call.
+ *
+ * The one subtlety it guards (issue #3023 / legacy scans): only an EXPLICIT
+ * snmpReachable === false is ping-only. undefined means a legacy scan row from
+ * before the field existed, where every host answered SNMP, so it must read as
+ * SNMP — not Monitor. And a nullish host must not throw, because a single junk
+ * element in the jsonb array used to take the whole page down from a table cell.
+ */
+
+function host(
+  overrides: Partial<DiscoveredNetworkDevice>,
+): DiscoveredNetworkDevice {
+  return { ipAddress: "10.0.0.1", ...overrides } as DiscoveredNetworkDevice;
+}
+
+describe("monitoringMethodForDiscoveredHost", () => {
+  test("an explicit snmpReachable === false is a monitor-backed device", () => {
+    expect(
+      monitoringMethodForDiscoveredHost(host({ snmpReachable: false })),
+    ).toBe(NetworkDeviceMonitoringMethod.Monitor);
+  });
+
+  test("snmpReachable === true is an SNMP device", () => {
+    expect(
+      monitoringMethodForDiscoveredHost(host({ snmpReachable: true })),
+    ).toBe(NetworkDeviceMonitoringMethod.Snmp);
+  });
+
+  test("undefined snmpReachable (legacy scan) reads as SNMP, not Monitor", () => {
+    expect(monitoringMethodForDiscoveredHost(host({}))).toBe(
+      NetworkDeviceMonitoringMethod.Snmp,
+    );
+    expect(
+      monitoringMethodForDiscoveredHost(host({ snmpReachable: undefined })),
+    ).toBe(NetworkDeviceMonitoringMethod.Snmp);
+  });
+
+  test("a null host reads as SNMP rather than throwing", () => {
+    expect(monitoringMethodForDiscoveredHost(null)).toBe(
+      NetworkDeviceMonitoringMethod.Snmp,
+    );
+  });
+
+  test("an undefined host reads as SNMP rather than throwing", () => {
+    expect(monitoringMethodForDiscoveredHost(undefined)).toBe(
+      NetworkDeviceMonitoringMethod.Snmp,
+    );
+  });
+});
+
+describe("isImportableDiscoveredHost", () => {
+  test("every alive discovered host is importable", () => {
+    expect(isImportableDiscoveredHost(host({ snmpReachable: true }))).toBe(
+      true,
+    );
+    expect(isImportableDiscoveredHost(host({ snmpReachable: false }))).toBe(
+      true,
+    );
+    expect(isImportableDiscoveredHost(host({}))).toBe(true);
+  });
+});