@oneuptime/common 14.0.9 → 14.0.11

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

@@ -140,3 +140,79 @@ describe("CopyTextButton", () => {
     );
   });
 });
+
+/*
+ * The dashboard loads Tailwind's browser runtime, which styles only the
+ * classes it knows. A width that is not on its spacing scale matches no rule,
+ * and the icon is simply not drawn - which is what the md size did with
+ * "w-4.5 h-4.5" (the scale has 3.5 and 4, then 5).
+ */
+const TAILWIND_SPACING_SCALE: Array<string> = [
+  "0",
+  "px",
+  "0.5",
+  "1",
+  "1.5",
+  "2",
+  "2.5",
+  "3",
+  "3.5",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  "10",
+  "11",
+  "12",
+];
+
+type ButtonSize = "xs" | "sm" | "md";
+
+const SIZE_CLASS: RegExp = /^[wh]-/;
+const ARBITRARY_LENGTH: RegExp = /^\[[0-9.]+(rem|px)\]$/;
+
+function iconSizeClasses(size: ButtonSize): Array<string> {
+  render(<CopyTextButton textToBeCopied="trace-4bf92f35" size={size} />);
+
+  const icon: SVGElement | null = screen
+    .getByRole("button", { name: "Copy" })
+    .querySelector("svg");
+
+  expect(icon).not.toBeNull();
+
+  return (icon!.getAttribute("class") || "")
+    .split(/\s+/)
+    .filter((className: string): boolean => {
+      return SIZE_CLASS.test(className);
+    });
+}
+
+describe("CopyTextButton icon sizes", () => {
+  test.each(["xs", "sm", "md"] as Array<ButtonSize>)(
+    "the %s icon has a width and a height Tailwind draws",
+    (size: ButtonSize) => {
+      const classes: Array<string> = iconSizeClasses(size);
+
+      expect(
+        classes.map((className: string): string => {
+          return className.slice(0, 2);
+        }),
+      ).toEqual(["w-", "h-"]);
+
+      for (const className of classes) {
+        const value: string = className.slice(2);
+
+        expect(
+          ARBITRARY_LENGTH.test(value) ||
+            TAILWIND_SPACING_SCALE.includes(value),
+        ).toBe(true);
+      }
+    },
+  );
+
+  test("the md icon is 18px, between sm's 16px and the md text", () => {
+    expect(iconSizeClasses("md")).toEqual(["w-[1.125rem]", "h-[1.125rem]"]);
+  });
+});

package/Tests/UI/Components/EditionLabelLapseCopy.ts

@@ -3,23 +3,23 @@
  * by the core EditionLabel suite and ee/Tests/UI/License, which renders the
  * same dialog with the Enterprise license manager.
  *
- * When the license lapses (after the trial or the grace period), single
- * sign-on (SAML and OIDC), SCIM provisioning and audit logging stop - the
- * Community Edition's behaviour - and "Require SSO" stops being enforced at
- * the same moment, so nobody is locked out: users sign in with their
- * password. Everything resumes as soon as a license is activated. The trial
- * and grace notices must say so BEFORE it happens, and the lapsed notice must
- * say what is off.
+ * When the license lapses (after the trial or the grace period), SCIM
+ * provisioning and audit logging stop - the Community Edition's behaviour -
+ * enterprise configuration becomes read-only and the enterprise admin
+ * dashboards are locked, until a license is activated, when everything
+ * resumes. The trial and grace notices must say so BEFORE it happens, and the
+ * lapsed notice must say what is off.
  *
