@oneuptime/common 11.6.0 → 11.6.2

package/Tests/Server/Utils/Monitor/DnsResolutionCache.test.ts

@@ -0,0 +1,194 @@
+import { describe, expect, test } from "@jest/globals";
+import DnsResolutionCache, {
+  ResolveHostnameFunction,
+} from "../../../../Server/Utils/Monitor/DnsResolutionCache";
+
+/*
+ * DnsResolutionCache correlates datagram source IPs (SNMP traps, syslog) to
+ * NetworkDevices registered by DNS name. It must not hammer the resolver on
+ * every datagram, so these tests pin the caching contract: positive results
+ * are cached for the TTL, failures are negative-cached as an empty list,
+ * the oldest entry is evicted at maxEntries, and hostnames are keyed
+ * case-insensitively. The resolver and clock are injected so no real DNS
+ * lookup or wall-clock wait is involved.
+ */
+
+const TTL_IN_MS: number = 1000;
+
+interface TestHarness {
+  cache: DnsResolutionCache;
+  callCount: () => number;
+  calledWith: () => Array<string>;
+  advanceClock: (byMs: number) => void;
+}
+
+function makeHarness(options: {
+  addressesByHostname?: Record<string, Array<string>>;
+  rejectAll?: boolean;
+  maxEntries?: number;
+}): TestHarness {
+  let nowInMs: number = 0;
+  const calls: Array<string> = [];
+
+  const resolver: ResolveHostnameFunction = (
+    hostname: string,
+  ): Promise<Array<string>> => {
+    calls.push(hostname);
+
+    if (options.rejectAll) {
+      return Promise.reject(new Error(`ENOTFOUND ${hostname}`));
+    }
+
+    return Promise.resolve(
+      options.addressesByHostname?.[hostname.toLowerCase()] || [],
+    );
+  };
+
+  const cache: DnsResolutionCache = new DnsResolutionCache({
+    ttlInMs: TTL_IN_MS,
+    resolver: resolver,
+    now: () => {
+      return nowInMs;
+    },
+    ...(options.maxEntries !== undefined
+      ? { maxEntries: options.maxEntries }
+      : {}),
+  });
+
+  return {
+    cache: cache,
+    callCount: () => {
+      return calls.length;
+    },
+    calledWith: () => {
+      return calls;
+    },
+    advanceClock: (byMs: number) => {
+      nowInMs += byMs;
+    },
+  };
+}
+
+describe("DnsResolutionCache", () => {
+  test("caches a positive result within the TTL — resolver called once", async () => {
+    const harness: TestHarness = makeHarness({
+      addressesByHostname: { "router.example.com": ["10.0.0.1", "10.0.0.2"] },
+    });
+
+    const first: Array<string> =
+      await harness.cache.resolve("router.example.com");
+    expect(first).toEqual(["10.0.0.1", "10.0.0.2"]);
+    expect(harness.callCount()).toBe(1);
+
+    // Just inside the TTL — the cached addresses come back, no new lookup.
+    harness.advanceClock(TTL_IN_MS - 1);
+
+    const second: Array<string> =
+      await harness.cache.resolve("router.example.com");
+    expect(second).toEqual(["10.0.0.1", "10.0.0.2"]);
+    expect(harness.callCount()).toBe(1);
+  });
+
+  test("re-resolves once the TTL has elapsed", async () => {
+    const harness: TestHarness = makeHarness({
+      addressesByHostname: { "router.example.com": ["10.0.0.1"] },
+    });
+
+    await harness.cache.resolve("router.example.com");
+    expect(harness.callCount()).toBe(1);
+
+    // expiresAt is exclusive: at exactly now + ttl the entry is stale.
+    harness.advanceClock(TTL_IN_MS);
+
+    const result: Array<string> =
+      await harness.cache.resolve("router.example.com");
+    expect(result).toEqual(["10.0.0.1"]);
+    expect(harness.callCount()).toBe(2);
+  });
+
+  test("negative-caches a resolution failure as an empty list within the TTL", async () => {
+    const harness: TestHarness = makeHarness({ rejectAll: true });
+
+    const first: Array<string> = await harness.cache.resolve(
+      "does-not-exist.example.com",
+    );
+    expect(first).toEqual([]);
+    expect(harness.callCount()).toBe(1);
+
+    harness.advanceClock(TTL_IN_MS - 1);
+
+    // Failure is cached — the resolver is not retried on every datagram.
+    const second: Array<string> = await harness.cache.resolve(
+      "does-not-exist.example.com",
+    );
+    expect(second).toEqual([]);
+    expect(harness.callCount()).toBe(1);
+  });
+
+  test("retries a negative-cached hostname after the TTL", async () => {
+    const harness: TestHarness = makeHarness({ rejectAll: true });
+
+    await harness.cache.resolve("does-not-exist.example.com");
+    harness.advanceClock(TTL_IN_MS);
+    await harness.cache.resolve("does-not-exist.example.com");
+
+    expect(harness.callCount()).toBe(2);
+  });
+
+  test("evicts the oldest entry at maxEntries", async () => {
+    const harness: TestHarness = makeHarness({
+      addressesByHostname: {
+        "a.example.com": ["10.0.0.1"],
+        "b.example.com": ["10.0.0.2"],
+        "c.example.com": ["10.0.0.3"],
+      },
+      maxEntries: 2,
+    });
+
+    await harness.cache.resolve("a.example.com");
+    await harness.cache.resolve("b.example.com");
+
+    // Third entry exceeds maxEntries — the oldest ("a") is evicted.
+    await harness.cache.resolve("c.example.com");
+    expect(harness.callCount()).toBe(3);
+
+    // "b" and "c" are still cached...
+    await harness.cache.resolve("b.example.com");
+    await harness.cache.resolve("c.example.com");
+    expect(harness.callCount()).toBe(3);
+
+    // ...but "a" was evicted, so it hits the resolver again.
+    await harness.cache.resolve("a.example.com");
+    expect(harness.callCount()).toBe(4);
+  });
+
+  test("keys hostnames case-insensitively", async () => {
+    const harness: TestHarness = makeHarness({
+      addressesByHostname: { "router.example.com": ["10.0.0.1"] },
+    });
+
+    const first: Array<string> =
+      await harness.cache.resolve("Router.Example.COM");
+    const second: Array<string> =
+      await harness.cache.resolve("router.example.com");
+
+    expect(first).toEqual(["10.0.0.1"]);
+    expect(second).toEqual(["10.0.0.1"]);
+    expect(harness.callCount()).toBe(1);
+
+    // The resolver sees the hostname as given, not the lowercased cache key.
+    expect(harness.calledWith()).toEqual(["Router.Example.COM"]);
+  });
+
+  test("clear() empties the cache so the next resolve hits the resolver", async () => {
+    const harness: TestHarness = makeHarness({
+      addressesByHostname: { "router.example.com": ["10.0.0.1"] },
+    });
+
+    await harness.cache.resolve("router.example.com");
+    harness.cache.clear();
+    await harness.cache.resolve("router.example.com");
+
+    expect(harness.callCount()).toBe(2);
+  });
+});

