@oneuptime/common 13.0.7 → 14.0.0

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

@@ -3,33 +3,39 @@ import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
 import HTTPResponse from "../../../Types/API/HTTPResponse";
 import { JSONObject } from "../../../Types/JSON";
 import "@testing-library/jest-dom";
-import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import {
+  act,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from "@testing-library/react";
 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;
 let billingEnabled: boolean = false;
 let isMasterAdmin: boolean = true;
+let isLoggedIn: boolean = true;
 
 /*
  * Object.defineProperty rather than getters in an object literal: this file is
@@ -65,6 +71,9 @@ jest.mock("../../../UI/Utils/User", () => {
       isMasterAdmin: (): boolean => {
         return isMasterAdmin;
       },
+      isLoggedIn: (): boolean => {
+        return isLoggedIn;
+      },
     },
   };
 });
@@ -127,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,
@@ -159,42 +175,99 @@ const openDialog: OpenDialogFunction = async (): Promise<void> => {
   fireEvent.click(screen.getByRole("button", { name: /Enterprise Edition/i }));
 };
 
-describe("EditionLabel - refreshing the license", () => {
+/*
+ * The license GET also serves the login page, so on its own the server answers
+ * a caller with no session with the reduced anonymous payload and a 200. Inside
+ * a signed-in app that caller is this component with an expired session, and
+ * the reduced payload reads as "no license, no instances". Sending
+ * `signedIn=true` makes the server answer 401 instead, which the API client
+ * refreshes and replays. On the login page (nobody signed in) the flag must
+ * NOT be sent, or the page would get a 401 instead of the edition pill.
+ */
+describe("EditionLabel - telling the license route we expect to be signed in", () => {
+  type LicenseGetFunction = () => FetchCall;
+
+  const licenseGet: LicenseGetFunction = (): FetchCall => {
+    const call: FetchCall | undefined = fetchCalls.find(
+      (candidate: FetchCall): boolean => {
+        return (
+          candidate.method === "GET" &&
+          candidate.url.includes("/global-config/license")
+        );
+      },
+    );
+
+    expect(call).toBeDefined();
+
+    return call as FetchCall;
+  };
+
+  type RenderAndSettleFunction = () => Promise<void>;
+
+  /*
+   * Renders and waits for the license GET, then lets the response's state
+   * updates land inside act() so they do not spill past the end of the test.
+   */
+  const renderAndSettle: RenderAndSettleFunction = async (): Promise<void> => {
+    render(<EditionLabel />);
+
+    await waitFor(() => {
+      expect(fetchCalls.length).toBeGreaterThan(0);
+    });
+
+    await act(async () => {
+      await new Promise<void>((resolve: () => void) => {
+        setTimeout(resolve, 0);
+      });
+    });
+  };
+
   beforeEach(() => {
     fetchCalls.length = 0;
     isEnterpriseEdition = true;
     billingEnabled = false;
     isMasterAdmin = true;
+    isLoggedIn = true;
     respond = (): HTTPResponse<JSONObject> => {
       return new HTTPResponse<JSONObject>(200, licensePayload(), {});
     };
   });
 
-  it("offers the button to a master admin once the license is valid", async () => {
-    await openDialog();
+  it("adds signedIn=true to the license fetch when a user is logged in", async () => {
+    isLoggedIn = true;
 
-    expect(
-      await screen.findByTestId("refresh-enterprise-license"),
-    ).toBeInTheDocument();
+    await renderAndSettle();
+
+    expect(licenseGet().url).toContain("signedIn=true");
   });
 
-  /*
-   * 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;
+  it("does not add signedIn to the license fetch when nobody is logged in", async () => {
+    isLoggedIn = false;
 
-    await openDialog();
+    await renderAndSettle();
 
-    await waitFor(() => {
-      expect(screen.getByText("Licensed seats")).toBeInTheDocument();
-    });
+    expect(licenseGet().url).toContain("/global-config/license");
+    expect(licenseGet().url).not.toContain("signedIn");
+  });
+});
 
-    expect(
-      screen.queryByTestId("refresh-enterprise-license"),
-    ).not.toBeInTheDocument();
-    expect(screen.queryByText("Change license key")).not.toBeInTheDocument();
+/*
+ * 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;
+    billingEnabled = false;
+    isMasterAdmin = true;
+    isLoggedIn = true;
+    respond = (): HTTPResponse<JSONObject> => {
+      return new HTTPResponse<JSONObject>(200, licensePayload(), {});
+    };
   });
 
   it("asks a non-admin to find one when the license needs activating", async () => {
@@ -202,7 +275,7 @@ describe("EditionLabel - refreshing the license", () => {
     respond = (): HTTPResponse<JSONObject> => {
       return new HTTPResponse<JSONObject>(
         200,
-        licensePayload({ licenseValid: false, token: null }),
+        licensePayload({ licenseValid: false, token: null, status: "missing" }),
         {},
       );
     };
@@ -217,163 +290,95 @@ 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("Licensed to")).toBeInTheDocument();
     expect(
-      await screen.findByText(/Could not reach OneUptime/),
-    ).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;
     billingEnabled = false;
     isMasterAdmin = true;
+    isLoggedIn = true;
     respond = (): HTTPResponse<JSONObject> => {
       return new HTTPResponse<JSONObject>(200, licensePayload(), {});
     };
   });
 
+  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,
@@ -382,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");
   });
 });