@oneuptime/common 12.0.33 → 13.0.0

package/Tests/Utils/NetworkAutomation/AutoImportRunChain.test.ts

@@ -0,0 +1,320 @@
+import AutoImportRunChain, {
+  AutoImportRunChainOutcome,
+} from "../../../Utils/NetworkAutomation/AutoImportRunChain";
+import {
+  AutoImportRuleRunResult,
+  MAX_AUTO_IMPORT_RUN_PASSES,
+} from "../../../Types/NetworkAutomation/RuleRunResult";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * One press of "Run Rule" drives as many capped server passes as the estate
+ * needs. Before OneUptime issue #3642 it drove exactly one, so a 909-device
+ * estate imported 500 and stopped — with the remainder reachable only by an
+ * operator who noticed the cap line and pressed the button again.
+ *
+ * The loop's exits are the whole contract: done, no progress, cancelled, or
+ * the chain's own ceiling. Each one is asserted here, with no renderer in the
+ * import graph.
+ */
+
+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,
+  };
+}
+
+// Answers with the given passes in order, then repeats the last one forever.
+function serve(responses: Array<AutoImportRuleRunResult | null>): {
+  runPass: () => Promise<AutoImportRuleRunResult | null>;
+  calls: () => number;
+} {
+  let index: number = 0;
+
+  return {
+    calls: (): number => {
+      return index;
+    },
+    runPass: async (): Promise<AutoImportRuleRunResult | null> => {
+      const answer: AutoImportRuleRunResult | null =
+        responses[Math.min(index, responses.length - 1)] ?? null;
+      index++;
+      return answer;
+    },
+  };
+}
+
+describe("AutoImportRunChain", () => {
+  /*
+   * The issue, reproduced at the seam that fixes it: the server can only do
+   * 500 at a time, the estate is 909, and one press has to finish it.
+   */
+  it("keeps running passes until the server stops reporting truncation", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({
+        hostsEvaluated: 909,
+        hostsMatched: 909,
+        devicesCreated: 500,
+        hostsPendingImport: 409,
+        isTruncated: true,
+      }),
+      pass({
+        hostsEvaluated: 909,
+        hostsMatched: 909,
+        hostsSkippedAlreadyRegistered: 500,
+        devicesCreated: 409,
+      }),
+    ]);
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: server.runPass,
+    });
+
+    expect(server.calls()).toBe(2);
+    expect(outcome.passCount).toBe(2);
+    expect(outcome.result?.devicesCreated).toBe(909);
+    expect(outcome.result?.isTruncated).toBe(false);
+    expect(outcome.result?.hostsPendingImport).toBe(0);
+  });
+
+  it("stops after one pass when nothing was truncated", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({ devicesCreated: 3 }),
+    ]);
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: server.runPass,
+    });
+
+    expect(server.calls()).toBe(1);
+    expect(outcome.result?.devicesCreated).toBe(3);
+  });
+
+  /*
+   * A pass that hit the cap without creating anything — every attempt failed,
+   * or a concurrent sweep had already spent the project's budget — would fail
+   * identically next time. Chaining into it would spin.
+   */
+  it("stops when a truncated pass made no progress", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({
+        devicesCreated: 0,
+        monitorsCreated: 0,
+        devicesFailed: 500,
+        hostsPendingImport: 409,
+        isTruncated: true,
+      }),
+    ]);
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: server.runPass,
+    });
+
+    expect(server.calls()).toBe(1);
+    expect(outcome.result?.isTruncated).toBe(true);
+    // The remainder is still reported, so the operator is not left guessing.
+    expect(outcome.result?.hostsPendingImport).toBe(409);
+  });
+
+  /*
+   * A pass that halted monitor provisioning has proved the fault is systemic
+   * (issue #3643). It creates nothing, so the no-progress exit already stops
+   * the chain — pinned here because chaining into a halted run would repeat
+   * the identical failure up to the pass ceiling.
+   */
+  it("does not chain past a run that halted monitor provisioning", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({
+        monitorsFailed: 500,
+        monitorProvisioningHalted: true,
+        monitorFailureReasons: [
+          "This rule's Monitor Template could not be loaded.",
+        ],
+        monitorsPendingCreation: 409,
+        isTruncated: true,
+      }),
+    ]);
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: server.runPass,
+    });
+
+    expect(server.calls()).toBe(1);
+    expect(outcome.result?.monitorProvisioningHalted).toBe(true);
+    expect(outcome.result?.monitorFailureReasons).toHaveLength(1);
+  });
+
+  // A monitor-only pass IS progress, even with zero devices created.
+  it("keeps going when only monitors were created", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({
+        monitorsCreated: 500,
+        monitorsPendingCreation: 409,
+        isTruncated: true,
+      }),
+      pass({ monitorsCreated: 409 }),
+    ]);
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: server.runPass,
+    });
+
+    expect(server.calls()).toBe(2);
+    expect(outcome.result?.monitorsCreated).toBe(909);
+    expect(outcome.result?.monitorsPendingCreation).toBe(0);
+  });
+
+  /*
+   * A dry run writes nothing, so the next pass would evaluate the identical
+   * estate and answer identically. Chaining it would be an infinite loop that
+   * accomplishes nothing.
+   */
+  it("never chains a dry run", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({ isDryRun: true, isTruncated: true, monitorsWouldCreate: 500 }),
+    ]);
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: true,
+      runPass: server.runPass,
+    });
+
+    expect(server.calls()).toBe(1);
+    expect(outcome.result?.isTruncated).toBe(true);
+  });
+
+  /*
+   * "One press finishes the job" must not mean "one press runs for an hour".
+   * Past the ceiling the operator gets a report of what is left and decides.
+   */
+  it("stops at its own ceiling and reports what is left", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({ devicesCreated: 500, hostsPendingImport: 400, isTruncated: true }),
+    ]);
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      maxPasses: 3,
+      runPass: server.runPass,
+    });
+
+    expect(server.calls()).toBe(3);
+    expect(outcome.passCount).toBe(3);
+    expect(outcome.result?.devicesCreated).toBe(1500);
+    expect(outcome.result?.isTruncated).toBe(true);
+    expect(outcome.result?.hostsPendingImport).toBe(400);
+  });
+
+  it("defaults to the shared pass ceiling", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({ devicesCreated: 1, hostsPendingImport: 1, isTruncated: true }),
+    ]);
+
+    await AutoImportRunChain.run({ isDryRun: false, runPass: server.runPass });
+
+    expect(server.calls()).toBe(MAX_AUTO_IMPORT_RUN_PASSES);
+  });
+
+  /*
+   * A failed pass does not undo the ones before it: 500 devices really were
+   * imported, and throwing that summary away would leave the operator less
+   * informed than before they pressed the button.
+   */
+  it("keeps earlier passes when a later one fails", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({ devicesCreated: 500, hostsPendingImport: 409, isTruncated: true }),
+      null,
+    ]);
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: server.runPass,
+    });
+
+    expect(server.calls()).toBe(2);
+    expect(outcome.passCount).toBe(1);
+    expect(outcome.result?.devicesCreated).toBe(500);
+  });
+
+  it("has nothing to report when the very first pass fails", async () => {
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: async (): Promise<AutoImportRuleRunResult | null> => {
+        return null;
+      },
+    });
+
+    expect(outcome.result).toBeNull();
+    expect(outcome.passCount).toBe(0);
+  });
+
+  // Closing the dialog must not leave a chain importing behind the operator.
+  it("stops chaining once cancelled", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({ devicesCreated: 500, hostsPendingImport: 409, isTruncated: true }),
+    ]);
+    let cancelled: boolean = false;
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: async (): Promise<AutoImportRuleRunResult | null> => {
+        cancelled = true;
+        return server.runPass();
+      },
+      isCancelled: (): boolean => {
+        return cancelled;
+      },
+    });
+
+    expect(server.calls()).toBe(1);
+    expect(outcome.wasCancelled).toBe(true);
+    // What the one completed pass did is still accounted for.
+    expect(outcome.result?.devicesCreated).toBe(500);
+  });
+
+  it("reports progress after each truncated pass, never after the last", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({ devicesCreated: 500, hostsPendingImport: 409, isTruncated: true }),
+      pass({ devicesCreated: 409 }),
+    ]);
+    const progressSeen: Array<number> = [];
+
+    await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: server.runPass,
+      onProgress: (progress: AutoImportRuleRunResult): void => {
+        progressSeen.push(progress.devicesCreated);
+      },
+    });
+
+    expect(progressSeen).toEqual([500]);
+  });
+});

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

