@oneuptime/common 13.0.7 → 14.0.0

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

@@ -0,0 +1,217 @@
+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, { ReactElement } from "react";
+
+/*
+ * Admin Dashboard > Settings > Authentication has the instance-wide "Require
+ * SSO for Login" toggle. SSO login is part of the Enterprise Edition, which
+ * the cloud (billing on) also runs, so the toggle is offered there. On the
+ * Community Edition the server does not enforce the setting (design v2
+ * section 0), so the page does not offer it as if it did something: it says
+ * the setting is an Enterprise Edition feature, that it is not enforced here,
+ * and that a saved value is kept.
+ *
+ * Billing and the edition are pinned in every test: CI's config.env sets
+ * BILLING_ENABLED=true.
+ */
+
+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;
+});
+
+interface CardModelDetailFormField {
+  field: Record<string, boolean>;
+  description?: string | undefined;
+}
+
+interface CardModelDetailProps {
+  name: string;
+  cardProps: { title: string };
+  formFields: Array<CardModelDetailFormField>;
+}
+
+// Each settings card, reduced to its name, the columns its form edits and their descriptions.
+jest.mock("../../../UI/Components/ModelDetail/CardModelDetail", () => {
+  return {
+    __esModule: true,
+    default: (props: CardModelDetailProps): ReactElement => {
+      return (
+        <section data-testid={`card-${props.name}`}>
+          <h2>{props.cardProps.title}</h2>
+          {props.formFields.map((formField: CardModelDetailFormField) => {
+            const column: string = Object.keys(formField.field)[0] || "";
+            return (
+              <span key={column} data-testid={`edits-${column}`}>
+                {column}
+                <span data-testid={`describes-${column}`}>
+                  {formField.description || ""}
+                </span>
+              </span>
+            );
+          })}
+        </section>
+      );
+    },
+  };
+});
+
+jest.mock("../../../UI/Components/Page/Page", () => {
+  const react: typeof React = jest.requireActual("react") as typeof React;
+
+  return {
+    __esModule: true,
+    default: (props: { children?: React.ReactNode }) => {
+      return react.createElement("div", null, props.children);
+    },
+  };
+});
+
+jest.mock(
+  "../../../../App/FeatureSet/AdminDashboard/src/Pages/Settings/SideMenu",
+  () => {
+    return {
+      __esModule: true,
+      default: (): null => {
+        return null;
+      },
+    };
+  },
+);
+
+jest.mock("react-i18next", () => {
+  return {
+    useTranslation: () => {
+      return {
+        t: (key: string): string => {
+          return key;
+        },
+      };
+    },
+  };
+});
+
+import AuthenticationSettings from "../../../../App/FeatureSet/AdminDashboard/src/Pages/Settings/Authentication/Index";
+
+const CE_NOTICE: RegExp =
+  /Requiring SSO for login is part of the OneUptime Enterprise Edition\. This server runs the Community Edition/;
+
+/*
+ * On a self-hosted Enterprise Edition whose license lapsed (after the trial or
+ * the grace period) SSO sign-in stops, so "Require SSO" is not enforced
+ * either - an admin turning it on must not believe it holds regardless.
+ */
+const LAPSE_NOTE: RegExp =
+  /not enforced while the Enterprise license is missing or expired \(after the 14-day trial, or 30 days after a license expires\), because SSO sign-in stops then too: users sign in with their password until a license is activated/;
+
+// The toggle's description before the license could switch SSO off.
+const RETIRED_TOGGLE_DESCRIPTION: string =
+  "When enabled, all users must sign in with SSO to access any project on this server. Master admins are exempt so they can always recover from a misconfigured SSO. A project's own SSO settings still apply on top of this.";
+
+describe("Admin Dashboard authentication settings: Require SSO for Login", () => {
+  beforeEach(() => {
+    billingEnabledForTest = false;
+    enterpriseEditionForTest = false;
+  });
+
+  afterEach(() => {
+    cleanup();
+    billingEnabledForTest = false;
+    enterpriseEditionForTest = false;
+  });
+
+  test("the Community Edition shows why the setting is not available instead of the toggle", () => {
+    render(<AuthenticationSettings />);
+
+    expect(screen.queryByTestId("card-SSO Settings")).not.toBeInTheDocument();
+    expect(
+      screen.queryByTestId("edits-requireSsoForLogin"),
+    ).not.toBeInTheDocument();
+    expect(screen.getByText("Single Sign-On (SSO)")).toBeInTheDocument();
+    expect(screen.getByText(CE_NOTICE)).toBeInTheDocument();
+    expect(
+      screen.getByText(/A value saved earlier is kept/),
+    ).toBeInTheDocument();
+  });
+
+  test.each([
+    ["the Enterprise Edition", true, false],
+    ["the cloud (billing on)", false, true],
+    ["the cloud on the Enterprise image", true, true],
+  ])(
+    "%s offers the toggle",
+    (_label: string, enterprise: boolean, billing: boolean) => {
+      enterpriseEditionForTest = enterprise;
+      billingEnabledForTest = billing;
+
+      render(<AuthenticationSettings />);
+
+      expect(screen.getByTestId("card-SSO Settings")).toBeInTheDocument();
+      expect(
+        screen.getByTestId("edits-requireSsoForLogin"),
+      ).toBeInTheDocument();
+      expect(screen.queryByText(CE_NOTICE)).not.toBeInTheDocument();
+    },
+  );
+
+  test("the toggle says it is not enforced once the Enterprise license lapses", () => {
+    enterpriseEditionForTest = true;
+
+    render(<AuthenticationSettings />);
+
+    expect(
+      screen.getByTestId("describes-requireSsoForLogin"),
+    ).toHaveTextContent(LAPSE_NOTE);
+  });
+
+  test("the lapse check rejects the description the toggle had before (negative control)", () => {
+    expect(LAPSE_NOTE.test(RETIRED_TOGGLE_DESCRIPTION)).toBe(false);
+  });
+
+  test.each([
+    [false, false],
+    [true, false],
+    [false, true],
+  ])(
+    "the other authentication settings stay on every edition (IS_ENTERPRISE_EDITION=%p, billing=%p)",
+    (enterprise: boolean, billing: boolean) => {
+      enterpriseEditionForTest = enterprise;
+      billingEnabledForTest = billing;
+
+      render(<AuthenticationSettings />);
+
+      expect(screen.getByTestId("edits-disableSignup")).toBeInTheDocument();
+      expect(
+        screen.getByTestId("edits-disableUserProjectCreation"),
+      ).toBeInTheDocument();
+    },
+  );
+});

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

