@oneuptime/common 13.0.5 → 13.0.6

package/Tests/Server/Services/NetworkDeviceDiscoveryScanService.test.ts

@@ -3594,3 +3594,109 @@ describe("NetworkDeviceDiscoveryScanService: a legacy save leaves the list rebui
     }
   });
 });
+
+/*
+ * The short-device-names toggle (issue #3678) is a NAMING choice, not a sweep
+ * input, and it is deliberately left out of SWEEP_COLUMNS.
+ *
+ * It changes what the scan's hosts are CALLED when they are imported — by the
+ * Review dialog and by the auto-import engine, both of which read it at import
+ * time — and nothing about what the probe asks of any address. The hosts
+ * already on the row are exactly the hosts a sweep with the toggle flipped
+ * would find. Retiring the run on this save would delete a finished result
+ * set (possibly a 24-hour sweep of a /16) to re-find the same hosts, and the
+ * dashboard copy promises the opposite: the toggle applies to the Review
+ * dialog without a rescan.
+ */
+describe("NetworkDeviceDiscoveryScanService: the short-device-names toggle is not a sweep setting", () => {
+  it("reads nothing and writes nothing when only the toggle is turned on", async () => {
+    const writes: Array<ReconcileWrite> = await saveSettings({
+      useShortDeviceNames: true,
+    });
+
+    // The cheap exit: not a sweep column, not a schedule column.
+    expect(lastFindByArgs).toBeNull();
+    expect(writes).toEqual([]);
+  });
+
+  it("reads nothing and writes nothing when only the toggle is turned off", async () => {
+    storedScans = [storedScan()];
+    (storedScans[0] as unknown as Record<string, unknown>)[
+      "useShortDeviceNames"
+    ] = true;
+
+    const writes: Array<ReconcileWrite> = await saveSettings({
+      useShortDeviceNames: false,
+    });
+
+    expect(lastFindByArgs).toBeNull();
+    expect(writes).toEqual([]);
+  });
+
+  /*
+   * Handed back as the SAME updateBy with no carry-forward, the pass-through
+   * the hook-free writers depend on — a toggle-only payload must look to this
+   * hook exactly like a rename.
+   */
+  it("passes a toggle-only update through untouched", async () => {
+    const updateBy: UpdateBy<NetworkDeviceDiscoveryScan> = makeUpdateBy({
+      useShortDeviceNames: true,
+    });
+
+    const result: { updateBy: unknown; carryForward: unknown } =
+      (await onBeforeUpdate(updateBy)) as {
+        updateBy: unknown;
+        carryForward: unknown;
+      };
+
+    expect(result.carryForward).toBeNull();
+    expect(result.updateBy).toBe(updateBy);
+    expect(Object.keys(updateBy.data)).toEqual(["useShortDeviceNames"]);
+  });
+
+  /*
+   * What the Edit dialog really sends: every declared field, the toggle
+   * flipped and nothing else changed. The sweep columns ride along, so the
+   * hook DOES read the stored row here — and must conclude nothing changed.
+   */
+  it("does not retire the run when the whole form is re-posted with only the toggle flipped", async () => {
+    const writes: Array<ReconcileWrite> = await saveSettings({
+      ...unchangedSave(),
+      useShortDeviceNames: true,
+    });
+
+    expect(writes).toEqual([]);
+  });
+
+  /*
+   * A sweep still in flight is the expensive case: retiring it would abandon
+   * the run and throw away the partial results already uploaded.
+   */
+  it("does not abandon a run that is still in progress when the toggle is flipped", async () => {
+    storedScans = [storedScan({ status: "In Progress" })];
+
+    const writes: Array<ReconcileWrite> = await saveSettings({
+      ...unchangedSave(),
+      useShortDeviceNames: true,
+    });
+
+    expect(writes).toEqual([]);
+  });
+
+  /*
+   * And the toggle does not mask a real change saved alongside it: the
+   * comparison is per sweep column, so a new target in the same save still
+   * retires the run.
+   */
+  it("still retires the run when a sweep setting changes in the same save", async () => {
+    const writes: Array<ReconcileWrite> = await saveSettings({
+      ...unchangedSave(),
+      useShortDeviceNames: true,
+      cidr: "10.0.0.0/24",
+    });
+
+    expect(writes).toHaveLength(1);
+    expect(writes[0]!.data["status"]).toBe("Pending");
+    expect(writes[0]!.data["discoveredDevices"]).toBeNull();
+  });
+});

package/Tests/Server/Services/NetworkDeviceRuleEngines.test.ts