@@ -0,0 +1,117 @@
+import {
+  DISCOVERY_SCAN_IMPORTABLE_STATUSES,
+  DiscoveryScanStatus,
+  isDiscoveryScanInProgress,
+} from "../../../Utils/NetworkDiscovery/DiscoveryScanStatus";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * The shared vocabulary for a discovery scan's lifecycle.
+ *
+ * `status` is a ShortText column holding one of four persisted strings, and
+ * those strings were written as bare literals in a dozen places — the two
+ * probe-ingest endpoints, the requeue/reaper worker, the auto-import worker
+ * and its engine, the scan service's retire payload, the Discovery page. That
+ * was fine until one question had to be answered identically in several of
+ * them: "which statuses may auto-import read from" (OneUptime issue #3599)
+ * has to match in the worker's query, in the engine's re-read AND in the
+ * compare-and-set that stamps the scan afterwards.
+ *
+ * These tests pin the values (they are persisted, so a rename is a migration,
+ * not an edit) and the membership of the importable set, which is a product
+ * decision rather than a spelling.
+ */
+
+describe("DiscoveryScanStatus", () => {
+  /*
+   * Persisted strings. A row written last year holds "In Progress" with that
+   * exact spelling and space; changing any of these silently stops matching
+   * every existing row.
+   */
+  it("spells the four persisted statuses exactly", () => {
+    expect(DiscoveryScanStatus.Pending).toBe("Pending");
+    expect(DiscoveryScanStatus.InProgress).toBe("In Progress");
+    expect(DiscoveryScanStatus.Completed).toBe("Completed");
+    expect(DiscoveryScanStatus.Failed).toBe("Failed");
+  });
+});
+
+describe("DISCOVERY_SCAN_IMPORTABLE_STATUSES", () => {
+  /*
+   * The change #3599 asked for: a sweep uploads what it has found every 30
+   * seconds, so a running scan's row already holds real hosts. Waiting for
+   * the whole range is what left 527 discovered switches unimportable for a
+   * day.
+   */
+  it("includes a scan that is still sweeping", () => {
+    expect(DISCOVERY_SCAN_IMPORTABLE_STATUSES).toContain(
+      DiscoveryScanStatus.InProgress,
+    );
+  });
+
+  it("includes a finished scan", () => {
+    expect(DISCOVERY_SCAN_IMPORTABLE_STATUSES).toContain(
+      DiscoveryScanStatus.Completed,
+    );
+  });
+
+  /*
+   * Excluded for opposite reasons, and both matter. A Pending row's results
+   * describe a run that has been superseded — the ingest endpoint discards
+   * results for one on exactly that ground, so importing from it would import
+   * a run the product has already disowned. A Failed row's results are real,
+   * but the operator has been told that run failed; importing from it should
+   * be their decision, through the rule's Run Now.
+   */
+  it("excludes a queued scan and a failed one", () => {
+    expect(DISCOVERY_SCAN_IMPORTABLE_STATUSES).not.toContain(
+      DiscoveryScanStatus.Pending,
+    );
+    expect(DISCOVERY_SCAN_IMPORTABLE_STATUSES).not.toContain(
+      DiscoveryScanStatus.Failed,
+    );
+  });
+
+  it("holds exactly those two, so a new status is a deliberate decision", () => {
+    expect([...DISCOVERY_SCAN_IMPORTABLE_STATUSES].sort()).toEqual([
+      "Completed",
+      "In Progress",
+    ]);
+  });
+
+  /*
+   * Read by a query builder, a re-read and a compare-and-set that must all
+   * mean the same thing — so nothing may push onto it at runtime.
+   */
+  it("is frozen", () => {
+    expect(Object.isFrozen(DISCOVERY_SCAN_IMPORTABLE_STATUSES)).toBe(true);
+  });
+});
+
+describe("isDiscoveryScanInProgress", () => {
+  it("is true only for a scan that is mid-sweep", () => {
+    expect(isDiscoveryScanInProgress({ status: "In Progress" })).toBe(true);
+    expect(isDiscoveryScanInProgress({ status: "Completed" })).toBe(false);
+    expect(isDiscoveryScanInProgress({ status: "Pending" })).toBe(false);
+    expect(isDiscoveryScanInProgress({ status: "Failed" })).toBe(false);
+  });
+
+  /*
+   * Nullish-safe: this is called from a table cell against rows read with
+   * whatever columns that page selected, so "the column is not here" must
+   * answer "not in progress" rather than throw inside a render.
+   */
+  it("answers false rather than throwing for a row it cannot read", () => {
+    expect(isDiscoveryScanInProgress(null)).toBe(false);
+    expect(isDiscoveryScanInProgress(undefined)).toBe(false);
+    expect(isDiscoveryScanInProgress({})).toBe(false);
+    expect(isDiscoveryScanInProgress({ status: undefined })).toBe(false);
+    expect(isDiscoveryScanInProgress({ status: null })).toBe(false);
+  });
+
+  // Persisted spelling, not a case-insensitive match.
+  it("does not accept a different spelling of the same idea", () => {
+    expect(isDiscoveryScanInProgress({ status: "in progress" })).toBe(false);
+    expect(isDiscoveryScanInProgress({ status: "InProgress" })).toBe(false);
+  });
+});

package/Tests/Utils/Rum/ChunkMath.test.ts

@@ -284,3 +284,86 @@ describe("ChunkMath", () => {
     });
   });
 });
