@oneuptime/common 13.0.8 → 14.0.0

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

@@ -12,6 +12,13 @@ import EmailTemplateType from "../../../Types/Email/EmailTemplateType";
 import HashedString from "../../../Types/HashedString";
 import ObjectID from "../../../Types/ObjectID";
 import { getJestSpyOn } from "../../Spy";
+import {
+  createLicenseSnapshotWithStatus,
+  installFakeEnterpriseModule,
+  uninstallEnterpriseModule,
+} from "../Enterprise/FakeEnterpriseModule";
+import { setTestBillingEnabled } from "../Enterprise/TestBillingFlag";
+import logger from "../../../Server/Utils/Logger";
 import {
   afterEach,
   beforeEach,
@@ -21,6 +28,28 @@ import {
   test,
 } from "@jest/globals";
 
+/*
+ * A status page's "require SSO" is an Enterprise Edition control: honoured
+ * while SSO is active (EnterpriseEdition.isFeatureActive(SSO)), relaxed on the
+ * Community Edition and on an Enterprise install whose license lapsed, where
+ * status page SSO login does not exist or refuses. Billing and the edition are
+ * pinned so the suite tests the same thing locally and in CI (whose
+ * config.env sets BILLING_ENABLED=true).
+ */
+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
+    >,
+  );
+});
+
 class TestService extends Service {
   public async completeCreation(
     user: StatusPagePrivateUser,
@@ -49,6 +78,8 @@ describe("StatusPagePrivateUserService invitation login policy", () => {
   beforeEach(() => {
     jest.useFakeTimers();
     jest.setSystemTime(FROZEN_NOW);
+    setTestBillingEnabled(false);
+    installFakeEnterpriseModule();
 
     service = new TestService();
     statusPage = new StatusPage();
@@ -86,6 +117,8 @@ describe("StatusPagePrivateUserService invitation login policy", () => {
   afterEach(() => {
     jest.useRealTimers();
     jest.restoreAllMocks();
+    uninstallEnterpriseModule();
+    setTestBillingEnabled(false);
   });
 
   test.each([false, undefined])(
@@ -112,6 +145,67 @@ describe("StatusPagePrivateUserService invitation login policy", () => {
     },
   );
 
+  test("the requirement still holds on the Enterprise Edition during the grace period", async () => {
+    installFakeEnterpriseModule({
+      snapshot: createLicenseSnapshotWithStatus("grace"),
+    });
+    statusPage.requireSsoForLogin = true;
+
+    await expect(service.completeCreation(user)).resolves.toBe(user);
+
+    expect(update).not.toHaveBeenCalled();
+    expect(sendMail).not.toHaveBeenCalled();
+  });
+
+  test.each(["expired", "missing", "invalid"] as const)(
+    "with a lapsed (%s) license a page that required SSO gets a usable password invitation, as on the Community Edition",
+    async (status: "expired" | "missing" | "invalid") => {
+      getJestSpyOn(logger, "warn").mockImplementation((): void => {
+        return undefined;
+      });
+      installFakeEnterpriseModule({
+        snapshot: createLicenseSnapshotWithStatus(status),
+      });
+      statusPage.requireSsoForLogin = true;
+
+      await expect(service.completeCreation(user)).resolves.toBe(user);
+
+      // Status page SSO refuses while the license is lapsed: without a password link the user could not sign in.
+      expect(update).toHaveBeenCalledTimes(1);
+      expect(sendMail).toHaveBeenCalledTimes(1);
+      expect(sendMail).toHaveBeenCalledWith(
+        expect.objectContaining({
+          templateType: EmailTemplateType.StatusPageWelcomeEmail,
+        }),
+        expect.anything(),
+      );
+    },
+  );
+
+  test.each([false, true])(
+    "on the Community Edition (billing=%p) a page that required SSO still gets a usable password invitation",
+    async (billing: boolean) => {
+      setTestBillingEnabled(billing);
+      uninstallEnterpriseModule();
+      statusPage.requireSsoForLogin = true;
+
+      await expect(service.completeCreation(user)).resolves.toBe(user);
+
+      /*
+       * Status page SSO does not exist on the Community Edition, so without a
+       * password link the invited user would have no way to sign in at all.
+       */
+      expect(update).toHaveBeenCalledTimes(1);
+      expect(sendMail).toHaveBeenCalledTimes(1);
+      expect(sendMail).toHaveBeenCalledWith(
+        expect.objectContaining({
+          templateType: EmailTemplateType.StatusPageWelcomeEmail,
+        }),
+        expect.anything(),
+      );
+    },
+  );
+
   test("SSO sign-ups do not create an unused password-reset credential", async () => {
     user.isSsoUser = true;
 

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/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();
     });
   });
 });