@oneuptime/common 12.0.25 → 12.0.27

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

@@ -0,0 +1,317 @@
+import { describe, expect, test } from "@jest/globals";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import { DiscoveredNetworkDevice } from "../../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import Hostname from "../../../Types/API/Hostname";
+import IP from "../../../Types/IP/IP";
+import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInstance";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+import {
+  buildPingMonitorDestination,
+  buildPingMonitorForDiscoveredHost,
+  buildPingMonitorName,
+  MAX_PING_MONITOR_NAME_LENGTH,
+  MonitorCriteriaSeedIds,
+  PING_MONITOR_INTERVAL,
+} from "../../../Utils/NetworkDiscovery/PingMonitorBuilder";
+
+/*
+ * The monitor a ping-only discovered host imports with.
+ *
+ * A host that answered ICMP but not SNMP becomes a monitor-backed device with
+ * no probe and no credentials — correct, but with nothing reporting its health
+ * it sits on "Pending" forever (OneUptime/oneuptime#3447). This builder is the
+ * other half: the Ping monitor that answers, on a schedule, the same question
+ * the discovery sweep already answered once.
+ */
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "11111111-0000-4000-8000-000000000001",
+);
+
+const SEED_IDS: MonitorCriteriaSeedIds = {
+  onlineMonitorStatusId: new ObjectID("22222222-0000-4000-8000-000000000001"),
+  offlineMonitorStatusId: new ObjectID("22222222-0000-4000-8000-000000000002"),
+  defaultIncidentSeverityId: new ObjectID(
+    "33333333-0000-4000-8000-000000000001",
+  ),
+  defaultAlertSeverityId: new ObjectID("44444444-0000-4000-8000-000000000001"),
+};
+
+function pingOnlyHost(ipAddress: string): DiscoveredNetworkDevice {
+  return {
+    ipAddress: ipAddress,
+    snmpReachable: false,
+  };
+}
+
+function firstStep(monitor: Monitor): MonitorStep {
+  const steps: Array<MonitorStep> =
+    monitor.monitorSteps?.data?.monitorStepsInstanceArray || [];
+
+  expect(steps).toHaveLength(1);
+
+  return steps[0]!;
+}
+
+function build(data: { ipAddress?: string; deviceName?: string }): Monitor {
+  return buildPingMonitorForDiscoveredHost({
+    projectId: PROJECT_ID,
+    host: pingOnlyHost(data.ipAddress ?? "10.246.174.13"),
+    deviceName: data.deviceName ?? "un0661voipcp01",
+    seedIds: SEED_IDS,
+  });
+}
+
+describe("buildPingMonitorName", () => {
+  test("names the monitor after the device", () => {
+    expect(buildPingMonitorName("core-switch-01")).toBe("Ping core-switch-01");
+  });
+
+  test("trims the device name before composing", () => {
+    expect(buildPingMonitorName("  edge-ap-02  ")).toBe("Ping edge-ap-02");
+  });
+
+  test("clamps to the slug-safe ceiling, not the name column", () => {
+    const name: string = buildPingMonitorName("d".repeat(400));
+
+    expect(name.length).toBe(MAX_PING_MONITOR_NAME_LENGTH);
+    expect(name.startsWith("Ping ")).toBe(true);
+  });
+
+  test("the ceiling leaves room for the slug suffix the create path appends", () => {
+    /*
+     * Monitor is @SlugifyColumn("name", "slug") and Slug.getSlug appends a
+     * dash plus ten random digits into a varchar(100), throwing rather than
+     * truncating on overflow. A 100-character name would therefore fail the
+     * create even though the name column accepts it.
+     */
+    expect(
+      MAX_PING_MONITOR_NAME_LENGTH + "-1234567890".length,
+    ).toBeLessThanOrEqual(100);
+  });
+
+  test("a device name at the builder's own ceiling still composes within the column", () => {
+    /*
+     * DiscoveredDeviceBuilder clamps device names to 80 characters, so this
+     * is the widest name that can actually reach here through the import path.
+     */
+    const name: string = buildPingMonitorName("d".repeat(80));
+
+    expect(name.length).toBeLessThanOrEqual(MAX_PING_MONITOR_NAME_LENGTH);
+    expect(name).toBe(`Ping ${"d".repeat(80)}`);
+  });
+});
+
+describe("buildPingMonitorDestination", () => {
+  test("an IPv4 address becomes an IP", () => {
+    const destination: IP | Hostname =
+      buildPingMonitorDestination("10.246.174.13");
+
+    expect(destination).toBeInstanceOf(IP);
+    expect(destination.toString()).toBe("10.246.174.13");
+  });
+
+  test("an IPv6 address becomes an IP", () => {
+    const destination: IP | Hostname = buildPingMonitorDestination("::1");
+
+    expect(destination).toBeInstanceOf(IP);
+  });
+
+  test("surrounding whitespace does not stop it being recognised as an IP", () => {
+    expect(buildPingMonitorDestination("  10.0.0.7  ")).toBeInstanceOf(IP);
+  });
+
+  test("anything that is not an IP is carried as a hostname rather than rejected", () => {
+    /*
+     * The scanner only ever produces addresses, but the column is free text
+     * and a hand-written scan row could hold a name. Refusing it would fail
+     * the import; MonitorStep accepts either type.
+     */
+    const destination: IP | Hostname = buildPingMonitorDestination(
+      "switch-01.example.com",
+    );
+
+    expect(destination).toBeInstanceOf(Hostname);
+  });
+});
+
+describe("buildPingMonitorForDiscoveredHost", () => {
+  test("builds a Ping monitor in the device's project", () => {
+    const monitor: Monitor = build({});
+
+    expect(monitor.monitorType).toBe(MonitorType.Ping);
+    expect(monitor.projectId?.toString()).toBe(PROJECT_ID.toString());
+    expect(monitor.name).toBe("Ping un0661voipcp01");
+  });
+
+  test("re-wraps the project id rather than sharing the caller's instance", () => {
+    const monitor: Monitor = build({});
+
+    expect(monitor.projectId).not.toBe(PROJECT_ID);
+    expect(monitor.projectId?.toString()).toBe(PROJECT_ID.toString());
+  });
+
+  test("points the step at the host's address", () => {
+    const step: MonitorStep = firstStep(build({ ipAddress: "10.246.174.13" }));
+
+    expect(step.data?.monitorDestination?.toString()).toBe("10.246.174.13");
+  });
+
+  test("the step carries a destination, which is what makes it valid for Ping", () => {
+    /*
+     * MonitorStep.validate rejects a Ping step with no destination
+     * ("Monitor Destination is required"), so a monitor built without one
+     * would be refused at create time and the device would import unbound —
+     * straight back into the Pending dead end.
+     */
+    const step: MonitorStep = firstStep(build({}));
+
+    expect(step.data?.monitorDestination).toBeDefined();
+  });
+
+  test("seeds the criteria with the project's own statuses and severities", () => {
+    const monitor: Monitor = build({});
+    const step: MonitorStep = firstStep(monitor);
+
+    // The criteria exist and were seeded, rather than left undefined.
+    expect(step.data?.monitorCriteria).toBeDefined();
+
+    expect(monitor.monitorSteps?.data?.defaultMonitorStatusId?.toString()).toBe(
+      SEED_IDS.onlineMonitorStatusId.toString(),
+    );
+  });
+
+  test("builds exactly one step", () => {
+    expect(
+      build({}).monitorSteps?.data?.monitorStepsInstanceArray,
+    ).toHaveLength(1);
+  });
+
+  test("describes where the monitor came from", () => {
+    const monitor: Monitor = build({ ipAddress: "10.246.174.13" });
+
+    expect(monitor.description).toContain("10.246.174.13");
+    expect(monitor.description).toContain("discovery scan");
+  });
+
+  test("a host with no address is refused rather than building a destination-less monitor", () => {
+    expect(() => {
+      return buildPingMonitorForDiscoveredHost({
+        projectId: PROJECT_ID,
+        host: { ipAddress: "" },
+        deviceName: "nameless",
+        seedIds: SEED_IDS,
+      });
+    }).toThrow();
+  });
+
+  test("a whitespace-only address is refused too", () => {
+    expect(() => {
+      return buildPingMonitorForDiscoveredHost({
+        projectId: PROJECT_ID,
+        host: { ipAddress: "   " },
+        deviceName: "nameless",
+        seedIds: SEED_IDS,
+      });
+    }).toThrow();
+  });
+
+  test("two hosts build two independent monitors", () => {
+    /*
+     * A bulk import runs this once per host. Sharing any nested object
+     * between them would make one device's edit rewrite another's monitor.
+     */
+    const first: Monitor = build({
+      ipAddress: "10.0.0.1",
+      deviceName: "one",
+    });
+    const second: Monitor = build({
+      ipAddress: "10.0.0.2",
+      deviceName: "two",
+    });
+
+    expect(first.monitorSteps).not.toBe(second.monitorSteps);
+    expect(firstStep(first)).not.toBe(firstStep(second));
+    expect(firstStep(first).data?.monitorDestination?.toString()).toBe(
+      "10.0.0.1",
+    );
+    expect(firstStep(second).data?.monitorDestination?.toString()).toBe(
+      "10.0.0.2",
+    );
+  });
+
+  test("does not persist anything or assume an id", () => {
+    /*
+     * The builder is pure: the caller creates the monitor through the API so
+     * billing, probe attachment and the status timeline hooks still run.
+     */
+    expect(build({})._id).toBeUndefined();
+  });
+});
+
+/*
+ * Two properties that exist because this runs as a BULK action.
+ *
+ * An operator ticking "Import Selected (14)" is recording inventory, not
+ * deliberately standing up fourteen alerting monitors. Both defaults below are
+ * right for a hand-made monitor and wrong for this one.
+ */
+describe("buildPingMonitorForDiscoveredHost - safe defaults for a bulk import", () => {
+  function criteriaOf(monitor: Monitor): Array<MonitorCriteriaInstance> {
+    return (
+      firstStep(monitor).data?.monitorCriteria?.data
+        ?.monitorCriteriaInstanceArray || []
+    );
+  }
+
+  test("does not open incidents", () => {
+    /*
+     * The stock Ping offline criteria sets createIncidents: true. Fourteen of
+     * those pointed at consumer gear means fourteen incidents, on-call
+     * notifications and status-page impact the first time one misses a ping.
+     */
+    const criteria: Array<MonitorCriteriaInstance> = criteriaOf(build({}));
+
+    expect(criteria.length).toBeGreaterThan(0);
+
+    for (const criteriaInstance of criteria) {
+      expect(criteriaInstance.data?.createIncidents).toBe(false);
+    }
+  });
+
+  test("still changes the monitor's status, which is what the device pill reads", () => {
+    /*
+     * Suppressing incidents must not suppress the status change: the whole
+     * point of the monitor is to move the device off "Pending".
+     */
+    const criteria: Array<MonitorCriteriaInstance> = criteriaOf(build({}));
+
+    const changesStatus: boolean = criteria.some(
+      (criteriaInstance: MonitorCriteriaInstance) => {
+        return criteriaInstance.data?.changeMonitorStatus === true;
+      },
+    );
+
+    expect(changesStatus).toBe(true);
+  });
+});
+
+describe("buildPingMonitorForDiscoveredHost - the polling cadence is chosen, not defaulted", () => {
+  test("sets an explicit monitoring interval", () => {
+    /*
+     * A NULL monitoringInterval is not "use a sensible default":
+     * MonitorProbeService falls back to now + 1 MINUTE when the column is
+     * null. Importing a subnet's worth of IP phones would otherwise ping
+     * every one of them every sixty seconds forever, because nobody chose
+     * that.
+     */
+    expect(build({}).monitoringInterval).toBe(PING_MONITOR_INTERVAL);
+  });
+
+  test("the interval is a cron expression the interval dropdown offers", () => {
+    // So the operator can change it from the same control as any other monitor.
+    expect(PING_MONITOR_INTERVAL).toBe("*/5 * * * *");
+  });
+});

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

