@oneuptime/common 13.0.8 → 14.0.0

package/Tests/App/Dashboard/IdentityEnterpriseShells.test.tsx

@@ -0,0 +1,319 @@
+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 } from "react";
+
+/*
+ * The six identity pages the Dashboard routes to - Settings > SSO / OIDC /
+ * SCIM and Status page > SSO / OIDC / SCIM - are Enterprise Edition screens
+ * (ee/Dashboard/SSO). Core keeps a shell at each page's original path, so the
+ * route files and the lazy page map never changed: the shell renders the
+ * Enterprise screen when the project may use the feature AND the bundle
+ * includes it, and the upsell card the page used to show otherwise.
+ *
+ * "@oneuptime/ee-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, the edition and the plan are pinned in every test: CI's
+ * config.env sets BILLING_ENABLED=true.
+ */
+
+let billingEnabledForTest: boolean = false;
+let enterpriseEditionForTest: boolean = false;
+let currentPlanForTest: string | null = null;
+
+const CLOUD_PLAN_ENV: Record<string, string> = {
+  SUBSCRIPTION_PLAN_BASIC: "Free,priceMonthlyId1,priceYearlyId1,0,0,1,0",
+  SUBSCRIPTION_PLAN_GROWTH: "Growth,priceMonthlyId2,priceYearlyId2,0,0,2,14",
+  SUBSCRIPTION_PLAN_SCALE: "Scale,priceMonthlyId3,priceYearlyId3,0,0,3,0",
+  SUBSCRIPTION_PLAN_ENTERPRISE:
+    "Enterprise,priceMonthlyId4,priceYearlyId4,-1,-1,4,14",
+};
+
+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;
+    },
+  });
+
+  mocked["getAllEnvVars"] = (): Record<string, string> => {
+    return CLOUD_PLAN_ENV;
+  };
+
+  return mocked;
+});
+
+jest.mock("../../../UI/Utils/Project", () => {
+  const actual: Record<string, any> = jest.requireActual(
+    "../../../UI/Utils/Project",
+  ) as Record<string, any>;
+
+  return {
+    __esModule: true,
+    ...actual,
+    default: {
+      ...actual["default"],
+      getCurrentPlan: (): string | null => {
+        return currentPlanForTest;
+      },
+    },
+  };
+});
+
+/*
+ * What getDashboardPlugins() returns in this suite. The shells read it on
+ * every render, so each test fills it in after the shells were imported.
+ */
+const mockEnterprisePlugins: Record<string, unknown> = {};
+
+jest.mock("@oneuptime/ee-dashboard", () => {
+  return { __esModule: true, default: mockEnterprisePlugins };
+});
+
+import SettingsOIDC from "../../../../App/FeatureSet/Dashboard/src/Pages/Settings/OIDC";
+import SettingsSCIM from "../../../../App/FeatureSet/Dashboard/src/Pages/Settings/SCIM";
+import SettingsSSO from "../../../../App/FeatureSet/Dashboard/src/Pages/Settings/SSO";
+import StatusPageViewOIDC from "../../../../App/FeatureSet/Dashboard/src/Pages/StatusPages/View/OIDC";
+import StatusPageViewSCIM from "../../../../App/FeatureSet/Dashboard/src/Pages/StatusPages/View/SCIM";
+import StatusPageViewSSO from "../../../../App/FeatureSet/Dashboard/src/Pages/StatusPages/View/SSO";
+import PageComponentProps from "../../../../App/FeatureSet/Dashboard/src/Pages/PageComponentProps";
+import { DashboardEnterprisePluginKey } from "../../../../App/FeatureSet/Dashboard/src/Enterprise/EnterprisePlugins";
+import Route from "../../../Types/API/Route";
+import { PlanType } from "../../../Types/Billing/SubscriptionPlan";
+
+interface ShellCase {
+  name: string;
+  Shell: FunctionComponent<PageComponentProps>;
+  pluginKey: DashboardEnterprisePluginKey;
+  // The upsell copy the page showed before it moved to ee/.
+  upsellTitle: string;
+  featureName: string;
+}
+
+const SHELLS: Array<ShellCase> = [
+  {
+    name: "Settings > SSO",
+    Shell: SettingsSSO,
+    pluginKey: "SettingsSSO",
+    upsellTitle: "Single Sign On (SSO)",
+    featureName: "SAML Single Sign On",
+  },
+  {
+    name: "Settings > OIDC",
+    Shell: SettingsOIDC,
+    pluginKey: "SettingsOIDC",
+    upsellTitle: "OpenID Connect (OIDC)",
+    featureName: "OIDC Single Sign On",
+  },
+  {
+    name: "Settings > SCIM",
+    Shell: SettingsSCIM,
+    pluginKey: "SettingsSCIM",
+    upsellTitle: "SCIM User Provisioning",
+    featureName: "SCIM User Provisioning",
+  },
+  {
+    name: "Status page > SSO",
+    Shell: StatusPageViewSSO,
+    pluginKey: "StatusPageSSO",
+    upsellTitle: "Status Page SSO",
+    featureName: "Status Page SAML SSO",
+  },
+  {
+    name: "Status page > OIDC",
+    Shell: StatusPageViewOIDC,
+    pluginKey: "StatusPageOIDC",
+    upsellTitle: "Status Page OIDC",
+    featureName: "Status Page OIDC SSO",
+  },
+  {
+    name: "Status page > SCIM",
+    Shell: StatusPageViewSCIM,
+    pluginKey: "StatusPageSCIM",
+    upsellTitle: "Status Page SCIM",
+    featureName: "Status Page SCIM Provisioning",
+  },
+];
+
+const PAGE_PROPS: PageComponentProps = {
+  pageRoute: new Route("/dashboard/project-id/settings/identity"),
+  currentProject: null,
+  hasPaymentMethod: true,
+};
+
+/*
+ * Stands in for an Enterprise screen: says which plugin key it is and echoes
+ * the props the shell handed it.
+ */
+const makeFakeScreen: (
+  pluginKey: string,
+) => FunctionComponent<PageComponentProps> = (
+  pluginKey: string,
+): FunctionComponent<PageComponentProps> => {
+  const FakeScreen: FunctionComponent<PageComponentProps> = (
+    props: PageComponentProps,
+  ): ReactElement => {
+    return (
+      <div data-testid="enterprise-screen">
+        {pluginKey}|{props.pageRoute.toString()}|
+        {String(props.hasPaymentMethod)}
+      </div>
+    );
+  };
+
+  return FakeScreen;
+};
+
+const installPlugins: (keys: Array<DashboardEnterprisePluginKey>) => void = (
+  keys: Array<DashboardEnterprisePluginKey>,
+): void => {
+  for (const key of keys) {
+    mockEnterprisePlugins[key] = makeFakeScreen(key);
+  }
+};
+
+const clearPlugins: () => void = (): void => {
+  for (const key of Object.keys(mockEnterprisePlugins)) {
+    delete mockEnterprisePlugins[key];
+  }
+};
+
+beforeEach(() => {
+  billingEnabledForTest = false;
+  enterpriseEditionForTest = false;
+  currentPlanForTest = null;
+  clearPlugins();
+});
+
+afterEach(() => {
+  cleanup();
+  clearPlugins();
+});
+
+describe.each(SHELLS)("$name shell", (shell: ShellCase) => {
+  test("Community Edition: the upsell card, even when a plugin is present", () => {
+    installPlugins([shell.pluginKey]);
+
+    render(<shell.Shell {...PAGE_PROPS} />);
+
+    expect(screen.getAllByText(shell.featureName).length).toBeGreaterThan(0);
+    expect(screen.getAllByText(shell.upsellTitle).length).toBeGreaterThan(0);
+    expect(
+      screen.getAllByText("Learn about Enterprise Edition").length,
+    ).toBeGreaterThan(0);
+    expect(screen.queryByTestId("enterprise-screen")).not.toBeInTheDocument();
+  });
+
+  test("Enterprise Edition: the Enterprise screen, with the page props", () => {
+    enterpriseEditionForTest = true;
+    installPlugins([shell.pluginKey]);
+
+    render(<shell.Shell {...PAGE_PROPS} />);
+
+    expect(screen.getByTestId("enterprise-screen")).toHaveTextContent(
+      `${shell.pluginKey}|/dashboard/project-id/settings/identity|true`,
+    );
+    expect(screen.queryByText(shell.featureName)).not.toBeInTheDocument();
+  });
+
+  test("Enterprise Edition on a Community bundle: the upsell, pointing at the edition", () => {
+    enterpriseEditionForTest = true;
+
+    render(<shell.Shell {...PAGE_PROPS} />);
+
+    expect(screen.getAllByText(shell.featureName).length).toBeGreaterThan(0);
+    expect(
+      screen.getAllByText("Learn about Enterprise Edition").length,
+    ).toBeGreaterThan(0);
+    expect(screen.queryByText("Upgrade to Scale")).not.toBeInTheDocument();
+  });
+
+  test("OneUptime Cloud below Scale: the plan upsell, never the screen", () => {
+    billingEnabledForTest = true;
+    enterpriseEditionForTest = true;
+    currentPlanForTest = PlanType.Growth;
+    installPlugins([shell.pluginKey]);
+
+    render(<shell.Shell {...PAGE_PROPS} />);
+
+    expect(screen.getAllByText("Upgrade to Scale").length).toBeGreaterThan(0);
+    expect(screen.getAllByText(shell.featureName).length).toBeGreaterThan(0);
+    expect(screen.queryByTestId("enterprise-screen")).not.toBeInTheDocument();
+  });
+
+  test.each([PlanType.Scale, PlanType.Enterprise])(
+    "OneUptime Cloud on %s: the Enterprise screen",
+    (plan: PlanType) => {
+      billingEnabledForTest = true;
+      enterpriseEditionForTest = true;
+      currentPlanForTest = plan;
+      installPlugins([shell.pluginKey]);
+
+      render(<shell.Shell {...PAGE_PROPS} />);
+
+      expect(screen.getByTestId("enterprise-screen")).toHaveTextContent(
+        shell.pluginKey,
+      );
+    },
+  );
+
+  test("renders its own plugin key when every identity screen is present", () => {
+    enterpriseEditionForTest = true;
+    installPlugins(
+      SHELLS.map((each: ShellCase) => {
+        return each.pluginKey;
+      }),
+    );
+
+    render(<shell.Shell {...PAGE_PROPS} />);
+
+    expect(screen.getByTestId("enterprise-screen")).toHaveTextContent(
+      `${shell.pluginKey}|`,
+    );
+  });
+
+  test("ignores other features' screens", () => {
+    enterpriseEditionForTest = true;
+    installPlugins(
+      SHELLS.map((each: ShellCase) => {
+        return each.pluginKey;
+      }).filter((key: DashboardEnterprisePluginKey) => {
+        return key !== shell.pluginKey;
+      }),
+    );
+
+    render(<shell.Shell {...PAGE_PROPS} />);
+
+    expect(screen.queryByTestId("enterprise-screen")).not.toBeInTheDocument();
+    expect(screen.getAllByText(shell.featureName).length).toBeGreaterThan(0);
+  });
+});
+
+describe("identity shells", () => {
+  test("each reads a different plugin key", () => {
+    const keys: Array<string> = SHELLS.map((shell: ShellCase) => {
+      return shell.pluginKey;
+    });
+
+    expect(new Set(keys).size).toBe(SHELLS.length);
+  });
+});