@@ -19,7 +19,7 @@ import RuleCriteria, {
   RuleCriteriaFilter,
   RuleCriteriaOperator,
 } from "../../../Types/Rules/RuleCriteria";
-import { describe, expect, it, afterEach } from "@jest/globals";
+import { describe, expect, it, afterEach, beforeEach } from "@jest/globals";
 
 /*
  * Contract under test - the network device label and owner rule engines, and
@@ -599,6 +599,15 @@ describe("NetworkDeviceLabelRuleEngineService - rule selection and attach", () =
 });
 
 describe("NetworkDeviceOwnerRuleEngineService - wildcard patterns", () => {
+  beforeEach(() => {
+    /*
+     * The engine skips owners the device already has, which reads the owner
+     * rows first. None of these devices has owners yet.
+     */
+    jest.spyOn(NetworkDeviceOwnerUserService, "findBy").mockResolvedValue([]);
+    jest.spyOn(NetworkDeviceOwnerTeamService, "findBy").mockResolvedValue([]);
+  });
+
   afterEach(() => {
     jest.restoreAllMocks();
   });

package/Tests/Server/Services/NetworkDeviceServicePastDueMonitoring.test.ts

@@ -0,0 +1,335 @@
+import { Service as NetworkDeviceServiceType } from "../../../Server/Services/NetworkDeviceService";
+import SubscriptionStatus, {
+  SubscriptionStatusUtil,
+} from "../../../Types/Billing/SubscriptionStatus";
+import ObjectID from "../../../Types/ObjectID";
+import {
+  CapturedStatement,
+  SUBSCRIPTION_COLUMNS,
+  SubscriptionColumn,
+  captureClaimStatements,
+  claimAdmitsProject,
+  expectPlaceholdersMatchParameters,
+  getBoundStatusList,
+  normalizeSql,
+} from "../TestingUtils/PastDueMonitoringClaimSql";
+import { afterEach, describe, expect, test } from "@jest/globals";
+
+/*
+ * WHAT THIS FILE IS DEFENDING
+ *
+ * claimDevicesForPolling is the device-owned twin of
+ * MonitorProbeService.claimMonitorProbesForProbing, and it carried the same
+ * hand-written "active subscription" copy: active and trialing only. A
+ * project whose subscription went past_due after ONE failed autopay attempt
+ * (in production, an India e-mandate card debit that sat in "processing" for
+ * a day and then declined) stopped having its network devices polled, while
+ * Stripe was still retrying and the dashboard still called the project
+ * active.
+ *
+ * Owner decision: past_due projects keep being monitored. Polling stops only
+ * for unpaid, canceled, incomplete, incomplete_expired, expired, paused.
+ * The status list is now SubscriptionStatusUtil.getActiveSubscriptionStatuses,
+ * bound as a parameter.
+ */
+
+const PROBE_ID: ObjectID = new ObjectID("33333333-3333-4333-8333-333333333333");
+
+const INACTIVE_STATUSES: Array<SubscriptionStatus> = [
+  SubscriptionStatus.Unpaid,
+  SubscriptionStatus.Canceled,
+  SubscriptionStatus.Incomplete,
+  SubscriptionStatus.IncompleteExpired,
+  SubscriptionStatus.Expired,
+  SubscriptionStatus.Paused,
+];
+
+const STILL_SERVED_STATUSES: Array<SubscriptionStatus | null> = [
+  null,
+  SubscriptionStatus.Active,
+  SubscriptionStatus.Trialing,
+  SubscriptionStatus.PastDue,
+];
+
+const ALL_VALUES: Array<SubscriptionStatus | null> = [
+  null,
+  ...Object.values(SubscriptionStatus),
+];
+
+type ProjectStatuses = {
+  paymentProviderSubscriptionStatus: string | null;
+  paymentProviderMeteredSubscriptionStatus: string | null;
+};
+
+async function captureClaim(
+  selectRows: Array<Record<string, unknown>> = [],
+  limit: number = 25,
+): Promise<{
+  statements: Array<CapturedStatement>;
+  select: CapturedStatement;
+  claimed: Array<ObjectID>;
+}> {
+  const service: NetworkDeviceServiceType = new NetworkDeviceServiceType();
+  const statements: Array<CapturedStatement> = captureClaimStatements(
+    service,
+    selectRows,
+  );
+
+  const claimed: Array<ObjectID> = await service.claimDevicesForPolling({
+    probeId: PROBE_ID,
+    limit,
+  });
+
+  expect(statements.length).toBeGreaterThanOrEqual(1);
+
+  return { statements, select: statements[0]!, claimed };
+}
+
+describe("NetworkDeviceService.claimDevicesForPolling keeps past_due projects polled", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("the production scenario", () => {
+    test("claims devices of a project whose metered subscription went past_due after a failed autopay", async () => {
+      const { select } = await captureClaim();
+
+      expect(
+        claimAdmitsProject(select, {
+          paymentProviderSubscriptionStatus: SubscriptionStatus.Active,
+          paymentProviderMeteredSubscriptionStatus: SubscriptionStatus.PastDue,
+        }),
+      ).toBe(true);
+    });
+
+    test("claims devices of a project with both subscriptions past_due", async () => {
+      const { select } = await captureClaim();
+
+      expect(
+        claimAdmitsProject(select, {
+          paymentProviderSubscriptionStatus: SubscriptionStatus.PastDue,
+          paymentProviderMeteredSubscriptionStatus: SubscriptionStatus.PastDue,
+        }),
+      ).toBe(true);
+    });
+
+    test("stops claiming once the subscription is canceled", async () => {
+      const { select } = await captureClaim();
+
+      expect(
+        claimAdmitsProject(select, {
+          paymentProviderSubscriptionStatus: SubscriptionStatus.Canceled,
+          paymentProviderMeteredSubscriptionStatus: SubscriptionStatus.PastDue,
+        }),
+      ).toBe(false);
+    });
+  });
+
+  describe.each(SUBSCRIPTION_COLUMNS)(
+    "the %s predicate",
+    (column: SubscriptionColumn) => {
+      const otherColumn: SubscriptionColumn = SUBSCRIPTION_COLUMNS.find(
+        (candidate: SubscriptionColumn) => {
+          return candidate !== column;
+        },
+      )!;
+
+      test.each(STILL_SERVED_STATUSES)(
+        "admits %p when the other subscription is active",
+        async (status: SubscriptionStatus | null) => {
+          const { select } = await captureClaim();
+
+          expect(
+            claimAdmitsProject(select, {
+              [column]: status,
+              [otherColumn]: SubscriptionStatus.Active,
+            } as ProjectStatuses),
+          ).toBe(true);
+        },
+      );
+
+      test.each(INACTIVE_STATUSES)(
+        "excludes %s even when the other subscription is active",
+        async (status: SubscriptionStatus) => {
+          const { select } = await captureClaim();
+
+          expect(
+            claimAdmitsProject(select, {
+              [column]: status,
+              [otherColumn]: SubscriptionStatus.Active,
+            } as ProjectStatuses),
+          ).toBe(false);
+        },
+      );
+
+      test.each(INACTIVE_STATUSES)(
+        "excludes a past_due project whose other subscription is %s",
+        async (status: SubscriptionStatus) => {
+          const { select } = await captureClaim();
+
+          expect(
+            claimAdmitsProject(select, {
+              [column]: SubscriptionStatus.PastDue,
+              [otherColumn]: status,
+            } as ProjectStatuses),
+          ).toBe(false);
+        },
+      );
+
+      test("appears exactly once and binds the shared active list", async () => {
+        const { select } = await captureClaim();
+
+        expect([...getBoundStatusList(select, column)].sort()).toEqual(
+          [...SubscriptionStatusUtil.getActiveSubscriptionStatuses()].sort(),
+        );
+      });
+    },
+  );
+
+  test("agrees with isSubscriptionActive for every combination of statuses", async () => {
+    const { select } = await captureClaim();
+
+    for (const planStatus of ALL_VALUES) {
+      for (const meteredStatus of ALL_VALUES) {
+        const expected: boolean =
+          SubscriptionStatusUtil.isSubscriptionActive(
+            planStatus || undefined,
+          ) &&
+          SubscriptionStatusUtil.isSubscriptionActive(
+            meteredStatus || undefined,
+          );
+
+        expect({
+          planStatus,
+          meteredStatus,
+          admitted: claimAdmitsProject(select, {
+            paymentProviderSubscriptionStatus: planStatus,
+            paymentProviderMeteredSubscriptionStatus: meteredStatus,
+          }),
+        }).toEqual({ planStatus, meteredStatus, admitted: expected });
+      }
+    }
+  });
+
+  /*
+   * Both claim queries must hand out the same set of projects. A device and
+   * a monitor in the same past_due project being treated differently is the
+   * same drift this change removes.
+   */
+  test("binds the same status list as the monitor claim query", async () => {
+    const { select } = await captureClaim();
+
+    expect(select.parameters[3]).toEqual(
+      SubscriptionStatusUtil.getActiveSubscriptionStatuses(),
+    );
+  });
+
+  describe("the statement itself", () => {
+    test("binds probeId, now, limit and the active statuses, in that order", async () => {
+      const { select } = await captureClaim([], 7);
+
+      expect(select.parameters).toHaveLength(4);
+      expect(select.parameters[0]).toBe(PROBE_ID.toString());
+      expect(select.parameters[1]).toBeInstanceOf(Date);
+      expect(select.parameters[2]).toBe(7);
+      expect(select.parameters[3]).toEqual(
+        SubscriptionStatusUtil.getActiveSubscriptionStatuses(),
+      );
+    });
+
+    test("uses every bound parameter and no unbound placeholder", async () => {
+      const { select } = await captureClaim();
+
+      expectPlaceholdersMatchParameters(select);
+    });
+
+    test("contains no hardcoded subscription status literal", async () => {
+      const { select } = await captureClaim();
+      const sql: string = normalizeSql(select.sql);
+
+      for (const status of Object.values(SubscriptionStatus)) {
+        expect(sql).not.toContain(`'${status}'`);
+        expect(sql).not.toContain(`"${status}"`);
+      }
+
+      expect(sql).not.toMatch(/SubscriptionStatus" IN \(/);
+    });
+
+    test("follows the shared list rather than a private copy", async () => {
+      jest
+        .spyOn(SubscriptionStatusUtil, "getActiveSubscriptionStatuses")
+        .mockReturnValue([SubscriptionStatus.Trialing]);
+
+      const { select } = await captureClaim();
+
+      expect(select.parameters[3]).toEqual([SubscriptionStatus.Trialing]);
+      expect(
+        claimAdmitsProject(select, {
+          paymentProviderSubscriptionStatus: SubscriptionStatus.Active,
+          paymentProviderMeteredSubscriptionStatus: null,
+        }),
+      ).toBe(false);
+    });
+
+    /*
+     * Everything else the claim guards - the tenancy backstop, the
+     * monitor-backed exclusion, the range-scan order, the device-only row
+     * lock - must be untouched by the subscription change.
+     */
+    test("keeps the tenancy backstop, ordering and locking intact", async () => {
+      const { select } = await captureClaim();
+      const sql: string = normalizeSql(select.sql);
+
+      expect(sql).toContain(
+        'INNER JOIN "Project" p ON nd."projectId" = p."_id"',
+      );
+      expect(sql).toContain('INNER JOIN "Probe" pr ON nd."probeId" = pr."_id"');
+      expect(sql).toContain(
+        'AND (pr."isGlobalProbe" = true OR pr."projectId" = nd."projectId")',
+      );
+      expect(sql).toContain('WHERE nd."probeId" = $1');
+      expect(sql).toContain('AND nd."nextPollAt" <= $2');
+      expect(sql).toContain('AND p."deletedAt" IS NULL');
+      expect(sql).toContain('ORDER BY nd."nextPollAt" ASC');
+      expect(sql).toContain("LIMIT $3");
+      expect(sql).toContain("FOR UPDATE OF nd SKIP LOCKED");
+    });
+  });
+
+  describe("after rows are claimed", () => {
+    test("returns nothing and runs no update when nothing is due", async () => {
+      const { statements, claimed } = await captureClaim([]);
+
+      expect(statements).toHaveLength(1);
+      expect(claimed).toEqual([]);
+    });
+
+    test("claims the selected rows and the update's own numbering still lines up", async () => {
+      const firstId: string = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
+      const secondId: string = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb";
+
+      const { statements, claimed } = await captureClaim([
+        { _id: firstId, pollingIntervalInMinutes: 10 },
+        { _id: secondId, pollingIntervalInMinutes: null },
+      ]);
+
+      expect(statements).toHaveLength(2);
+
+      const update: CapturedStatement = statements[1]!;
+
+      expect(normalizeSql(update.sql)).toContain('UPDATE "NetworkDevice"');
+      // (id, nextPollAt) per row, then the ids again for the IN list.
+      expect(update.parameters).toHaveLength(6);
+      expect(update.parameters).not.toContainEqual(
+        SubscriptionStatusUtil.getActiveSubscriptionStatuses(),
+      );
+      expectPlaceholdersMatchParameters(update);
+
+      expect(
+        claimed.map((id: ObjectID) => {
+          return id.toString();
+        }),
+      ).toEqual([firstId, secondId]);
+    });
+  });
+});