@oneuptime/common 13.0.8 → 14.0.1

package/Tests/UI/Components/EditionLabelLicenseRefresh.test.tsx

@@ -14,23 +14,22 @@ import React from "react";
 import { beforeEach, describe, expect, it } from "@jest/globals";
 
 /*
- * The "Refresh license" button, and who is allowed to see it.
+ * What EditionLabel on its own still does around the license GET and the seat
+ * figures, with no license manager (the login page, a build without the
+ * Enterprise plugin). This suite must pass with ee/ deleted.
  *
- * The seat limit is set on oneuptime.com and can change on any day. It reaches
- * a self-hosted installation through a job that runs once a day — which was
- * merely slow while nothing acted on the number, and is a real problem now that
- * the installation refuses users above it. An administrator who has just bought
- * ten seats should not have to wait until tomorrow, and should not have to
- * re-type the license key into a box the dialog hides while the license is
- * valid. This button is the answer, so these tests pin that it:
+ * The "Refresh license" button this suite used to cover - offered only to a
+ * master admin, sending no key, showing the new limit, reporting a failure -
+ * is the Enterprise plugin's license manager now, together with the seat
+ * card. ee/Tests/UI/License/LicenseManagerRefresh.test.tsx runs every one of
+ * this suite's original tests against EditionLabel with that manager. What
+ * stays here:
  *
- *   - is offered only to a master admin, matching the server, which now
- *     requires one on both license writes;
- *   - sends no license key, so it can only ever refresh the key already
- *     stored and never replace a working license with a typo;
- *   - shows the new limit afterwards;
- *   - says so when it fails, rather than looking like it worked. The whole
- *     reason it was pressed is a belief that the stored terms are stale.
+ *   - the signedIn flag on the license GET;
+ *   - a non-admin is told who can activate the license;
+ *   - EditionLabel never offers a refresh, a key change or the seat card by
+ *     itself, and writes nothing;
+ *   - the pill still reads the seat figures, enforced usage first.
  */
 
 let isEnterpriseEdition: boolean = true;
@@ -137,7 +136,14 @@ const licensePayload: LicensePayloadFunction = (
     expiresAt: EXPIRES_AT,
     licenseKey: "acme-license-key",
     token: "signed.jwt.token",
+    edition: "enterprise",
+    status: "valid",
+    verification: "verified",
+    graceReason: null,
+    graceEndsAt: null,
+    activationMode: "online",
     licenseValid: true,
+    isEvaluation: false,
     isEvaluationLicense: false,
     userLimit: 50,
     currentUserCount: 50,
@@ -245,7 +251,14 @@ describe("EditionLabel - telling the license route we expect to be signed in", (
   });
 });
 