package/Tests/App/Dashboard/OnboardingSsoEmptyState.test.tsx

@@ -0,0 +1,185 @@
+import "@testing-library/jest-dom";
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+} from "@testing-library/react";
+import React, { ReactElement, useEffect } from "react";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import ProjectUtil from "../../../UI/Utils/Project";
+import Navigation from "../../../UI/Utils/Navigation";
+import ObjectID from "../../../Types/ObjectID";
+import Route from "../../../Types/API/Route";
+import URL from "../../../Types/API/URL";
+import OnboardingSsoPage from "../../../../App/FeatureSet/Dashboard/src/Pages/Onboarding/SSO";
+import PageMap from "../../../../App/FeatureSet/Dashboard/src/Utils/PageMap";
+import RouteMap from "../../../../App/FeatureSet/Dashboard/src/Utils/RouteMap";
+import { getJestSpyOn } from "../../Spy";
+
+/*
+ * Dashboard > project SSO sign-in (Onboarding/SSO): where a user lands when a
+ * project requires SSO. It lists the project's providers from
+ * /project-sso/:projectId/sso-list.
+ *
+ * That list is empty when the project has no enabled provider - and always on
+ * the Community Edition, where SSO login is part of the Enterprise Edition and
+ * the server lists no providers. The page must then explain why and offer a
+ * way back to sign-in, rather than a dead end.
+ */
+
+type ProviderRow = { _id: string; name: string };
+
+interface ProviderListProps {
+  id: string;
+  overrideFetchApiUrl: URL;
+  noItemsMessage: string;
+  onListLoaded?: (list: Array<ProviderRow>) => void;
+  onSelectChange?: (list: Array<ProviderRow>) => void;
+}
+
+let providersForTest: Array<ProviderRow> = [];
+
+/*
+ * The real ModelList fetches over HTTP; this stand-in "loads" the configured
+ * providers the same way (onListLoaded after mount) and renders them.
+ */
+jest.mock("../../../UI/Components/ModelList/ModelList", () => {
+  return {
+    __esModule: true,
+    default: (props: ProviderListProps): ReactElement => {
+      useEffect(() => {
+        props.onListLoaded?.(providersForTest);
+      }, []);
+
+      return (
+        <div
+          data-testid={props.id}
+          data-fetch-url={props.overrideFetchApiUrl.toString()}
+        >
+          {providersForTest.length === 0 ? (
+            <p>{props.noItemsMessage}</p>
+          ) : (
+            providersForTest.map((provider: ProviderRow) => {
+              return (
+                <button
+                  key={provider._id}
+                  onClick={() => {
+                    props.onSelectChange?.([provider]);
+                  }}
+                >
+                  {provider.name}
+                </button>
+              );
+            })
+          )}
+        </div>
+      );
+    },
+  };
+});
+
+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);
+    },
+  };
+});
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+
+const renderPage: () => Promise<void> = async (): Promise<void> => {
+  await act(async () => {
+    render(
+      <OnboardingSsoPage
+        pageRoute={new Route("/dashboard/project/sso")}
+        currentProject={null}
+        hasPaymentMethod={false}
+      />,
+    );
+  });
+};
+
+describe("Dashboard project SSO sign-in page", () => {
+  beforeEach(() => {
+    providersForTest = [];
+    getJestSpyOn(ProjectUtil, "getCurrentProjectId").mockReturnValue(
+      PROJECT_ID,
+    );
+  });
+
+  afterEach(() => {
+    cleanup();
+    jest.restoreAllMocks();
+  });
+
+  test("with no provider (always the case on the Community Edition) it explains why and links back to sign-in", async () => {
+    await renderPage();
+
+    const help: HTMLElement = await screen.findByTestId(
+      "sso-no-providers-help",
+    );
+
+    expect(help).toHaveTextContent(
+      "This project has no single sign-on provider you can use to log in.",
+    );
+    expect(help).toHaveTextContent(
+      "Single sign-on is part of the OneUptime Enterprise Edition",
+    );
+    expect(help).toHaveTextContent(
+      "sign in with your email and password instead",
+    );
+
+    const backToSignIn: HTMLElement = screen.getByText("Back to sign in");
+
+    expect(backToSignIn.closest("a")).toHaveAttribute(
+      "href",
+      RouteMap[PageMap.LOGOUT]!.toString(),
+    );
+  });
+
+  test("with providers it lists them, shows no help text, and signs in with the chosen one", async () => {
+    providersForTest = [
+      { _id: "22222222-2222-4222-8222-222222222222", name: "Okta" },
+    ];
+    const navigate: ReturnType<typeof getJestSpyOn> = getJestSpyOn(
+      Navigation,
+      "navigate",
+    ).mockImplementation(() => {});
+
+    await renderPage();
+
+    expect(
+      screen.queryByTestId("sso-no-providers-help"),
+    ).not.toBeInTheDocument();
+
+    fireEvent.click(screen.getByText("Okta"));
+
+    expect(navigate).toHaveBeenCalledTimes(1);
+    expect(String(navigate.mock.calls[0]![0])).toContain(
+      `/sso/${PROJECT_ID.toString()}/22222222-2222-4222-8222-222222222222`,
+    );
+  });
+
+  test("lists providers from the project's sso-list endpoint", async () => {
+    await renderPage();
+
+    expect(
+      screen.getByTestId("sso-list").getAttribute("data-fetch-url"),
+    ).toContain(`/project-sso/${PROJECT_ID.toString()}/sso-list`);
+  });
+});

