@oneuptime/common 11.0.1 → 11.0.3

package/Tests/Server/API/ResellerPlanAPI.test.ts

@@ -0,0 +1,207 @@
+import ResellerPlanAPI from "../../../Server/API/ResellerPlanAPI";
+import ProjectService from "../../../Server/Services/ProjectService";
+import ResellerPlanService from "../../../Server/Services/ResellerPlanService";
+import {
+  NextFunction,
+  OneUptimeRequest,
+  OneUptimeResponse,
+} from "../../../Server/Utils/Express";
+import Response from "../../../Server/Utils/Response";
+import { mockRouter } from "./Helpers";
+import { describe, expect, it } from "@jest/globals";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import ObjectID from "../../../Types/ObjectID";
+import Project from "../../../Models/DatabaseModels/Project";
+import ResellerPlan from "../../../Models/DatabaseModels/ResellerPlan";
+
+jest.mock("../../../Server/Utils/Express", () => {
+  return {
+    getRouter: () => {
+      return mockRouter;
+    },
+  };
+});
+
+jest.mock("../../../Server/Utils/Response", () => {
+  return {
+    sendEntityArrayResponse: jest.fn().mockImplementation((...args: []) => {
+      return args;
+    }),
+    sendJsonObjectResponse: jest.fn().mockImplementation((...args: []) => {
+      return args;
+    }),
+    sendEmptySuccessResponse: jest.fn(),
+    sendEntityResponse: jest.fn().mockImplementation((...args: []) => {
+      return args;
+    }),
+    sendErrorResponse: jest.fn().mockImplementation((...args: []) => {
+      return args;
+    }),
+  };
+});
+
+jest.mock("../../../Server/Services/ResellerPlanService");
+jest.mock("../../../Server/Services/ProjectService");
+jest.mock("../../../Server/Services/BillingService");
+jest.mock("../../../Server/Services/PromoCodeService");
+
+describe("ResellerPlanAPI", () => {
+  let mockRequest: OneUptimeRequest;
+  let mockResponse: OneUptimeResponse;
+  let nextFunction: NextFunction;
+
+  const resellerExternalId: string = "reseller_a";
+  const resellerObjectId: ObjectID = ObjectID.generate();
+  const resellerPlanObjectId: ObjectID = ObjectID.generate();
+  const projectObjectId: ObjectID = ObjectID.generate();
+  const licenseKey: string = "license_123";
+
+  const mockResellerPlan: ResellerPlan = {
+    id: resellerPlanObjectId,
+    planId: "plan_basic",
+    reseller: {
+      id: resellerObjectId,
+      resellerId: resellerExternalId,
+    },
+    monitorLimit: 10,
+    teamMemberLimit: 5,
+  } as unknown as ResellerPlan;
+
+  beforeEach(() => {
+    new ResellerPlanAPI();
+
+    ResellerPlanService.findOneBy = jest
+      .fn()
+      .mockResolvedValue(mockResellerPlan);
+    ProjectService.findOneBy = jest.fn().mockResolvedValue(null);
+    ProjectService.updateOneById = jest.fn().mockResolvedValue(undefined);
+    ProjectService.deleteOneBy = jest.fn().mockResolvedValue(undefined);
+
+    mockRequest = {
+      params: { resellerId: resellerExternalId },
+      bearerTokenData: { resellerId: resellerExternalId },
+      body: {
+        action: "enhance_tier",
+        plan_id: "plan_basic",
+        uuid: licenseKey,
+        activation_email: "customer@example.com",
+      },
+    } as unknown as OneUptimeRequest;
+    mockResponse = {
+      send: jest.fn(),
+      json: jest.fn(),
+      status: jest.fn().mockReturnThis(),
+    } as unknown as OneUptimeResponse;
+    nextFunction = jest.fn();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("POST /reseller-plan/action/:resellerId", () => {
+    it("should scope the project lookup to the authenticated reseller on tier change", async () => {
+      await mockRouter
+        .match("post", "/reseller-plan/action/:resellerId")
+        .handlerFunction(mockRequest, mockResponse, nextFunction);
+
+      expect(ProjectService.findOneBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          query: {
+            resellerLicenseId: licenseKey,
+            resellerId: resellerObjectId,
+          },
+        }),
+      );
+      // license key belongs to another reseller -> scoped lookup finds nothing.
+      expect(nextFunction).toHaveBeenCalledWith(
+        new BadDataException("Project not found with this license key"),
+      );
+      expect(ProjectService.updateOneById).not.toHaveBeenCalled();
+    });
+
+    it("should not delete another reseller's project on refund", async () => {
+      mockRequest.body["action"] = "refund";
+
+      await mockRouter
+        .match("post", "/reseller-plan/action/:resellerId")
+        .handlerFunction(mockRequest, mockResponse, nextFunction);
+
+      expect(ProjectService.findOneBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          query: {
+            resellerLicenseId: licenseKey,
+            resellerId: resellerObjectId,
+          },
+        }),
+      );
+      expect(ProjectService.deleteOneBy).not.toHaveBeenCalled();
+      // refund is idempotent: respond as refunded without deleting anything.
+      expect(Response.sendJsonObjectResponse).toHaveBeenCalledWith(
+        mockRequest,
+        mockResponse,
+        {
+          message: "product refunded",
+        },
+      );
+    });
+
+    it("should update limits for the owning reseller's project", async () => {
+      ProjectService.findOneBy = jest.fn().mockResolvedValue({
+        id: projectObjectId,
+      } as Project);
+
+      await mockRouter
+        .match("post", "/reseller-plan/action/:resellerId")
+        .handlerFunction(mockRequest, mockResponse, nextFunction);
+
+      expect(nextFunction).not.toHaveBeenCalled();
+      expect(ProjectService.updateOneById).toHaveBeenCalledWith(
+        expect.objectContaining({
+          id: projectObjectId,
+          data: {
+            activeMonitorsLimit: 10,
+            seatLimit: 5,
+            resellerPlanId: resellerPlanObjectId,
+          },
+        }),
+      );
+      expect(Response.sendJsonObjectResponse).toHaveBeenCalledWith(
+        mockRequest,
+        mockResponse,
+        {
+          message: "product enhanced",
+        },
+      );
+    });
+
+    it("should delete the owning reseller's project on refund with a reseller-scoped query", async () => {
+      mockRequest.body["action"] = "refund";
+      ProjectService.findOneBy = jest.fn().mockResolvedValue({
+        id: projectObjectId,
+      } as Project);
+
+      await mockRouter
+        .match("post", "/reseller-plan/action/:resellerId")
+        .handlerFunction(mockRequest, mockResponse, nextFunction);
+
+      expect(nextFunction).not.toHaveBeenCalled();
+      expect(ProjectService.deleteOneBy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          query: {
+            resellerLicenseId: licenseKey,
+            resellerId: resellerObjectId,
+            _id: projectObjectId.toString(),
+          },
+        }),
+      );
+      expect(Response.sendJsonObjectResponse).toHaveBeenCalledWith(
+        mockRequest,
+        mockResponse,
+        {
+          message: "product refunded",
+        },
+      );
+    });
+  });
+});

