@oneuptime/common 13.0.5 → 13.0.6

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

@@ -68,7 +68,11 @@ jest.mock("../../../Server/Utils/Logger", () => {
   };
 });
 
-import { AUTO_IMPORT_SCAN_CREDENTIAL_SELECT } from "../../../Server/Services/NetworkDeviceAutoImportRuleEngineService";
+import {
+  AUTO_IMPORT_SCAN_BUILDER_SELECT,
+  AUTO_IMPORT_SCAN_CREDENTIAL_SELECT,
+} from "../../../Server/Services/NetworkDeviceAutoImportRuleEngineService";
+import NetworkDeviceDiscoveryScan from "../../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
 import { describe, expect, test } from "@jest/globals";
 import fs from "fs";
 import path from "path";
@@ -99,6 +103,73 @@ const BUILDER_SOURCE: string = fs.readFileSync(
   "utf8",
 );
 
+const ENGINE_SOURCE: string = fs.readFileSync(
+  path.join(
+    REPO_ROOT,
+    "Common",
+    "Server",
+    "Services",
+    "NetworkDeviceAutoImportRuleEngineService.ts",
+  ),
+  "utf8",
+);
+
+/*
+ * The property names an interface in DiscoveredDeviceBuilder.ts declares,
+ * INCLUDING the ones it inherits through `extends` from another interface in
+ * the same file.
+ *
+ * Read from source because an interface does not exist at runtime, and the
+ * inheritance is followed because that is exactly how the naming choice
+ * reaches DiscoveredDeviceScanSource: `useShortDeviceNames` is declared on
+ * DiscoveredHostNaming, not on the scan source itself. A parser that read
+ * only the scan source's own braces would never see it, and the pin below
+ * would pass on a select that forgot it.
+ *
+ * Comments are stripped first — the interfaces carry long block comments, and
+ * a sentence like "ON only when exactly `true`:" must not read as a property.
+ */
+function extractInterfaceProperties(
+  source: string,
+  interfaceName: string,
+): Array<string> {
+  const withoutComments: string = source
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/^\s*\/\/.*$/gm, "");
+
+  const match: RegExpMatchArray | null = withoutComments.match(
+    new RegExp(
+      `export\\s+interface\\s+${interfaceName}\\b(?:\\s+extends\\s+([\\w\\s,]+?))?\\s*\\{([^}]*)\\}`,
+    ),
+  );
+
+  if (!match) {
+    throw new Error(
+      `interface ${interfaceName} not found in DiscoveredDeviceBuilder.ts`,
+    );
+  }
+
+  const ownProperties: Array<string> = Array.from(
+    match[2]!.matchAll(/^\s*(\w+)\??\s*:/gm),
+  ).map((propertyMatch: RegExpMatchArray) => {
+    return propertyMatch[1]!;
+  });
+
+  const inheritedProperties: Array<string> = (match[1] || "")
+    .split(",")
+    .map((name: string) => {
+      return name.trim();
+    })
+    .filter((name: string) => {
+      return Boolean(name);
+    })
+    .flatMap((parentName: string) => {
+      return extractInterfaceProperties(source, parentName);
+    });
+
+  return Array.from(new Set([...inheritedProperties, ...ownProperties]));
+}
+
 /*
  * Every `snmp*: true` in the claim endpoint is a select entry — the file's
  * only other snmp mention is the `snmpReachable !== false` responder count,
@@ -221,3 +292,131 @@ describe("AUTO_IMPORT_SCAN_CREDENTIAL_SELECT", () => {
     expect(engineSelectKeysNeverMentionedByBuilder).toEqual([]);
   });
 });
+
+/*
+ * AUTO_IMPORT_SCAN_BUILDER_SELECT is what the engine ACTUALLY reads a scan
+ * with: the credentials above plus the scan's naming choice (issue #3678).
+ *
+ * The naming column is the same silent-drop hazard as a credential. The
+ * builder turns short names on only when `useShortDeviceNames === true`, so a
+ * scan read without that column arrives with it undefined — "off" — and every
+ * host of a scan that asked for "wb-0660-kds01" is auto-imported as
+ * "wb-0660-kds01.wbhq.com". No error, no log line, and on the one import path
+ * nobody reviews. These pin the select against the builder's own declared
+ * input, and pin the engine to reading scans through it.
+ */
+describe("AUTO_IMPORT_SCAN_BUILDER_SELECT", () => {
+  // Guard against the interface parser rotting into a vacuous pass.
+  test("the builder's scan source is extractable from its source, inherited naming included", () => {
+    const properties: Array<string> = extractInterfaceProperties(
+      BUILDER_SOURCE,
+      "DiscoveredDeviceScanSource",
+    );
+
+    expect(properties).toContain("probeId");
+    expect(properties).toContain("snmpConfigs");
+    expect(properties).toContain("snmpV3PrivKey");
+    /*
+     * Declared on DiscoveredHostNaming and inherited, so this is the assertion
+     * that proves `extends` is being followed rather than ignored.
+     */
+    expect(properties).toContain("useShortDeviceNames");
+    // Comment prose must never parse as a property.
+    expect(properties).not.toContain("ON");
+  });
+
+  test("selects the credential columns plus the naming choice, and nothing else", () => {
+    expect(Object.keys(AUTO_IMPORT_SCAN_BUILDER_SELECT).sort()).toEqual(
+      [
+        ...Object.keys(AUTO_IMPORT_SCAN_CREDENTIAL_SELECT),
+        "useShortDeviceNames",
+      ].sort(),
+    );
+
+    for (const key of Object.keys(AUTO_IMPORT_SCAN_BUILDER_SELECT)) {
+      expect({
+        key: key,
+        selected: AUTO_IMPORT_SCAN_BUILDER_SELECT[key],
+      }).toEqual({ key: key, selected: true });
+    }
+  });
+
+  /*
+   * The pin proper. Any name listed in this failure is a scan column the
+   * builder reads (it is on DiscoveredDeviceScanSource) that the engine does
+   * not select — a device built from that scan gets undefined for it.
+   */
+  test("covers every scan column the device builder reads", () => {
+    const scan: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan();
+
+    const scanSourceColumns: Array<string> = extractInterfaceProperties(
+      BUILDER_SOURCE,
+      "DiscoveredDeviceScanSource",
+    ).filter((property: string) => {
+      return scan.isTableColumn(property);
+    });
+
+    // Not vacuous: the credentials and the naming choice are all real columns.
+    expect(scanSourceColumns).toContain("snmpConfigs");
+    expect(scanSourceColumns).toContain("useShortDeviceNames");
+
+    const builderColumnsMissingFromEngineSelect: Array<string> =
+      scanSourceColumns.filter((column: string) => {
+        return !(column in AUTO_IMPORT_SCAN_BUILDER_SELECT);
+      });
+
+    expect(builderColumnsMissingFromEngineSelect).toEqual([]);
+  });
+
+  /*
+   * And the reverse: every key selected is a real column of the scan model.
+   * A misspelt key ("useShortDeviceName") would select nothing, and TypeORM
+   * would not say so — the select would simply carry a column that does not
+   * exist while the real one arrived undefined.
+   */
+  test("selects only real columns of the scan model", () => {
+    const scan: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan();
+
+    const selectKeysThatAreNotScanColumns: Array<string> = Object.keys(
+      AUTO_IMPORT_SCAN_BUILDER_SELECT,
+    ).filter((key: string) => {
+      return !scan.isTableColumn(key);
+    });
+
+    expect(selectKeysThatAreNotScanColumns).toEqual([]);
+  });
+
+  /*
+   * The credential select stays exactly what the probe sweeps with. The
+   * naming choice is not a sweep input, so it belongs to the builder select
+   * only; leaking it into the credential select would break the claim-endpoint
+   * lockstep above and hand the probe a column it has no use for.
+   */
+  test("leaves the naming choice out of the credential select", () => {
+    expect("useShortDeviceNames" in AUTO_IMPORT_SCAN_CREDENTIAL_SELECT).toBe(
+      false,
+    );
+  });
+
+  /*
+   * Both engine reads — the automatic path's (processCompletedScan) and Run
+   * Now's per-scan re-read (dry run included) — spread the BUILDER select. A
+   * read that spread the credential select instead would still compile and
+   * still import devices that poll; it would only import them under the wrong
+   * name, which is the failure no other test on the credential side can see.
+   * The engine suite pins the same thing behaviourally, per path.
+   */
+  test("the engine reads scans through the builder select on both paths", () => {
+    const builderSelectSpreads: number = Array.from(
+      ENGINE_SOURCE.matchAll(/\.\.\.AUTO_IMPORT_SCAN_BUILDER_SELECT\b/g),
+    ).length;
+
+    const credentialSelectSpreads: number = Array.from(
+      ENGINE_SOURCE.matchAll(/\.\.\.AUTO_IMPORT_SCAN_CREDENTIAL_SELECT\b/g),
+    ).length;
+
+    expect(builderSelectSpreads).toBe(2);
+    // Only inside the builder select's own definition.
+    expect(credentialSelectSpreads).toBe(1);
+  });
+});

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