- * The dialog used to promise the opposite ("SSO, SCIM and audit logging never
- * stop"), so the checks reject that copy too. Plain functions over text, with
- * no jest dependency, so a test can prove each check fails on the wrong copy.
+ * Single sign-on (SAML and OIDC) and "Require SSO" are part of every edition
+ * and do not depend on the license, so a lapse notice must not name them at
+ * all. The dialog first promised that SSO, SCIM and audit logging never stop,
+ * and later said that single sign-on stops with the license; the checks
+ * reject both. Plain functions over text, with no jest dependency, so a test
+ * can prove each check fails on the wrong copy.
  */
 
 // Before the lapse: the trial and grace notices, after "Without a valid license (...), ".
 export const LAPSE_WARNING_PHRASES: ReadonlyArray<string> = [
-  "single sign-on (SAML and OIDC) stops",
-  '"Require SSO" is no longer enforced, so users sign in with their password',
   "SCIM provisioning stops",
   "audit logging stops recording",
   "enterprise configuration becomes read-only",
@@ -30,8 +30,7 @@ export const LAPSE_WARNING_PHRASES: ReadonlyArray<string> = [
 
 // After the lapse: the license-required notice (expired, missing, invalid).
 export const LAPSED_STATE_PHRASES: ReadonlyArray<string> = [
-  "Single sign-on (SAML and OIDC) and SCIM provisioning are off",
-  '"Require SSO" is not enforced, so users sign in with their password',
+  "SCIM provisioning is off",
   "SCIM requests are refused",
   "Audit logging is not recording",
   "Enterprise configuration is read-only",
@@ -48,6 +47,18 @@ export const RETIRED_SOFT_ENFORCEMENT_COPY: ReadonlyArray<RegExp> = [
   /never (?:silently )?weakens?/i,
 ];
 
+/*
+ * Single sign-on named in a lapse notice at all - that it stops, that it
+ * keeps running, or that "Require SSO" is relaxed. The license does not
+ * touch it.
+ */
+export const SINGLE_SIGN_ON_MENTIONS: ReadonlyArray<RegExp> = [
+  /single sign-on/i,
+  /\bSSO\b/,
+  /\bSAML\b/,
+  /\bOIDC\b/,
+];
+
 // The copy the dialog shipped before the owner's decision, verbatim.
 export const RETIRED_NOTICE_EXAMPLES: ReadonlyArray<string> = [
   "Without a valid license (after the 14-day grace period), enterprise configuration becomes read-only and the enterprise admin dashboards are locked. Everything you already configured keeps working — SSO, SCIM and audit logging never stop — and core monitoring is never affected.",
@@ -55,6 +66,17 @@ export const RETIRED_NOTICE_EXAMPLES: ReadonlyArray<string> = [
   "The Enterprise license expired and its grace period is over. Enterprise configuration is read-only and the enterprise admin dashboards are locked until a valid license is added. Everything you already configured keeps working — SSO, SCIM and audit logging never stop — and core monitoring is never affected.",
 ];
 
+/*
+ * The copy the dialog shipped while single sign-on was an Enterprise Edition
+ * feature that stopped with the license, verbatim: a trial warning, a grace
+ * warning and a lapsed notice.
+ */
+export const RETIRED_SINGLE_SIGN_ON_STOPS_EXAMPLES: ReadonlyArray<string> = [
+  'Without a valid license (after the 14-day trial), single sign-on (SAML and OIDC) stops and "Require SSO" is no longer enforced, so users sign in with their password; SCIM provisioning stops; audit logging stops recording; enterprise configuration becomes read-only; and the enterprise admin dashboards are locked. Everything resumes as soon as a license is activated, and core monitoring is never affected.',
+  'Without a valid license (after the 30-day grace period), single sign-on (SAML and OIDC) stops and "Require SSO" is no longer enforced, so users sign in with their password; SCIM provisioning stops; audit logging stops recording; enterprise configuration becomes read-only; and the enterprise admin dashboards are locked. Everything resumes as soon as a license is activated, and core monitoring is never affected.',
+  'The Enterprise license expired and its grace period is over. Single sign-on (SAML and OIDC) and SCIM provisioning are off: "Require SSO" is not enforced, so users sign in with their password, and your identity provider\'s SCIM requests are refused. Audit logging is not recording. Enterprise configuration is read-only and the enterprise admin dashboards are locked. Everything resumes, without a restart, as soon as a valid license is added, and core monitoring is never affected.',
+];
+
 type CopyCheck = (text: string | null | undefined) => Array<string>;
 
 // Whitespace-normalized, so a check does not depend on how JSX wraps a line.
@@ -64,6 +86,19 @@ const normalize: (text: string | null | undefined) => string = (
   return (text || "").replace(/\s+/g, " ").trim();
 };
 
+// Which single sign-on mentions a text has (empty when it has none).
+export const singleSignOnMentions: CopyCheck = (
+  text: string | null | undefined,
+): Array<string> => {
+  const flat: string = normalize(text);
+
+  return SINGLE_SIGN_ON_MENTIONS.filter((mention: RegExp) => {
+    return mention.test(flat);
+  }).map((mention: RegExp) => {
+    return `mentions single sign-on: ${mention.source}`;
+  });
+};
+
 const copyProblems: (
   text: string | null | undefined,
   requiredPhrases: ReadonlyArray<string>,
@@ -86,6 +121,8 @@ const copyProblems: (
     }
   }
 
+  problems.push(...singleSignOnMentions(flat));
+
   return problems;
 };
 

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

@@ -19,8 +19,10 @@ import {
   LAPSED_STATE_PHRASES,
   LAPSE_WARNING_PHRASES,
   RETIRED_NOTICE_EXAMPLES,
+  RETIRED_SINGLE_SIGN_ON_STOPS_EXAMPLES,
   lapsedStateProblems,
   lapseWarningProblems,
+  singleSignOnMentions,
 } from "./EditionLabelLapseCopy";
 import "@testing-library/jest-dom";
 import {
@@ -29,6 +31,7 @@ import {
   render,
   screen,
   waitFor,
+  within,
 } from "@testing-library/react";
 import React from "react";
 import { afterEach, beforeEach, describe, expect, it } from "@jest/globals";
@@ -49,12 +52,14 @@ import { afterEach, beforeEach, describe, expect, it } from "@jest/globals";
  *   grace    either an expired license's grace period (renew) or an unlicensed
  *            installation's trial counted from its first run (add a license) -
  *            the two must never be confused;
- *   expired, missing, invalid - with the lapse said plainly: single sign-on,
- *            SCIM and audit logging are off, "Require SSO" is not enforced
- *            (users sign in with their password), configuration is
+ *   expired, missing, invalid - with the lapse said plainly: SCIM
+ *            provisioning and audit logging are off, configuration is
  *            read-only, and everything resumes when a license is added. The
  *            trial and grace notices warn about exactly that beforehand
- *            (EditionLabelLapseCopy.ts);
+ *            (EditionLabelLapseCopy.ts). None of them names single sign-on,
+ *            which is part of every edition and does not depend on the
+ *            license - the Community dialog lists it among the Community
+ *            features;
  *   the Community Edition image running with IS_ENTERPRISE_EDITION set, told to
  *            a master admin;
  *   and what EditionLabel hands a license manager, and where its parts land.
@@ -316,7 +321,10 @@ describe("EditionLabel - an expired license in its grace period", () => {
     expect(notice).toHaveTextContent(
       "Every enterprise feature keeps working until the grace period ends",
     );
-    // What stops when it ends: SSO, SCIM and audit logging, not just configuration.
+    /*
+     * What stops when it ends: SCIM provisioning and audit logging, not just
+     * configuration - and nothing about single sign-on.
+     */
     expect(lapseWarningProblems(notice.textContent)).toEqual([]);
   });
 
@@ -339,7 +347,7 @@ describe("EditionLabel - an expired license in its grace period", () => {
     );
 
     expect(notice).toHaveTextContent(
-      "Without a valid license (after the 30-day grace period), single sign-on (SAML and OIDC) stops",
+      "Without a valid license (after the 30-day grace period), SCIM provisioning stops",
     );
     expect(notice).not.toHaveTextContent(/trial/i);
   });
@@ -419,7 +427,10 @@ describe("EditionLabel - an unlicensed installation's trial", () => {
     expect(notice).toHaveTextContent(
       new Date(graceEndsAt).toLocaleDateString(),
     );
-    // What stops when it ends: SSO, SCIM and audit logging, not just configuration.
+    /*
+     * What stops when it ends: SCIM provisioning and audit logging, not just
+     * configuration - and nothing about single sign-on.
+     */
     expect(lapseWarningProblems(notice.textContent)).toEqual([]);
   });
 
@@ -436,7 +447,7 @@ describe("EditionLabel - an unlicensed installation's trial", () => {
     );
 
     expect(notice).toHaveTextContent(
-      "Without a valid license (after the 14-day trial), single sign-on (SAML and OIDC) stops",
+      "Without a valid license (after the 14-day trial), SCIM provisioning stops",
     );
     expect(notice).not.toHaveTextContent(/grace/i);
   });
@@ -538,9 +549,10 @@ describe("EditionLabel - no usable license", () => {
 
       expect(notice).toHaveTextContent(noticeTitle);
       /*
-       * The lapse, said plainly: single sign-on, SCIM and audit logging are
-       * off, "Require SSO" is not enforced, configuration is read-only, it
-       * all resumes with a license, and core monitoring is not touched.
+       * The lapse, said plainly: SCIM provisioning and audit logging are
+       * off, configuration is read-only, it all resumes with a license, and
+       * core monitoring is not touched. Single sign-on is not mentioned: the
+       * license does not touch it.
        */
       expect(lapsedStateProblems(notice.textContent)).toEqual([]);
     },
@@ -569,7 +581,7 @@ describe("EditionLabel - no usable license", () => {
    * immediately" - the list is services (support, indemnification) as much as
    * features, so it still must not. It then said "Nothing you already
    * configured stops working without one", which stopped being true when
-   * single sign-on, SCIM and audit logging began to stop with the license.
+   * SCIM provisioning and audit logging began to stop with the license.
    */
   it("says what a license keeps running, and no longer that nothing stops without one", async () => {
     respondWith(adminPayload({ status: "missing", licenseValid: false }));
@@ -584,7 +596,7 @@ describe("EditionLabel - no usable license", () => {
     // Without a manager nobody here can add the license, so it names who can.
     expect(
       screen.getByText(
-        /A master admin can add the license to keep single sign-on, SCIM provisioning and audit logging running/,
+        /A master admin can add the license to keep SCIM provisioning and audit logging running/,
       ),
     ).toBeInTheDocument();
     expect(
@@ -592,17 +604,35 @@ describe("EditionLabel - no usable license", () => {
     ).not.toBeInTheDocument();
   });
 
-  it("asks for a license to turn single sign-on, SCIM and audit logging back on", async () => {
+  it("asks for a license to turn SCIM provisioning and audit logging back on", async () => {
     respondWith(adminPayload({ status: "expired", licenseValid: false }));
 
     await openDialog();
 
     expect(
       await screen.findByText(
-        "Add a valid license to turn single sign-on, SCIM and audit logging back on and make enterprise configuration editable.",
+        "Add a valid license to turn SCIM provisioning and audit logging back on and make enterprise configuration editable.",
       ),
     ).toBeInTheDocument();
   });
+
+  /*
+   * Single sign-on is part of every edition: nothing a lapsed installation
+   * shows about the license says it stops, is off or needs the license.
+   */
+  it.each(["expired", "missing", "invalid"])(
+    "a %s license: nothing in the dialog names single sign-on",
+    async (status: string) => {
+      respondWith(adminPayload({ status, licenseValid: false }));
+
+      await openDialog();
+
+      await screen.findByTestId("enterprise-license-required-notice");
+      await screen.findByText("What your license unlocks");
+
+      expect(singleSignOnMentions(document.body.textContent)).toEqual([]);
+    },
+  );
 });
 
 describe("EditionLabel - an unverified legacy license", () => {
@@ -684,6 +714,37 @@ describe("EditionLabel - the Community Edition", () => {
     expect(screen.getByText("v13.0.0")).toBeInTheDocument();
   });
 
+  /*
+   * SAML and OIDC single sign-on, for projects, status pages and the whole
+   * instance, and "Require SSO for login" are Community Edition features;
+   * the Enterprise column does not claim them.
+   */
+  it("lists single sign-on among the Community Edition's features, not the Enterprise Edition's", async () => {
+    render(<EditionLabel />);
+    fireEvent.click(screen.getByRole("button", { name: /Community Edition/ }));
+
+    await screen.findByText(/You are running the Community Edition/);
+
+    const communityColumn: HTMLElement = screen.getByText("Community Edition", {
+      selector: "h4",
+    }).parentElement as HTMLElement;
+    const enterpriseColumn: HTMLElement = screen.getByText(
+      "Enterprise Edition",
+      { selector: "h4" },
+    ).parentElement as HTMLElement;
+
+    const communityFeatures: Array<string> = within(communityColumn)
+      .getAllByRole("listitem")
+      .map((item: HTMLElement) => {
+        return item.textContent || "";
+      });
+
+    expect(communityFeatures).toContain(
+      'SAML and OIDC single sign-on (SSO) for projects, status pages, and the whole instance, including "Require SSO for login".',
+    );
+    expect(singleSignOnMentions(enterpriseColumn.textContent)).toEqual([]);
+  });
+
   /*
    * A leftover IS_ENTERPRISE_EDITION=true on the Community image: the server
    * tells the frontend through env.js. Only a master admin can switch the
@@ -901,7 +962,7 @@ describe("EditionLabel - without a license manager", () => {
     ).toBeInTheDocument();
     expect(
       screen.getByText(
-        /A master admin can add the license to keep single sign-on, SCIM provisioning and audit logging running and enterprise configuration editable/,
+        /A master admin can add the license to keep SCIM provisioning and audit logging running and enterprise configuration editable/,
       ),
     ).toBeInTheDocument();
   });
@@ -1167,7 +1228,7 @@ describe("EditionLabel - with a license manager", () => {
     // With a manager to add it with, a master admin is pointed at it.
     expect(
       screen.getByText(
-        "Add a license below before the trial ends to keep single sign-on, SCIM and audit logging running and enterprise configuration editable.",
+        "Add a license below before the trial ends to keep SCIM provisioning and audit logging running and enterprise configuration editable.",
       ),
     ).toBeInTheDocument();
   });
@@ -1285,9 +1346,10 @@ describe("EditionLabel - with a license manager", () => {
 /*
  * The lapse checks the notices above rely on (EditionLabelLapseCopy.ts), and
  * the sentences EditionLabel builds its notices from. Each check has to fail
- * on the copy that promised SSO, SCIM and audit logging never stop, and on
- * copy that drops any single consequence - otherwise a passing notice test
- * proves nothing.
+ * on the copy that promised SSO, SCIM and audit logging never stop, on the
+ * copy that said single sign-on stops with the license, and on copy that
+ * drops any single consequence - otherwise a passing notice test proves
+ * nothing.
  */
 describe("EditionLabel - the lapse copy and its checks", () => {
   it.each(RETIRED_NOTICE_EXAMPLES)(
@@ -1296,18 +1358,64 @@ describe("EditionLabel - the lapse copy and its checks", () => {
       expect(lapseWarningProblems(retired)).toContain("retired: never stop");
       expect(lapsedStateProblems(retired)).toContain("retired: never stop");
       expect(lapseWarningProblems(retired)).toContain(
-        "missing: single sign-on (SAML and OIDC) stops",
+        "missing: SCIM provisioning stops",
       );
       expect(lapsedStateProblems(retired)).toContain(
-        "missing: Single sign-on (SAML and OIDC) and SCIM provisioning are off",
+        "missing: SCIM provisioning is off",
       );
+      expect(lapseWarningProblems(retired)).toContain(
+        "mentions single sign-on: \\bSSO\\b",
+      );
+    },
+  );
+
+  /*
+   * The notices said single sign-on stops with the license while it was an
+   * Enterprise Edition feature. Everything else in them is still right, so
+   * the single sign-on check is what rejects them.
+   */
+  it.each(RETIRED_SINGLE_SIGN_ON_STOPS_EXAMPLES.slice(0, 2))(
+    "rejects the warning that said single sign-on stops: %s",
+    (retired: string) => {
+      expect(lapseWarningProblems(retired)).toEqual([
+        "mentions single sign-on: single sign-on",
+        "mentions single sign-on: \\bSSO\\b",
+        "mentions single sign-on: \\bSAML\\b",
+        "mentions single sign-on: \\bOIDC\\b",
+      ]);
     },
   );
 
+  it("rejects the lapsed notice that said single sign-on is off", () => {
+    const retired: string = RETIRED_SINGLE_SIGN_ON_STOPS_EXAMPLES[2] || "";
+
+    expect(lapsedStateProblems(retired)).toEqual(
+      expect.arrayContaining([
+        "mentions single sign-on: single sign-on",
+        "mentions single sign-on: \\bSSO\\b",
+      ]),
+    );
+    expect(lapsedStateProblems(retired)).not.toEqual([]);
+  });
+
+  it("rejects a notice that names single sign-on at all, even to say it is unaffected", () => {
+    expect(
+      lapseWarningProblems(
+        `${GRACE_ENFORCEMENT_SUMMARY} Single sign-on is part of every edition.`,
+      ),
+    ).toEqual(["mentions single sign-on: single sign-on"]);
+    expect(
+      lapsedStateProblems(
+        `${LICENSE_LAPSED_STATE} "Require SSO" still applies.`,
+      ),
+    ).toEqual(["mentions single sign-on: \\bSSO\\b"]);
+  });
+
   it("accepts the sentences EditionLabel ships", () => {
     expect(lapseWarningProblems(TRIAL_ENFORCEMENT_SUMMARY)).toEqual([]);
     expect(lapseWarningProblems(GRACE_ENFORCEMENT_SUMMARY)).toEqual([]);
     expect(lapsedStateProblems(LICENSE_LAPSED_STATE)).toEqual([]);
+    expect(singleSignOnMentions(LICENSE_LAPSE_CONSEQUENCES)).toEqual([]);
   });
 
   it.each(
@@ -1345,7 +1453,7 @@ describe("EditionLabel - the lapse copy and its checks", () => {
       lapsedStateProblems(
         `${LICENSE_LAPSED_STATE} SSO, SCIM and audit logging never stop.`,
       ),
-    ).toEqual(["retired: never stop"]);
+    ).toEqual(["retired: never stop", "mentions single sign-on: \\bSSO\\b"]);
   });
 
   it("warns without calling the trial a grace period, or the grace period a trial", () => {

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

@@ -0,0 +1,142 @@
+import "@testing-library/jest-dom";
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import * as React from "react";
+
+/*
+ * ErrorMessage is what an empty table draws, as well as a failed one. An
+ * empty list that can be added to now passes the "Create X" button as the
+ * message's `action`, and that button takes the Refresh link's place:
+ * reloading a list that has just loaded empty only shows the same nothing
+ * again, and an underlined "Refresh?" under "No monitors yet." read like the
+ * load had failed.
+ *
+ * Everything else about the refresh control (a real, focusable button - see
+ * ErrorMessageRefreshControl.test.tsx) is unchanged when there is no action.
+ */
+
+jest.mock("../../../UI/Utils/Translation", () => {
+  return {
+    __esModule: true,
+    default: () => {
+      return {
+        translateString: (value: string | undefined): string | undefined => {
+          return value;
+        },
+        translateValue: (value: unknown): unknown => {
+          return value;
+        },
+      };
+    },
+  };
+});
+
+import ErrorMessage from "../../../UI/Components/ErrorMessage/ErrorMessage";
+
+describe("ErrorMessage action", () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  test("renders the action under the message", () => {
+    render(
+      <ErrorMessage
+        message="No monitors yet."
+        action={<button data-testid="create-first">Create Monitor</button>}
+      />,
+    );
+
+    const action: HTMLElement = screen.getByTestId("empty-action");
+
+    expect(screen.getByText("No monitors yet.")).toBeInTheDocument();
+    expect(action).toContainElement(screen.getByTestId("create-first"));
+  });
+
+  test("the action takes the Refresh link's place", () => {
+    render(
+      <ErrorMessage
+        message="No monitors yet."
+        onRefreshClick={() => {}}
+        action={<button data-testid="create-first">Create Monitor</button>}
+      />,
+    );
+
+    expect(screen.getByTestId("create-first")).toBeInTheDocument();
+    expect(screen.queryByTestId("refresh-button")).toBeNull();
+    expect(screen.queryByText("Refresh?")).toBeNull();
+  });
+
+  test("the action is live, and does not refresh", () => {
+    let creates: number = 0;
+    let refreshes: number = 0;
+
+    render(
+      <ErrorMessage
+        message="No monitors yet."
+        onRefreshClick={() => {
+          refreshes++;
+        }}
+        action={
+          <button
+            data-testid="create-first"
+            onClick={() => {
+              creates++;
+            }}
+          >
+            Create Monitor
+          </button>
+        }
+      />,
+    );
+
+    fireEvent.click(screen.getByTestId("create-first"));
+
+    expect(creates).toBe(1);
+    expect(refreshes).toBe(0);
+  });
+
+  test("an element message gets the action too", () => {
+    render(
+      <ErrorMessage
+        message={<span data-testid="rich-message">Nothing here yet.</span>}
+        action={<button data-testid="create-first">Create Monitor</button>}
+      />,
+    );
+
+    expect(screen.getByTestId("rich-message")).toBeInTheDocument();
+    expect(screen.getByTestId("create-first")).toBeInTheDocument();
+  });
+
+  test("without an action, the Refresh link is exactly as before", () => {
+    let refreshes: number = 0;
+
+    render(
+      <ErrorMessage
+        message="Something went wrong"
+        onRefreshClick={() => {
+          refreshes++;
+        }}
+      />,
+    );
+
+    const refresh: HTMLElement = screen.getByTestId("refresh-button");
+
+    expect(screen.queryByTestId("empty-action")).toBeNull();
+    expect(refresh.tagName).toBe("BUTTON");
+    expect(refresh).toHaveAttribute("type", "button");
+    expect(refresh).toHaveTextContent("Refresh?");
+
+    fireEvent.click(refresh);
+
+    expect(refreshes).toBe(1);
+  });
+
+  test("with neither, only the message is drawn", () => {
+    const { container } = render(<ErrorMessage message="Nothing here" />);
+
+    expect(screen.getByText("Nothing here")).toBeInTheDocument();
+    expect(screen.queryByTestId("empty-action")).toBeNull();
+    expect(screen.queryByTestId("refresh-button")).toBeNull();
+    expect(container.querySelectorAll("button")).toHaveLength(0);
+  });
+});