package/Tests/Server/Infrastructure/GlobalCache.test.ts

@@ -0,0 +1,100 @@
+import GlobalCache from "../../../Server/Infrastructure/GlobalCache";
+import Redis from "../../../Server/Infrastructure/Redis";
+import OneUptimeDate from "../../../Types/Date";
+import DatabaseNotConnectedException from "../../../Types/Exception/DatabaseNotConnectedException";
+
+jest.mock("../../../Server/Infrastructure/Redis", () => {
+  return {
+    __esModule: true,
+    default: {
+      getClient: jest.fn(),
+      isConnected: jest.fn(),
+    },
+  };
+});
+
+type MockClient = {
+  set: jest.Mock;
+  expire: jest.Mock;
+  get: jest.Mock;
+};
+
+describe("GlobalCache.setString", () => {
+  let client: MockClient;
+
+  beforeEach(() => {
+    client = {
+      set: jest.fn().mockResolvedValue("OK"),
+      expire: jest.fn().mockResolvedValue(1),
+      get: jest.fn(),
+    };
+    (Redis.getClient as jest.Mock).mockReturnValue(client);
+    (Redis.isConnected as jest.Mock).mockReturnValue(true);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  /*
+   * The TTL must be applied atomically with the SET. A separate
+   * SET + EXPIRE pair can crash in between and leave a key that
+   * never expires — for fence/throttle keys (e.g. the OTel ingest
+   * maintenance fence) that permanently suppresses the work the
+   * key gates.
+   */
+  test("sets the value and TTL in one atomic SET ... EX call", async () => {
+    await GlobalCache.setString("ns", "key", "value", {
+      expiresInSeconds: 60,
+    });
+
+    expect(client.set).toHaveBeenCalledTimes(1);
+    expect(client.set).toHaveBeenCalledWith("ns-key", "value", "EX", 60);
+    expect(client.expire).not.toHaveBeenCalled();
+  });
+
+  test("defaults the TTL to 30 days when no option is passed", async () => {
+    await GlobalCache.setString("ns", "key", "value");
+
+    expect(client.set).toHaveBeenCalledTimes(1);
+    expect(client.set).toHaveBeenCalledWith(
+      "ns-key",
+      "value",
+      "EX",
+      OneUptimeDate.getSecondsInDays(30),
+    );
+    expect(client.expire).not.toHaveBeenCalled();
+  });
+
+  test("throws when the cache is not connected", async () => {
+    (Redis.isConnected as jest.Mock).mockReturnValue(false);
+
+    await expect(GlobalCache.setString("ns", "key", "value")).rejects.toThrow(
+      DatabaseNotConnectedException,
+    );
+    expect(client.set).not.toHaveBeenCalled();
+  });
+
+  test("setStringArray and setJSON funnel through the atomic setString", async () => {
+    await GlobalCache.setStringArray("ns", "arr", ["a", "b"], {
+      expiresInSeconds: 120,
+    });
+    await GlobalCache.setJSON("ns", "obj", { a: 1 }, { expiresInSeconds: 180 });
+
+    expect(client.set).toHaveBeenNthCalledWith(
+      1,
+      "ns-arr",
+      JSON.stringify(["a", "b"]),
+      "EX",
+      120,
+    );
+    expect(client.set).toHaveBeenNthCalledWith(
+      2,
+      "ns-obj",
+      expect.any(String),
+      "EX",
+      180,
+    );
+    expect(client.expire).not.toHaveBeenCalled();
+  });
+});

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

@@ -1057,6 +1057,111 @@ describe("BillingService", () => {
         });
       });
 
