@oneuptime/common 13.0.8 → 14.0.1

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

@@ -1,56 +1,59 @@
-import GlobalConfigAPI from "../../../Server/API/GlobalConfigAPI";
+import GlobalConfigAPI, {
+  LICENSE_RESPONSE_CONFIG_SELECT,
+} from "../../../Server/API/GlobalConfigAPI";
 import MasterAdminAuthorization from "../../../Server/Middleware/MasterAdminAuthorization";
 import UserMiddleware from "../../../Server/Middleware/UserAuthorization";
 import GlobalConfigService from "../../../Server/Services/GlobalConfigService";
-import UserService from "../../../Server/Services/UserService";
 import Response from "../../../Server/Utils/Response";
+import { AppVersion } from "../../../Server/EnvironmentConfig";
+import EnterpriseEdition from "../../../Server/Enterprise/EnterpriseEdition";
+import EnterpriseFeature from "../../../Server/Enterprise/EnterpriseFeature";
+import {
+  EnterpriseLicenseSnapshot,
+  EnterpriseLicenseStatus,
+  SeatUsage,
+} from "../../../Server/Enterprise/EnterpriseLicenseSnapshot";
 import GlobalConfig from "../../../Models/DatabaseModels/GlobalConfig";
-import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
-import HTTPResponse from "../../../Types/API/HTTPResponse";
-import BadDataException from "../../../Types/Exception/BadDataException";
 import Exception from "../../../Types/Exception/Exception";
 import NotAuthenticatedException from "../../../Types/Exception/NotAuthenticatedException";
 import { JSONObject } from "../../../Types/JSON";
 import ObjectID from "../../../Types/ObjectID";
-import PositiveNumber from "../../../Types/PositiveNumber";
 import UserType from "../../../Types/UserType";
-import API from "../../../Utils/API";
 import {
   NextFunction,
   OneUptimeRequest,
   OneUptimeResponse,
 } from "../../../Server/Utils/Express";
 import { mockRouter } from "./Helpers";
-import { beforeEach, afterEach, describe, expect, it } from "@jest/globals";
+import FakeEnterpriseModule, {
+  createLicenseSnapshot,
+  createLicenseSnapshotWithStatus,
+  installFakeEnterpriseModule,
+  uninstallEnterpriseModule,
+} from "../Enterprise/FakeEnterpriseModule";
+import { setTestBillingEnabled } from "../Enterprise/TestBillingFlag";
+import { afterEach, beforeEach, describe, expect, it } from "@jest/globals";
 
 /*
- * The self-hosted half of the licence: activating a key, refreshing the key
- * the installation already holds, and reporting what the seat limit means
- * right now.
+ * GET /global-config/license: the one license route that stays in core.
  *
- * Two things brought this suite into being.
+ * Activating and refreshing a license moved into the Enterprise license client
+ * (ee/Server/License, tested in ee/Tests/Server/License). What stays here is
+ * the read, because the Community Edition still needs the version and
+ * update-check half of the edition dialog, and because the answer has to be
+ * cut down per caller:
  *
- * The seat limit is set on oneuptime.com and changes on any day — a customer
- * buys ten more seats at noon. It reaches the installation through the daily
- * report job, so until now the only way to apply it sooner was for somebody to
- * re-type the licence key into a box that is HIDDEN while the licence is
- * valid. /license/refresh is that missing button, and it exists precisely
- * because the installation now refuses users above the limit: waiting a day to
- * learn about seats you have already paid for is a different feature when the
- * old number is being enforced.
+ *   - this route serves the signed-out login page, so it cannot require
+ *     authentication, and anonymous callers used to be told the seat limit,
+ *     the current user count and more;
+ *   - any signed-in user - including a status-page subscriber, whose token
+ *     also decodes to a userId - used to receive the license key, the token
+ *     and the host of every instance on the license.
  *
- * And both writes used to run on UserMiddleware.getUserMiddleware, which lets
- * anonymous callers through — it has to, because the GET on the same path
- * serves the signed-out login page. That made the route that decides this
- * installation's seat ceiling reachable without signing in at all.
+ * Now a master admin gets everything and everybody else gets only what the
+ * edition pill shows.
  */
 
