@oneuptime/common 13.0.8 → 14.0.0

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

@@ -0,0 +1,254 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import { act, cleanup, render } from "@testing-library/react";
+import React, { ReactElement } from "react";
+import fs from "fs";
+import path from "path";
+
+/*
+ * The core Header (Admin Dashboard) and Footer (Dashboard) hand their edition
+ * pill the Enterprise plugin's LicenseManager, read from the plugin door
+ * inside render. With the Community stub - which is what this jest config
+ * resolves the plugin specifiers to - they hand it nothing, and the pill
+ * shows the license status only.
+ *
+ * EditionLabel is replaced with a probe that records the prop, and each door
+ * with one that returns whatever the test sets (the real Community stub by
+ * default). This is core, and must pass with ee/ deleted.
+ */
+
+const receivedManagers: Array<unknown> = [];
+
+jest.mock("../../../UI/Components/EditionLabel/EditionLabel", () => {
+  return {
+    __esModule: true,
+    default: (props: { licenseManager?: unknown }): ReactElement => {
+      receivedManagers.push(props.licenseManager);
+
+      return <span data-testid="edition-label" />;
+    },
+  };
+});
+
+jest.mock("../../../UI/Images/logos/OneUptimeSVG/3-transparent.svg", () => {
+  return "data:image/svg+xml;base64,bG9nbw==";
+});
+
+jest.mock("react-i18next", () => {
+  return {
+    useTranslation: () => {
+      return {
+        t: (key: string): string => {
+          return key;
+        },
+      };
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/User", () => {
+  return {
+    __esModule: true,
+    default: {
+      isMasterAdmin: (): boolean => {
+        return true;
+      },
+      isLoggedIn: (): boolean => {
+        return true;
+      },
+    },
+  };
+});
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/LanguageSwitcher/LanguageSwitcher",
+  () => {
+    return {
+      __esModule: true,
+      default: (): ReactElement => {
+        return <span data-testid="language-switcher" />;
+      },
+    };
+  },
+);
+
+let mockAdminPlugins: Record<string, unknown> = {};
+let mockDashboardPlugins: Record<string, unknown> = {};
+let adminDoorReads: number = 0;
+let dashboardDoorReads: number = 0;
+
+jest.mock(
+  "../../../../App/FeatureSet/AdminDashboard/src/Enterprise/Plugins",
+  () => {
+    return {
+      getAdminDashboardPlugins: (): Record<string, unknown> => {
+        adminDoorReads += 1;
+        return mockAdminPlugins;
+      },
+    };
+  },
+);
+
+jest.mock("../../../../App/FeatureSet/Dashboard/src/Enterprise/Plugins", () => {
+  return {
+    getDashboardPlugins: (): Record<string, unknown> => {
+      dashboardDoorReads += 1;
+      return mockDashboardPlugins;
+    },
+  };
+});
+
+import AdminCommunityPlugins from "../../../../App/FeatureSet/AdminDashboard/src/Enterprise/CommunityPlugins";
+import DashboardCommunityPlugins from "../../../../App/FeatureSet/Dashboard/src/Enterprise/CommunityPlugins";
+import AdminDashboardHeader from "../../../../App/FeatureSet/AdminDashboard/src/Components/Header/Header";
+import DashboardFooter from "../../../../App/FeatureSet/Dashboard/src/Components/Footer/Footer";
+import { ADMIN_DASHBOARD_ENTERPRISE_PLUGIN_KEYS } from "../../../../App/FeatureSet/AdminDashboard/src/Enterprise/EnterprisePlugins";
+import { DASHBOARD_ENTERPRISE_PLUGIN_KEYS } from "../../../../App/FeatureSet/Dashboard/src/Enterprise/EnterprisePlugins";
+
+const FakeAdminLicenseManager: () => ReactElement = (): ReactElement => {
+  return <span />;
+};
+
+const FakeDashboardLicenseManager: () => ReactElement = (): ReactElement => {
+  return <span />;
+};
+
+const APP_DIR: string = path.resolve(__dirname, "..", "..", "..", "..", "App");
+
+interface Caller {
+  name: string;
+  file: string;
+  render: () => void;
+  setPlugins: (plugins: Record<string, unknown>) => void;
+  communityStub: Record<string, unknown>;
+  fake: () => ReactElement;
+  doorReads: () => number;
+}
+
+const CALLERS: Array<Caller> = [
+  {
+    name: "the Admin Dashboard header",
+    file: path.join(
+      APP_DIR,
+      "FeatureSet/AdminDashboard/src/Components/Header/Header.tsx",
+    ),
+    render: (): void => {
+      render(<AdminDashboardHeader />);
+    },
+    setPlugins: (plugins: Record<string, unknown>): void => {
+      mockAdminPlugins = plugins;
+    },
+    communityStub: AdminCommunityPlugins as Record<string, unknown>,
+    fake: FakeAdminLicenseManager,
+    doorReads: (): number => {
+      return adminDoorReads;
+    },
+  },
+  {
+    name: "the Dashboard footer",
+    file: path.join(
+      APP_DIR,
+      "FeatureSet/Dashboard/src/Components/Footer/Footer.tsx",
+    ),
+    render: (): void => {
+      render(<DashboardFooter />);
+    },
+    setPlugins: (plugins: Record<string, unknown>): void => {
+      mockDashboardPlugins = plugins;
+    },
+    communityStub: DashboardCommunityPlugins as Record<string, unknown>,
+    fake: FakeDashboardLicenseManager,
+    doorReads: (): number => {
+      return dashboardDoorReads;
+    },
+  },
+];
+
+beforeEach(() => {
+  receivedManagers.length = 0;
+  adminDoorReads = 0;
+  dashboardDoorReads = 0;
+  mockAdminPlugins = AdminCommunityPlugins as Record<string, unknown>;
+  mockDashboardPlugins = DashboardCommunityPlugins as Record<string, unknown>;
+});
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("LicenseManager is a key of both plugin contracts", () => {
+  test("the Admin Dashboard's", () => {
+    expect(ADMIN_DASHBOARD_ENTERPRISE_PLUGIN_KEYS).toContain("LicenseManager");
+  });
+
+  test("the Dashboard's", () => {
+    expect(DASHBOARD_ENTERPRISE_PLUGIN_KEYS).toContain("LicenseManager");
+  });
+
+  test("and neither Community stub provides it", () => {
+    expect(
+      (AdminCommunityPlugins as Record<string, unknown>)["LicenseManager"],
+    ).toBeUndefined();
+    expect(
+      (DashboardCommunityPlugins as Record<string, unknown>)["LicenseManager"],
+    ).toBeUndefined();
+  });
+});
+
+describe.each(CALLERS)("$name", (caller: Caller) => {
+  test("passes the plugin's LicenseManager to the edition pill", async () => {
+    caller.setPlugins({ LicenseManager: caller.fake });
+
+    await act(async () => {
+      caller.render();
+    });
+
+    expect(receivedManagers).toContain(caller.fake);
+    expect(
+      receivedManagers.every((value: unknown): boolean => {
+        return value === caller.fake;
+      }),
+    ).toBe(true);
+  });
+
+  test("passes nothing with the Community stub (negative control)", async () => {
+    caller.setPlugins(caller.communityStub);
+
+    await act(async () => {
+      caller.render();
+    });
+
+    expect(receivedManagers.length).toBeGreaterThan(0);
+    expect(
+      receivedManagers.every((value: unknown): boolean => {
+        return value === undefined;
+      }),
+    ).toBe(true);
+  });
+
+  test("reads the door while rendering, not when the module loads", async () => {
+    // The module was imported above; no render has happened yet.
+    expect(caller.doorReads()).toBe(0);
+
+    await act(async () => {
+      caller.render();
+    });
+
+    expect(caller.doorReads()).toBeGreaterThan(0);
+  });
+
+  test("names the prop in its source, so the wiring is not a coincidence", () => {
+    const source: string = fs.readFileSync(caller.file, "utf8");
+
+    expect(source).toMatch(
+      /licenseManager=\{get(AdminDashboard|Dashboard)Plugins\(\)\.LicenseManager\}/,
+    );
+  });
+});

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");
   });
 });