@@ -0,0 +1,262 @@
+import {
+  MINIMUM_RESCAN_INTERVAL_IN_MINUTES,
+  clampRescanIntervalInMinutes,
+  getNextScanAt,
+} from "../../../Utils/NetworkDiscovery/RescanIntervalUtil";
+import OneUptimeDate from "../../../Types/Date";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * Contract under test: when a recurring discovery scan runs again.
+ *
+ * `nextScanAt` is the ONLY thing the requeue worker looks at — its query is
+ * `isRecurring = true AND nextScanAt <= now AND status IN (Completed,
+ * Failed)` — and `NULL <= now` is UNKNOWN in SQL, so a NULL there does not
+ * mean "soon", it means "never". That is the shape of the bug this module was
+ * written for: the column had exactly one writer, the endpoint that records a
+ * finished run, and it only wrote when the scan was ALREADY recurring at that
+ * moment. Turning recurrence on afterwards set the flag and scheduled
+ * nothing, and the scans list rendered "Every 60 min" over a scan that would
+ * never run again (OneUptime issue #3444).
+ *
+ * So the column stops being a fact somebody remembered to write and becomes
+ * derived state: a function of the recurrence settings and the last
+ * completion, recomputed by the service whenever those change. Two properties
+ * carry the whole design and are pinned below:
+ *
+ *   - it is TOTAL. Every combination has an answer, and `null` is one of the
+ *     answers rather than "no opinion" — a scan with recurrence off must have
+ *     the column CLEARED, or turning recurrence back on months later would
+ *     find a timestamp already in the past and fire an unasked-for sweep.
+ *   - it is IDEMPOTENT. The same row always produces the same moment, so
+ *     re-saving an unchanged schedule writes nothing. This is why it is not
+ *     clamped forward to "now": a due-in-the-past answer is correct, and
+ *     clamping would make every save move it.
+ */
+
+const COMPLETED_AT: Date = OneUptimeDate.fromString("2026-01-01T00:00:00.000Z");
+const NOW: Date = OneUptimeDate.fromString("2026-01-01T00:30:00.000Z");
+
+type MinutesAfterCompletionFunction = (result: Date | null) => number | null;
+
+const minutesAfterCompletion: MinutesAfterCompletionFunction = (
+  result: Date | null,
+): number | null => {
+  if (!result) {
+    return null;
+  }
+
+  return (result.getTime() - COMPLETED_AT.getTime()) / 60000;
+};
+
+describe("clampRescanIntervalInMinutes", () => {
+  it("leaves an interval at or above the floor alone", () => {
+    expect(clampRescanIntervalInMinutes(15)).toBe(15);
+    expect(clampRescanIntervalInMinutes(60)).toBe(60);
+    expect(clampRescanIntervalInMinutes(1440)).toBe(1440);
+  });
+
+  /*
+   * Clamped, not rejected — the stated policy of the ingest endpoint this
+   * replaced. A row stored before the form enforced a floor, or by an API
+   * client, still recurs; it just cannot outrun the probe.
+   */
+  it("raises a too-short interval to the floor rather than refusing it", () => {
+    expect(clampRescanIntervalInMinutes(1)).toBe(
+      MINIMUM_RESCAN_INTERVAL_IN_MINUTES,
+    );
+    expect(clampRescanIntervalInMinutes(14)).toBe(
+      MINIMUM_RESCAN_INTERVAL_IN_MINUTES,
+    );
+  });
+
+  /*
+   * Null for everything that is not a cadence at all. Zero especially: the
+   * column is nullable and a zero would otherwise divide the schedule into
+   * "run again immediately, forever".
+   */
+  it("reports anything that is not a cadence as no cadence", () => {
+    expect(clampRescanIntervalInMinutes(0)).toBeNull();
+    expect(clampRescanIntervalInMinutes(-5)).toBeNull();
+    expect(clampRescanIntervalInMinutes(null)).toBeNull();
+    expect(clampRescanIntervalInMinutes(undefined)).toBeNull();
+    expect(clampRescanIntervalInMinutes(NaN)).toBeNull();
+    expect(clampRescanIntervalInMinutes(Infinity)).toBeNull();
+  });
+
+  it("keeps the floor the whole product is sized against", () => {
+    expect(MINIMUM_RESCAN_INTERVAL_IN_MINUTES).toBe(15);
+  });
+});
+
+describe("getNextScanAt", () => {
+  it("schedules a finished recurring scan one interval after it finished", () => {
+    const result: Date | null = getNextScanAt(
+      {
+        isRecurring: true,
+        rescanIntervalInMinutes: 60,
+        status: "Completed",
+        completedAt: COMPLETED_AT,
+      },
+      NOW,
+    );
+
+    expect(minutesAfterCompletion(result)).toBe(60);
+  });
+
+  /*
+   * A failed sweep is still a completed run. Ending the recurrence because one
+   * sweep failed would quietly turn a monitoring scan off at exactly the
+   * moment something is wrong.
+   */
+  it("schedules a failed run the same way", () => {
+    const result: Date | null = getNextScanAt(
+      {
+        isRecurring: true,
+        rescanIntervalInMinutes: 60,
+        status: "Failed",
+        completedAt: COMPLETED_AT,
+      },
+      NOW,
+    );
+
+    expect(minutesAfterCompletion(result)).toBe(60);
+  });
+
+  it("schedules nothing at all when recurrence is off", () => {
+    expect(
+      getNextScanAt(
+        {
+          isRecurring: false,
+          rescanIntervalInMinutes: 60,
+          status: "Completed",
+          completedAt: COMPLETED_AT,
+        },
+        NOW,
+      ),
+    ).toBeNull();
+  });
+
+  /*
+   * The gate the ingest endpoint has always had. A recurring scan with no
+   * interval must not become due, or the worker re-queues it every minute
+   * forever.
+   */
+  it("schedules nothing for a recurring scan with no usable interval", () => {
+    for (const interval of [null, undefined, 0, -1]) {
+      expect(
+        getNextScanAt(
+          {
+            isRecurring: true,
+            rescanIntervalInMinutes: interval,
+            status: "Completed",
+            completedAt: COMPLETED_AT,
+          },
+          NOW,
+        ),
+      ).toBeNull();
+    }
+  });
+
+  /*
+   * A run is already queued or under way; the endpoint that records its
+   * result schedules the one after it. Answering here would race that.
+   */
+  it("schedules nothing while a run is queued or in flight", () => {
+    for (const status of ["Pending", "In Progress"]) {
+      expect(
+        getNextScanAt(
+          {
+            isRecurring: true,
+            rescanIntervalInMinutes: 60,
+            status: status,
+            completedAt: null,
+          },
+          NOW,
+        ),
+      ).toBeNull();
+    }
+  });
+
+  it("applies the floor, so a one-minute cadence cannot be scheduled", () => {
+    const result: Date | null = getNextScanAt(
+      {
+        isRecurring: true,
+        rescanIntervalInMinutes: 1,
+        status: "Completed",
+        completedAt: COMPLETED_AT,
+      },
+      NOW,
+    );
+
+    expect(minutesAfterCompletion(result)).toBe(
+      MINIMUM_RESCAN_INTERVAL_IN_MINUTES,
+    );
+  });
+
+  /*
+   * Measured from the last run, never from the caller's clock — that is what
+   * makes it safe to recompute on every save. The answer here is already in
+   * the past, and deliberately so: the worker's predicate is `<= now`, so a
+   * past moment reads as "due", and clamping it forward would make an
+   * unchanged schedule rewrite the column every time it was saved.
+   */
+  it("answers with a moment already past for an overdue scan, rather than moving it", () => {
+    const longAfter: Date = OneUptimeDate.fromString(
+      "2026-06-01T00:00:00.000Z",
+    );
+
+    const result: Date | null = getNextScanAt(
+      {
+        isRecurring: true,
+        rescanIntervalInMinutes: 60,
+        status: "Completed",
+        completedAt: COMPLETED_AT,
+      },
+      longAfter,
+    );
+
+    expect(minutesAfterCompletion(result)).toBe(60);
+    expect(result!.getTime()).toBeLessThan(longAfter.getTime());
+  });
+
+  it("gives the same answer every time it is asked", () => {
+    const scan: {
+      isRecurring: boolean;
+      rescanIntervalInMinutes: number;
+      status: string;
+      completedAt: Date;
+    } = {
+      isRecurring: true,
+      rescanIntervalInMinutes: 60,
+      status: "Completed",
+      completedAt: COMPLETED_AT,
+    };
+
+    expect(getNextScanAt(scan, NOW)!.getTime()).toBe(
+      getNextScanAt(
+        scan,
+        OneUptimeDate.fromString("2026-03-03T03:03:00.000Z"),
+      )!.getTime(),
+    );
+  });
+
+  /*
+   * A Completed row with no completedAt should not exist — every writer of one
+   * writes the other — but a row written by an older build must still get a
+   * next run rather than being stranded.
+   */
+  it("falls back to now for a finished scan that never recorded when", () => {
+    const result: Date | null = getNextScanAt(
+      {
+        isRecurring: true,
+        rescanIntervalInMinutes: 60,
+        status: "Completed",
+        completedAt: null,
+      },
+      NOW,
+    );
+
+    expect(result!.getTime()).toBe(NOW.getTime() + 60 * 60000);
+  });
+});