@oneuptime/common 13.0.8 → 14.0.1

package/Tests/App/AdminDashboard/EnterpriseLicensesShell.test.tsx

@@ -0,0 +1,214 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import { cleanup, render, screen } from "@testing-library/react";
+import React, { FunctionComponent, ReactElement, ReactNode } from "react";
+
+/*
+ * Settings > Enterprise Licenses and one license: the core shells left at the
+ * old page paths after the license server's screens moved to
+ * ee/AdminDashboard/EnterpriseLicenses.
+ *
+ * The screens belong to the OneUptime Cloud license server, so the shells
+ * render the Enterprise plugin only when billing is enabled, and otherwise
+ * keep the "Only available on OneUptime Cloud" state the page has always shown
+ * on self-hosted installs. A Cloud deployment whose Admin Dashboard was built
+ * without the Enterprise plugin says so instead.
+ *
+ * Billing is pinned in every test (CI's config.env sets BILLING_ENABLED=true).
+ * The plugins are the Community stub unless a test hands in a fake - this is
+ * core, and must pass with ee/ deleted.
+ */
+
+let billingEnabledForTest: boolean = false;
+
+jest.mock("../../../UI/Config", () => {
+  const actual: Record<string, unknown> = jest.requireActual(
+    "../../../UI/Config",
+  ) as Record<string, unknown>;
+
+  const mocked: Record<string, unknown> = { ...actual };
+
+  Object.defineProperty(mocked, "BILLING_ENABLED", {
+    get: (): boolean => {
+      return billingEnabledForTest;
+    },
+  });
+
+  return mocked;
+});
+
+jest.mock("react-i18next", () => {
+  return {
+    useTranslation: () => {
+      return {
+        t: (key: string): string => {
+          return key;
+        },
+      };
+    },
+  };
+});
+
+// The page frame is not what this suite is about; keep its title and children.
+jest.mock("../../../UI/Components/Page/Page", () => {
+  return {
+    __esModule: true,
+    default: (props: { title?: string; children: ReactNode }): ReactElement => {
+      return (
+        <div data-testid="page" data-title={props.title}>
+          {props.children}
+        </div>
+      );
+    },
+  };
+});
+
+/*
+ * The plugin door, pointed at whatever the test sets. Starts as the real
+ * Community stub (what "@oneuptime/ee-admin-dashboard" is in core).
+ */
+let mockPluginsForTest: Record<string, unknown> = {};
+
+jest.mock(
+  "../../../../App/FeatureSet/AdminDashboard/src/Enterprise/Plugins",
+  () => {
+    return {
+      getAdminDashboardPlugins: (): Record<string, unknown> => {
+        return mockPluginsForTest;
+      },
+    };
+  },
+);
+
+import CommunityPlugins from "../../../../App/FeatureSet/AdminDashboard/src/Enterprise/CommunityPlugins";
+import EnterpriseLicenses from "../../../../App/FeatureSet/AdminDashboard/src/Pages/EnterpriseLicenses/Index";
+import EnterpriseLicenseView from "../../../../App/FeatureSet/AdminDashboard/src/Pages/EnterpriseLicenses/View/Index";
+
+const FakeLicensesList: FunctionComponent = (): ReactElement => {
+  return <div data-testid="ee-licenses-list" />;
+};
+
+const FakeLicenseView: FunctionComponent = (): ReactElement => {
+  return <div data-testid="ee-license-view" />;
+};
+
+const CLOUD_ONLY_TITLE: string = "Only available on OneUptime Cloud";
+const ENTERPRISE_BUILD_TITLE: string =
+  "Requires the OneUptime Enterprise Edition";
+
+interface ShellCase {
+  name: string;
+  Shell: FunctionComponent;
+  pluginKey: "EnterpriseLicensesList" | "EnterpriseLicenseView";
+  Fake: FunctionComponent;
+  testId: string;
+}
+
+const SHELLS: Array<ShellCase> = [
+  {
+    name: "the license list",
+    Shell: EnterpriseLicenses,
+    pluginKey: "EnterpriseLicensesList",
+    Fake: FakeLicensesList,
+    testId: "ee-licenses-list",
+  },
+  {
+    name: "one license",
+    Shell: EnterpriseLicenseView,
+    pluginKey: "EnterpriseLicenseView",
+    Fake: FakeLicenseView,
+    testId: "ee-license-view",
+  },
+];
+
+beforeEach(() => {
+  billingEnabledForTest = false;
+  mockPluginsForTest = CommunityPlugins as unknown as Record<string, unknown>;
+});
+
+afterEach(() => {
+  cleanup();
+});
+
+describe.each(SHELLS)(
+  "Enterprise Licenses shell: $name",
+  (shell: ShellCase) => {
+    test("the Community build has no license screens at all", () => {
+      expect(CommunityPlugins).toEqual({});
+    });
+
+    test("self-hosted Community Edition: the Cloud-only empty state", () => {
+      const { Shell } = shell;
+
+      render(<Shell />);
+
+      expect(screen.getByText(CLOUD_ONLY_TITLE)).toBeInTheDocument();
+      expect(
+        screen.getByText(
+          "Enterprise licenses are issued and tracked on the hosted oneuptime.com, where billing is enabled. This self-hosted instance does not manage licenses.",
+        ),
+      ).toBeInTheDocument();
+      expect(screen.getByTestId("page")).toHaveAttribute(
+        "data-title",
+        "pages.enterpriseLicenses.title",
+      );
+    });
+
+    test("self-hosted Enterprise Edition: still the Cloud-only empty state - the plugin is never rendered", () => {
+      const { Shell, Fake } = shell;
+
+      mockPluginsForTest = { [shell.pluginKey]: Fake };
+
+      render(<Shell />);
+
+      expect(screen.getByText(CLOUD_ONLY_TITLE)).toBeInTheDocument();
+      expect(screen.queryByTestId(shell.testId)).not.toBeInTheDocument();
+    });
+
+    test("OneUptime Cloud with the Enterprise plugin: the Enterprise screen", () => {
+      const { Shell, Fake } = shell;
+
+      billingEnabledForTest = true;
+      mockPluginsForTest = { [shell.pluginKey]: Fake };
+
+      render(<Shell />);
+
+      expect(screen.getByTestId(shell.testId)).toBeInTheDocument();
+      expect(screen.queryByText(CLOUD_ONLY_TITLE)).not.toBeInTheDocument();
+    });
+
+    test("OneUptime Cloud built without the plugin: says the Enterprise Edition is required", () => {
+      const { Shell } = shell;
+
+      billingEnabledForTest = true;
+
+      render(<Shell />);
+
+      expect(screen.getByText(ENTERPRISE_BUILD_TITLE)).toBeInTheDocument();
+      expect(screen.queryByText(CLOUD_ONLY_TITLE)).not.toBeInTheDocument();
+    });
+
+    test("reads only its own plugin key", () => {
+      const { Shell, Fake } = shell;
+      const otherKey: string =
+        shell.pluginKey === "EnterpriseLicensesList"
+          ? "EnterpriseLicenseView"
+          : "EnterpriseLicensesList";
+
+      billingEnabledForTest = true;
+      mockPluginsForTest = { [otherKey]: Fake };
+
+      render(<Shell />);
+
+      expect(screen.queryByTestId(shell.testId)).not.toBeInTheDocument();
+      expect(screen.getByText(ENTERPRISE_BUILD_TITLE)).toBeInTheDocument();
+    });
+  },
+);