+
+describe("ChunkMath player helpers", () => {
+  const entry: (
+    chunkIndex: number,
+    eventCount: number,
+  ) => SessionReplayChunkManifestEntry = (
+    chunkIndex: number,
+    eventCount: number,
+  ): SessionReplayChunkManifestEntry => {
+    return {
+      chunkIndex: chunkIndex,
+      tabId: "tab-1",
+      chunkStartOffsetMs: chunkIndex * 15000,
+      chunkEndOffsetMs: (chunkIndex + 1) * 15000,
+      eventCount: eventCount,
+      hasFullSnapshot: false,
+      payloadBytes: 100,
+      errorCount: 0,
+      rageClickCount: 0,
+      deadClickCount: 0,
+      errorClickCount: 0,
+      refreshRageCount: 0,
+      routeCount: 0,
+    };
+  };
+
+  describe("isTerminatorEntry", () => {
+    it("recognises the recorder's zero-event closing rows", () => {
+      expect(ChunkMath.isTerminatorEntry(entry(3, 0))).toBe(true);
+      expect(ChunkMath.isTerminatorEntry(entry(3, 1))).toBe(false);
+      /* A malformed count is not footage either. */
+      expect(ChunkMath.isTerminatorEntry(entry(3, Number.NaN))).toBe(true);
+    });
+  });
+
+  describe("findNextAnchorAfter", () => {
+    it("returns the smallest anchor strictly after the index", () => {
+      expect(ChunkMath.findNextAnchorAfter([0, 4, 8], 4)).toBe(8);
+      expect(ChunkMath.findNextAnchorAfter([8, 0, 4], 1)).toBe(4);
+      expect(ChunkMath.findNextAnchorAfter([0, 4, 8], 8)).toBeNull();
+      expect(ChunkMath.findNextAnchorAfter([], 0)).toBeNull();
+    });
+  });
+
+  describe("isContiguousRange", () => {
+    it("is true only when every index in the range is present", () => {
+      const present: Set<number> = new Set<number>([0, 1, 2, 4]);
+
+      expect(ChunkMath.isContiguousRange(present, 0, 2)).toBe(true);
+      expect(ChunkMath.isContiguousRange(present, 1, 4)).toBe(false);
+      expect(ChunkMath.isContiguousRange(present, 2, 2)).toBe(true);
+      expect(ChunkMath.isContiguousRange(present, 3, 2)).toBe(false);
+    });
+  });
+
+  describe("planPriorityPage", () => {
+    it("pairs the anchor with the chunk after it, else the one before it", () => {
+      expect(ChunkMath.planPriorityPage(new Set<number>([0, 1, 2]), 0)).toEqual(
+        [0, 1],
+      );
+      expect(ChunkMath.planPriorityPage(new Set<number>([0, 1, 2]), 2)).toEqual(
+        [1, 2],
+      );
+      expect(ChunkMath.planPriorityPage(new Set<number>([5]), 5)).toEqual([5]);
+      expect(ChunkMath.planPriorityPage(new Set<number>([5]), 6)).toEqual([]);
+    });
+  });
+
+  describe("clampSeekOffset", () => {
+    it("clamps into [earliest playable, duration] and never below the first snapshot", () => {
+      expect(ChunkMath.clampSeekOffset(0, 15000, 60000)).toBe(15000);
+      expect(ChunkMath.clampSeekOffset(-5, 0, 60000)).toBe(0);
+      expect(ChunkMath.clampSeekOffset(30000, 15000, 60000)).toBe(30000);
+      expect(ChunkMath.clampSeekOffset(99000, 15000, 60000)).toBe(60000);
+      expect(ChunkMath.clampSeekOffset(Number.NaN, 15000, 60000)).toBe(15000);
+    });
+
+    it("lands on the earliest playable moment when the duration is behind it", () => {
+      /* A manifest whose only anchor sits past its stated end still plays. */
+      expect(ChunkMath.clampSeekOffset(0, 30000, 20000)).toBe(30000);
+    });
+  });
+});