@oneuptime/common 14.0.10 → 14.0.11

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

@@ -0,0 +1,246 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import { cleanup, render, screen } from "@testing-library/react";
+import * as React from "react";
+
+/*
+ * The setup cards of the push monitors, shown on the Overview while a
+ * monitor waits for its first signal and on its Documentation tab: the
+ * Incoming Email Address card, the heartbeat URL card and the server
+ * agent's install commands.
+ *
+ * Each put what the reader came for - the address, the URL, the commands -
+ * in Card's `description`. Card renders that in a <p> hidden below md
+ * ("max-md:hidden"), so a phone showed a title over an empty card, and a
+ * <p> cannot hold the <div>s, <p>s and code blocks put there: React warned
+ * about the nesting.
+ *
+ * jsdom has no Tailwind, so this pins the structure: a card's description
+ * is plain text, what the reader needs is in the card's body, and nothing
+ * warns. That the details really stay on screen at 390px is checked in a
+ * browser, by "setup details stay on screen at 390px" in
+ * packages/E2E/MonitorOverview/MonitorOverview.spec.ts.
+ */
+
+let mockInboundEmailDomain: string | undefined = "inbound.example.com";
+
+jest.mock("../../../UI/Config", () => {
+  const actual: Record<string, unknown> = jest.requireActual(
+    "../../../UI/Config",
+  ) as Record<string, unknown>;
+
+  const config: Record<string, unknown> = {
+    ...actual,
+    __esModule: true,
+    HOST: "oneuptime.example.com",
+  };
+
+  // A getter, so a test can switch the domain off.
+  Object.defineProperty(config, "INBOUND_EMAIL_DOMAIN", {
+    enumerable: true,
+    get: (): string | undefined => {
+      return mockInboundEmailDomain;
+    },
+  });
+
+  return config;
+});
+
+import IncomingEmailMonitorLink, {
+  VERIFY_ADDRESS_DOCS_ROUTE,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/Monitor/IncomingEmailMonitor/IncomingEmailMonitorLink";
+import IncomingMonitorLink, {
+  getHeartbeatUrl,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/Monitor/IncomingRequestMonitor/IncomingMonitorLink";
+import ServerMonitorDocumentation from "../../../../App/FeatureSet/Dashboard/src/Components/Monitor/ServerMonitor/Documentation";
+import ObjectID from "../../../Types/ObjectID";
+
+const EMAIL_SECRET: ObjectID = new ObjectID(
+  "5ec2e7a1-0b1c-4d2e-9f30-4a5b6c7d8e9f",
+);
+const HEARTBEAT_SECRET: ObjectID = new ObjectID(
+  "6fd3f8b2-1c2d-4e3f-a041-5b6c7d8e9fa0",
+);
+const SERVER_SECRET: ObjectID = new ObjectID(
+  "7ae4a9c3-2d3e-4f40-b152-6c7d8e9fa0b1",
+);
+
+let consoleErrorSpy: ReturnType<typeof jest.spyOn>;
+
+beforeEach(() => {
+  consoleErrorSpy = jest.spyOn(console, "error");
+});
+
+afterEach(() => {
+  cleanup();
+  consoleErrorSpy.mockRestore();
+  mockInboundEmailDomain = "inbound.example.com";
+});
+
+// What React said about the markup while the card rendered.
+function nestingWarnings(): Array<string> {
+  return consoleErrorSpy.mock.calls
+    .map((call: Array<unknown>): string => {
+      return call.map(String).join(" ");
+    })
+    .filter((message: string): boolean => {
+      return message.includes("validateDOMNesting");
+    });
+}
+
+/*
+ * A card's description may only be text: Card hides it below md, and its
+ * <p> can hold nothing else.
+ */
+function expectTextOnlyDescriptions(): void {
+  for (const description of screen.queryAllByTestId("card-description")) {
+    expect(description.children).toHaveLength(0);
+  }
+}
+
+function expectOutsideDescriptions(element: HTMLElement): void {
+  for (const description of screen.queryAllByTestId("card-description")) {
+    expect(description).not.toContainElement(element);
+  }
+}
+
+describe("The Incoming Email Address card", () => {
+  test("keeps the address, its copy button and the hint in the body", () => {
+    render(<IncomingEmailMonitorLink secretKey={EMAIL_SECRET} />);
+
+    const address: HTMLElement = screen.getByTestId("incoming-email-address");
+    const copy: HTMLElement = screen.getByRole("button", {
+      name: "Copy email address",
+    });
+    const verify: HTMLElement = screen.getByRole("link", {
+      name: "How to verify the address",
+    });
+
+    expect(address).toHaveTextContent(
+      `monitor-${EMAIL_SECRET.toString()}@inbound.example.com`,
+    );
+    expect(verify).toHaveAttribute("href", VERIFY_ADDRESS_DOCS_ROUTE);
+    expect(verify).toHaveAttribute("target", "_blank");
+
+    for (const element of [address, copy, verify]) {
+      expectOutsideDescriptions(element);
+      expect(screen.getByTestId("incoming-email-setup")).toContainElement(
+        element,
+      );
+    }
+
+    expectTextOnlyDescriptions();
+    expect(screen.getByTestId("card-description")).toHaveTextContent(
+      "Please send emails to this unique monitor email address.",
+    );
+    expect(nestingWarnings()).toEqual([]);
+  });
+
+  test("shows a custom address the same way", () => {
+    render(
+      <IncomingEmailMonitorLink
+        secretKey={EMAIL_SECRET}
+        customLocalPart="nightly-backups"
+      />,
+    );
+
+    const address: HTMLElement = screen.getByTestId("incoming-email-address");
+
+    expect(address).toHaveTextContent("nightly-backups@inbound.example.com");
+    expectOutsideDescriptions(address);
+    expect(nestingWarnings()).toEqual([]);
+  });
+
+  test("says inbound email is not configured in the body, where a phone shows it", () => {
+    mockInboundEmailDomain = undefined;
+
+    render(<IncomingEmailMonitorLink secretKey={EMAIL_SECRET} />);
+
+    const message: HTMLElement = screen.getByText(
+      /Inbound email is not configured/,
+    );
+    const docs: HTMLElement = screen.getByRole("link", {
+      name: "View Setup Documentation",
+    });
+
+    expect(docs).toHaveAttribute(
+      "href",
+      "/docs/self-hosted/sendgrid-inbound-email",
+    );
+    expectOutsideDescriptions(message);
+    expect(screen.queryByTestId("card-description")).not.toBeInTheDocument();
+    expect(screen.queryByTestId("incoming-email-address")).toBeNull();
+    expect(nestingWarnings()).toEqual([]);
+  });
+});
+
+describe("The heartbeat URL card", () => {
+  test("keeps the URL and its copy button in the body", () => {
+    render(<IncomingMonitorLink secretKey={HEARTBEAT_SECRET} />);
+
+    const url: string = getHeartbeatUrl(HEARTBEAT_SECRET).toString();
+    const urlText: HTMLElement = screen.getByTestId("incoming-request-url");
+    const link: HTMLElement = urlText.closest("a")!;
+    const copy: HTMLElement = screen.getByRole("button", {
+      name: "Copy heartbeat URL",
+    });
+
+    expect(url).toContain(`/heartbeat/${HEARTBEAT_SECRET.toString()}`);
+    expect(urlText).toHaveTextContent(url);
+    expect(link).toHaveAttribute("href", url);
+    expect(link).toHaveAttribute("target", "_blank");
+
+    for (const element of [urlText, copy]) {
+      expectOutsideDescriptions(element);
+      expect(screen.getByTestId("incoming-request-setup")).toContainElement(
+        element,
+      );
+    }
+
+    expectTextOnlyDescriptions();
+    expect(screen.getByTestId("card-description")).toHaveTextContent(
+      "Please send inbound heartbeat GET or POST requests to this URL.",
+    );
+    expect(nestingWarnings()).toEqual([]);
+  });
+});
+
+describe("The server agent's install cards", () => {
+  test("keep both sets of commands in the body", () => {
+    render(<ServerMonitorDocumentation secretKey={SERVER_SECRET} />);
+
+    for (const testId of [
+      "server-monitor-setup-linux",
+      "server-monitor-setup-windows",
+    ]) {
+      const setup: HTMLElement = screen.getByTestId(testId);
+      // CodeBlock draws the commands as <pre><code>, highlighted by hljs.
+      const code: Element | null = setup.querySelector("pre code");
+
+      expect(code).not.toBeNull();
+      expect(code!.textContent).toContain(
+        `--secret-key=${SERVER_SECRET.toString()}`,
+      );
+      expect(code!.textContent).toMatch(
+        /--oneuptime-url=https?:\/\/oneuptime\.example\.com/,
+      );
+      expectOutsideDescriptions(setup);
+    }
+
+    expect(
+      screen.getByText("Set up your Server Monitor (Linux/Mac)"),
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText("Set up your Server Monitor (Windows)"),
+    ).toBeInTheDocument();
+    expect(screen.queryAllByTestId("card-description")).toHaveLength(0);
+    expect(nestingWarnings()).toEqual([]);
+  });
+});

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

@@ -106,6 +106,14 @@ const SEARCH_CASES: Array<[string, string, string]> = [
   ["redis", "Databases", PageMap.DATABASE_SERVERS],
   ["mongodb", "Databases", PageMap.DATABASE_SERVERS],
   ["sql server", "Databases", PageMap.DATABASE_SERVERS],
+  ["kafka", "Queues", PageMap.MESSAGE_QUEUES],
+  ["rabbitmq", "Queues", PageMap.MESSAGE_QUEUES],
+  ["sqs", "Queues", PageMap.MESSAGE_QUEUES],
+  ["service bus", "Queues", PageMap.MESSAGE_QUEUES],
+  ["pub/sub", "Queues", PageMap.MESSAGE_QUEUES],
+  ["consumer lag", "Queues", PageMap.MESSAGE_QUEUES],
+  ["dead letter", "Queues", PageMap.MESSAGE_QUEUES],
+  ["message queue", "Queues", PageMap.MESSAGE_QUEUES],
 ];
 
 function navbar(): React.ReactElement {

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

@@ -30,10 +30,10 @@ import { getJestSpyOn } from "../../Spy";
  * 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.
+ * That list is empty when the project has no enabled provider. The page must
+ * then explain why and offer a way back to sign-in, rather than a dead end.
+ * Single sign-on is part of every edition, so the explanation makes no claim
+ * about editions or licenses.
  */
 
 type ProviderRow = { _id: string; name: string };
@@ -127,7 +127,7 @@ describe("Dashboard project SSO sign-in page", () => {
     jest.restoreAllMocks();
   });
 
-  test("with no provider (always the case on the Community Edition) it explains why and links back to sign-in", async () => {
+  test("with no provider it explains why and links back to sign-in", async () => {
     await renderPage();
 
     const help: HTMLElement = await screen.findByTestId(
@@ -135,13 +135,7 @@ describe("Dashboard project SSO sign-in page", () => {
     );
 
     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",
+      "This project has no single sign-on provider you can use to log in. Ask a project admin to enable one.",
     );
 
     const backToSignIn: HTMLElement = screen.getByText("Back to sign in");
@@ -152,6 +146,27 @@ describe("Dashboard project SSO sign-in page", () => {
     );
   });
 
+  /*
+   * The help used to tell every user that single sign-on is part of the
+   * Enterprise Edition and to sign in with a password on a Community server,
+   * which is no longer true anywhere.
+   */
+  test("the help makes no claim about editions or licenses", async () => {
+    await renderPage();
+
+    const help: HTMLElement = await screen.findByTestId(
+      "sso-no-providers-help",
+    );
+
+    expect(help).not.toHaveTextContent(/Enterprise/i);
+    expect(help).not.toHaveTextContent(/Community/i);
+    expect(help).not.toHaveTextContent(/licen[cs]e/i);
+    expect(help).not.toHaveTextContent(/edition/i);
+    expect(help).not.toHaveTextContent(
+      "sign in with your email and password instead",
+    );
+  });
+
   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" },

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

@@ -0,0 +1,292 @@
+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, useEffect } from "react";
+
+/*
+ * PlanGatedPage: what a page every edition includes, but OneUptime Cloud
+ * sells on a plan (single sign-on), renders through.
+ *
+ * Only the plan counts, and only on the Cloud (billing on): the page, or the
+ * plan upsell card with the Plan reason - never the Enterprise Edition one.
+ * With billing off (every self-hosted install) the page always renders, and
+ * the edition flag and the plan are never consulted. The check runs on every
+ * render, and an ineligible project never mounts the page at all, so the
+ * page's own requests and hooks never run for it.
+ *
+ * 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;
+let currentPlanThrows: boolean = false;
+let editionReads: number = 0;
+
+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 => {
+      editionReads += 1;
+      return enterpriseEditionForTest;
+    },
+  });
+
+  mocked["getAllEnvVars"] = (): Record<string, string> => {
+    return CLOUD_PLAN_ENV;
+  };
+
+  return mocked;
+});
+
+import PlanGatedPage, {
+  PlanGatedPageUpsellProps,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/Billing/PlanGatedPage";
+import { SSO_REQUIRED_PLAN } from "../../../../App/FeatureSet/Dashboard/src/Enterprise/EnterpriseEligibility";
+import { PlanType } from "../../../Types/Billing/SubscriptionPlan";
+import IconProp from "../../../Types/Icon/IconProp";
+import ProjectUtil from "../../../UI/Utils/Project";
+import { getJestSpyOn } from "../../Spy";
+
+const UPSELL: PlanGatedPageUpsellProps = {
+  title: "Single Sign On (SSO)",
+  description: "Configure SAML SSO for your project.",
+  featureName: "SAML Single Sign On",
+  featureDescription: "Let team members sign in with your IdP.",
+  benefits: [
+    {
+      icon: IconProp.Lock,
+      title: "Centralized auth",
+      subtitle: "Revoke access from one place.",
+    },
+  ],
+};
+
+let pageMounts: number = 0;
+let pageRenders: number = 0;
+
+// A page with hooks and an effect, like the real ones (tables that load).
+const FakePage: FunctionComponent = (): ReactElement => {
+  const [label] = React.useState<string>("the page");
+
+  pageRenders += 1;
+
+  useEffect(() => {
+    pageMounts += 1;
+  }, []);
+
+  return <div data-testid="gated-page">{label}</div>;
+};
+
+const renderGate: (
+  requiredPlan?: PlanType.Scale | PlanType.Enterprise,
+) => ReturnType<typeof render> = (
+  requiredPlan: PlanType.Scale | PlanType.Enterprise = SSO_REQUIRED_PLAN,
+): ReturnType<typeof render> => {
+  return render(
+    <PlanGatedPage requiredPlan={requiredPlan} upsell={UPSELL}>
+      <FakePage />
+    </PlanGatedPage>,
+  );
+};
+
+const expectUpsell: (planName: string) => void = (planName: string): void => {
+  expect(screen.getAllByText(`Upgrade to ${planName}`)).toHaveLength(2);
+  expect(screen.getByText("SAML Single Sign On")).toBeInTheDocument();
+  expect(screen.getByText("Single Sign On (SSO)")).toBeInTheDocument();
+  expect(screen.getByText("Centralized auth")).toBeInTheDocument();
+  expect(screen.getByText("Compare plans")).toBeInTheDocument();
+  expect(
+    screen.queryByText("Learn about Enterprise Edition"),
+  ).not.toBeInTheDocument();
+  expect(screen.queryByText(/Enterprise Edition/)).not.toBeInTheDocument();
+  expect(screen.queryByTestId("gated-page")).not.toBeInTheDocument();
+};
+
+beforeEach(() => {
+  billingEnabledForTest = false;
+  enterpriseEditionForTest = false;
+  currentPlanForTest = null;
+  currentPlanThrows = false;
+  editionReads = 0;
+  pageMounts = 0;
+  pageRenders = 0;
+
+  getJestSpyOn(ProjectUtil, "getCurrentPlan").mockImplementation(
+    (): string | null => {
+      if (currentPlanThrows) {
+        throw new Error("Plan ID is invalid");
+      }
+
+      return currentPlanForTest;
+    },
+  );
+});
+
+afterEach(() => {
+  cleanup();
+  jest.restoreAllMocks();
+});
+
+describe("PlanGatedPage when self-hosted (billing off)", () => {
+  test.each([
+    ["the Community Edition", false],
+    ["the Enterprise Edition", true],
+  ])(
+    "renders the page on %s, without reading the edition or the plan",
+    (_edition: string, isEnterprise: boolean) => {
+      enterpriseEditionForTest = isEnterprise;
+      // A plan read would throw: it must not happen.
+      currentPlanThrows = true;
+
+      renderGate();
+
+      expect(screen.getByTestId("gated-page")).toHaveTextContent("the page");
+      expect(pageMounts).toBe(1);
+      expect(screen.queryByText("SAML Single Sign On")).not.toBeInTheDocument();
+      expect(editionReads).toBe(0);
+      expect(ProjectUtil.getCurrentPlan).not.toHaveBeenCalled();
+    },
+  );
+
+  test("renders the page for an Enterprise-plan feature too: no plan applies off the Cloud", () => {
+    renderGate(PlanType.Enterprise);
+
+    expect(screen.getByTestId("gated-page")).toBeInTheDocument();
+  });
+});
+
+describe("PlanGatedPage on OneUptime Cloud (billing on)", () => {
+  beforeEach(() => {
+    billingEnabledForTest = true;
+    // The Cloud runs the Enterprise image; the edition must not unlock anything.
+    enterpriseEditionForTest = true;
+  });
+
+  test.each([PlanType.Free, PlanType.Growth])(
+    "a project on the %s plan sees the Scale plan upsell and never mounts the page",
+    (plan: PlanType) => {
+      currentPlanForTest = plan;
+
+      renderGate();
+
+      expectUpsell("Scale");
+      expect(pageMounts).toBe(0);
+      expect(pageRenders).toBe(0);
+      expect(
+        screen.getByText(
+          "SAML Single Sign On is available on the Scale plan and above. Upgrade to enable it for this project.",
+        ),
+      ).toBeInTheDocument();
+    },
+  );
+
+  test.each([PlanType.Scale, PlanType.Enterprise])(
+    "a project on the %s plan gets the page",
+    (plan: PlanType) => {
+      currentPlanForTest = plan;
+
+      renderGate();
+
+      expect(screen.getByTestId("gated-page")).toBeInTheDocument();
+      expect(screen.queryByText("Upgrade to Scale")).not.toBeInTheDocument();
+    },
+  );
+
+  test("no plan, or one the Dashboard cannot read, fails closed", () => {
+    currentPlanForTest = null;
+
+    const { unmount } = renderGate();
+
+    expectUpsell("Scale");
+    unmount();
+
+    currentPlanThrows = true;
+
+    renderGate();
+
+    expectUpsell("Scale");
+  });
+
+  test("uses the page's own plan: Scale is not enough for an Enterprise-plan page", () => {
+    currentPlanForTest = PlanType.Scale;
+
+    renderGate(PlanType.Enterprise);
+
+    expectUpsell("Enterprise");
+    expect(
+      screen.getByText(
+        "SAML Single Sign On is available on the Enterprise plan. Upgrade to enable it for this project.",
+      ),
+    ).toBeInTheDocument();
+  });
+
+  test("never falls back to the edition flag", () => {
+    currentPlanForTest = PlanType.Free;
+
+    renderGate();
+
+    expectUpsell("Scale");
+    expect(editionReads).toBe(0);
+  });
+
+  test("checks the plan on every render: the page comes and goes with it, hooks intact", () => {
+    currentPlanForTest = null;
+
+    const { rerender } = renderGate();
+
+    expectUpsell("Scale");
+
+    const renderAgain: () => void = (): void => {
+      rerender(
+        <PlanGatedPage requiredPlan={SSO_REQUIRED_PLAN} upsell={UPSELL}>
+          <FakePage />
+        </PlanGatedPage>,
+      );
+    };
+
+    currentPlanForTest = PlanType.Scale;
+    renderAgain();
+
+    expect(screen.getByTestId("gated-page")).toBeInTheDocument();
+    expect(pageMounts).toBe(1);
+
+    currentPlanForTest = PlanType.Growth;
+    renderAgain();
+
+    expectUpsell("Scale");
+
+    currentPlanForTest = PlanType.Enterprise;
+    renderAgain();
+
+    expect(screen.getByTestId("gated-page")).toBeInTheDocument();
+    expect(pageMounts).toBe(2);
+  });
+});