@oneuptime/common 13.0.7 → 14.0.0

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

@@ -2,10 +2,13 @@ import TelemetryIngestionKeyService, {
   Service,
 } from "../../../Server/Services/TelemetryIngestionKeyService";
 import PayAsYouGoBillingService from "../../../Server/Services/PayAsYouGoBillingService";
+import BillingService from "../../../Server/Services/BillingService";
+import ProjectService from "../../../Server/Services/ProjectService";
 import TelemetryIngest, {
   TelemetryRequest,
 } from "../../../Server/Middleware/TelemetryIngest";
 import TelemetryIngestionKey from "../../../Models/DatabaseModels/TelemetryIngestionKey";
+import Project from "../../../Models/DatabaseModels/Project";
 import CreateBy from "../../../Server/Types/Database/CreateBy";
 import UpdateBy from "../../../Server/Types/Database/UpdateBy";
 import {
@@ -16,6 +19,9 @@ import {
 import TelemetryIngestSurface from "../../../Types/Telemetry/TelemetryIngestSurface";
 import TelemetryIngestionKeyType from "../../../Types/Telemetry/TelemetryIngestionKeyType";
 import PaymentRequiredException from "../../../Types/Exception/PaymentRequiredException";
+import SubscriptionPlan, {
+  PlanType,
+} from "../../../Types/Billing/SubscriptionPlan";
 import ObjectID from "../../../Types/ObjectID";
 import * as EnvironmentConfig from "../../../Server/EnvironmentConfig";
 import {
@@ -101,6 +107,25 @@ function expectPaymentCheckedFor(project: ObjectID): void {
   }
 }
 
+function useRealPaymentEligibility(plan: PlanType): void {
+  jest.mocked(PayAsYouGoBillingService.canUsePayAsYouGo).mockRestore();
+  PayAsYouGoBillingService.invalidate(projectId);
+  PayAsYouGoBillingService.invalidate(otherProjectId);
+  jest.spyOn(BillingService, "isBillingEnabled").mockReturnValue(true);
+  jest.spyOn(BillingService, "hasPaymentMethods").mockResolvedValue(false);
+  jest.spyOn(ProjectService, "findOneById").mockResolvedValue(
+    Object.assign(new Project(), {
+      paymentProviderPlanId: plan,
+      paymentProviderCustomerId: "cus_telemetry_project",
+    }),
+  );
+  jest
+    .spyOn(SubscriptionPlan, "getSubscriptionPlanById")
+    .mockReturnValue(
+      new SubscriptionPlan(plan, `${plan}_yearly`, plan, 0, 0, 0, 0),
+    );
+}
+
 beforeEach(() => {
   jest.restoreAllMocks();
   (EnvironmentConfig as { IsBillingEnabled: boolean }).IsBillingEnabled = true;
@@ -353,3 +378,109 @@ describe("HTTP telemetry admission integrates key resolution and billing", () =>
     expect(TelemetryIngestionKeyService.markUsed).toHaveBeenCalledTimes(1);
   });
 });
+
+describe("telemetry operations use the stored subscription plan for payment eligibility", () => {
+  describe.each([PlanType.Growth, PlanType.Scale, PlanType.Enterprise])(
+    "%s telemetry keys without a payment method",
+    (plan: PlanType) => {
+      test.each(Object.values(TelemetryIngestionKeyType))(
+        "allows creating a %s key",
+        async (keyType: TelemetryIngestionKeyType) => {
+          useRealPaymentEligibility(plan);
+          const input: CreateBy<TelemetryIngestionKey> = createInput();
+          input.data.keyType = keyType;
+          input.data.allowedOrigins = ["https://example.com"];
+
+          await expect(hooks.onBeforeCreate(input)).resolves.toBeDefined();
+
+          expect(ProjectService.findOneById).toHaveBeenCalledWith(
+            expect.objectContaining({ id: projectId }),
+          );
+          expect(BillingService.hasPaymentMethods).not.toHaveBeenCalled();
+        },
+      );
+
+      test("allows re-enabling a key using its stored project", async () => {
+        useRealPaymentEligibility(plan);
+        jest.spyOn(service, "findBy").mockResolvedValue([key(otherProjectId)]);
+
+        await expect(
+          hooks.onBeforeUpdate(updateInput({ isEnabled: true })),
+        ).resolves.toBeDefined();
+
+        expect(ProjectService.findOneById).toHaveBeenCalledWith(
+          expect.objectContaining({ id: otherProjectId }),
+        );
+        expect(BillingService.hasPaymentMethods).not.toHaveBeenCalled();
+      });
+    },
+  );
+
+  test("still requires a payment method to create or re-enable Free telemetry keys", async () => {
+    useRealPaymentEligibility(PlanType.Free);
+    jest.spyOn(service, "findBy").mockResolvedValue([key()]);
+
+    await expect(hooks.onBeforeCreate(createInput())).rejects.toBeInstanceOf(
+      PaymentRequiredException,
+    );
+    await expect(
+      hooks.onBeforeUpdate(updateInput({ isEnabled: true })),
+    ).rejects.toBeInstanceOf(PaymentRequiredException);
+
+    expect(BillingService.hasPaymentMethods).toHaveBeenCalledWith(
+      "cus_telemetry_project",
+    );
+  });
+
+  describe.each([
+    PlanType.Free,
+    PlanType.Growth,
+    PlanType.Scale,
+    PlanType.Enterprise,
+  ])("%s HTTP telemetry without a payment method", (plan: PlanType) => {
+    test.each(Object.values(TelemetryIngestSurface))(
+      "applies plan eligibility before the %s handler",
+      async (surface: TelemetryIngestSurface) => {
+        useRealPaymentEligibility(plan);
+        const existingKey: TelemetryIngestionKey = key();
+        jest
+          .spyOn(TelemetryIngestionKeyService, "findOneBy")
+          .mockResolvedValue(existingKey);
+        jest
+          .spyOn(TelemetryIngestionKeyService, "markUsed")
+          .mockResolvedValue(undefined);
+        const request: ExpressRequest = {
+          headers: { "x-oneuptime-token": existingKey.secretKey!.toString() },
+        } as unknown as ExpressRequest;
+        const next: NextFunction = jest.fn() as unknown as NextFunction;
+
+        await TelemetryIngest.forSurface(surface)(
+          request,
+          {} as ExpressResponse,
+          next,
+        );
+
+        expect(next).toHaveBeenCalledTimes(1);
+        if (plan === PlanType.Free) {
+          expect(next).toHaveBeenCalledWith(
+            expect.any(PaymentRequiredException),
+          );
+          expect((request as TelemetryRequest).projectId).toBeUndefined();
+          expect(TelemetryIngestionKeyService.markUsed).not.toHaveBeenCalled();
+          expect(BillingService.hasPaymentMethods).toHaveBeenCalledWith(
+            "cus_telemetry_project",
+          );
+        } else {
+          expect(next).toHaveBeenCalledWith();
+          expect((request as TelemetryRequest).projectId.toString()).toBe(
+            projectId.toString(),
+          );
+          expect(TelemetryIngestionKeyService.markUsed).toHaveBeenCalledTimes(
+            1,
+          );
+          expect(BillingService.hasPaymentMethods).not.toHaveBeenCalled();
+        }
+      },
+    );
+  });
+});

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

@@ -1,3 +1,4 @@
+import crypto from "crypto";
 import DatabaseConfig from "../../../Server/DatabaseConfig";
 import { EncryptionSecret } from "../../../Server/EnvironmentConfig";
 import MailService from "../../../Server/Services/MailService";
@@ -928,6 +929,40 @@ describe("UserService -- master-admin authentication management", () => {
       expect(first).not.toBe(second);
     });
 
+    test("mints the token from the CSPRNG, never ObjectID's non-crypto fallback", async () => {
+      /*
+       * The token is a bearer secret: whoever holds it can set the password.
+       * ObjectID.generate() falls back to Math.random() when no Web Crypto
+       * API is present, so the token comes from node:crypto directly.
+       */
+      const randomUUIDSpy: ReturnType<typeof jest.spyOn> = jest.spyOn(
+        crypto,
+        "randomUUID",
+      );
+      const objectIdSpy: ReturnType<typeof jest.spyOn> = jest.spyOn(
+        ObjectID,
+        "generate",
+      );
+
+      resolveUser(buildUser({ id: userId, email: "user@example.com" }));
+
+      try {
+        await UserService.sendPasswordResetLink({ userId: userId });
+
+        const tokenInEmail: string = sentLink().split("/reset-password/")[1]!;
+
+        expect(randomUUIDSpy).toHaveBeenCalledTimes(1);
+        expect(tokenInEmail).toBe(randomUUIDSpy.mock.results[0]!.value);
+        expect(tokenInEmail).toMatch(
+          /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/,
+        );
+        expect(objectIdSpy).not.toHaveBeenCalled();
+      } finally {
+        randomUUIDSpy.mockRestore();
+        objectIdSpy.mockRestore();
+      }
+    });
+
     test("the link points at the ordinary /accounts/reset-password page", async () => {
       /*
        * There is deliberately no admin-specific redemption route: the link an

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

@@ -38,6 +38,7 @@ import NotificationRuleType from "../../../Types/NotificationRule/NotificationRu
 import ObjectID from "../../../Types/ObjectID";
 import UserNotificationEventType from "../../../Types/UserNotification/UserNotificationEventType";
 import UserNotificationStatus from "../../../Types/UserNotification/UserNotificationStatus";
+import UserType from "../../../Types/UserType";
 import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
 
 /*
@@ -616,6 +617,11 @@ describe("UserNotificationRule administrative write guards", () => {
        * An API key has no user identity. If the widened create list ever admits
        * one, "actor equals owner" is trivially false and must NOT be read as
        * "nobody else involved, carry on".
+       *
+       * The fixture says userType API because an API key is the only actor-less
+       * caller that can reach this hook: DatabaseService.create now refuses a
+       * caller with no credentials at all (no userId, not an API key) with a
+       * 401 before any hook runs.
        */
       stubs.teamMemberFind.mockResolvedValue(null as never);
 
@@ -623,7 +629,7 @@ describe("UserNotificationRule administrative write guards", () => {
         hooks().onBeforeCreate(
           createBy({
             userId: VICTIM_USER_ID,
-            props: { tenantId: PROJECT_ID },
+            props: { tenantId: PROJECT_ID, userType: UserType.API },
             channels: { userEmailId: METHOD_ID },
           }),
         ),
@@ -631,10 +637,15 @@ describe("UserNotificationRule administrative write guards", () => {
     });
 
     test("a rule with neither an owner nor an actor is refused rather than written unowned", async () => {
+      /*
+       * Actor-less means an API key here, for the same reason as above: an
+       * anonymous caller is refused (401) by DatabaseService.create before
+       * this hook, so it never sees this 400.
+       */
       await expect(
         hooks().onBeforeCreate(
           createBy({
-            props: { tenantId: PROJECT_ID },
+            props: { tenantId: PROJECT_ID, userType: UserType.API },
             channels: { userEmailId: METHOD_ID },
           }),
         ),

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

@@ -1,11 +1,16 @@
 import UserService from "../../../Server/Services/UserService";
-import EnterpriseLicenseSeatUtil from "../../../Server/Utils/EnterpriseLicense/EnterpriseLicenseSeatUtil";
+import EnterpriseEdition from "../../../Server/Enterprise/EnterpriseEdition";
 import CreateBy from "../../../Server/Types/Database/CreateBy";
 import User from "../../../Models/DatabaseModels/User";
 import Email from "../../../Types/Email";
 import BadDataException from "../../../Types/Exception/BadDataException";
 import ObjectID from "../../../Types/ObjectID";
 import PositiveNumber from "../../../Types/PositiveNumber";
+import FakeEnterpriseModule, {
+  installFakeEnterpriseModule,
+  uninstallEnterpriseModule,
+} from "../Enterprise/FakeEnterpriseModule";
+import { setTestBillingEnabled } from "../Enterprise/TestBillingFlag";
 import { beforeEach, afterEach, describe, expect, it } from "@jest/globals";
 
 /*
@@ -21,6 +26,11 @@ import { beforeEach, afterEach, describe, expect, it } from "@jest/globals";
  * else; a check on the invitation would have left signup and SSO as open doors
  * beside it.
  *
+ * The limit itself is the Enterprise license client's (ee/Server/License); core
+ * asks it through EnterpriseEdition.assertSeatAvailableForNewUser, which is a
+ * no-op on the Community Edition. What the license client decides (billing,
+ * license status, the live user count) is tested in ee/Tests/Server/License.
+ *
  * The single most important assertion in this file is the isRoot one. Team
  * invitations create the invited user with `props: { isRoot: true }`
  * (TeamMemberService.onBeforeCreate), so the usual "internal writes bypass
@@ -28,17 +38,20 @@ import { beforeEach, afterEach, describe, expect, it } from "@jest/globals";
  * asked for.
  */
 
-jest.mock(
-  "../../../Server/Utils/EnterpriseLicense/EnterpriseLicenseSeatUtil",
-  () => {
-    return {
-      __esModule: true,
-      default: {
-        assertSeatAvailableForNewUser: jest.fn(),
-      },
-    };
-  },
-);
+// CI's config.env sets BILLING_ENABLED=true; this suite pins it per test.
+jest.mock("../../../Server/EnvironmentConfig", () => {
+  const billingFlag: typeof import("../Enterprise/TestBillingFlag") =
+    jest.requireActual(
+      "../Enterprise/TestBillingFlag",
+    ) as typeof import("../Enterprise/TestBillingFlag");
+
+  return billingFlag.withLiveBillingFlag(
+    jest.requireActual("../../../Server/EnvironmentConfig") as Record<
+      string,
+      unknown
+    >,
+  );
+});
 
 type OnBeforeCreateFunction = (createBy: CreateBy<User>) => Promise<unknown>;
 
@@ -71,37 +84,53 @@ const makeCreateBy: MakeCreateByFunction = (
   } as unknown as CreateBy<User>;
 };
 
-type AssertSeatMockFunction = () => jest.Mock;
-
-const assertSeatMock: AssertSeatMockFunction = (): jest.Mock => {
-  return EnterpriseLicenseSeatUtil.assertSeatAvailableForNewUser as unknown as jest.Mock;
-};
-
 describe("UserService - the enterprise seat limit", () => {
+  let fake: FakeEnterpriseModule;
+
   beforeEach(() => {
     jest.clearAllMocks();
-    assertSeatMock().mockResolvedValue(undefined);
+    setTestBillingEnabled(false);
+    fake = installFakeEnterpriseModule();
     UserService.countBy = jest.fn().mockResolvedValue(new PositiveNumber(7));
   });
 
   afterEach(() => {
+    uninstallEnterpriseModule();
+    setTestBillingEnabled(false);
     jest.restoreAllMocks();
   });
 
-  it("checks the seat limit before creating a user", async () => {
+  it("asks the Enterprise license client before creating a user", async () => {
+    const assertSpy: jest.SpyInstance = jest.spyOn(
+      EnterpriseEdition,
+      "assertSeatAvailableForNewUser",
+    );
+
     await onBeforeCreate(makeCreateBy());
 
-    expect(assertSeatMock()).toHaveBeenCalledTimes(1);
+    expect(assertSpy).toHaveBeenCalledTimes(1);
+    expect(assertSpy).toHaveBeenCalledWith();
+    expect(fake.licensing.seatChecks).toBe(1);
   });
 
   it("refuses the create when there is no seat for the new user", async () => {
-    assertSeatMock().mockRejectedValue(new BadDataException("No seats left"));
+    fake.licensing.seatError = new BadDataException("No seats left");
 
     await expect(onBeforeCreate(makeCreateBy())).rejects.toBeInstanceOf(
       BadDataException,
     );
   });
 
+  it("passes the license client's refusal through unchanged", async () => {
+    fake.licensing.seatError = new BadDataException(
+      "This OneUptime installation has reached the 10-user limit of its enterprise license.",
+    );
+
+    await expect(onBeforeCreate(makeCreateBy())).rejects.toThrow(
+      "reached the 10-user limit",
+    );
+  });
+
   /*
    * The one that matters. TeamMemberService creates the invited user as root,
    * so an isRoot exemption would exempt invitations — and inviting users past
@@ -116,7 +145,21 @@ describe("UserService - the enterprise seat limit", () => {
     async (_label: string, props: Record<string, unknown>) => {
       await onBeforeCreate(makeCreateBy(props));
 
-      expect(assertSeatMock()).toHaveBeenCalledTimes(1);
+      expect(fake.licensing.seatChecks).toBe(1);
+    },
+  );
+
+  it.each([
+    ["a root write", { isRoot: true }],
+    ["a master admin", { isMasterAdmin: true }],
+  ])(
+    "refuses %s when the license is full",
+    async (_label: string, props: Record<string, unknown>) => {
+      fake.licensing.seatError = new BadDataException("No seats left");
+
+      await expect(onBeforeCreate(makeCreateBy(props))).rejects.toBeInstanceOf(
+        BadDataException,
+      );
     },
   );
 
@@ -126,7 +169,7 @@ describe("UserService - the enterprise seat limit", () => {
      * that, a rejected create would still have done work; more importantly the
      * ordering pins that nothing was inserted ahead of the check later on.
      */
-    assertSeatMock().mockRejectedValue(new BadDataException("No seats left"));
+    fake.licensing.seatError = new BadDataException("No seats left");
 
     const createBy: CreateBy<User> = makeCreateBy();
     (createBy.data as unknown as Record<string, unknown>)["clickIds"] = {
@@ -136,47 +179,42 @@ describe("UserService - the enterprise seat limit", () => {
     await expect(onBeforeCreate(createBy)).rejects.toBeInstanceOf(
       BadDataException,
     );
+    expect(
+      (createBy.data as unknown as Record<string, unknown>)["clickIds"],
+    ).toEqual({ gclid: "abc" });
   });
 
-  describe("the user count it enforces against", () => {
-    type GetLocalUserCountFunction = () => Promise<number>;
-
-    type CapturedCallbackFunction = () => GetLocalUserCountFunction;
-
-    const capturedCallback: CapturedCallbackFunction =
-      (): GetLocalUserCountFunction => {
-        const call: Record<string, unknown> = assertSeatMock().mock
-          .calls[0]![0] as Record<string, unknown>;
-
-        return call["getLocalUserCount"] as GetLocalUserCountFunction;
-      };
-
-    it("counts every user on this installation, not just the caller's project", async () => {
-      await onBeforeCreate(makeCreateBy());
+  /*
+   * Counting users is the license client's business, and only when a limit
+   * applies. The create path of every user on the installation must not pay
+   * for a count in core.
+   */
+  it("does not count users itself", async () => {
+    await onBeforeCreate(makeCreateBy());
 
-      const count: number = await capturedCallback()();
+    expect(UserService.countBy).not.toHaveBeenCalled();
+  });
 
-      expect(count).toBe(7);
+  describe("on the Community Edition", () => {
+    beforeEach(() => {
+      uninstallEnterpriseModule();
+    });
 
-      const countCall: Record<string, unknown> = (
-        UserService.countBy as unknown as jest.Mock
-      ).mock.calls[0]![0] as Record<string, unknown>;
+    it("has no seat limit at all", async () => {
+      await expect(onBeforeCreate(makeCreateBy())).resolves.toBeDefined();
+      expect(UserService.countBy).not.toHaveBeenCalled();
+    });
 
-      expect(countCall["query"]).toEqual({});
-      expect((countCall["props"] as Record<string, unknown>)["isRoot"]).toBe(
-        true,
-      );
+    it("has no seat limit for root writes either", async () => {
+      await expect(
+        onBeforeCreate(makeCreateBy({ isRoot: true })),
+      ).resolves.toBeDefined();
     });
 
-    /*
-     * The count is deliberately behind a callback rather than passed in: on
-     * Community Edition, and on a licence with no seat limit, it must never
-     * run at all. This is the create path of every user on the installation.
-     */
-    it("does not count users unless the seat check asks for it", async () => {
-      await onBeforeCreate(makeCreateBy());
+    it("has no seat limit with billing on", async () => {
+      setTestBillingEnabled(true);
 
-      expect(UserService.countBy).not.toHaveBeenCalled();
+      await expect(onBeforeCreate(makeCreateBy())).resolves.toBeDefined();
     });
   });
 });