@oneuptime/common 12.0.34 → 13.0.0

package/Tests/Types/NetworkAutomation/AutoImportRunMerge.test.ts

@@ -0,0 +1,235 @@
+import {
+  AutoImportRuleRunResult,
+  RuleRunResultUtil,
+} from "../../../Types/NetworkAutomation/RuleRunResult";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * One press of "Run Rule" is now several capped server passes
+ * (OneUptime issue #3642), and this is the arithmetic that turns them back
+ * into one report. It is the part most easily got wrong: every pass re-reads
+ * the SAME scans, so most counters describe the estate rather than the work,
+ * and summing them would multiply the estate by the pass count.
+ */
+
+function pass(
+  overrides: Partial<AutoImportRuleRunResult>,
+): AutoImportRuleRunResult {
+  return {
+    hostsEvaluated: 0,
+    hostsMatched: 0,
+    hostsExcluded: 0,
+    hostsSkippedAlreadyRegistered: 0,
+    devicesCreated: 0,
+    devicesFailed: 0,
+    monitorsWouldCreate: 0,
+    monitorsCreated: 0,
+    monitorsSkippedAlreadyExisting: 0,
+    monitorsSkippedUnsupportedHost: 0,
+    monitorsFailed: 0,
+    deviceFailureReasons: [],
+    monitorFailureReasons: [],
+    monitorProvisioningHalted: false,
+    isTruncated: false,
+    hostsPendingImport: 0,
+    monitorsPendingCreation: 0,
+    hasUnevaluatedScans: false,
+    hasMoreScans: false,
+    isDryRun: false,
+    matchedIpAddressSample: [],
+    ...overrides,
+  };
+}
+
+describe("RuleRunResultUtil.mergeAutoImportRunPasses", () => {
+  it("returns a single pass unchanged", () => {
+    const only: AutoImportRuleRunResult = pass({ devicesCreated: 7 });
+
+    expect(RuleRunResultUtil.mergeAutoImportRunPasses([only])).toBe(only);
+  });
+
+  it("refuses to invent a report out of no passes", () => {
+    expect(() => {
+      return RuleRunResultUtil.mergeAutoImportRunPasses([]);
+    }).toThrow("at least one run result");
+  });
+
+  /*
+   * The issue's own numbers: 909 hosts, a 500-per-pass cap, two passes.
+   */
+  it("sums the work done and keeps the estate from the first pass", () => {
+    const merged: AutoImportRuleRunResult =
+      RuleRunResultUtil.mergeAutoImportRunPasses([
+        pass({
+          hostsEvaluated: 909,
+          hostsMatched: 909,
+          devicesCreated: 500,
+          hostsPendingImport: 409,
+          isTruncated: true,
+        }),
+        pass({
+          hostsEvaluated: 909,
+          hostsMatched: 909,
+          hostsSkippedAlreadyRegistered: 500,
+          devicesCreated: 409,
+        }),
+      ]);
+
+    expect(merged.devicesCreated).toBe(909);
+    // Not 1,818: the second pass looked at the same 909 hosts.
+    expect(merged.hostsEvaluated).toBe(909);
+    expect(merged.hostsMatched).toBe(909);
+    /*
+     * And not 500 either. Reporting the run's own creates back as
+     * "already registered" would contradict "imported 909" in the same
+     * paragraph.
+     */
+    expect(merged.hostsSkippedAlreadyRegistered).toBe(0);
+    expect(merged.isTruncated).toBe(false);
+    expect(merged.hostsPendingImport).toBe(0);
+  });
+
+  it("sums monitor work and failures across passes", () => {
+    const merged: AutoImportRuleRunResult =
+      RuleRunResultUtil.mergeAutoImportRunPasses([
+        pass({
+          monitorsCreated: 500,
+          monitorsFailed: 2,
+          devicesFailed: 1,
+          monitorsSkippedAlreadyExisting: 4,
+          monitorsSkippedUnsupportedHost: 3,
+          isTruncated: true,
+        }),
+        pass({ monitorsCreated: 409, monitorsFailed: 1 }),
+      ]);
+
+    expect(merged.monitorsCreated).toBe(909);
+    expect(merged.monitorsFailed).toBe(3);
+    expect(merged.devicesFailed).toBe(1);
+    // Estate state, not work: taken from the first pass, never doubled.
+    expect(merged.monitorsSkippedAlreadyExisting).toBe(4);
+    expect(merged.monitorsSkippedUnsupportedHost).toBe(3);
+  });
+
+  it("carries the last pass's leftovers, not the first pass's", () => {
+    const merged: AutoImportRuleRunResult =
+      RuleRunResultUtil.mergeAutoImportRunPasses([
+        pass({
+          devicesCreated: 500,
+          hostsPendingImport: 900,
+          monitorsPendingCreation: 900,
+          hasUnevaluatedScans: true,
+          isTruncated: true,
+        }),
+        pass({
+          devicesCreated: 500,
+          hostsPendingImport: 400,
+          monitorsPendingCreation: 400,
+          hasUnevaluatedScans: false,
+          hasMoreScans: true,
+          isTruncated: true,
+        }),
+      ]);
+
+    expect(merged.hostsPendingImport).toBe(400);
+    expect(merged.monitorsPendingCreation).toBe(400);
+    expect(merged.hasUnevaluatedScans).toBe(false);
+    expect(merged.hasMoreScans).toBe(true);
+    expect(merged.isTruncated).toBe(true);
+  });
+
+  /*
+   * The sample answers "which hosts is this rule claiming". Drawn before the
+   * run changed anything, it still does; drawn from the final pass it would
+   * be whatever happened to be left over.
+   */
+  it("keeps the first pass's host sample", () => {
+    const merged: AutoImportRuleRunResult =
+      RuleRunResultUtil.mergeAutoImportRunPasses([
+        pass({
+          devicesCreated: 1,
+          isTruncated: true,
+          matchedIpAddressSample: ["10.0.0.1"],
+        }),
+        pass({ devicesCreated: 1, matchedIpAddressSample: ["10.9.9.9"] }),
+      ]);
+
+    expect(merged.matchedIpAddressSample).toEqual(["10.0.0.1"]);
+  });
+
+  /*
+   * Failure reasons are what issue #3643 added to this report, and across a
+   * chain they are a set: the same fault reappears in every pass, and a
+   * different fault in a later pass is exactly what has to be surfaced.
+   */
+  it("deduplicates failure reasons across passes and keeps new ones", () => {
+    const merged: AutoImportRuleRunResult =
+      RuleRunResultUtil.mergeAutoImportRunPasses([
+        pass({
+          devicesCreated: 500,
+          monitorsFailed: 1,
+          monitorFailureReasons: ["Template could not be loaded."],
+          deviceFailureReasons: ["Name already taken."],
+          isTruncated: true,
+        }),
+        pass({
+          devicesCreated: 400,
+          monitorsFailed: 2,
+          monitorFailureReasons: [
+            "Template could not be loaded.",
+            "Monitor limit reached.",
+          ],
+          deviceFailureReasons: ["Name already taken."],
+        }),
+      ]);
+
+    expect(merged.monitorFailureReasons).toEqual([
+      "Template could not be loaded.",
+      "Monitor limit reached.",
+    ]);
+    expect(merged.deviceFailureReasons).toEqual(["Name already taken."]);
+  });
+
+  it("caps the merged reason list the way one pass is capped", () => {
+    const merged: AutoImportRuleRunResult =
+      RuleRunResultUtil.mergeAutoImportRunPasses([
+        pass({
+          devicesCreated: 1,
+          isTruncated: true,
+          monitorFailureReasons: ["one", "two"],
+        }),
+        pass({ devicesCreated: 1, monitorFailureReasons: ["three", "four"] }),
+      ]);
+
+    expect(merged.monitorFailureReasons).toEqual(["one", "two", "three"]);
+  });
+
+  /*
+   * Halting is a property of the pass that halted, and the chain stops after
+   * one — so reading only the last pass would lose it.
+   */
+  it("reports a halt from any pass, not only the last", () => {
+    const merged: AutoImportRuleRunResult =
+      RuleRunResultUtil.mergeAutoImportRunPasses([
+        pass({
+          devicesCreated: 500,
+          monitorProvisioningHalted: true,
+          isTruncated: true,
+        }),
+        pass({ devicesCreated: 400, monitorProvisioningHalted: false }),
+      ]);
+
+    expect(merged.monitorProvisioningHalted).toBe(true);
+  });
+
+  it("keeps the dry-run flag so a preview never reads as a write", () => {
+    const merged: AutoImportRuleRunResult =
+      RuleRunResultUtil.mergeAutoImportRunPasses([
+        pass({ isDryRun: true, monitorsWouldCreate: 500, isTruncated: true }),
+        pass({ isDryRun: true, monitorsWouldCreate: 9 }),
+      ]);
+
+    expect(merged.isDryRun).toBe(true);
+    expect(merged.monitorsWouldCreate).toBe(509);
+  });
+});

package/Tests/Types/NetworkAutomation/RuleRunResult.test.ts

@@ -1,6 +1,7 @@
 import {
   AutoImportRuleRunResult,
   LabelRuleRunResult,
+  MAX_RUN_FAILURE_REASON_LENGTH,
   RuleRunResultUtil,
   SiteAssignmentRuleRunResult,
 } from "../../../Types/NetworkAutomation/RuleRunResult";
@@ -199,6 +200,9 @@ describe("RuleRunResultUtil.parseAutoImportRuleRunResult", () => {
         monitorsSkippedAlreadyExisting: 2,
         monitorsSkippedUnsupportedHost: 1,
         monitorsFailed: 1,
+        deviceFailureReasons: ["Name too long"],
+        monitorFailureReasons: ["Plan limit reached"],
+        monitorProvisioningHalted: true,
         isTruncated: true,
         hasMoreScans: true,
         isDryRun: false,
@@ -217,13 +221,75 @@ describe("RuleRunResultUtil.parseAutoImportRuleRunResult", () => {
       monitorsSkippedAlreadyExisting: 2,
       monitorsSkippedUnsupportedHost: 1,
       monitorsFailed: 1,
+      deviceFailureReasons: ["Name too long"],
+      monitorFailureReasons: ["Plan limit reached"],
+      monitorProvisioningHalted: true,
       isTruncated: true,
+      /*
+       * Absent from the payload above, which is what a pre-#3642 server
+       * sends: a truncated run from one of those reports nothing pending
+       * rather than NaN, and the summary falls back to its unquantified
+       * "stopped at the run cap" sentence.
+       */
+      hostsPendingImport: 0,
+      monitorsPendingCreation: 0,
+      hasUnevaluatedScans: false,
       hasMoreScans: true,
       isDryRun: false,
       matchedIpAddressSample: ["10.0.0.1", "10.0.0.2"],
     });
   });
 
+  /*
+   * The reasons come from a server that may be older than this dashboard, or
+   * from a hand-rolled client. Anything that is not a usable string is dropped
+   * rather than rendered into the modal, and the list is bounded on both axes
+   * so a pathological payload cannot become the whole dialog.
+   */
+  it("reads absent failure reasons as empty rather than undefined", () => {
+    const parsed: AutoImportRuleRunResult =
+      RuleRunResultUtil.parseAutoImportRuleRunResult({ hostsEvaluated: 1 });
+
+    expect(parsed.deviceFailureReasons).toEqual([]);
+    expect(parsed.monitorFailureReasons).toEqual([]);
+    expect(parsed.monitorProvisioningHalted).toBe(false);
+  });
+
+  it("drops non-string, blank and surplus failure reasons", () => {
+    const parsed: AutoImportRuleRunResult =
+      RuleRunResultUtil.parseAutoImportRuleRunResult({
+        monitorFailureReasons: [
+          "  plan limit  ",
+          "",
+          "   ",
+          42,
+          null,
+          "duplicate key",
+          "third",
+          "fourth",
+        ],
+        deviceFailureReasons: "not an array",
+      } as unknown as JSONObject);
+
+    expect(parsed.monitorFailureReasons).toEqual([
+      "plan limit",
+      "duplicate key",
+      "third",
+    ]);
+    expect(parsed.deviceFailureReasons).toEqual([]);
+  });
+
+  it("truncates an over-long failure reason", () => {
+    const parsed: AutoImportRuleRunResult =
+      RuleRunResultUtil.parseAutoImportRuleRunResult({
+        monitorFailureReasons: ["x".repeat(MAX_RUN_FAILURE_REASON_LENGTH + 50)],
+      } as unknown as JSONObject);
+
+    expect(parsed.monitorFailureReasons[0]!.length).toBe(
+      MAX_RUN_FAILURE_REASON_LENGTH,
+    );
+  });
+
   it("reads every missing monitor counter as zero for older servers", () => {
     const parsed: AutoImportRuleRunResult =
       RuleRunResultUtil.parseAutoImportRuleRunResult({

package/Tests/Types/NetworkAutomation/RuleRunResultDescribe.test.ts

@@ -27,7 +27,13 @@ function result(
     monitorsSkippedAlreadyExisting: 0,
     monitorsSkippedUnsupportedHost: 0,
     monitorsFailed: 0,
+    deviceFailureReasons: [],
+    monitorFailureReasons: [],
+    monitorProvisioningHalted: false,
     isTruncated: false,
+    hostsPendingImport: 0,
+    monitorsPendingCreation: 0,
+    hasUnevaluatedScans: false,
     hasMoreScans: false,
     isDryRun: false,
     matchedIpAddressSample: [],
@@ -59,7 +65,29 @@ describe("RuleRunResultUtil.describeAutoImportRun", () => {
       hostsEvaluated: 12,
     });
     expect(summary).toContain("No devices were imported.");
-    expect(summary).toContain("matched 0 hosts out of the 12 hosts");
+    expect(summary).toContain(
+      "matched 0 hosts out of the 12 discovered hosts it looked at",
+    );
+  });
+
+  /*
+   * The denominator used to compose two nouns — "out of the 501 hosts
+   * discovered hosts it looked at" — which is what the report on issue #3643
+   * actually read.
+   */
+  it("does not double the noun in the matched-out-of sentence", () => {
+    expect(describe_({ hostsMatched: 501, hostsEvaluated: 501 })).not.toContain(
+      "hosts discovered hosts",
+    );
+    expect(
+      describe_({ isDryRun: true, hostsMatched: 0, hostsEvaluated: 501 }),
+    ).not.toContain("hosts discovered hosts");
+  });
+
+  it("uses singular grammar for a single discovered host", () => {
+    expect(describe_({ hostsMatched: 0, hostsEvaluated: 1 })).toContain(
+      "out of the 1 discovered host it looked at",
+    );
   });
 
   it("a dry run that would import reports the projection and writes nothing", () => {
@@ -137,9 +165,289 @@ describe("RuleRunResultUtil.describeAutoImportRun", () => {
     expect(dry).not.toContain("run again to continue");
   });
 
+  /*
+   * Issue #3643. A run that reached the cap having created nothing has nothing
+   * to resume: the identical run would fail identically. "Run again to
+   * continue" was the advice that report gave, and it was an instruction to
+   * repeat a doomed run.
+   */
+  it("does not promise progress for a truncated run that created nothing", () => {
+    const summary: string = describe_({
+      isTruncated: true,
+      hostsMatched: 501,
+      hostsEvaluated: 501,
+      hostsSkippedAlreadyRegistered: 501,
+      devicesCreated: 0,
+      monitorsCreated: 0,
+      monitorsFailed: 500,
+    });
+
+    expect(summary).not.toContain("run again to continue");
+    expect(summary).toContain(
+      "Stopped at the run cap without creating anything",
+    );
+    expect(summary).toContain("fix the failures reported above first");
+  });
+
+  it("still promises progress for a truncated run that created monitors only", () => {
+    expect(
+      describe_({
+        isTruncated: true,
+        devicesCreated: 0,
+        monitorsCreated: 12,
+      }),
+    ).toContain("run again to continue");
+  });
+
+  it("gives the reason monitors could not be created instead of pointing at logs", () => {
+    const summary: string = describe_({
+      hostsMatched: 501,
+      hostsEvaluated: 501,
+      monitorsFailed: 501,
+      monitorFailureReasons: [
+        "This rule's Monitor Template could not be loaded",
+      ],
+    });
+
+    expect(summary).toContain(
+      "Reason: This rule's Monitor Template could not be loaded.",
+    );
+    expect(summary).not.toContain("check the server logs");
+  });
+
+  it("still points at the logs when the server recorded no reason", () => {
+    expect(describe_({ monitorsFailed: 2 })).toContain(
+      "Their network devices remain imported. Check the server logs for the reason.",
+    );
+    expect(describe_({ devicesFailed: 2 })).toContain(
+      "2 hosts could not be imported. Check the server logs for the reason.",
+    );
+  });
+
+  it("renders several distinct reasons as one list and punctuates each", () => {
+    const summary: string = describe_({
+      monitorsFailed: 4,
+      monitorFailureReasons: ["Plan limit reached", "Duplicate key."],
+    });
+
+    expect(summary).toContain("Reasons: Plan limit reached. Duplicate key.");
+  });
+
+  it("gives the reason devices could not be imported", () => {
+    expect(
+      describe_({
+        devicesFailed: 3,
+        deviceFailureReasons: ["Device name is too long"],
+      }),
+    ).toContain(
+      "3 hosts could not be imported. Reason: Device name is too long.",
+    );
+  });
+
+  it("says monitor provisioning stopped rather than leaving it implied", () => {
+    const summary: string = describe_({
+      hostsMatched: 501,
+      hostsEvaluated: 501,
+      monitorsFailed: 501,
+      monitorProvisioningHalted: true,
+      monitorFailureReasons: ["Plan limit reached"],
+    });
+
+    expect(summary).toContain(
+      "Monitor provisioning stopped for the rest of this run",
+    );
+    expect(summary).toContain("Fix it and run this rule again.");
+  });
+
   it("warns when older scans went unread", () => {
     expect(describe_({ hasMoreScans: true, devicesCreated: 1 })).toContain(
       "Only the newest 100 completed scans were read",
     );
   });
+
+  /*
+   * OneUptime issue #3642: "909 discovered, 500+ imported, the rest silently
+   * skipped". The cap itself was working as designed; what made it read as
+   * silence was a report that named neither how much was left nor the fact
+   * that the monitor half of the work had its own separate ceiling.
+   */
+  describe("what a capped run says it left behind (issue #3642)", () => {
+    it("names the hosts a device cap left un-imported", () => {
+      const summary: string = describe_({
+        isTruncated: true,
+        devicesCreated: 500,
+        hostsEvaluated: 909,
+        hostsMatched: 909,
+        hostsPendingImport: 409,
+      });
+
+      expect(summary).toContain("Imported 500 hosts as network devices.");
+      expect(summary).toContain(
+        "Stopped at the run cap with 409 hosts still to import.",
+      );
+      expect(summary).toContain("Run again to continue");
+    });
+
+    it("names the devices a monitor cap left unmonitored", () => {
+      const summary: string = describe_({
+        isTruncated: true,
+        devicesCreated: 0,
+        monitorsCreated: 500,
+        hostsEvaluated: 909,
+        hostsMatched: 909,
+        hostsSkippedAlreadyRegistered: 909,
+        monitorsPendingCreation: 409,
+      });
+
+      expect(summary).toContain(
+        "Stopped at the run cap with 409 active Network Device monitors still to create.",
+      );
+      // The device half is not claimed as pending — it was already imported.
+      expect(summary).not.toContain("still to import");
+    });
+
+    it("reports both halves when both caps left work behind", () => {
+      expect(
+        describe_({
+          isTruncated: true,
+          devicesCreated: 500,
+          monitorsCreated: 500,
+          hostsPendingImport: 12,
+          monitorsPendingCreation: 3,
+        }),
+      ).toContain(
+        "12 hosts still to import and 3 active Network Device monitors still to create",
+      );
+    });
+
+    it("uses singular grammar for a remainder of one", () => {
+      const summary: string = describe_({
+        isTruncated: true,
+        devicesCreated: 500,
+        hostsPendingImport: 1,
+        monitorsPendingCreation: 1,
+      });
+
+      expect(summary).toContain("1 host still to import");
+      expect(summary).toContain("1 active Network Device monitor still to");
+    });
+
+    /*
+     * A capped run stops opening scans, so what it counted is a floor. It
+     * must not be reported as the total, or the operator reads "409 left",
+     * runs it again, and finds more than 409 appear.
+     */
+    it("reports the remainder as a floor when scans went unread", () => {
+      expect(
+        describe_({
+          isTruncated: true,
+          devicesCreated: 500,
+          hostsPendingImport: 409,
+          hasUnevaluatedScans: true,
+        }),
+      ).toContain("at least 409 hosts still to import");
+    });
+
+    it("quantifies a dry run's remainder without promising a resume", () => {
+      const summary: string = describe_({
+        isDryRun: true,
+        isTruncated: true,
+        hostsMatched: 909,
+        hostsEvaluated: 909,
+        hostsPendingImport: 409,
+      });
+
+      expect(summary).toContain(
+        "Stopped counting at the run cap with 409 hosts still to import",
+      );
+      expect(summary).toContain("device-import and active-monitor creation");
+      expect(summary).not.toContain("run again to continue");
+    });
+
+    /*
+     * A pre-#3642 server sends no pending counters, so they parse as zero.
+     * The sentence must fall back rather than print "with  —".
+     */
+    /*
+     * The two truncation truths compose. A run that created nothing resumes
+     * nowhere (issue #3643), but the remainder is still the size of the
+     * problem to fix, so it is named without the "run again" advice.
+     */
+    it("names the remainder without promising a resume when nothing was created", () => {
+      const summary: string = describe_({
+        isTruncated: true,
+        devicesCreated: 0,
+        monitorsCreated: 0,
+        monitorsFailed: 500,
+        monitorsPendingCreation: 409,
+      });
+
+      expect(summary).toContain(
+        "Stopped at the run cap without creating anything, with 409 active Network Device monitors still to create.",
+      );
+      expect(summary).toContain("would repeat the same failures");
+      expect(summary).not.toContain("Run again to continue");
+    });
+
+    it("falls back to the unquantified sentence with nothing counted", () => {
+      const summary: string = describe_({
+        isTruncated: true,
+        devicesCreated: 5,
+      });
+
+      expect(summary).toContain(
+        "Stopped at the run cap — run again to continue",
+      );
+      expect(summary).not.toContain("still to import");
+    });
+
+    /*
+     * A monitor backfill over an already-imported estate creates no devices
+     * at all. "No devices were imported" read as total failure directly
+     * above "Created 500 active Network Device monitors".
+     */
+    it("does not read a monitor backfill as an import that did nothing", () => {
+      const summary: string = describe_({
+        devicesCreated: 0,
+        monitorsCreated: 500,
+        hostsEvaluated: 909,
+        hostsMatched: 909,
+        hostsSkippedAlreadyRegistered: 909,
+      });
+
+      expect(summary).toContain("No new network devices were imported.");
+      expect(summary).toContain(
+        "Created 500 active Network Device monitors from the selected Monitor Template.",
+      );
+    });
+
+    it("still says nothing happened when nothing happened", () => {
+      expect(describe_({ hostsEvaluated: 9, hostsMatched: 0 })).toContain(
+        "No devices were imported. This rule matched 0 hosts out of the 9 discovered hosts it looked at.",
+      );
+    });
+  });
+
+  /*
+   * The "still working" line a chained press shows between passes. It exists
+   * because a run that now spans several requests must not look like a hang.
+   */
+  describe("progress while the passes are still chaining", () => {
+    it("names what has landed so far", () => {
+      const progress: string = RuleRunResultUtil.describeAutoImportProgress(
+        result({ devicesCreated: 500, monitorsCreated: 500 }),
+      );
+
+      expect(progress).toContain(
+        "500 hosts imported, 500 active Network Device monitors created so far",
+      );
+      expect(progress).toContain("leave this open");
+    });
+
+    it("says something even before the first pass has created anything", () => {
+      expect(RuleRunResultUtil.describeAutoImportProgress(result({}))).toBe(
+        "Still importing…",
+      );
+    });
+  });
 });