@@ -0,0 +1,254 @@
+import { Service as BillingInvoiceService } from "../../../Server/Services/BillingInvoiceService";
+import logger from "../../../Server/Utils/Logger";
+import SubscriptionStatus from "../../../Types/Billing/SubscriptionStatus";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import ObjectID from "../../../Types/ObjectID";
+import { getJestSpyOn } from "../../Spy";
+import { beforeEach, describe, expect, it } from "@jest/globals";
+
+/*
+ * refreshSubscriptionStatus runs on every invoice list and every pay attempt,
+ * under a per-project Redis mutex. It only released that mutex when it got to
+ * the end, so any Stripe or database error left the project locked until the
+ * 15s lock timeout - and the next Pay Invoice click or invoice list waited on
+ * the 20s acquire timeout first. The customer who clicked Pay Invoice ten
+ * times during the stale-card incident was hitting exactly that path.
+ */
+
+const lockMock: jest.Mock = jest.fn();
+const releaseMock: jest.Mock = jest.fn();
+const findOneByIdMock: jest.Mock = jest.fn();
+const updateOneByIdMock: jest.Mock = jest.fn();
+const reactiveSubscriptionMock: jest.Mock = jest.fn();
+const getSubscriptionStatusMock: jest.Mock = jest.fn();
+const getInvoicesMock: jest.Mock = jest.fn();
+
+jest.mock("stripe", () => {
+  return jest.fn(() => {
+    return {};
+  });
+});
+
+jest.mock("../../../Server/Infrastructure/Semaphore", () => {
+  return {
+    __esModule: true,
+    default: {
+      lock: (...args: Array<unknown>) => {
+        return lockMock(...args);
+      },
+      release: (...args: Array<unknown>) => {
+        return releaseMock(...args);
+      },
+    },
+  };
+});
+
+jest.mock("../../../Server/Services/ProjectService", () => {
+  return {
+    __esModule: true,
+    default: {
+      findOneById: (...args: Array<unknown>) => {
+        return findOneByIdMock(...args);
+      },
+      updateOneById: (...args: Array<unknown>) => {
+        return updateOneByIdMock(...args);
+      },
+      reactiveSubscription: (...args: Array<unknown>) => {
+        return reactiveSubscriptionMock(...args);
+      },
+    },
+  };
+});
+
+jest.mock("../../../Server/Services/BillingService", () => {
+  return {
+    __esModule: true,
+    default: {
+      getSubscriptionStatus: (...args: Array<unknown>) => {
+        return getSubscriptionStatusMock(...args);
+      },
+      getInvoices: (...args: Array<unknown>) => {
+        return getInvoicesMock(...args);
+      },
+    },
+  };
+});
+
+const PROJECT_ID: ObjectID = ObjectID.generate();
+const MUTEX: { id: string } = { id: "mutex-for-project" };
+
+describe("BillingInvoiceService.refreshSubscriptionStatus mutex", () => {
+  let service: BillingInvoiceService;
+
+  type RefreshFunction = () => Promise<void>;
+
+  const refresh: RefreshFunction = (): Promise<void> => {
+    return service.refreshSubscriptionStatus({ projectId: PROJECT_ID });
+  };
+
+  beforeEach(() => {
+    jest.restoreAllMocks();
+    service = new BillingInvoiceService();
+
+    getJestSpyOn(logger, "error").mockImplementation(() => {
+      return undefined;
+    });
+    getJestSpyOn(logger, "debug").mockImplementation(() => {
+      return undefined;
+    });
+
+    lockMock.mockReset().mockResolvedValue(MUTEX);
+    releaseMock.mockReset().mockResolvedValue(undefined);
+    findOneByIdMock.mockReset().mockResolvedValue({
+      id: PROJECT_ID,
+      paymentProviderCustomerId: "cus_stale_card_customer",
+      paymentProviderSubscriptionId: "sub_plan",
+      paymentProviderMeteredSubscriptionId: "sub_pinned_metered",
+    });
+    updateOneByIdMock.mockReset().mockResolvedValue(undefined);
+    reactiveSubscriptionMock.mockReset().mockResolvedValue(undefined);
+    getSubscriptionStatusMock
+      .mockReset()
+      .mockResolvedValue(SubscriptionStatus.Active);
+    getInvoicesMock.mockReset().mockResolvedValue([]);
+  });
+
+  it("locks per project and releases the same mutex after a normal refresh", async () => {
+    await refresh();
+
+    expect(lockMock).toHaveBeenCalledWith(
+      expect.objectContaining({ key: PROJECT_ID.toString() }),
+    );
+    expect(updateOneByIdMock).toHaveBeenCalledTimes(1);
+    expect(releaseMock).toHaveBeenCalledTimes(1);
+    expect(releaseMock).toHaveBeenCalledWith(MUTEX);
+  });
+
+  it("releases the mutex after reactivating a subscription whose invoices are all paid", async () => {
+    getSubscriptionStatusMock.mockResolvedValue(SubscriptionStatus.Unpaid);
+    getInvoicesMock.mockResolvedValue([{ status: "paid" }]);
+
+    await refresh();
+
+    expect(reactiveSubscriptionMock).toHaveBeenCalledWith(PROJECT_ID);
+    expect(releaseMock).toHaveBeenCalledTimes(1);
+    expect(
+      updateOneByIdMock.mock.invocationCallOrder[
+        updateOneByIdMock.mock.invocationCallOrder.length - 1
+      ]!,
+    ).toBeLessThan(releaseMock.mock.invocationCallOrder[0]!);
+  });
+
+  it("releases the mutex when the project lookup throws, and still reports the error", async () => {
+    const failure: Error = new Error("database unavailable");
+    findOneByIdMock.mockRejectedValue(failure);
+
+    await expect(refresh()).rejects.toBe(failure);
+
+    expect(releaseMock).toHaveBeenCalledTimes(1);
+    expect(releaseMock).toHaveBeenCalledWith(MUTEX);
+  });
+
+  it("releases the mutex when the project does not exist", async () => {
+    findOneByIdMock.mockResolvedValue(null);
+
+    await expect(refresh()).rejects.toThrow(
+      new BadDataException("Project not found"),
+    );
+
+    expect(releaseMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("releases the mutex when the project has no payment provider customer", async () => {
+    findOneByIdMock.mockResolvedValue({ id: PROJECT_ID });
+
+    await expect(refresh()).rejects.toThrow(BadDataException);
+
+    expect(releaseMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("releases the mutex when Stripe fails to return the subscription status", async () => {
+    const stripeFailure: Error = Object.assign(new Error("Stripe HTTP 500"), {
+      type: "StripeAPIError",
+    });
+    getSubscriptionStatusMock.mockRejectedValue(stripeFailure);
+
+    await expect(refresh()).rejects.toBe(stripeFailure);
+
+    expect(updateOneByIdMock).not.toHaveBeenCalled();
+    expect(releaseMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("releases the mutex when saving the refreshed status fails", async () => {
+    const failure: Error = new Error("update failed");
+    updateOneByIdMock.mockRejectedValue(failure);
+
+    await expect(refresh()).rejects.toBe(failure);
+
+    expect(releaseMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("releases the mutex when listing invoices for an inactive subscription fails", async () => {
+    const failure: Error = new Error("Stripe invoices list failed");
+    getSubscriptionStatusMock.mockResolvedValue(SubscriptionStatus.Canceled);
+    getInvoicesMock.mockRejectedValue(failure);
+
+    await expect(refresh()).rejects.toBe(failure);
+
+    expect(releaseMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("releases the mutex exactly once when the thrown error happens late in the refresh", async () => {
+    const failure: Error = new Error("final status write failed");
+    getSubscriptionStatusMock.mockResolvedValue(SubscriptionStatus.Unpaid);
+    getInvoicesMock.mockResolvedValue([]);
+    updateOneByIdMock
+      .mockResolvedValueOnce(undefined)
+      .mockRejectedValueOnce(failure);
+
+    await expect(refresh()).rejects.toBe(failure);
+
+    expect(releaseMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("reports the refresh error, not the release error, when both fail", async () => {
+    const failure: Error = new Error("database unavailable");
+    const releaseFailure: Error = new Error("redis unavailable");
+    findOneByIdMock.mockRejectedValue(failure);
+    releaseMock.mockRejectedValue(releaseFailure);
+
+    await expect(refresh()).rejects.toBe(failure);
+
+    expect(releaseMock).toHaveBeenCalledTimes(1);
+    expect(logger.error).toHaveBeenCalledWith(
+      releaseFailure,
+      expect.objectContaining({ projectId: PROJECT_ID.toString() }),
+    );
+  });
+
+  it("does not fail a successful refresh when releasing the mutex fails", async () => {
+    releaseMock.mockRejectedValue(new Error("redis unavailable"));
+
+    await expect(refresh()).resolves.toBeUndefined();
+
+    expect(updateOneByIdMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("still refreshes without a lock, and releases nothing, when the lock cannot be acquired", async () => {
+    lockMock.mockRejectedValue(new Error("acquire timeout"));
+
+    await refresh();
+
+    expect(updateOneByIdMock).toHaveBeenCalledTimes(1);
+    expect(releaseMock).not.toHaveBeenCalled();
+  });
+
+  it("releases nothing when the lock cannot be acquired and the refresh throws", async () => {
+    lockMock.mockRejectedValue(new Error("acquire timeout"));
+    findOneByIdMock.mockResolvedValue(null);
+
+    await expect(refresh()).rejects.toThrow(BadDataException);
+
+    expect(releaseMock).not.toHaveBeenCalled();
+  });
+});

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

@@ -697,6 +697,18 @@ describe("BillingService", () => {
           newMockMeteredSubscription.id,
         );
 
+        /*
+         * The replacements follow the customer's default card rather than
+         * being pinned to pm_123. A pin outranks the customer default at
+         * Stripe, so a customer who later replaced pm_123 would keep being
+         * charged on it.
+         */
+        expect(mockStripe.subscriptions.create).toHaveBeenCalledTimes(2);
+        for (const call of (mockStripe.subscriptions.create as jest.Mock).mock
+          .calls) {
+          expect(call[0]).not.toHaveProperty("default_payment_method");
+        }
+
         expect(mockStripe.subscriptions.update).not.toHaveBeenCalled();
         expect(mockStripe.subscriptions.del).toHaveBeenCalledWith(
           newPlan.subscriptionId,
@@ -1211,17 +1223,75 @@ describe("BillingService", () => {
         billingService.getPaymentMethods =
           getJestMockFunction().mockResolvedValue(mockPaymentMethods);
 
+        // deletePaymentMethod checks the card belongs to this customer first.
+        mockStripe.paymentMethods.retrieve =
+          getJestMockFunction().mockResolvedValue({
+            id: paymentMethodId,
+            customer: customerId,
+          });
+
         mockStripe.paymentMethods.detach =
           getJestMockFunction().mockResolvedValue({});
 
+        // After the detach, the subscriptions are re-synced to the new default.
+        const customerWithDefault: Stripe.Customer =
+          getStripeCustomer(customerId);
+        customerWithDefault.invoice_settings.default_payment_method = "pm_456";
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(customerWithDefault);
+        mockStripe.customers.update = getJestMockFunction().mockResolvedValue(
+          {},
+        );
+        mockStripe.subscriptions.list = getJestMockFunction().mockResolvedValue(
+          { data: [] },
+        );
+
         await billingService.deletePaymentMethod(customerId, paymentMethodId);
 
         expect(mockStripe.paymentMethods.detach).toHaveBeenCalledWith(
           paymentMethodId,
         );
+
+        // pm_123 was the default, so the remaining card is promoted.
+        expect(mockStripe.customers.update).toHaveBeenCalledWith(customerId, {
+          invoice_settings: {
+            default_payment_method: "pm_456",
+          },
+        });
+        expect(mockStripe.subscriptions.list).toHaveBeenCalledWith({
+          customer: customerId,
+          status: "all",
+          limit: 100,
+        });
+      });
+
+      it("should not delete a payment method that belongs to another customer", async () => {
+        billingService.getPaymentMethods =
+          getJestMockFunction().mockResolvedValue(mockPaymentMethods);
+
+        mockStripe.paymentMethods.retrieve =
+          getJestMockFunction().mockResolvedValue({
+            id: paymentMethodId,
+            customer: "cus_another_project",
+          });
+
+        mockStripe.paymentMethods.detach =
+          getJestMockFunction().mockResolvedValue({});
+
+        await expect(
+          billingService.deletePaymentMethod(customerId, paymentMethodId),
+        ).rejects.toThrow("Payment method does not belong to this project");
+
+        expect(mockStripe.paymentMethods.detach).not.toHaveBeenCalled();
       });
 
       it("should throw an exception if it's the only payment method", async () => {
+        mockStripe.paymentMethods.retrieve =
+          getJestMockFunction().mockResolvedValue({
+            id: paymentMethodId,
+            customer: customerId,
+          });
+
         // mock a single payment method to simulate a scenario where deletion is not allowed
         const mockSinglePaymentMethod: Array<PaymentMethod> = [
           {