package/Tests/Server/Utils/Monitor/NetworkDeviceHydrationUtil.test.ts

@@ -13,6 +13,7 @@ import SnmpV3Auth from "../../../../Types/Monitor/SnmpMonitor/SnmpV3Auth";
 import SnmpSecurityLevel from "../../../../Types/Monitor/SnmpMonitor/SnmpSecurityLevel";
 import SnmpAuthProtocol from "../../../../Types/Monitor/SnmpMonitor/SnmpAuthProtocol";
 import SnmpPrivProtocol from "../../../../Types/Monitor/SnmpMonitor/SnmpPrivProtocol";
+import SnmpOid from "../../../../Types/Monitor/SnmpMonitor/SnmpOid";
 import ObjectID from "../../../../Types/ObjectID";
 
 /*
@@ -500,3 +501,157 @@ describe("NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors", () => {
     });
   });
 });
+
+/*
+ * Under device-owned polling the device polling pipeline calls
+ * buildSnmpMonitorConfig directly (the device row supplies WHAT to collect;
+ * this assembles HOW to connect). It is the same assembly the legacy
+ * hydration path above uses internally, so its credential rules must match:
+ * flattened v3 columns first, legacy snmpV3Auth JSON as fallback, community
+ * string for v1/v2c, port defaulting to 161.
+ */
+describe("NetworkDeviceHydrationUtil.buildSnmpMonitorConfig", () => {
+  test("a v2c device produces a community config with no v3 auth", () => {
+    const config: MonitorStepSnmpMonitor =
+      NetworkDeviceHydrationUtil.buildSnmpMonitorConfig({
+        device: buildDevice({
+          snmpVersion: "V2c",
+          snmpCommunityString: "s3cret",
+        }),
+        oids: [],
+        monitorInterfaces: true,
+      });
+
+    expect(config.snmpVersion).toBe(SnmpVersion.V2c);
+    expect(config.hostname).toBe("10.0.0.1");
+    expect(config.communityString).toBe("s3cret");
+    expect(config.snmpV3Auth).toBeUndefined();
+  });
+
+  test("a v2c device with no community string leaves it unset for the probe to default", () => {
+    const config: MonitorStepSnmpMonitor =
+      NetworkDeviceHydrationUtil.buildSnmpMonitorConfig({
+        device: buildDevice({ snmpVersion: "V2c" }),
+        oids: [],
+        monitorInterfaces: true,
+      });
+
+    expect(config.communityString).toBeUndefined();
+  });
+
+  test("a v3 device's flattened columns become a complete authPriv SnmpV3Auth", () => {
+    const config: MonitorStepSnmpMonitor =
+      NetworkDeviceHydrationUtil.buildSnmpMonitorConfig({
+        device: buildV3Device(),
+        oids: [],
+        monitorInterfaces: true,
+      });
+
+    expect(config.snmpVersion).toBe(SnmpVersion.V3);
+    expect(config.snmpV3Auth).toEqual({
+      securityLevel: SnmpSecurityLevel.AuthPriv,
+      username: "monitoring",
+      authProtocol: SnmpAuthProtocol.SHA,
+      authKey: "auth-passphrase",
+      privProtocol: SnmpPrivProtocol.AES,
+      privKey: "priv-passphrase",
+    } as SnmpV3Auth);
+  });
+
+  test("a device predating the flattened columns falls back to the legacy snmpV3Auth JSON", () => {
+    const config: MonitorStepSnmpMonitor =
+      NetworkDeviceHydrationUtil.buildSnmpMonitorConfig({
+        device: buildDevice({
+          snmpVersion: "V3",
+          snmpV3Auth: {
+            securityLevel: SnmpSecurityLevel.AuthPriv,
+            username: "legacy-user",
+            authProtocol: SnmpAuthProtocol.MD5,
+            authKey: "legacy-auth",
+            privProtocol: SnmpPrivProtocol.DES,
+            privKey: "legacy-priv",
+          },
+        }),
+        oids: [],
+        monitorInterfaces: true,
+      });
+
+    expect(config.snmpVersion).toBe(SnmpVersion.V3);
+    expect(config.snmpV3Auth?.username).toBe("legacy-user");
+    expect(config.snmpV3Auth?.authProtocol).toBe(SnmpAuthProtocol.MD5);
+  });
+
+  test("the flattened columns win over a stale legacy blob", () => {
+    const config: MonitorStepSnmpMonitor =
+      NetworkDeviceHydrationUtil.buildSnmpMonitorConfig({
+        device: buildV3Device({
+          snmpV3Auth: {
+            securityLevel: SnmpSecurityLevel.NoAuthNoPriv,
+            username: "stale-legacy-user",
+          },
+        }),
+        oids: [],
+        monitorInterfaces: true,
+      });
+
+    expect(config.snmpV3Auth?.username).toBe("monitoring");
+  });
+
+  test("a v3 device with no credentials anywhere yields no auth at all", () => {
+    const config: MonitorStepSnmpMonitor =
+      NetworkDeviceHydrationUtil.buildSnmpMonitorConfig({
+        device: buildDevice({ snmpVersion: "V3" }),
+        oids: [],
+        monitorInterfaces: true,
+      });
+
+    expect(config.snmpV3Auth).toBeUndefined();
+  });
+
+  test("a device with no port falls back to 161, and a stored port passes through", () => {
+    const defaulted: MonitorStepSnmpMonitor =
+      NetworkDeviceHydrationUtil.buildSnmpMonitorConfig({
+        device: buildDevice({ snmpPort: undefined }),
+        oids: [],
+        monitorInterfaces: true,
+      });
+    const explicit: MonitorStepSnmpMonitor =
+      NetworkDeviceHydrationUtil.buildSnmpMonitorConfig({
+        device: buildDevice({ snmpPort: 1610 }),
+        oids: [],
+        monitorInterfaces: true,
+      });
+
+    expect(defaulted.port).toBe(161);
+    expect(explicit.port).toBe(1610);
+  });
+
+  test("oids and monitorInterfaces are passed through from the caller", () => {
+    const oids: Array<SnmpOid> = [
+      { oid: "1.3.6.1.2.1.1.1.0", name: "sysDescr" },
+      { oid: "1.3.6.1.2.1.1.3.0", name: "sysUpTime" },
+    ];
+
+    const config: MonitorStepSnmpMonitor =
+      NetworkDeviceHydrationUtil.buildSnmpMonitorConfig({
+        device: buildDevice({ snmpVersion: "V2c" }),
+        oids: oids,
+        monitorInterfaces: false,
+      });
+
+    expect(config.oids).toEqual(oids);
+    expect(config.monitorInterfaces).toBe(false);
+  });
+
+  test("every config carries the fixed probe timeout and retry policy", () => {
+    const config: MonitorStepSnmpMonitor =
+      NetworkDeviceHydrationUtil.buildSnmpMonitorConfig({
+        device: buildDevice({}),
+        oids: [],
+        monitorInterfaces: true,
+      });
+
+    expect(config.timeout).toBe(5000);
+    expect(config.retries).toBe(3);
+  });
+});