@@ -0,0 +1,357 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import { act, cleanup, render, screen } from "@testing-library/react";
+import React, { FunctionComponent, ReactElement } from "react";
+
+/*
+ * The Admin Dashboard's Enterprise plugin door and the component every
+ * enterprise admin shell renders.
+ *
+ * The admin dashboard has no project and no plan: a screen is shown when this
+ * is the Enterprise Edition (the effective edition the server writes into
+ * env.js) AND this bundle includes the plugin, and the upsell card otherwise.
+ * A shell with its own rule - the license server pages exist on OneUptime
+ * Cloud only - passes isEligible.
+ *
+ * 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.
+ */
+
+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;
+});
+
+import EnterprisePluginPage from "../../../../App/FeatureSet/AdminDashboard/src/Enterprise/EnterprisePluginPage";
+import { getAdminDashboardPlugins } from "../../../../App/FeatureSet/AdminDashboard/src/Enterprise/Plugins";
+import {
+  ADMIN_DASHBOARD_ENTERPRISE_PLUGIN_KEYS,
+  AdminDashboardEnterprisePlugins,
+  EnterprisePluginComponent,
+} from "../../../../App/FeatureSet/AdminDashboard/src/Enterprise/EnterprisePlugins";
+import IconProp from "../../../Types/Icon/IconProp";
+
+const UPSELL: {
+  title: string;
+  description: string;
+  featureName: string;
+  benefits: Array<{ icon: IconProp; title: string; subtitle: string }>;
+} = {
+  title: "Global SSO",
+  description: "Instance-wide SAML providers.",
+  featureName: "Global SAML Single Sign On",
+  benefits: [
+    {
+      icon: IconProp.Lock,
+      title: "One sign-in for every project",
+      subtitle: "Point every project at your IdP once.",
+    },
+  ],
+};
+
+const FakeGlobalSSOList: FunctionComponent = (): ReactElement => {
+  return <div data-testid="fake-global-sso" />;
+};
+
+let lazyLoads: number = 0;
+let releaseLazyPlugin: (() => void) | null = null;
+
+const makeLazyPlugin: (
+  holdUntilReleased: boolean,
+) => EnterprisePluginComponent = (
+  holdUntilReleased: boolean,
+): EnterprisePluginComponent => {
+  return React.lazy(async (): Promise<{ default: FunctionComponent }> => {
+    lazyLoads += 1;
+
+    if (holdUntilReleased) {
+      await new Promise<void>((resolve: () => void) => {
+        releaseLazyPlugin = resolve;
+      });
+    }
+
+    return { default: FakeGlobalSSOList };
+  });
+};
+
+beforeEach(() => {
+  billingEnabledForTest = false;
+  enterpriseEditionForTest = false;
+  lazyLoads = 0;
+  releaseLazyPlugin = null;
+});
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("EnterprisePluginPage (Admin Dashboard)", () => {
+  test.each([
+    ["self-hosted", false],
+    ["OneUptime Cloud", true],
+  ])(
+    "renders the plugin on the Enterprise Edition (%s)",
+    (_label: string, billingEnabled: boolean) => {
+      billingEnabledForTest = billingEnabled;
+      enterpriseEditionForTest = true;
+
+      render(
+        <EnterprisePluginPage plugin={FakeGlobalSSOList} upsell={UPSELL} />,
+      );
+
+      expect(screen.getByTestId("fake-global-sso")).toBeInTheDocument();
+      expect(
+        screen.queryByText("Global SAML Single Sign On"),
+      ).not.toBeInTheDocument();
+    },
+  );
+
+  test.each([
+    ["self-hosted", false],
+    ["OneUptime Cloud", true],
+  ])(
+    "shows the edition upsell on the Community Edition, and never downloads the plugin (%s)",
+    (_label: string, billingEnabled: boolean) => {
+      billingEnabledForTest = billingEnabled;
+      enterpriseEditionForTest = false;
+
+      render(
+        <EnterprisePluginPage plugin={makeLazyPlugin(false)} upsell={UPSELL} />,
+      );
+
+      expect(
+        screen.getByText("Global SAML Single Sign On"),
+      ).toBeInTheDocument();
+      expect(
+        screen.getAllByText("Learn about Enterprise Edition"),
+      ).toHaveLength(2);
+      expect(screen.queryByTestId("fake-global-sso")).not.toBeInTheDocument();
+      expect(lazyLoads).toBe(0);
+    },
+  );
+
+  test("shows the upsell on the Enterprise Edition when the bundle has no plugin", () => {
+    enterpriseEditionForTest = true;
+
+    render(<EnterprisePluginPage plugin={undefined} upsell={UPSELL} />);
+
+    expect(screen.getByText("Global SAML Single Sign On")).toBeInTheDocument();
+  });
+
+  test("a lazy plugin shows the in-card loader, then the plugin", async () => {
+    enterpriseEditionForTest = true;
+
+    render(
+      <EnterprisePluginPage plugin={makeLazyPlugin(true)} upsell={UPSELL} />,
+    );
+
+    expect(await screen.findByTestId("component-loader")).toBeInTheDocument();
+
+    await act(async () => {
+      releaseLazyPlugin?.();
+    });
+
+    expect(await screen.findByTestId("fake-global-sso")).toBeInTheDocument();
+    expect(lazyLoads).toBe(1);
+  });
+
+  test("uses a caller's loading element while the plugin downloads", async () => {
+    enterpriseEditionForTest = true;
+
+    render(
+      <EnterprisePluginPage
+        plugin={makeLazyPlugin(true)}
+        upsell={UPSELL}
+        loadingElement={<div data-testid="custom-loading" />}
+      />,
+    );
+
+    expect(await screen.findByTestId("custom-loading")).toBeInTheDocument();
+
+    await act(async () => {
+      releaseLazyPlugin?.();
+    });
+
+    expect(await screen.findByTestId("fake-global-sso")).toBeInTheDocument();
+  });
+
+  test("isEligible overrides the edition, both ways", () => {
+    // A Cloud-only screen on a self-hosted Enterprise install stays hidden.
+    enterpriseEditionForTest = true;
+    const { unmount } = render(
+      <EnterprisePluginPage
+        plugin={FakeGlobalSSOList}
+        upsell={UPSELL}
+        isEligible={false}
+      />,
+    );
+    expect(screen.queryByTestId("fake-global-sso")).not.toBeInTheDocument();
+    unmount();
+
+    enterpriseEditionForTest = false;
+    render(
+      <EnterprisePluginPage
+        plugin={FakeGlobalSSOList}
+        upsell={UPSELL}
+        isEligible={true}
+      />,
+    );
+    expect(screen.getByTestId("fake-global-sso")).toBeInTheDocument();
+  });
+
+  test("renderUpsell replaces the shared card", () => {
+    enterpriseEditionForTest = false;
+
+    render(
+      <EnterprisePluginPage
+        plugin={FakeGlobalSSOList}
+        renderUpsell={(): ReactElement => {
+          return <div data-testid="health-upsell">Health upsell</div>;
+        }}
+      />,
+    );
+
+    expect(screen.getByTestId("health-upsell")).toBeInTheDocument();
+    expect(
+      screen.queryByText("Learn about Enterprise Edition"),
+    ).not.toBeInTheDocument();
+  });
+});
+
+describe("the Community admin plugin door (what this jest config resolves)", () => {
+  test("getAdminDashboardPlugins() is the empty Community stub", () => {
+    const plugins: AdminDashboardEnterprisePlugins = getAdminDashboardPlugins();
+
+    expect(plugins).toEqual({});
+    expect(plugins.buildMarker).toBeUndefined();
+
+    for (const key of ADMIN_DASHBOARD_ENTERPRISE_PLUGIN_KEYS) {
+      expect([key, plugins[key]]).toEqual([key, undefined]);
+    }
+  });
+
+  test("names every screen a plugin can provide, once", () => {
+    expect([...ADMIN_DASHBOARD_ENTERPRISE_PLUGIN_KEYS].sort()).toEqual(
+      [
+        "EnterpriseLicenseView",
+        "EnterpriseLicensesList",
+        "GlobalOIDCList",
+        "GlobalOIDCView",
+        "GlobalSSOList",
+        "GlobalSSOView",
+        "HealthClickhouseCluster",
+        "HealthLogs",
+        "HealthOverview",
+        "HealthPostgres",
+        "HealthQueryConsole",
+        "HealthQueues",
+        "HealthRedis",
+        "HealthTelemetry",
+        "LicenseManager",
+      ].sort(),
+    );
+    expect(new Set(ADMIN_DASHBOARD_ENTERPRISE_PLUGIN_KEYS).size).toBe(
+      ADMIN_DASHBOARD_ENTERPRISE_PLUGIN_KEYS.length,
+    );
+  });
+
+  /*
+   * The instance log is Community content (the audit trail of ClickHouse
+   * capacity notifications and pruning) that core renders on every edition.
+   * No core shell reads a plugin for it, so the contract has no key an ee
+   * plugin could fill in and have silently ignored.
+   */
+  test("has no key for the instance log", () => {
+    expect([...ADMIN_DASHBOARD_ENTERPRISE_PLUGIN_KEYS]).not.toContain(
+      "HealthInstanceLogs",
+    );
+  });
+
+  test("a shell reading the real door on a Community build shows the upsell even on the Enterprise Edition", () => {
+    enterpriseEditionForTest = true;
+
+    render(
+      <EnterprisePluginPage
+        plugin={getAdminDashboardPlugins().GlobalSSOList}
+        upsell={UPSELL}
+      />,
+    );
+
+    expect(screen.getByText("Global SAML Single Sign On")).toBeInTheDocument();
+  });
+});
+
+describe("the admin plugin door with other plugin modules", () => {
+  beforeEach(() => {
+    jest.resetModules();
+  });
+
+  afterEach(() => {
+    jest.dontMock("@oneuptime/ee-admin-dashboard");
+    jest.resetModules();
+  });
+
+  test("hands back the Enterprise plugin object as is", async () => {
+    const enterprisePlugins: AdminDashboardEnterprisePlugins = {
+      buildMarker: "ONEUPTIME_EE_ADMIN_DASHBOARD_PLUGIN_v1",
+      GlobalSSOList: FakeGlobalSSOList,
+    };
+
+    jest.doMock("@oneuptime/ee-admin-dashboard", () => {
+      return { __esModule: true, default: enterprisePlugins };
+    });
+
+    const door: {
+      getAdminDashboardPlugins: () => AdminDashboardEnterprisePlugins;
+    } = await import(
+      "../../../../App/FeatureSet/AdminDashboard/src/Enterprise/Plugins"
+    );
+
+    expect(door.getAdminDashboardPlugins()).toBe(enterprisePlugins);
+  });
+
+  test("fails loudly, naming the rule, when read before the plugin module finished loading", async () => {
+    jest.doMock("@oneuptime/ee-admin-dashboard", () => {
+      return { __esModule: true, default: undefined };
+    });
+
+    const door: {
+      getAdminDashboardPlugins: () => AdminDashboardEnterprisePlugins;
+    } = await import(
+      "../../../../App/FeatureSet/AdminDashboard/src/Enterprise/Plugins"
+    );
+
+    expect(() => {
+      return door.getAdminDashboardPlugins();
+    }).toThrow(
+      "getAdminDashboardPlugins() ran before the Enterprise plugin module finished loading. Call it inside a render or function body, never at module top level.",
+    );
+  });
+});