package/Tests/App/Dashboard/SecurityEventConnectionDiagnostics.test.tsx

@@ -48,7 +48,6 @@ import ListResult from "../../../Types/BaseDatabase/ListResult";
 import RangeStartAndEndDateTime from "../../../Types/Time/RangeStartAndEndDateTime";
 import TimeRange from "../../../Types/Time/TimeRange";
 import { JSONObject } from "../../../Types/JSON";
-import JSONFunctions from "../../../Types/JSONFunctions";
 import ObjectID from "../../../Types/ObjectID";
 import {
   SecurityConnectorSample,
@@ -269,12 +268,36 @@ function eventsParams(route: Route): URLSearchParams {
   return new URLSearchParams(text.slice(text.indexOf("?")));
 }
 
-// The table's own filter on the link; {} when the link sets none.
+/*
+ * The chips the link opens the events explorer with, re-shaped as
+ * `{ attributes: { key: value } }` — the reading these assertions have always
+ * used.
+ *
+ * The link's grammar is the explorers' own `filters` param
+ * (`[["attributes.<key>", "<value>"], ...]`); it used to be the model
+ * table's serialized column filter, which went away with the table. Anything
+ * the explorer does not express as an attribute chip is left out, so an
+ * assertion that a key is absent still means "the link does not filter on
+ * it".
+ */
 function eventsFilter(route: Route): JSONObject {
-  const raw: string | null = eventsParams(route).get(
-    "security-events-table-filter",
-  );
-  return raw ? JSONFunctions.deserialize(JSON.parse(raw) as JSONObject) : {};
+  const raw: string | null = eventsParams(route).get("filters");
+
+  if (!raw) {
+    return {};
+  }
+
+  const attributes: JSONObject = {};
+
+  for (const pair of JSON.parse(raw) as Array<[string, string]>) {
+    if (!Array.isArray(pair) || !pair[0]?.startsWith("attributes.")) {
+      continue;
+    }
+
+    attributes[pair[0].substring("attributes.".length)] = pair[1];
+  }
+
+  return Object.keys(attributes).length > 0 ? { attributes } : {};
 }
 
 /*
@@ -1481,25 +1504,38 @@ describe("View events for a connection run", () => {
     expect(eventsFilter(route)["attributes"]).toBeUndefined();
   });
 
-  test("the window is the page's time range, not a table filter", (): void => {
+  test("the window is the page's time range, not a chip", (): void => {
     const route: Route = connectionEventsRoute(result(), CONNECTION_ID);
     const params: URLSearchParams = eventsParams(route);
 
     expect(params.get("range")).toBe(TimeRange.CUSTOM);
     expect(params.get("start")).toBe("2026-09-09T01:30:29.000Z");
     expect(params.get("end")).toBe("2026-09-09T01:30:31.000Z");
-    // The table no longer offers a Time filter, so none is written for it.
+    // The window is the explorer's own range, never one of its chips.
     expect(eventsFilter(route)["time"]).toBeUndefined();
     expect(eventsFilter(route)["attributes"]).toEqual({
       [SECURITY_CONNECTION_ID_ATTRIBUTE]: CONNECTION_ID,
     });
   });
 
-  test("a link with nothing to filter on sets no table filter at all", (): void => {
+  test("the connection chip is written in the explorer's filters grammar", (): void => {
+    const raw: string | null = eventsParams(
+      connectionEventsRoute(result(), CONNECTION_ID),
+    ).get("filters");
+
+    expect(raw).not.toBeNull();
+    expect(JSON.parse(raw as string)).toEqual([
+      [`attributes.${SECURITY_CONNECTION_ID_ATTRIBUTE}`, CONNECTION_ID],
+    ]);
+  });
+
+  test("a link with nothing to filter on sets no chips at all", (): void => {
     const params: URLSearchParams = eventsParams(
       connectionEventsRoute(result()),
     );
 
+    expect(params.get("filters")).toBeNull();
+    // The retired model table's own filter param is gone for good.
     expect(params.get("security-events-table-filter")).toBeNull();
     expect(params.get("range")).toBe(TimeRange.CUSTOM);
   });