-describe("EditionLabel - refreshing the license", () => {
+/*
+ * Refreshing the license, changing its key and the seat card are the
+ * Enterprise plugin's license manager now (ee/Tests/UI/License runs this
+ * suite's original refresh and seat tests against it). What EditionLabel
+ * still owns is below: telling a non-admin who can act, reading the seat
+ * figures for the pill, and never writing the license itself.
+ */
+describe("EditionLabel - the license, read-only", () => {
   beforeEach(() => {
     fetchCalls.length = 0;
     isEnterpriseEdition = true;
@@ -257,39 +270,12 @@ describe("EditionLabel - refreshing the license", () => {
     };
   });
 
-  it("offers the button to a master admin once the license is valid", async () => {
-    await openDialog();
-
-    expect(
-      await screen.findByTestId("refresh-enterprise-license"),
-    ).toBeInTheDocument();
-  });
-
-  /*
-   * The server requires a master admin on both license writes, so offering the
-   * button to anyone else would only ever produce a permission error.
-   */
-  it("does not offer the button to a user who is not a master admin", async () => {
-    isMasterAdmin = false;
-
-    await openDialog();
-
-    await waitFor(() => {
-      expect(screen.getByText("Licensed seats")).toBeInTheDocument();
-    });
-
-    expect(
-      screen.queryByTestId("refresh-enterprise-license"),
-    ).not.toBeInTheDocument();
-    expect(screen.queryByText("Change license key")).not.toBeInTheDocument();
-  });
-
   it("asks a non-admin to find one when the license needs activating", async () => {
     isMasterAdmin = false;
     respond = (): HTTPResponse<JSONObject> => {
       return new HTTPResponse<JSONObject>(
         200,
-        licensePayload({ licenseValid: false, token: null }),
+        licensePayload({ licenseValid: false, token: null, status: "missing" }),
         {},
       );
     };
@@ -304,95 +290,28 @@ describe("EditionLabel - refreshing the license", () => {
     ).not.toBeInTheDocument();
   });
 
-  /*
-   * No license key in the body. A refresh that carried one would be an
-   * activation with a friendlier name.
-   */
-  it("refreshes the stored license without sending a key", async () => {
-    await openDialog();
-
-    fireEvent.click(await screen.findByTestId("refresh-enterprise-license"));
-
-    await waitFor(() => {
-      expect(
-        fetchCalls.some((call: FetchCall): boolean => {
-          return call.url.includes("/global-config/license/refresh");
-        }),
-      ).toBe(true);
-    });
-
-    const refreshCall: FetchCall = fetchCalls.find(
-      (call: FetchCall): boolean => {
-        return call.url.includes("/global-config/license/refresh");
-      },
-    ) as FetchCall;
-
-    expect(refreshCall.method).toBe("POST");
-    expect(refreshCall.data).toBeUndefined();
-  });
-
-  it("shows the new seat limit after a refresh", async () => {
+  it("offers no refresh, key change or seat card on its own, even to a master admin", async () => {
     await openDialog();
 
-    await screen.findByTestId("refresh-enterprise-license");
-
-    // Ten more seats bought on oneuptime.com since the page loaded.
-    respond = (): HTTPResponse<JSONObject> => {
-      return new HTTPResponse<JSONObject>(
-        200,
-        licensePayload({
-          userLimit: 60,
-          seatsRemaining: 10,
-          canAddMoreUsers: true,
-        }),
-        {},
-      );
-    };
-
-    fireEvent.click(screen.getByTestId("refresh-enterprise-license"));
-
-    expect(
-      await screen.findByText(/License refreshed from OneUptime/),
-    ).toBeInTheDocument();
-    expect(await screen.findByText(/60 seats/)).toBeInTheDocument();
-  });
-
-  /*
-   * A refresh that quietly kept the old terms and said nothing would be worse
-   * than no button at all: the administrator pressed it precisely because they
-   * think the stored terms are wrong.
-   */
-  it("reports a failed refresh instead of looking like it worked", async () => {
-    await openDialog();
-
-    await screen.findByTestId("refresh-enterprise-license");
-
-    respond = (
-      call: FetchCall,
-    ): HTTPResponse<JSONObject> | HTTPErrorResponse => {
-      if (call.url.includes("/refresh")) {
-        return new HTTPErrorResponse(
-          500,
-          { message: "Could not reach OneUptime." },
-          {},
-        );
-      }
-
-      return new HTTPResponse<JSONObject>(200, licensePayload(), {});
-    };
-
-    fireEvent.click(screen.getByTestId("refresh-enterprise-license"));
-
-    expect(
-      await screen.findByText(/Could not reach OneUptime/),
-    ).toBeInTheDocument();
+    expect(await screen.findByText("Licensed to")).toBeInTheDocument();
     expect(
-      screen.queryByText(/License refreshed from OneUptime/),
+      screen.queryByTestId("refresh-enterprise-license"),
     ).not.toBeInTheDocument();
+    expect(screen.queryByText("Change license key")).not.toBeInTheDocument();
+    expect(screen.queryByText("Licensed seats")).not.toBeInTheDocument();
+    expect(
+      fetchCalls.filter((call: FetchCall): boolean => {
+        return call.method !== "GET" || call.url.includes("/refresh");
+      }),
+    ).toEqual([]);
   });
 });
 
-describe("EditionLabel - what an exhausted seat limit looks like", () => {
+/*
+ * The pill still reads the seat figures: an exhausted limit is what a master
+ * admin has to see on every page, not only inside the dialog.
+ */
+describe("EditionLabel - what an exhausted seat limit looks like on the pill", () => {
   beforeEach(() => {
     fetchCalls.length = 0;
     isEnterpriseEdition = true;
@@ -404,64 +323,62 @@ describe("EditionLabel - what an exhausted seat limit looks like", () => {
     };
   });
 
+  const pillNamed: (name: string) => Promise<void> = async (
+    name: string,
+  ): Promise<void> => {
+    render(<EditionLabel />);
+
+    await waitFor(() => {
+      expect(
+        screen.getByRole("button", { name: /Enterprise Edition/ }),
+      ).toHaveAccessibleName(name);
+    });
+  };
+
   /*
-   * 50 of 50 is not over the limit, so the old arithmetic called it "nearly
-   * full" — an amber nudge in front of a door that is already shut. Once the
-   * limit is enforced, being exactly on it is the thing the administrator has
-   * to act on.
+   * 50 of 50 is not over the limit, but once the limit is enforced nobody
+   * else gets in: a breach, not an amber nudge.
    */
-  it("treats a full license as a breach rather than a nudge", async () => {
-    await openDialog();
+  it("treats a full enforced license as a breach, on the pill and the dialog badge", async () => {
+    await pillNamed("Enterprise Edition, User limit exceeded");
 
-    expect(
-      await screen.findByText("Every licensed seat is in use"),
-    ).toBeInTheDocument();
-    expect(screen.getByText("Limit exceeded")).toBeInTheDocument();
+    fireEvent.click(screen.getByRole("button", { name: /Enterprise Edition/ }));
+
+    expect(await screen.findByText("Seat limit exceeded")).toBeInTheDocument();
   });
 
-  it("says plainly that no more users can be added", async () => {
-    await openDialog();
+  it("measures against the live enforced usage rather than the last reported count", async () => {
+    respond = (): HTTPResponse<JSONObject> => {
+      return new HTTPResponse<JSONObject>(
+        200,
+        licensePayload({ currentUserCount: 40, seatsInUse: 50 }),
+        {},
+      );
+    };
 
-    expect(
-      await screen.findByText(
-        /New users cannot be invited, signed up or provisioned/,
-      ),
-    ).toBeInTheDocument();
+    await pillNamed("Enterprise Edition, User limit exceeded");
   });
 
-  /*
-   * seatsInUse is computed from the live User table; currentUserCount is the
-   * licence-wide figure oneuptime.com last computed, up to a day ago. The card
-   * has to show the one enforcement uses, or it contradicts the invitation that
-   * just bounced.
-   */
-  it("shows the live enforced usage rather than the last reported count", async () => {
+  it("says nothing is wrong when the server reports no enforcement and seats are free", async () => {
     respond = (): HTTPResponse<JSONObject> => {
       return new HTTPResponse<JSONObject>(
         200,
         licensePayload({
-          currentUserCount: 40,
-          seatsInUse: 50,
+          isSeatLimitEnforced: false,
+          seatsInUse: null,
+          seatsRemaining: null,
+          canAddMoreUsers: true,
+          currentUserCount: 10,
+          userLimit: 50,
         }),
         {},
       );
     };
 
-    await openDialog();
-
-    await waitFor(() => {
-      expect(screen.getByText("Licensed seats")).toBeInTheDocument();
-    });
-
-    expect(screen.getByText("50")).toBeInTheDocument();
-    expect(screen.queryByText("40")).not.toBeInTheDocument();
+    await pillNamed("Enterprise Edition, View details");
   });
 
-  /*
-   * A build or a deployment that reports no enforcement must not be rendered as
-   * one that is refusing users.
-   */
-  it("says nothing about enforcement when the server reports none", async () => {
+  it("nudges when seats are nearly full", async () => {
     respond = (): HTTPResponse<JSONObject> => {
       return new HTTPResponse<JSONObject>(
         200,
@@ -470,24 +387,13 @@ describe("EditionLabel - what an exhausted seat limit looks like", () => {
           seatsInUse: null,
           seatsRemaining: null,
           canAddMoreUsers: true,
-          currentUserCount: 10,
+          currentUserCount: 46,
           userLimit: 50,
         }),
         {},
       );
     };
 
-    await openDialog();
-
-    await waitFor(() => {
-      expect(screen.getByText("Licensed seats")).toBeInTheDocument();
-    });
-
-    expect(
-      screen.queryByText(/New users cannot be invited/),
-    ).not.toBeInTheDocument();
-    expect(
-      screen.queryByText(/This installation enforces the seat limit/),
-    ).not.toBeInTheDocument();
+    await pillNamed("Enterprise Edition, Seats nearly full");
   });
 });