package/Tests/App/AdminDashboard/GlobalSSOEnterpriseShells.test.tsx

@@ -0,0 +1,271 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import { cleanup, render, screen } from "@testing-library/react";
+import React, { FunctionComponent, ReactElement, ReactNode } from "react";
+
+/*
+ * Settings > Global SSO and Global OIDC (the provider lists and one
+ * provider's page) are Enterprise Edition screens
+ * (ee/AdminDashboard/GlobalSSO). Core keeps a shell at each page's original
+ * path, so App.tsx and its routes never changed: the shell renders the
+ * Enterprise screen on the Enterprise Edition when the bundle includes it,
+ * and otherwise the upsell card the page used to show, inside the settings
+ * layout.
+ *
+ * "@oneuptime/ee-admin-dashboard" is replaced by a plugin object the tests
+ * fill in, standing in for the Enterprise bundle; left empty it is the
+ * Community bundle. Billing and the edition are pinned in every test: CI's
+ * config.env sets BILLING_ENABLED=true, and the admin rule must not depend
+ * on it. The page chrome (Page, the settings side menu) is replaced by a
+ * plain wrapper that shows the side menu and breadcrumbs.
+ */
+
+let billingEnabledForTest: boolean = false;
+let enterpriseEditionForTest: boolean = false;
+
+jest.mock("../../../UI/Config", () => {
+  const actual: Record<string, unknown> = jest.requireActual(
+    "../../../UI/Config",
+  ) as Record<string, unknown>;
+
+  const mocked: Record<string, unknown> = { ...actual };
+
+  Object.defineProperty(mocked, "BILLING_ENABLED", {
+    get: (): boolean => {
+      return billingEnabledForTest;
+    },
+  });
+
+  Object.defineProperty(mocked, "IS_ENTERPRISE_EDITION", {
+    get: (): boolean => {
+      return enterpriseEditionForTest;
+    },
+  });
+
+  return mocked;
+});
+
+jest.mock("../../../UI/Components/Page/Page", () => {
+  return {
+    __esModule: true,
+    default: (props: {
+      title?: string;
+      breadcrumbLinks?: Array<{ title: string }>;
+      sideMenu?: ReactNode;
+      children?: ReactNode;
+    }): ReactElement => {
+      return (
+        <div data-testid="settings-page">
+          {props.sideMenu}
+          <div data-testid="settings-page-breadcrumbs">
+            {(props.breadcrumbLinks || [])
+              .map((link: { title: string }) => {
+                return link.title;
+              })
+              .join(" > ")}
+          </div>
+          {props.children}
+        </div>
+      );
+    },
+  };
+});
+
+jest.mock(
+  "../../../../App/FeatureSet/AdminDashboard/src/Pages/Settings/SideMenu",
+  () => {
+    return {
+      __esModule: true,
+      default: (): ReactElement => {
+        return <nav data-testid="settings-side-menu" />;
+      },
+    };
+  },
+);
+
+/*
+ * What getAdminDashboardPlugins() returns in this suite. The shells read it
+ * on every render, so each test fills it in after the shells were imported.
+ */
+const mockAdminEnterprisePlugins: Record<string, unknown> = {};
+
+jest.mock("@oneuptime/ee-admin-dashboard", () => {
+  return { __esModule: true, default: mockAdminEnterprisePlugins };
+});
+
+import SettingsGlobalOIDC from "../../../../App/FeatureSet/AdminDashboard/src/Pages/Settings/GlobalOIDC/Index";
+import SettingsGlobalOIDCView from "../../../../App/FeatureSet/AdminDashboard/src/Pages/Settings/GlobalOIDC/View";
+import SettingsGlobalSSO from "../../../../App/FeatureSet/AdminDashboard/src/Pages/Settings/GlobalSSO/Index";
+import SettingsGlobalSSOView from "../../../../App/FeatureSet/AdminDashboard/src/Pages/Settings/GlobalSSO/View";
+import { AdminDashboardEnterprisePluginKey } from "../../../../App/FeatureSet/AdminDashboard/src/Enterprise/EnterprisePlugins";
+
+interface ShellCase {
+  name: string;
+  Shell: FunctionComponent;
+  pluginKey: AdminDashboardEnterprisePluginKey;
+  // The upsell copy (and breadcrumb) the page showed before it moved to ee/.
+  provider: "Global SSO" | "Global OIDC";
+  upsellDescription: string;
+}
+
+const GLOBAL_SSO_DESCRIPTION: string =
+  "Instance-wide SAML 2.0 identity providers that can be connected to any project on this OneUptime server.";
+const GLOBAL_OIDC_DESCRIPTION: string =
+  "Instance-wide OpenID Connect identity providers that can be connected to any project on this OneUptime server.";
+
+const SHELLS: Array<ShellCase> = [
+  {
+    name: "Global SSO list",
+    Shell: SettingsGlobalSSO,
+    pluginKey: "GlobalSSOList",
+    provider: "Global SSO",
+    upsellDescription: GLOBAL_SSO_DESCRIPTION,
+  },
+  {
+    name: "Global SSO provider",
+    Shell: SettingsGlobalSSOView,
+    pluginKey: "GlobalSSOView",
+    provider: "Global SSO",
+    upsellDescription: GLOBAL_SSO_DESCRIPTION,
+  },
+  {
+    name: "Global OIDC list",
+    Shell: SettingsGlobalOIDC,
+    pluginKey: "GlobalOIDCList",
+    provider: "Global OIDC",
+    upsellDescription: GLOBAL_OIDC_DESCRIPTION,
+  },
+  {
+    name: "Global OIDC provider",
+    Shell: SettingsGlobalOIDCView,
+    pluginKey: "GlobalOIDCView",
+    provider: "Global OIDC",
+    upsellDescription: GLOBAL_OIDC_DESCRIPTION,
+  },
+];
+
+const makeFakeScreen: (pluginKey: string) => FunctionComponent = (
+  pluginKey: string,
+): FunctionComponent => {
+  const FakeScreen: FunctionComponent = (): ReactElement => {
+    return <div data-testid="enterprise-screen">{pluginKey}</div>;
+  };
+
+  return FakeScreen;
+};
+
+const installPlugins: (
+  keys: Array<AdminDashboardEnterprisePluginKey>,
+) => void = (keys: Array<AdminDashboardEnterprisePluginKey>): void => {
+  for (const key of keys) {
+    mockAdminEnterprisePlugins[key] = makeFakeScreen(key);
+  }
+};
+
+const clearPlugins: () => void = (): void => {
+  for (const key of Object.keys(mockAdminEnterprisePlugins)) {
+    delete mockAdminEnterprisePlugins[key];
+  }
+};
+
+beforeEach(() => {
+  billingEnabledForTest = false;
+  enterpriseEditionForTest = false;
+  clearPlugins();
+});
+
+afterEach(() => {
+  cleanup();
+  clearPlugins();
+});
+
+describe.each(SHELLS)("$name shell", (shell: ShellCase) => {
+  test.each([false, true])(
+    "Community Edition (billing=%s): the upsell inside the settings layout, even when a plugin is present",
+    (billing: boolean) => {
+      billingEnabledForTest = billing;
+      installPlugins([shell.pluginKey]);
+
+      render(<shell.Shell />);
+
+      expect(screen.getByTestId("settings-page")).toBeInTheDocument();
+      expect(screen.getByTestId("settings-side-menu")).toBeInTheDocument();
+      expect(screen.getByTestId("settings-page-breadcrumbs")).toHaveTextContent(
+        shell.provider,
+      );
+      expect(screen.getByText(shell.upsellDescription)).toBeInTheDocument();
+      expect(
+        screen.getAllByText("Learn about Enterprise Edition").length,
+      ).toBeGreaterThan(0);
+      expect(screen.queryByTestId("enterprise-screen")).not.toBeInTheDocument();
+    },
+  );
+
+  test.each([false, true])(
+    "Enterprise Edition (billing=%s): the Enterprise screen, on its own",
+    (billing: boolean) => {
+      billingEnabledForTest = billing;
+      enterpriseEditionForTest = true;
+      installPlugins([shell.pluginKey]);
+
+      render(<shell.Shell />);
+
+      expect(screen.getByTestId("enterprise-screen")).toHaveTextContent(
+        shell.pluginKey,
+      );
+      // The Enterprise screen brings its own layout.
+      expect(screen.queryByTestId("settings-page")).not.toBeInTheDocument();
+      expect(
+        screen.queryByText(shell.upsellDescription),
+      ).not.toBeInTheDocument();
+    },
+  );
+
+  test("Enterprise Edition on a Community bundle: the upsell", () => {
+    enterpriseEditionForTest = true;
+
+    render(<shell.Shell />);
+
+    expect(screen.getByText(shell.upsellDescription)).toBeInTheDocument();
+    expect(screen.queryByTestId("enterprise-screen")).not.toBeInTheDocument();
+  });
+
+  test("renders its own plugin key when every Global SSO screen is present", () => {
+    enterpriseEditionForTest = true;
+    installPlugins(
+      SHELLS.map((each: ShellCase) => {
+        return each.pluginKey;
+      }),
+    );
+
+    render(<shell.Shell />);
+
+    expect(screen.getByTestId("enterprise-screen")).toHaveTextContent(
+      shell.pluginKey,
+    );
+    expect(screen.getAllByTestId("enterprise-screen")).toHaveLength(1);
+  });
+
+  test("ignores the other Global SSO screens", () => {
+    enterpriseEditionForTest = true;
+    installPlugins(
+      SHELLS.map((each: ShellCase) => {
+        return each.pluginKey;
+      }).filter((key: AdminDashboardEnterprisePluginKey) => {
+        return key !== shell.pluginKey;
+      }),
+    );
+
+    render(<shell.Shell />);
+
+    expect(screen.queryByTestId("enterprise-screen")).not.toBeInTheDocument();
+    expect(screen.getByText(shell.upsellDescription)).toBeInTheDocument();
+  });
+});