+      it("should mark the customer's default payment method and order it first", async () => {
+        const mockPaymentMethodsResponse: {
+          data: Array<Stripe.PaymentMethod>;
+        } = {
+          data: [
+            {
+              id: "pm_123",
+              type: "card",
+              // @ts-expect-error - Simplified mock card object for testing without all required Stripe card properties
+              card: { last4: "4242", brand: "mastercard" },
+            },
+            {
+              id: "pm_456",
+              type: "card",
+              // @ts-expect-error - Simplified mock card object for testing without all required Stripe card properties
+              card: { last4: "4343", brand: "mastercard" },
+            },
+          ],
+        };
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+
+        const customerWithDefault: Stripe.Customer = getStripeCustomer(
+          customer.id.toString(),
+        );
+        customerWithDefault.invoice_settings.default_payment_method = "pm_456";
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(customerWithDefault);
+
+        const paymentMethods: PaymentMethod[] =
+          await billingService.getPaymentMethods(customerId);
+
+        expect(paymentMethods).toHaveLength(2);
+        expect(paymentMethods[0]?.id).toBe("pm_456");
+        expect(paymentMethods[0]?.isDefault).toBe(true);
+        expect(paymentMethods[1]?.id).toBe("pm_123");
+        expect(paymentMethods[1]?.isDefault).toBe(false);
+        expect(mockStripe.customers.update).not.toHaveBeenCalled();
+      });
+
+      it("should not mark any payment method as default when the default is not in the list", async () => {
+        const mockPaymentMethodsResponse: {
+          data: Array<Stripe.PaymentMethod>;
+        } = {
+          data: [
+            {
+              id: "pm_123",
+              type: "card",
+              // @ts-expect-error - Simplified mock card object for testing without all required Stripe card properties
+              card: { last4: "4242", brand: "mastercard" },
+            },
+          ],
+        };
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+
+        const customerWithDetachedDefault: Stripe.Customer = getStripeCustomer(
+          customer.id.toString(),
+        );
+        customerWithDetachedDefault.invoice_settings.default_payment_method =
+          "pm_detached";
+        mockStripe.customers.retrieve = getJestMockFunction().mockResolvedValue(
+          customerWithDetachedDefault,
+        );
+
+        const paymentMethods: PaymentMethod[] =
+          await billingService.getPaymentMethods(customerId);
+
+        expect(paymentMethods).toHaveLength(1);
+        expect(paymentMethods[0]?.isDefault).toBe(false);
+        expect(mockStripe.customers.update).not.toHaveBeenCalled();
+      });
+
+      it("should set the first payment method as default when none is set", async () => {
+        const mockPaymentMethodsResponse: {
+          data: Array<Stripe.PaymentMethod>;
+        } = {
+          data: [
+            {
+              id: "pm_123",
+              type: "card",
+              // @ts-expect-error - Simplified mock card object for testing without all required Stripe card properties
+              card: { last4: "4242", brand: "mastercard" },
+            },
+          ],
+        };
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(mockCustomer);
+
+        const paymentMethods: PaymentMethod[] =
+          await billingService.getPaymentMethods(customerId);
+
+        expect(paymentMethods[0]?.isDefault).toBe(true);
+        expect(mockStripe.customers.update).toHaveBeenCalledWith(customerId, {
+          invoice_settings: {
+            default_payment_method: "pm_123",
+          },
+        });
+      });
+
       it("should return an empty array if no payment methods are present", async () => {
         const mockEmptyPaymentMethodsResponse: {
           data: Array<PaymentMethod>;
@@ -1440,6 +1545,224 @@ describe("BillingService", () => {
           },
         );
       });
+
+      const mockTwoPaymentMethodsResponse: PaymentMethodsResponse = {
+        data: [
+          {
+            id: "pm_123",
+            type: "card",
+            last4Digits: "4242",
+            isDefault: false,
+          },
+          {
+            id: "pm_456",
+            type: "card",
+            last4Digits: "4343",
+            isDefault: false,
+          },
+        ],
+      };
+
+      type GetCardDeclinedErrorFunction = () => Error;
+
+      const getCardDeclinedError: GetCardDeclinedErrorFunction = (): Error => {
+        return Object.assign(new Error("Your card was declined."), {
+          type: "StripeCardError",
+          code: "card_declined",
+        });
+      };
+
+      it("should fall back to the next payment method when the first is declined", async () => {
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockTwoPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(mockCustomer);
+
+        const mockPaidInvoice: Stripe.Invoice = getStripeInvoice();
+        mockStripe.invoices.pay = getJestMockFunction()
+          .mockRejectedValueOnce(getCardDeclinedError())
+          .mockResolvedValue(mockPaidInvoice);
+
+        const paidInvoice: Invoice = await billingService.payInvoice(
+          customerId,
+          mockPaidInvoice.id || "",
+        );
+
+        expect(paidInvoice.id).toBe(mockPaidInvoice.id);
+        expect(mockStripe.invoices.pay).toHaveBeenCalledTimes(2);
+        expect(mockStripe.invoices.pay).toHaveBeenNthCalledWith(
+          1,
+          mockPaidInvoice.id,
+          {
+            payment_method: "pm_123",
+          },
+        );
+        expect(mockStripe.invoices.pay).toHaveBeenNthCalledWith(
+          2,
+          mockPaidInvoice.id,
+          {
+            payment_method: "pm_456",
+          },
+        );
+      });
+
+      it("should charge the customer's default payment method first", async () => {
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockTwoPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+
+        const customerWithDefault: Stripe.Customer = getStripeCustomer(
+          customer.id.toString(),
+        );
+        customerWithDefault.invoice_settings.default_payment_method = "pm_456";
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(customerWithDefault);
+
+        const mockPaidInvoice: Stripe.Invoice = getStripeInvoice();
+        mockStripe.invoices.pay =
+          getJestMockFunction().mockResolvedValue(mockPaidInvoice);
+
+        await billingService.payInvoice(customerId, mockPaidInvoice.id || "");
+
+        expect(mockStripe.invoices.pay).toHaveBeenCalledTimes(1);
+        expect(mockStripe.invoices.pay).toHaveBeenCalledWith(
+          mockPaidInvoice.id,
+          {
+            payment_method: "pm_456",
+          },
+        );
+      });
+
+      it("should throw the last error when all payment methods are declined", async () => {
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockTwoPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(mockCustomer);
+
+        const lastError: Error = Object.assign(
+          new Error("Insufficient funds."),
+          {
+            type: "StripeCardError",
+            code: "card_declined",
+          },
+        );
+        mockStripe.invoices.pay = getJestMockFunction()
+          .mockRejectedValueOnce(getCardDeclinedError())
+          .mockRejectedValueOnce(lastError);
+
+        await expect(
+          billingService.payInvoice(customerId, invoiceId),
+        ).rejects.toThrow(lastError);
+        expect(mockStripe.invoices.pay).toHaveBeenCalledTimes(2);
+      });
+
+      it("should not try other payment methods on errors unrelated to the payment method", async () => {
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockTwoPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(mockCustomer);
+
+        const invoiceStateError: Error = Object.assign(
+          new Error("Invoice is already paid."),
+          {
+            type: "StripeInvalidRequestError",
+            code: "invoice_already_paid",
+          },
+        );
+        mockStripe.invoices.pay =
+          getJestMockFunction().mockRejectedValue(invoiceStateError);
+
+        await expect(
+          billingService.payInvoice(customerId, invoiceId),
+        ).rejects.toThrow(invoiceStateError);
+        expect(mockStripe.invoices.pay).toHaveBeenCalledTimes(1);
+      });
+
+      it("should fall back to the next payment method on payment method and bank account errors", async () => {
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockTwoPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(mockCustomer);
+
+        const bankAccountError: Error = Object.assign(
+          new Error("This bank account cannot be used."),
+          {
+            type: "StripeInvalidRequestError",
+            code: "bank_account_unusable",
+          },
+        );
+
+        const mockPaidInvoice: Stripe.Invoice = getStripeInvoice();
+        mockStripe.invoices.pay = getJestMockFunction()
+          .mockRejectedValueOnce(bankAccountError)
+          .mockResolvedValue(mockPaidInvoice);
+
+        const paidInvoice: Invoice = await billingService.payInvoice(
+          customerId,
+          mockPaidInvoice.id || "",
+        );
+
+        expect(paidInvoice.id).toBe(mockPaidInvoice.id);
+        expect(mockStripe.invoices.pay).toHaveBeenCalledTimes(2);
+      });
+
+      it("should not try other payment methods when authentication is required", async () => {
+        /*
+         * the interactive 3DS flow in BillingInvoiceAPI must surface
+         * authentication for the default payment method instead.
+         */
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockTwoPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(mockCustomer);
+
+        const requiresActionError: Error = Object.assign(
+          new Error("This payment requires additional authentication."),
+          {
+            type: "StripeInvalidRequestError",
+            code: "invoice_payment_intent_requires_action",
+          },
+        );
+        mockStripe.invoices.pay =
+          getJestMockFunction().mockRejectedValue(requiresActionError);
+
+        await expect(
+          billingService.payInvoice(customerId, invoiceId),
+        ).rejects.toThrow(requiresActionError);
+        expect(mockStripe.invoices.pay).toHaveBeenCalledTimes(1);
+      });
+
+      it("should try at most three payment methods", async () => {
+        const mockFourPaymentMethodsResponse: PaymentMethodsResponse = {
+          data: ["pm_1", "pm_2", "pm_3", "pm_4"].map((id: string) => {
+            return {
+              id,
+              type: "card",
+              last4Digits: "4242",
+              isDefault: false,
+            };
+          }),
+        };
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockFourPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(mockCustomer);
+
+        mockStripe.invoices.pay = getJestMockFunction().mockRejectedValue(
+          getCardDeclinedError(),
+        );
+
+        await expect(
+          billingService.payInvoice(customerId, invoiceId),
+        ).rejects.toThrow("Your card was declined.");
+        expect(mockStripe.invoices.pay).toHaveBeenCalledTimes(3);
+      });
     });
   });
 });