-/*
- * PasswordHash carries a pre-existing TS diagnostic that fails any suite whose
- * require graph reaches it, and BaseAPI's graph still reaches it. Replaced with
- * a factory rather than automocked, because an automock still type-checks the
- * real file.
- */
 jest.mock("../../../Server/Utils/PasswordHash", () => {
   return {
     __esModule: true,
@@ -64,7 +67,6 @@ jest.mock("../../../Server/Utils/PasswordHash", () => {
   };
 });
 
-// Same story as PasswordHash: a local-only diagnostic in a module dragged in.
 jest.mock("../../../Server/Utils/VerificationCode", () => {
   return {
     __esModule: true,
@@ -103,79 +105,19 @@ jest.mock("../../../Server/Utils/Response", () => {
   };
 });
 
-/*
- * The deployment flags live on globalThis rather than in module-scope
- * variables, and the getters below reference nothing but globalThis.
- *
- * jest hoists the mock factory above every declaration in this file, and
- * BaseAPI's import graph reaches IncidentFeedService, which reads
- * IsBillingEnabled at module scope. That read lands inside these getters
- * during the import — before a `let` in this file has initialised — and a
- * getter that closed over one would throw a temporal-dead-zone
- * ReferenceError before a single test ran. Absent flags read as false, which
- * is a fine thing for an unrelated service to see on its way past.
- *
- * They are also live accessors rather than values: the routes read the flags
- * when they run, and object spread would flatten them at import time.
- */
-const BILLING_FLAG_KEY: string = "__oneUptimeTestIsBillingEnabled";
-const ENTERPRISE_FLAG_KEY: string = "__oneUptimeTestIsEnterpriseEdition";
-
-type SetDeploymentFlagFunction = (key: string, value: boolean) => void;
-
-const setDeploymentFlag: SetDeploymentFlagFunction = (
-  key: string,
-  value: boolean,
-): void => {
-  (globalThis as unknown as Record<string, unknown>)[key] = value;
-};
-
+// CI's config.env sets BILLING_ENABLED=true; this suite pins it per test.
 jest.mock("../../../Server/EnvironmentConfig", () => {
-  const actual: Record<string, unknown> = jest.requireActual(
-    "../../../Server/EnvironmentConfig",
-  ) as Record<string, unknown>;
-
-  const mocked: Record<string, unknown> = {
-    ...actual,
-    __esModule: true,
-  };
-
-  Object.defineProperty(mocked, "IsBillingEnabled", {
-    get: (): boolean => {
-      return (
-        (globalThis as unknown as Record<string, unknown>)[
-          "__oneUptimeTestIsBillingEnabled"
-        ] === true
-      );
-    },
-  });
-
-  Object.defineProperty(mocked, "IsEnterpriseEdition", {
-    get: (): boolean => {
-      return (
-        (globalThis as unknown as Record<string, unknown>)[
-          "__oneUptimeTestIsEnterpriseEdition"
-        ] === true
-      );
-    },
-  });
-
-  return mocked;
-});
-
-/*
- * Factories rather than automocks. An automock still loads the real module to
- * copy its shape, and loading UserService drags in most of the service graph -
- * some of which reads IsBillingEnabled at module scope, before the flags above
- * have initialised. Nothing here needs the real implementations.
- */
-jest.mock("../../../Utils/API", () => {
-  return {
-    __esModule: true,
-    default: {
-      post: jest.fn(),
-    },
-  };
+  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
+    >,
+  );
 });
 
 jest.mock("../../../Server/Services/GlobalConfigService", () => {
@@ -202,7 +144,47 @@ const LICENSE_ROUTE: string = "/global-config/license";
 const REFRESH_ROUTE: string = "/global-config/license/refresh";
 
 const STORED_LICENSE_KEY: string = "acme-stored-license-key";
+const STORED_TOKEN: string = "stored.license.token";
 const INSTANCE_ID: ObjectID = ObjectID.generate();
+const DAY_IN_MS: number = 24 * 60 * 60 * 1000;
+
+// Exactly what anybody but a master admin may learn.
+const PUBLIC_KEYS: Array<string> = [
+  "companyName",
+  "edition",
+  "expiresAt",
+  "features",
+  "graceEndsAt",
+  "graceReason",
+  "isEvaluation",
+  "isEvaluationLicense",
+  "licenseValid",
+  "status",
+  "verification",
+].sort();
+
+// Never in a response to anybody but a master admin.
+const MASTER_ADMIN_ONLY_KEYS: Array<string> = [
+  "activationMode",
+  "canAddMoreUsers",
+  "currentUserCount",
+  "currentVersion",
+  "instanceId",
+  "instances",
+  "isSeatLimitEnforced",
+  "isUpdateAvailable",
+  "isUpdateCheckDisabled",
+  "latestVersion",
+  "latestVersionCheckedAt",
+  "latestVersionPublishedAt",
+  "licenseKey",
+  "message",
+  "seatsInUse",
+  "seatsRemaining",
+  "token",
+  "userCountUpdatedAt",
+  "userLimit",
+].sort();
 
 type MakeStoredConfigFunction = (
   overrides?: Record<string, unknown>,
@@ -215,100 +197,103 @@ const makeStoredConfig: MakeStoredConfigFunction = (
   config.id = ObjectID.getZeroObjectID();
   config.instanceId = INSTANCE_ID;
   config.enterpriseLicenseKey = STORED_LICENSE_KEY;
+  config.enterpriseLicenseToken = STORED_TOKEN;
+  config.enterpriseLicenseUserLimit = 999;
+  config.enterpriseLicenseCurrentUserCount = 42;
+  config.enterpriseLicenseUserCountUpdatedAt = new Date(
+    "2026-09-01T00:00:00.000Z",
+  );
+  config.enterpriseLicenseInstances = [
+    {
+      instanceId: INSTANCE_ID.toString(),
+      host: "prod.acme.internal",
+      userCount: 42,
+      lastReportedAt: "2026-09-01T00:00:00.000Z",
+      version: "13.0.0",
+    },
+  ];
+  config.latestReleaseVersion = "99.0.0";
+  config.latestReleasePublishedAt = new Date("2026-09-10T00:00:00.000Z");
+  config.latestReleaseCheckedAt = new Date("2026-09-11T00:00:00.000Z");
 
   return Object.assign(config, overrides || {});
 };
 
-type LicenseServerPayloadFunction = (
-  overrides?: Record<string, unknown>,
-) => JSONObject;
-
-const licenseServerPayload: LicenseServerPayloadFunction = (
-  overrides?: Record<string, unknown>,
-): JSONObject => {
-  return {
-    companyName: "Acme Inc",
-    expiresAt: "2030-01-01T00:00:00.000Z",
-    licenseKey: STORED_LICENSE_KEY,
-    token: "signed.jwt.token",
-    isEvaluationLicense: false,
-    userLimit: 150,
-    currentUserCount: 42,
-    userCountUpdatedAt: "2026-01-01T00:00:00.000Z",
-    instances: [],
-    ...overrides,
-  };
-};
-
-type GetResponseBodyFunction = () => JSONObject;
-
-const getResponseBody: GetResponseBodyFunction = (): JSONObject => {
-  const calls: Array<Array<unknown>> = (
-    Response.sendJsonObjectResponse as unknown as jest.Mock
-  ).mock.calls as Array<Array<unknown>>;
-
-  expect(calls).toHaveLength(1);
-
-  return calls[0]![2] as JSONObject;
+const ENFORCED_SEAT_USAGE: SeatUsage = {
+  isEnforced: true,
+  userLimit: 50,
+  seatsInUse: 49,
+  seatsRemaining: 1,
+  hasSeatForNewUser: true,
+  seatsUsedByOtherInstances: 0,
 };
 
-type GetStoredUpdateFunction = () => JSONObject;
-
-const getStoredUpdate: GetStoredUpdateFunction = (): JSONObject => {
-  const calls: Array<Array<unknown>> = (
-    GlobalConfigService.updateOneById as unknown as jest.Mock
-  ).mock.calls as Array<Array<unknown>>;
+type CallerKind = "anonymous" | "signed-in user" | "master admin";
 
-  expect(calls.length).toBeGreaterThan(0);
-
-  return (calls[0]![0] as Record<string, unknown>)["data"] as JSONObject;
-};
-
-describe("GlobalConfigAPI licence routes", () => {
+describe("GET /global-config/license", () => {
   let mockRequest: OneUptimeRequest;
   let mockResponse: OneUptimeResponse;
   let nextFunction: NextFunction;
 
-  type CallRouteFunction = (route: string) => Promise<void>;
+  const setCaller: (caller: CallerKind) => void = (
+    caller: CallerKind,
+  ): void => {
+    const request: Record<string, unknown> = mockRequest as unknown as Record<
+      string,
+      unknown
+    >;
+
+    if (caller === "anonymous") {
+      delete request["userAuthorization"];
+      return;
+    }
+
+    request["userAuthorization"] = {
+      userId: ObjectID.generate(),
+      isMasterAdmin: caller === "master admin",
+    };
+  };
 
-  const callRoute: CallRouteFunction = async (route: string): Promise<void> => {
+  const callGet: () => Promise<JSONObject> = async (): Promise<JSONObject> => {
     await mockRouter
-      .match("post", route)
+      .match("get", LICENSE_ROUTE)
       .handlerFunction(mockRequest, mockResponse, nextFunction);
-  };
 
-  type NextErrorFunction = () => Error;
+    expect(nextFunction).not.toHaveBeenCalled();
 
-  const nextError: NextErrorFunction = (): Error => {
-    const calls: Array<Array<unknown>> = (nextFunction as unknown as jest.Mock)
-      .mock.calls as Array<Array<unknown>>;
+    const calls: Array<Array<unknown>> = (
+      Response.sendJsonObjectResponse as unknown as jest.Mock
+    ).mock.calls as Array<Array<unknown>>;
 
     expect(calls).toHaveLength(1);
 
-    return calls[0]![0] as Error;
+    return calls[0]![2] as JSONObject;
+  };
+
+  const installWithSnapshot: (
+    snapshot: EnterpriseLicenseSnapshot | null,
+    seatUsage?: SeatUsage | null,
+  ) => FakeEnterpriseModule = (
+    snapshot: EnterpriseLicenseSnapshot | null,
+    seatUsage?: SeatUsage | null,
+  ): FakeEnterpriseModule => {
+    return installFakeEnterpriseModule({
+      snapshot,
+      seatUsage: seatUsage === undefined ? ENFORCED_SEAT_USAGE : seatUsage,
+    });
   };
 
   beforeEach(() => {
     jest.clearAllMocks();
     mockRouter.routes = [];
-    setDeploymentFlag(BILLING_FLAG_KEY, false);
-    setDeploymentFlag(ENTERPRISE_FLAG_KEY, true);
+    setTestBillingEnabled(false);
+    uninstallEnterpriseModule();
 
     new GlobalConfigAPI();
 
     GlobalConfigService.findOneById = jest
       .fn()
       .mockResolvedValue(makeStoredConfig());
-    GlobalConfigService.updateOneById = jest.fn().mockResolvedValue(undefined);
-    GlobalConfigService.create = jest.fn().mockResolvedValue(undefined);
-
-    UserService.countBy = jest.fn().mockResolvedValue(new PositiveNumber(42));
-
-    (API.post as unknown as jest.Mock) = jest
-      .fn()
-      .mockResolvedValue(
-        new HTTPResponse<JSONObject>(200, licenseServerPayload(), {}),
-      );
 
     /*
      * Express always gives a request a `query` object; the licence GET reads
@@ -329,469 +314,729 @@ describe("GlobalConfigAPI licence routes", () => {
   });
 
   afterEach(() => {
+    uninstallEnterpriseModule();
+    setTestBillingEnabled(false);
     jest.restoreAllMocks();
   });
 
-  describe("who is allowed to write the licence", () => {
-    /*
-     * The seat limit these routes store is the number UserService refuses new
-     * users against. UserMiddleware.getUserMiddleware — which the GET on the
-     * same path uses, and has to, because it serves the signed-out login page —
-     * lets anonymous callers straight through, so it is not a guard here.
-     */
-    it.each([
-      ["activating a licence key", LICENSE_ROUTE],
-      ["refreshing the stored licence", REFRESH_ROUTE],
-    ])("requires a master admin for %s", (_label: string, route: string) => {
-      expect(mockRouter.match("post", route).middlewares).toContain(
-        MasterAdminAuthorization.isAuthorizedMasterAdminMiddleware,
+  describe("the routes core still serves", () => {
+    it("serves the GET to anyone, so the login page keeps working", () => {
+      const route: ReturnType<typeof mockRouter.match> = mockRouter.match(
+        "get",
+        LICENSE_ROUTE,
       );
-    });
 
-    it("still serves the licence GET to anyone, so the login page keeps working", () => {
-      expect(mockRouter.match("get", LICENSE_ROUTE).middlewares).not.toContain(
+      expect(route.middlewares).toEqual([UserMiddleware.getUserMiddleware]);
+      expect(route.middlewares).not.toContain(
         MasterAdminAuthorization.isAuthorizedMasterAdminMiddleware,
       );
     });
+
+    /*
+     * Activation and refresh are the Enterprise license client's now. A copy
+     * left behind in core would be a second writer of the license, served
+     * even by the Community Edition.
+     */
+    it.each([LICENSE_ROUTE, REFRESH_ROUTE])(
+      "no longer registers POST %s in core",
+      (route: string) => {
+        const posts: Array<string> = mockRouter.routes
+          .filter((registered: { method: string; uri: string }): boolean => {
+            return registered.method === "POST";
+          })
+          .map((registered: { uri: string }): string => {
+            return registered.uri;
+          });
+
+        expect(posts).not.toContain(route);
+      },
+    );
+
+    it("keeps /global-config/vars", () => {
+      expect(
+        mockRouter.match("get", "/global-config/vars").handlerFunction,
+      ).toBeDefined();
+    });
   });
 
-  describe("POST /global-config/license - activating a key", () => {
-    it("rejects a request with no licence key", async () => {
-      mockRequest.body = {};
+  describe("on the Community Edition", () => {
+    it.each([
+      "anonymous",
+      "signed-in user",
+      "master admin",
+    ] as Array<CallerKind>)(
+      "says community with no license to a %s",
+      async (caller: CallerKind) => {
+        setCaller(caller);
+
+        const body: JSONObject = await callGet();
+
+        expect(body["edition"]).toBe("community");
+        expect(body["status"]).toBeNull();
+        expect(body["verification"]).toBeNull();
+        expect(body["licenseValid"]).toBe(false);
+        expect(body["companyName"]).toBeNull();
+        expect(body["expiresAt"]).toBeNull();
+      },
+    );
+
+    /*
+     * The Community Edition dialog still has a version card: which build is
+     * running and whether a newer one exists is a property of the
+     * installation, not of a license.
+     */
+    it("still gives a master admin the version and update-check fields", async () => {
+      setCaller("master admin");
+
+      const body: JSONObject = await callGet();
 
-      await callRoute(LICENSE_ROUTE);
+      expect(body["currentVersion"]).toBe(AppVersion);
+      expect(body["latestVersion"]).toBe("99.0.0");
+      expect(body["latestVersionPublishedAt"]).toBe("2026-09-10T00:00:00.000Z");
+      expect(body["latestVersionCheckedAt"]).toBe("2026-09-11T00:00:00.000Z");
+      expect(typeof body["isUpdateAvailable"]).toBe("boolean");
+      expect(typeof body["isUpdateCheckDisabled"]).toBe("boolean");
+    });
 
-      expect(nextError()).toBeInstanceOf(BadDataException);
-      expect(API.post).not.toHaveBeenCalled();
+    /*
+     * A key or token left over from an earlier Enterprise image licenses
+     * nothing on the Community Edition, so it is not reported as if it did.
+     */
+    it("reports no license key, token, topology or seats even when old license columns remain", async () => {
+      setCaller("master admin");
+
+      const body: JSONObject = await callGet();
+
+      expect(body["licenseKey"]).toBeNull();
+      expect(body["token"]).toBeNull();
+      expect(body["activationMode"]).toBeNull();
+      expect(body["instances"]).toEqual([]);
+      expect(body["instanceId"]).toBeNull();
+      expect(body["userLimit"]).toBeNull();
+      expect(body["currentUserCount"]).toBeNull();
+      expect(body["isSeatLimitEnforced"]).toBe(false);
+      expect(body["canAddMoreUsers"]).toBe(true);
     });
 
-    it("rejects a licence key that is only whitespace", async () => {
-      mockRequest.body = { licenseKey: "   " };
+    it("gives everybody else only the public fields and reads nothing", async () => {
+      setCaller("signed-in user");
 
-      await callRoute(LICENSE_ROUTE);
+      const body: JSONObject = await callGet();
 
-      expect(nextError()).toBeInstanceOf(BadDataException);
+      expect(Object.keys(body).sort()).toEqual(PUBLIC_KEYS);
+      expect(GlobalConfigService.findOneById).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("on the Enterprise Edition - what each caller gets", () => {
+    beforeEach(() => {
+      installWithSnapshot(createLicenseSnapshot({ userLimit: 50 }));
     });
 
-    it("validates the supplied key against oneuptime.com", async () => {
-      mockRequest.body = { licenseKey: "  a-new-key  " };
+    it.each(["anonymous", "signed-in user"] as Array<CallerKind>)(
+      "gives a %s exactly the public fields",
+      async (caller: CallerKind) => {
+        setCaller(caller);
 
-      await callRoute(LICENSE_ROUTE);
+        const body: JSONObject = await callGet();
 
-      const sent: JSONObject = (
-        (API.post as unknown as jest.Mock).mock.calls[0]![0] as Record<
-          string,
-          JSONObject
-        >
-      )["data"] as JSONObject;
+        expect(Object.keys(body).sort()).toEqual(PUBLIC_KEYS);
 
-      expect(sent["licenseKey"]).toBe("a-new-key");
-      expect(sent["instanceId"]).toBe(INSTANCE_ID.toString());
+        for (const key of MASTER_ADMIN_ONLY_KEYS) {
+          expect(body).not.toHaveProperty(key);
+        }
+      },
+    );
+
+    /*
+     * The finding this closes: a signed-in (non-admin) user, or anybody whose
+     * token decodes to a userId, used to receive the license key, the token
+     * and every instance's host.
+     */
+    it("never gives a signed-in user who is not a master admin the key, the token or the topology", async () => {
+      setCaller("signed-in user");
+
+      const body: JSONObject = await callGet();
+      const serialized: string = JSON.stringify(body);
+
+      expect(serialized).not.toContain(STORED_LICENSE_KEY);
+      expect(serialized).not.toContain(STORED_TOKEN);
+      expect(serialized).not.toContain("prod.acme.internal");
+      expect(serialized).not.toContain(INSTANCE_ID.toString());
     });
 
-    it("stores the seat limit the licence server reported", async () => {
-      mockRequest.body = { licenseKey: STORED_LICENSE_KEY };
+    it("does not read the config row or count seats for anybody but a master admin", async () => {
+      const fake: FakeEnterpriseModule = installWithSnapshot(
+        createLicenseSnapshot(),
+      );
+      const seatUsageSpy: jest.SpyInstance = jest.spyOn(
+        fake.licensing,
+        "getSeatUsage",
+      );
 
-      await callRoute(LICENSE_ROUTE);
+      setCaller("anonymous");
 
-      expect(getStoredUpdate()["enterpriseLicenseUserLimit"]).toBe(150);
+      await callGet();
+
+      expect(GlobalConfigService.findOneById).not.toHaveBeenCalled();
+      expect(seatUsageSpy).not.toHaveBeenCalled();
+    });
+
+    it("gives a master admin the public fields plus everything needed to manage the license", async () => {
+      setCaller("master admin");
+
+      const body: JSONObject = await callGet();
+
+      expect(Object.keys(body).sort()).toEqual(
+        [...PUBLIC_KEYS, ...MASTER_ADMIN_ONLY_KEYS].sort(),
+      );
+      expect(body["licenseKey"]).toBe(STORED_LICENSE_KEY);
+      expect(body["token"]).toBe(STORED_TOKEN);
+      expect(body["instanceId"]).toBe(INSTANCE_ID.toString());
+      expect(body["instances"]).toHaveLength(1);
+      expect(body["currentUserCount"]).toBe(42);
+      expect(body["userCountUpdatedAt"]).toBe("2026-09-01T00:00:00.000Z");
+      expect(body["currentVersion"]).toBe(AppVersion);
+      expect(body["activationMode"]).toBe("online");
+    });
+
+    it("reads the row with exactly the columns the response needs, as root", async () => {
+      setCaller("master admin");
+
+      await callGet();
+
+      const call: Record<string, unknown> = (
+        GlobalConfigService.findOneById as unknown as jest.Mock
+      ).mock.calls[0]![0] as Record<string, unknown>;
+
+      expect(call["select"]).toEqual(LICENSE_RESPONSE_CONFIG_SELECT);
+      expect((call["props"] as Record<string, unknown>)["isRoot"]).toBe(true);
     });
-  });
 
-  describe("POST /global-config/license/refresh", () => {
     /*
-     * The whole point of the route: no key in the body. A refresh that
-     * accepted one would be an activation with a friendlier name, and a
-     * mistyped key would be able to replace a working licence by accident.
+     * A verified license's limits come from its signed claims; the column is
+     * only a mirror a master admin could once overwrite. The snapshot is the
+     * truth, so the response reports its limit, not the column's 999.
      */
-    it("refreshes using the stored key and ignores anything in the body", async () => {
-      mockRequest.body = { licenseKey: "somebody-elses-key" };
+    it("reports the seat limit from the license snapshot, not the stored column", async () => {
+      setCaller("master admin");
+
+      const body: JSONObject = await callGet();
+
+      expect(body["userLimit"]).toBe(50);
+    });
+
+    it("reports the seat enforcement the license client computed", async () => {
+      setCaller("master admin");
+
+      const body: JSONObject = await callGet();
+
+      expect(body["isSeatLimitEnforced"]).toBe(true);
+      expect(body["seatsInUse"]).toBe(49);
+      expect(body["seatsRemaining"]).toBe(1);
+      expect(body["canAddMoreUsers"]).toBe(true);
+    });
 
-      await callRoute(REFRESH_ROUTE);
+    it("says the limit is not enforced when the license client reports no usage", async () => {
+      installWithSnapshot(createLicenseSnapshot(), null);
+      setCaller("master admin");
 
-      const sent: JSONObject = (
-        (API.post as unknown as jest.Mock).mock.calls[0]![0] as Record<
-          string,
-          JSONObject
-        >
-      )["data"] as JSONObject;
+      const body: JSONObject = await callGet();
 
-      expect(sent["licenseKey"]).toBe(STORED_LICENSE_KEY);
+      expect(body["isSeatLimitEnforced"]).toBe(false);
+      expect(body["seatsInUse"]).toBeNull();
+      expect(body["seatsRemaining"]).toBeNull();
+      expect(body["canAddMoreUsers"]).toBe(true);
     });
 
-    it("refuses to refresh an installation that has no licence key yet", async () => {
+    it("calls an installation with a token but no key offline-activated", async () => {
       GlobalConfigService.findOneById = jest
         .fn()
         .mockResolvedValue(
           makeStoredConfig({ enterpriseLicenseKey: undefined }),
         );
+      setCaller("master admin");
+
+      const body: JSONObject = await callGet();
+
+      expect(body["activationMode"]).toBe("offline");
+      expect(body["licenseKey"]).toBeNull();
+    });
 
-      await callRoute(REFRESH_ROUTE);
+    it("has no activation mode when there is no token at all", async () => {
+      GlobalConfigService.findOneById = jest.fn().mockResolvedValue(
+        makeStoredConfig({
+          enterpriseLicenseToken: undefined,
+        }),
+      );
+      setCaller("master admin");
+
+      const body: JSONObject = await callGet();
 
-      expect(nextError()).toBeInstanceOf(BadDataException);
-      expect(API.post).not.toHaveBeenCalled();
+      expect(body["activationMode"]).toBeNull();
     });
 
-    it("refuses to refresh when there is no config row at all", async () => {
+    it("survives a missing config row", async () => {
       GlobalConfigService.findOneById = jest.fn().mockResolvedValue(null);
+      setCaller("master admin");
 
-      await callRoute(REFRESH_ROUTE);
+      const body: JSONObject = await callGet();
 
-      expect(nextError()).toBeInstanceOf(BadDataException);
-      expect(API.post).not.toHaveBeenCalled();
+      expect(body["licenseKey"]).toBeNull();
+      expect(body["instances"]).toEqual([]);
+      expect(body["latestVersion"]).toBeNull();
+      expect(body["edition"]).toBe("enterprise");
     });
+  });
 
+  describe("on the Enterprise Edition - what each license status looks like", () => {
     /*
-     * The reason the button exists. The customer raised the limit on
-     * oneuptime.com; the stored 50 is what this installation is refusing users
-     * against until something writes the new number down.
+     * licenseValid is the pill's verdict. Grace must read as valid: nothing
+     * has changed yet, and telling an administrator the license is gone while
+     * everything still works would be a false alarm.
      */
-    it("applies a seat limit that has been raised on oneuptime.com", async () => {
-      (API.post as unknown as jest.Mock).mockResolvedValue(
-        new HTTPResponse<JSONObject>(
-          200,
-          licenseServerPayload({ userLimit: 500 }),
-          {},
-        ),
+    it.each<[EnterpriseLicenseStatus, boolean]>([
+      ["valid", true],
+      ["grace", true],
+      ["expired", false],
+      ["missing", false],
+      ["invalid", false],
+    ])(
+      "status %s reads as licenseValid=%s to everybody",
+      async (status: EnterpriseLicenseStatus, expected: boolean) => {
+        installWithSnapshot(createLicenseSnapshotWithStatus(status));
+
+        for (const caller of [
+          "anonymous",
+          "signed-in user",
+          "master admin",
+        ] as Array<CallerKind>) {
+          (Response.sendJsonObjectResponse as unknown as jest.Mock).mockClear();
+          setCaller(caller);
+
+          const body: JSONObject = await callGet();
+
+          expect(body["edition"]).toBe("enterprise");
+          expect(body["status"]).toBe(status);
+          expect(body["licenseValid"]).toBe(expected);
+        }
+      },
+    );
+
+    it("tells everybody when an expired license's grace period ends", async () => {
+      const graceEndsAt: Date = new Date(Date.now() + 5 * DAY_IN_MS);
+      const expiresAt: Date = new Date(Date.now() - 9 * DAY_IN_MS);
+
+      installWithSnapshot(
+        createLicenseSnapshotWithStatus("grace", {
+          graceReason: "expired",
+          graceEndsAt,
+          expiresAt,
+        }),
       );
+      setCaller("anonymous");
 
-      await callRoute(REFRESH_ROUTE);
+      const body: JSONObject = await callGet();
 
-      expect(getStoredUpdate()["enterpriseLicenseUserLimit"]).toBe(500);
-      expect(getResponseBody()["userLimit"]).toBe(500);
+      expect(body["graceReason"]).toBe("expired");
+      expect(body["graceEndsAt"]).toBe(graceEndsAt.toISOString());
+      expect(body["expiresAt"]).toBe(expiresAt.toISOString());
     });
 
-    it("applies a seat limit that has been lowered on oneuptime.com", async () => {
-      (API.post as unknown as jest.Mock).mockResolvedValue(
-        new HTTPResponse<JSONObject>(
-          200,
-          licenseServerPayload({ userLimit: 5 }),
-          {},
-        ),
-      );
+    it("reports an unlicensed installation inside its first-seen grace as a trial", async () => {
+      const graceEndsAt: Date = new Date(Date.now() + 10 * DAY_IN_MS);
+
+      installWithSnapshot({
+        status: "grace",
+        verification: "none",
+        graceReason: "unlicensed",
+        graceEndsAt,
+        userLimit: null,
+        isEvaluation: false,
+        features: "all",
+      });
+      setCaller("signed-in user");
 
-      await callRoute(REFRESH_ROUTE);
+      const body: JSONObject = await callGet();
 
-      expect(getStoredUpdate()["enterpriseLicenseUserLimit"]).toBe(5);
+      expect(body["status"]).toBe("grace");
+      expect(body["graceReason"]).toBe("unlicensed");
+      expect(body["verification"]).toBe("none");
+      expect(body["licenseValid"]).toBe(true);
+      expect(body["graceEndsAt"]).toBe(graceEndsAt.toISOString());
+      expect(body["companyName"]).toBeNull();
     });
 
-    it("clears the seat limit when the licence no longer carries one", async () => {
-      (API.post as unknown as jest.Mock).mockResolvedValue(
-        new HTTPResponse<JSONObject>(
-          200,
-          licenseServerPayload({ userLimit: null }),
-          {},
-        ),
+    it("reports an unverified legacy license as valid but unverified", async () => {
+      installWithSnapshot(
+        createLicenseSnapshot({ verification: "unverified" }),
       );
+      setCaller("anonymous");
+
+      const body: JSONObject = await callGet();
+
+      expect(body["licenseValid"]).toBe(true);
+      expect(body["verification"]).toBe("unverified");
+    });
+
+    it("reports the evaluation flag under both its names", async () => {
+      installWithSnapshot(createLicenseSnapshot({ isEvaluation: true }));
+      setCaller("anonymous");
 
-      await callRoute(REFRESH_ROUTE);
+      const body: JSONObject = await callGet();
 
-      expect(getStoredUpdate()["enterpriseLicenseUserLimit"]).toBeNull();
+      expect(body["isEvaluation"]).toBe(true);
+      expect(body["isEvaluationLicense"]).toBe(true);
     });
 
-    it("refreshes the expiry as well as the seat limit", async () => {
-      (API.post as unknown as jest.Mock).mockResolvedValue(
-        new HTTPResponse<JSONObject>(
-          200,
-          licenseServerPayload({ expiresAt: "2031-06-01T00:00:00.000Z" }),
-          {},
-        ),
+    it("explains an invalid license to a master admin only", async () => {
+      installWithSnapshot(
+        createLicenseSnapshotWithStatus("invalid", {
+          message: "The license is bound to a different OneUptime instance.",
+        }),
       );
 
-      await callRoute(REFRESH_ROUTE);
+      setCaller("master admin");
+      expect((await callGet())["message"]).toBe(
+        "The license is bound to a different OneUptime instance.",
+      );
 
-      expect(
-        (
-          getStoredUpdate()["enterpriseLicenseExpiresAt"] as unknown as Date
-        ).toISOString(),
-      ).toBe("2031-06-01T00:00:00.000Z");
+      (Response.sendJsonObjectResponse as unknown as jest.Mock).mockClear();
+      setCaller("signed-in user");
+      expect(await callGet()).not.toHaveProperty("message");
     });
 
     /*
-     * An installation that cannot reach oneuptime.com must be told so rather
-     * than quietly keeping the old terms and reporting success — the
-     * administrator pressed this button precisely because they believe the old
-     * terms are wrong.
+     * The snapshot could not be read at all (the facade falls back to the
+     * cached snapshot, and there is none yet). The answer is "not licensed",
+     * never an error page on the login screen.
      */
-    it("surfaces a failure from the licence server instead of storing anything", async () => {
-      (API.post as unknown as jest.Mock).mockResolvedValue(
-        new HTTPErrorResponse(500, { message: "License key is invalid" }, {}),
-      );
+    it("reads as not licensed when no snapshot is available", async () => {
+      const fake: FakeEnterpriseModule = installWithSnapshot(null);
+      fake.licensing.getSnapshotError = new Error("database is down");
+      setCaller("anonymous");
 
-      await callRoute(REFRESH_ROUTE);
+      const body: JSONObject = await callGet();
 
-      const error: Error = nextError();
-
-      expect(error).toBeInstanceOf(BadDataException);
-      expect(error.message).toBe("License key is invalid");
-      expect(GlobalConfigService.updateOneById).not.toHaveBeenCalled();
+      expect(body["edition"]).toBe("enterprise");
+      expect(body["status"]).toBeNull();
+      expect(body["licenseValid"]).toBe(false);
     });
 
-    it("does not store anything when the returned expiry is not a date", async () => {
-      (API.post as unknown as jest.Mock).mockResolvedValue(
-        new HTTPResponse<JSONObject>(
-          200,
-          licenseServerPayload({ expiresAt: "the-first-of-never" }),
-          {},
-        ),
+    it("asks the facade for the snapshot rather than reading license columns itself", async () => {
+      installWithSnapshot(createLicenseSnapshot());
+      const snapshotSpy: jest.SpyInstance = jest.spyOn(
+        EnterpriseEdition,
+        "getLicenseSnapshot",
       );
+      setCaller("anonymous");
 
-      await callRoute(REFRESH_ROUTE);
+      await callGet();
 
-      expect(nextError()).toBeInstanceOf(BadDataException);
-      expect(GlobalConfigService.updateOneById).not.toHaveBeenCalled();
+      expect(snapshotSpy).toHaveBeenCalledTimes(1);
     });
   });
 
-  describe("the seat enforcement the response reports", () => {
-    it("reports the seats in use against the freshly refreshed limit", async () => {
-      UserService.countBy = jest.fn().mockResolvedValue(new PositiveNumber(42));
-
-      await callRoute(REFRESH_ROUTE);
+  /*
+   * THE EXPIRED-SESSION CASE
+   *
+   * The dashboard's access-token cookie expires with the JWT inside it, so a
+   * signed-in tab left idle past the token lifetime asks for the licence
+   * with no session at all. On its own this route cannot tell that apart
+   * from the login page, and answers with the reduced anonymous payload and
+   * a 200 - which the edition pill reads as "no licence, no instances". The
+   * dashboards now say `?signedIn=true`; a caller that says so but carries
+   * no credentials is answered 401, the one status the browser client
+   * refreshes the session and replays on.
+   */
+  describe("?signedIn=true", () => {
+    const setRequest: (fields: Record<string, unknown>) => void = (
+      fields: Record<string, unknown>,
+    ): void => {
+      Object.assign(mockRequest as unknown as Record<string, unknown>, fields);
+    };
 
-      const body: JSONObject = getResponseBody();
+    const callGetExpectingError: () => Promise<Error> =
+      async (): Promise<Error> => {
+        await mockRouter
+          .match("get", LICENSE_ROUTE)
+          .handlerFunction(mockRequest, mockResponse, nextFunction);
 
-      expect(body["isSeatLimitEnforced"]).toBe(true);
-      expect(body["seatsInUse"]).toBe(42);
-      expect(body["seatsRemaining"]).toBe(108);
-      expect(body["canAddMoreUsers"]).toBe(true);
-    });
+        expect(nextFunction).toHaveBeenCalledTimes(1);
 
-    /*
-     * The live count is what enforcement uses, and it is allowed to be higher
-     * than the licence-wide figure oneuptime.com last computed — that figure is
-     * up to a day old.
-     */
-    it("prefers the live user count over the licence server's stale one", async () => {
-      UserService.countBy = jest
-        .fn()
-        .mockResolvedValue(new PositiveNumber(150));
+        return (nextFunction as unknown as jest.Mock).mock
+          .calls[0]![0] as Error;
+      };
 
-      await callRoute(REFRESH_ROUTE);
+    it.each([
+      ["no userType at all", {}],
+      [
+        "userType Public (what getUserMiddleware stamps)",
+        { userType: UserType.Public },
+      ],
+    ])(
+      "answers an anonymous caller (%s) with a 401 before reading anything",
+      async (_label: string, caller: Record<string, unknown>) => {
+        installWithSnapshot(createLicenseSnapshot());
+        const snapshotSpy: jest.SpyInstance = jest.spyOn(
+          EnterpriseEdition,
+          "getLicenseSnapshot",
+        );
 
-      const body: JSONObject = getResponseBody();
+        setRequest({ ...caller, query: { signedIn: "true" } });
 
-      expect(body["seatsInUse"]).toBe(150);
-      expect(body["seatsRemaining"]).toBe(0);
-      expect(body["canAddMoreUsers"]).toBe(false);
-    });
+        const error: Error = await callGetExpectingError();
 
-    it("says the limit is not enforced when the licence has none", async () => {
-      (API.post as unknown as jest.Mock).mockResolvedValue(
-        new HTTPResponse<JSONObject>(
-          200,
-          licenseServerPayload({ userLimit: null }),
-          {},
-        ),
-      );
+        expect(error).toBeInstanceOf(NotAuthenticatedException);
+        expect((error as Exception).code).toBe(401);
+        expect(error.message).toBe(
+          UserMiddleware.AUTHENTICATION_REQUIRED_MESSAGE,
+        );
+        expect(snapshotSpy).not.toHaveBeenCalled();
+        expect(GlobalConfigService.findOneById).not.toHaveBeenCalled();
+        expect(Response.sendJsonObjectResponse).not.toHaveBeenCalled();
+      },
+    );
 
-      await callRoute(REFRESH_ROUTE);
+    it("answers the 401 on the Community Edition too", async () => {
+      setRequest({ userType: UserType.Public, query: { signedIn: "true" } });
 
-      const body: JSONObject = getResponseBody();
+      const error: Error = await callGetExpectingError();
 
-      expect(body["isSeatLimitEnforced"]).toBe(false);
-      expect(body["seatsInUse"]).toBeNull();
-      expect(body["canAddMoreUsers"]).toBe(true);
+      expect(error).toBeInstanceOf(NotAuthenticatedException);
+      expect(Response.sendJsonObjectResponse).not.toHaveBeenCalled();
     });
 
-    it("says the limit is not enforced on Community Edition", async () => {
-      setDeploymentFlag(ENTERPRISE_FLAG_KEY, false);
+    // The login page does not send the flag and must keep working.
+    it("still serves an anonymous caller without the flag the public payload", async () => {
+      installWithSnapshot(createLicenseSnapshot());
+      setRequest({ userType: UserType.Public, query: {} });
 
-      await callRoute(REFRESH_ROUTE);
+      const body: JSONObject = await callGet();
 
-      const body: JSONObject = getResponseBody();
-
-      expect(body["isSeatLimitEnforced"]).toBe(false);
-      expect(body["canAddMoreUsers"]).toBe(true);
-      expect(UserService.countBy).not.toHaveBeenCalled();
+      expect(Object.keys(body).sort()).toEqual(PUBLIC_KEYS);
+      expect(body["licenseKey"]).toBeUndefined();
     });
-  });
 
-  describe("GET /global-config/license", () => {
-    type CallGetFunction = () => Promise<void>;
+    it.each([
+      ["signedIn=false", { signedIn: "false" }],
+      ["an empty signedIn", { signedIn: "" }],
+      ["signedIn=1", { signedIn: "1" }],
+    ])(
+      'only the exact string "true" asks for a 401 (%s serves the public payload)',
+      async (_label: string, query: Record<string, unknown>) => {
+        setRequest({ userType: UserType.Public, query: query });
 
-    const callGet: CallGetFunction = async (): Promise<void> => {
-      await mockRouter
-        .match("get", LICENSE_ROUTE)
-        .handlerFunction(mockRequest, mockResponse, nextFunction);
-    };
+        const body: JSONObject = await callGet();
 
-    beforeEach(() => {
-      GlobalConfigService.findOneById = jest.fn().mockResolvedValue(
-        makeStoredConfig({
-          enterpriseLicenseUserLimit: 150,
-          enterpriseLicenseCurrentUserCount: 42,
-          enterpriseLicenseInstances: [],
-        }),
-      );
-    });
+        expect(Object.keys(body).sort()).toEqual(PUBLIC_KEYS);
+      },
+    );
 
-    it("tells a signed-in administrator how close the installation is to refusing users", async () => {
-      (mockRequest as unknown as Record<string, unknown>)["userAuthorization"] =
-        {
-          userId: ObjectID.generate(),
-        };
-      UserService.countBy = jest
-        .fn()
-        .mockResolvedValue(new PositiveNumber(149));
+    it("serves a signed-in master admin the full payload with the flag", async () => {
+      installWithSnapshot(createLicenseSnapshot({ userLimit: 50 }));
+      setCaller("master admin");
+      setRequest({ userType: UserType.User, query: { signedIn: "true" } });
 
-      await callGet();
-
-      const body: JSONObject = getResponseBody();
+      const body: JSONObject = await callGet();
 
-      expect(body["isSeatLimitEnforced"]).toBe(true);
-      expect(body["seatsInUse"]).toBe(149);
-      expect(body["seatsRemaining"]).toBe(1);
-      expect(body["canAddMoreUsers"]).toBe(true);
+      expect(body["licenseKey"]).toBe(STORED_LICENSE_KEY);
+      expect(body["instanceId"]).toBe(INSTANCE_ID.toString());
     });
 
-    /*
-     * The same route serves the signed-out login page. How near this server is
-     * to refusing new accounts is operational detail, and counting its users
-     * for an anonymous visitor would be a free query on an unauthenticated
-     * endpoint besides.
-     */
-    it("tells an anonymous visitor nothing about seat enforcement", async () => {
-      await callGet();
+    it("serves a signed-in user who is not a master admin the public payload with the flag", async () => {
+      installWithSnapshot(createLicenseSnapshot());
+      setCaller("signed-in user");
+      setRequest({ userType: UserType.User, query: { signedIn: "true" } });
 
-      const body: JSONObject = getResponseBody();
+      const body: JSONObject = await callGet();
 
-      expect(body["isSeatLimitEnforced"]).toBe(false);
-      expect(body["seatsInUse"]).toBeNull();
-      expect(body["seatsRemaining"]).toBeNull();
-      expect(body["canAddMoreUsers"]).toBe(true);
-      expect(UserService.countBy).not.toHaveBeenCalled();
+      expect(Object.keys(body).sort()).toEqual(PUBLIC_KEYS);
     });
 
     /*
-     * THE EXPIRED-SESSION CASE
-     *
-     * The dashboard's access-token cookie expires with the JWT inside it, so a
-     * signed-in tab left idle past the token lifetime asks for the licence
-     * with no session at all. On its own this route cannot tell that apart
-     * from the login page, and answers with the reduced anonymous payload and
-     * a 200 - which the edition pill reads as "no licence, no instances". The
-     * dashboards now say `?signedIn=true`; a caller that says so but carries
-     * no credentials is answered 401, the one status the browser client
-     * refreshes the session and replays on.
+     * A project API key has credentials, so it is not an expired session:
+     * no 401. It has no user either, so it still gets only what an
+     * anonymous caller gets.
      */
-    describe("?signedIn=true", () => {
-      type SetCallerFunction = (caller: Record<string, unknown>) => void;
-
-      const setCaller: SetCallerFunction = (
-        caller: Record<string, unknown>,
-      ): void => {
-        Object.assign(
-          mockRequest as unknown as Record<string, unknown>,
-          caller,
-        );
-      };
+    it("does not 401 an API-key caller that sends the flag", async () => {
+      installWithSnapshot(createLicenseSnapshot());
+      setRequest({ userType: UserType.API, query: { signedIn: "true" } });
 
-      it.each([
-        ["no userType at all", {}],
-        [
-          "userType Public (what getUserMiddleware stamps)",
-          { userType: UserType.Public },
-        ],
-      ])(
-        "answers an anonymous caller (%s) with a 401 before reading the config",
-        async (_label: string, caller: Record<string, unknown>) => {
-          setCaller({ ...caller, query: { signedIn: "true" } });
-
-          await callGet();
-
-          const error: Error = nextError();
-
-          expect(error).toBeInstanceOf(NotAuthenticatedException);
-          expect((error as Exception).code).toBe(401);
-          expect(error.message).toBe(
-            UserMiddleware.AUTHENTICATION_REQUIRED_MESSAGE,
-          );
-          expect(GlobalConfigService.findOneById).not.toHaveBeenCalled();
-          expect(UserService.countBy).not.toHaveBeenCalled();
-          expect(Response.sendJsonObjectResponse).not.toHaveBeenCalled();
-        },
-      );
+      const body: JSONObject = await callGet();
 
-      // The login page does not send the flag and must keep working.
-      it("still serves an anonymous caller without the flag the reduced payload", async () => {
-        setCaller({ userType: UserType.Public, query: {} });
+      expect(Object.keys(body).sort()).toEqual(PUBLIC_KEYS);
+    });
+  });
 
-        await callGet();
+  describe("errors", () => {
+    it("passes a database failure to next instead of answering", async () => {
+      GlobalConfigService.findOneById = jest
+        .fn()
+        .mockRejectedValue(new Error("database is down"));
+      setCaller("master admin");
 
-        expect(nextFunction).not.toHaveBeenCalled();
-        expect(GlobalConfigService.findOneById).toHaveBeenCalledTimes(1);
+      await mockRouter
+        .match("get", LICENSE_ROUTE)
+        .handlerFunction(mockRequest, mockResponse, nextFunction);
 
-        const body: JSONObject = getResponseBody();
+      expect(nextFunction).toHaveBeenCalledTimes(1);
+      expect(Response.sendJsonObjectResponse).not.toHaveBeenCalled();
+    });
+  });
+});
 
-        expect(body["licenseKey"]).toBeNull();
-        expect(body["token"]).toBeNull();
-        expect(body["instanceId"]).toBeNull();
-        expect(body["instances"]).toEqual([]);
-        expect(body["currentVersion"]).toBeNull();
-        expect(body["seatsInUse"]).toBeNull();
-      });
+describe("GlobalConfigAPI.buildLicenseResponse", () => {
+  it("ignores a snapshot handed to it when the Enterprise Edition is not loaded", () => {
+    const body: JSONObject = GlobalConfigAPI.buildLicenseResponse({
+      audience: "master-admin",
+      isEnterpriseEditionLoaded: false,
+      snapshot: createLicenseSnapshot(),
+      config: makeStoredConfig(),
+      seatUsage: ENFORCED_SEAT_USAGE,
+    });
 
-      it.each([
-        ["signedIn=false", { signedIn: "false" }],
-        ["an empty signedIn", { signedIn: "" }],
-        ["signedIn=1", { signedIn: "1" }],
-      ])(
-        'only the exact string "true" asks for a 401 (%s serves the reduced payload)',
-        async (_label: string, query: Record<string, unknown>) => {
-          setCaller({ userType: UserType.Public, query: query });
+    expect(body["edition"]).toBe("community");
+    expect(body["licenseValid"]).toBe(false);
+    expect(body["licenseKey"]).toBeNull();
+    expect(body["isSeatLimitEnforced"]).toBe(false);
+  });
 
-          await callGet();
+  it("has the same keys for every audience whatever the license state", () => {
+    const statuses: Array<EnterpriseLicenseStatus> = [
+      "valid",
+      "grace",
+      "expired",
+      "missing",
+      "invalid",
+    ];
+
+    for (const status of statuses) {
+      const publicBody: JSONObject = GlobalConfigAPI.buildLicenseResponse({
+        audience: "public",
+        isEnterpriseEditionLoaded: true,
+        snapshot: createLicenseSnapshotWithStatus(status),
+        config: makeStoredConfig(),
+        seatUsage: ENFORCED_SEAT_USAGE,
+      });
+      const adminBody: JSONObject = GlobalConfigAPI.buildLicenseResponse({
+        audience: "master-admin",
+        isEnterpriseEditionLoaded: true,
+        snapshot: createLicenseSnapshotWithStatus(status),
+        config: makeStoredConfig(),
+        seatUsage: ENFORCED_SEAT_USAGE,
+      });
 
-          expect(nextFunction).not.toHaveBeenCalled();
-          expect(getResponseBody()["licenseKey"]).toBeNull();
-        },
+      expect(Object.keys(publicBody).sort()).toEqual(PUBLIC_KEYS);
+      expect(Object.keys(adminBody).sort()).toEqual(
+        [...PUBLIC_KEYS, ...MASTER_ADMIN_ONLY_KEYS].sort(),
       );
+    }
+  });
 
-      it("serves a signed-in user the full payload with the flag", async () => {
-        setCaller({
-          userType: UserType.User,
-          userAuthorization: { userId: ObjectID.generate() },
-          query: { signedIn: "true" },
-        });
+  describe("features", () => {
+    const buildPublic: (
+      snapshot: EnterpriseLicenseSnapshot | null,
+      isEnterpriseEditionLoaded?: boolean,
+    ) => JSONObject = (
+      snapshot: EnterpriseLicenseSnapshot | null,
+      isEnterpriseEditionLoaded?: boolean,
+    ): JSONObject => {
+      return GlobalConfigAPI.buildLicenseResponse({
+        audience: "public",
+        isEnterpriseEditionLoaded: isEnterpriseEditionLoaded !== false,
+        snapshot,
+        config: null,
+        seatUsage: null,
+      });
+    };
 
-        await callGet();
+    it('is "all" for a license that covers everything', () => {
+      expect(buildPublic(createLicenseSnapshot())["features"]).toBe("all");
+    });
 
-        expect(nextFunction).not.toHaveBeenCalled();
+    /*
+     * A valid license that leaves SSO out stops SSO (isFeatureActive), and
+     * licenseValid alone cannot tell a settings page that.
+     */
+    it("lists the features of a license that names them, so a page can tell one is left out", () => {
+      const body: JSONObject = buildPublic(
+        createLicenseSnapshot({
+          features: [EnterpriseFeature.SCIM, EnterpriseFeature.AuditLogs],
+        }),
+      );
 
-        const body: JSONObject = getResponseBody();
+      expect(body["licenseValid"]).toBe(true);
+      expect(body["features"]).toEqual(["scim", "audit-logs"]);
+      expect(body["features"]).not.toContain(EnterpriseFeature.SSO);
+    });
+
+    it("is an empty list when the license entitles nothing", () => {
+      expect(
+        buildPublic(createLicenseSnapshotWithStatus("missing"))["features"],
+      ).toEqual([]);
+    });
+
+    it("is null on the Community Edition, whatever snapshot is handed in", () => {
+      expect(buildPublic(null)["features"]).toBeNull();
+      expect(
+        buildPublic(createLicenseSnapshot(), false)["features"],
+      ).toBeNull();
+    });
 
-        expect(body["licenseKey"]).toBe(STORED_LICENSE_KEY);
-        expect(body["instanceId"]).toBe(INSTANCE_ID.toString());
-        expect(body["seatsInUse"]).toBe(42);
+    it("hands out a copy, never the snapshot's own list", () => {
+      const snapshot: EnterpriseLicenseSnapshot = createLicenseSnapshot({
+        features: [EnterpriseFeature.SSO],
       });
+      const features: Array<string> = buildPublic(snapshot)[
+        "features"
+      ] as Array<string>;
 
-      it("serves a signed-in user the same full payload without the flag", async () => {
-        setCaller({
-          userType: UserType.User,
-          userAuthorization: { userId: ObjectID.generate() },
-          query: {},
-        });
+      features.push("mutated");
 
-        await callGet();
+      expect(snapshot.features).toEqual([EnterpriseFeature.SSO]);
+    });
 
-        expect(nextFunction).not.toHaveBeenCalled();
-        expect(getResponseBody()["licenseKey"]).toBe(STORED_LICENSE_KEY);
+    it("is the same for a master admin", () => {
+      const body: JSONObject = GlobalConfigAPI.buildLicenseResponse({
+        audience: "master-admin",
+        isEnterpriseEditionLoaded: true,
+        snapshot: createLicenseSnapshot({ features: [EnterpriseFeature.SSO] }),
+        config: makeStoredConfig(),
+        seatUsage: ENFORCED_SEAT_USAGE,
       });
 
-      /*
-       * A project API key has credentials, so it is not an expired session:
-       * no 401. It has no user either, so it still gets only what an
-       * anonymous caller gets.
-       */
-      it("does not 401 an API-key caller that sends the flag", async () => {
-        setCaller({ userType: UserType.API, query: { signedIn: "true" } });
+      expect(body["features"]).toEqual(["sso"]);
+    });
+  });
 
-        await callGet();
+  it("maps unenforced seat usage to the 'nothing to enforce' fields", () => {
+    expect(
+      GlobalConfigAPI.getSeatUsageResponseFields({
+        ...ENFORCED_SEAT_USAGE,
+        isEnforced: false,
+      }),
+    ).toEqual({
+      isSeatLimitEnforced: false,
+      seatsInUse: null,
+      seatsRemaining: null,
+      canAddMoreUsers: true,
+    });
+  });
 
-        expect(nextFunction).not.toHaveBeenCalled();
-        expect(getResponseBody()["licenseKey"]).toBeNull();
-      });
+  it("reports a full license as unable to take more users", () => {
+    expect(
+      GlobalConfigAPI.getSeatUsageResponseFields({
+        ...ENFORCED_SEAT_USAGE,
+        seatsInUse: 50,
+        seatsRemaining: 0,
+        hasSeatForNewUser: false,
+      }),
+    ).toEqual({
+      isSeatLimitEnforced: true,
+      seatsInUse: 50,
+      seatsRemaining: 0,
+      canAddMoreUsers: false,
     });
   });
 });