@oneuptime/common 13.0.0 → 13.0.1

package/Tests/UI/MicrosoftTeams/MicrosoftTeamsMessagingEndpointGuidance.test.tsx

@@ -19,8 +19,8 @@ import MicrosoftTeamsIntegrationDocumentation from "../../../../App/FeatureSet/D
  * cheapest check an admin runs next — opening the messaging endpoint in a
  * browser — used to return "Page not found". So the docs are what has to
  * carry the diagnosis: the two directions are independent, a working alert
- * tests only one of them, and an empty Chats list is the confirmation rather
- * than a second unrelated bug.
+ * tests only one of them, and an empty Chats list calls for checking inbound
+ * delivery, authentication, and project mapping.
  *
  * These assertions are on prose because the failure was prose.
  */
@@ -174,20 +174,30 @@ describe("Self-hosted docs: the unreachable-endpoint troubleshooting section", (
     );
   });
 
-  test("states the single root cause up front", () => {
-    expect(section).toContain(
-      "**Azure Bot Service cannot reach your messaging endpoint.**",
+  test("identifies inbound delivery as a likely cause and names the checks up front", () => {
+    const introduction: string = section.trim().split("\n\n")[0]!;
+
+    expect(introduction).toContain("These symptoms often mean");
+    expect(introduction).toContain(
+      "**Azure Bot Service cannot deliver authenticated activities to your messaging endpoint**",
     );
-    expect(section).toContain("These are one failure, not two");
+    expect(introduction).toContain(
+      "Check routing, bot authentication, and project configuration",
+    );
+    expect(introduction).not.toContain("These are one failure, not two");
   });
 
   test("explains that a working alert card tests the opposite direction", () => {
     const lowered: string = section.toLowerCase();
 
     expect(lowered).toContain("oneuptime calls microsoft");
-    expect(lowered).toMatch(
-      /tells you nothing at all about the bot endpoint|working alert/,
+    expect(lowered).toContain(
+      "a working alert verifies that particular outbound send",
     );
+    expect(lowered).toContain(
+      "it does not verify every graph permission or the inbound bot endpoint",
+    );
+    expect(lowered).not.toContain("graph permissions are fine");
   });
 
   test("tabulates which paths need inbound access and which do not", () => {
@@ -216,11 +226,17 @@ describe("Self-hosted docs: the unreachable-endpoint troubleshooting section", (
     ).toBeGreaterThanOrEqual(3);
   });
 
-  test("explains why the empty Chats list confirms the diagnosis", () => {
+  test("explains what an empty Chats list means and what Refresh Chats reads", () => {
     const lowered: string = section.toLowerCase();
 
-    expect(lowered).toContain("refresh chats");
-    expect(lowered).toContain("application permissions");
+    expect(lowered).toContain("no chat has been recorded for that project");
+    expect(lowered).toContain(
+      "check incoming requests, authentication errors, and tenant/project mapping",
+    );
+    expect(lowered).toContain(
+      "**refresh chats** re-reads oneuptime's stored chats",
+    );
+    expect(lowered).not.toContain("no bot activity has ever been received");
   });
 
   test("names all three activities that register a chat, not just the install event", () => {
@@ -238,7 +254,7 @@ describe("Self-hosted docs: the unreachable-endpoint troubleshooting section", (
 
     expect(lowered).toContain("installed");
     expect(lowered).toContain("added to the conversation");
-    expect(lowered).toContain("any message sent to the bot");
+    expect(lowered).toContain("a message sent to the bot in that chat");
   });
 
   test("the inbound table describes chat registration as an activity, not an install event", () => {
@@ -257,6 +273,21 @@ describe("Self-hosted docs: the unreachable-endpoint troubleshooting section", (
     expect(section).toContain("grep 'POST /api/microsoft-bot/messages'");
   });
 
+  test("checks log coverage when POSTs are absent and processing errors when they arrive", () => {
+    const lowered: string = section.toLowerCase();
+
+    expect(lowered).toContain(
+      "if there are no post lines, confirm that the correct access log is recording requests",
+    );
+    expect(lowered).toContain(
+      "check the configured azure endpoint and the network path",
+    );
+    expect(lowered).toContain(
+      "if posts arrive, inspect their responses and oneuptime's authentication or project-mapping errors",
+    );
+    expect(lowered).not.toContain("nothing inside oneuptime is at fault");
+  });
+
   test("covers the certificate chain, with a command that checks it", () => {
     expect(section).toContain("publicly trusted certificate");
     expect(section).toContain("full chain");

package/Tests/UI/ReactDomBuild.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, test } from "@jest/globals";
+import childProcess from "child_process";
+import path from "path";
+
+const COMMON_ROOT: string = path.resolve(__dirname, "..", "..");
+
+interface RendererBuild {
+  rendererFiles: Array<string>;
+  clientFiles: Array<string>;
+  foreignRendererFiles: Array<string>;
+  outputBytes: number;
+}
+
+describe("frontend renderer deduplication", () => {
+  test.each(["production", "development"])(
+    "bundles one renderer for the entry point and shared portals in %s",
+    (environment: string) => {
+      /*
+       * Use a subprocess because esbuild requires Node's native Uint8Array.
+       * Separate physical installs reproduce the app/Common package layout;
+       * symlinking both to one install would hide the original duplication.
+       */
+      const result: RendererBuild = JSON.parse(
+        childProcess.execFileSync(
+          process.execPath,
+          [
+            "-e",
+            String.raw`
+              const fs = require("fs");
+              const os = require("os");
+              const path = require("path");
+              const esbuild = require("esbuild");
+              const { createConfig } = require("./UI/esbuild-config");
+              const reactDomRoot = path.dirname(require.resolve("react-dom/package.json"));
+              const root = fs.mkdtempSync(path.join(os.tmpdir(), "oneuptime-renderer-"));
+
+              async function run() {
+                try {
+                  for (const name of ["app", "shared"]) {
+                    const destination = path.join(root, name, "node_modules/react-dom");
+                    fs.cpSync(reactDomRoot, destination, { recursive: true });
+                  }
+
+                  const entry = path.join(root, "app/index.js");
+                  fs.writeFileSync(entry, [
+                    'import { createRoot } from "react-dom/client";',
+                    'export { createRoot };',
+                    'export { createPortal, flushSync } from "../shared/index.js";',
+                  ].join("\n"));
+                  fs.writeFileSync(path.join(root, "shared/index.js"),
+                    'export { createPortal, flushSync } from "react-dom";');
+
+                  const config = createConfig({
+                    serviceName: "Dashboard",
+                    publicPath: "/dashboard/dist/",
+                    entryPoint: entry,
+                    outdir: path.join(root, "dist"),
+                  });
+                  const built = await esbuild.build({
+                    ...config,
+                    nodePaths: [path.resolve("node_modules")],
+                    metafile: true,
+                    write: false,
+                    logLevel: "silent",
+                  });
+                  const inputs = Object.keys(built.metafile.inputs);
+                  const rendererFiles = inputs.filter((file) =>
+                    /react-dom[/\\]cjs[/\\]react-dom\.(production\.min|development)\.js$/.test(file));
+                  const clientFiles = inputs.filter((file) => /react-dom[/\\]client\.js$/.test(file));
+                  const foreignRendererFiles = inputs.filter((file) =>
+                    path.resolve(file).startsWith(root) && file.includes("react-dom"));
+                  console.log(JSON.stringify({
+                    rendererFiles,
+                    clientFiles,
+                    foreignRendererFiles,
+                    outputBytes: built.outputFiles.reduce((sum, file) => sum + file.contents.length, 0),
+                  }));
+                } finally {
+                  fs.rmSync(root, { recursive: true, force: true });
+                }
+              }
+              run().catch((error) => { console.error(error); process.exitCode = 1; });
+            `,
+          ],
+          {
+            cwd: COMMON_ROOT,
+            env: { ...process.env, NODE_ENV: environment },
+            encoding: "utf8",
+          },
+        ),
+      ) as RendererBuild;
+
+      expect(result.outputBytes).toBeGreaterThan(0);
+      expect(result.rendererFiles).toHaveLength(1);
+      expect(result.rendererFiles[0]).toContain(
+        environment === "production"
+          ? "react-dom.production.min.js"
+          : "react-dom.development.js",
+      );
+      expect(result.clientFiles).toHaveLength(1);
+      expect(result.foreignRendererFiles).toEqual([]);
+    },
+  );
+});

package/Tests/UI/ReactRouterSingletonBuild.test.ts

@@ -58,12 +58,22 @@ function renderSharedLink(nodeEnv: string): RenderResult {
 
   fs.copyFileSync(APP_LINK, path.join(root, "shared", "AppLink.tsx"));
   const entry: string = path.join(root, "public", "Entry.tsx");
+  /*
+   * The entry renders through react-dom/server.browser rather than the bare
+   * react-dom/server specifier. esbuild-config aliases "react-dom" to an
+   * absolute directory, and an esbuild alias rewrites subpaths too, so
+   * "react-dom/server" would become a plain file path and skip react-dom's
+   * exports map - landing on server.node.js, which imports "stream" and "util"
+   * and cannot resolve on the browser platform this config builds for.
+   * server.browser is the renderer that exports map picks for a browser build
+   * anyway, so this asks for it directly instead of relying on the alias.
+   */
   fs.writeFileSync(
     entry,
     `
       import React from "react";
       import { MemoryRouter } from "react-router-dom";
-      import { renderToStaticMarkup } from "react-dom/server";
+      import { renderToStaticMarkup } from "react-dom/server.browser";
       import AppLink from "../shared/AppLink";
 
       globalThis.routerFixtureMarkup = renderToStaticMarkup(

package/Tests/UI/Utils/Breadcrumb/fixtures/RealBreadcrumbTrails.ts

@@ -2922,6 +2922,154 @@ const realBreadcrumbTrails: Array<BreadcrumbTrailFixture> = [
     pagePattern: "/dashboard/:projectId/users/custom-fields",
     titles: ["Project", "Users", "Custom Fields"],
   },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware",
+    titles: ["Project", "VMware", "vCenters"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id",
+    titles: ["Project", "VMware", "View vCenter"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/alerts",
+    titles: ["Project", "VMware", "View vCenter", "Alerts"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/audit-logs",
+    titles: ["Project", "VMware", "View vCenter", "Audit Logs"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/clusters",
+    titles: ["Project", "VMware", "View vCenter", "Clusters"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/clusters/:subModelId",
+    titles: ["Project", "VMware", "View vCenter", "Clusters", "Cluster Detail"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/datastores",
+    titles: ["Project", "VMware", "View vCenter", "Datastores"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/datastores/:subModelId",
+    titles: [
+      "Project",
+      "VMware",
+      "View vCenter",
+      "Datastores",
+      "Datastore Detail",
+    ],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/delete",
+    titles: ["Project", "VMware", "View vCenter", "Delete vCenter"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/documentation",
+    titles: ["Project", "VMware", "View vCenter", "Documentation"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/feed",
+    titles: ["Project", "VMware", "View vCenter", "Feed"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/hosts",
+    titles: ["Project", "VMware", "View vCenter", "Hosts"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/hosts/:subModelId",
+    titles: ["Project", "VMware", "View vCenter", "Hosts", "Host Detail"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/incidents",
+    titles: ["Project", "VMware", "View vCenter", "Incidents"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/insights",
+    titles: ["Project", "VMware", "View vCenter", "Insights"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/logs",
+    titles: ["Project", "VMware", "View vCenter", "Logs"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/metrics",
+    titles: ["Project", "VMware", "View vCenter", "Metrics"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/owners",
+    titles: ["Project", "VMware", "View vCenter", "Owners"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/recommendations",
+    titles: ["Project", "VMware", "View vCenter", "Recommendations"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/resource-pools",
+    titles: ["Project", "VMware", "View vCenter", "Resource Pools"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/scheduled-maintenance",
+    titles: ["Project", "VMware", "View vCenter", "Scheduled Maintenance"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/settings",
+    titles: ["Project", "VMware", "View vCenter", "Settings"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/:id/virtual-machines",
+    titles: ["Project", "VMware", "View vCenter", "Virtual Machines"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern:
+      "/dashboard/:projectId/vmware/:id/virtual-machines/:subModelId",
+    titles: [
+      "Project",
+      "VMware",
+      "View vCenter",
+      "Virtual Machines",
+      "Virtual Machine Detail",
+    ],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/documentation",
+    titles: ["Project", "VMware", "Documentation"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/settings/label-rules",
+    titles: ["Project", "VMware", "Settings", "Label Rules"],
+  },
+  {
+    getter: "getVMwareBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/vmware/settings/owner-rules",
+    titles: ["Project", "VMware", "Settings", "Owner Rules"],
+  },
   {
     getter: "getWorkflowsBreadcrumbs",
     pagePattern: "/dashboard/:projectId/workflows",

package/Tests/UI/Utils/Breadcrumb/fixtures/RealRoutePatterns.ts

@@ -355,6 +355,35 @@ const realRoutePatterns: Array<string> = [
   "/dashboard/:projectId/proxmox/settings/owner-rules",
   "/dashboard/:projectId/proxmox/settings/label-rules",
   "/dashboard/:projectId/proxmox/archived",
+  "/dashboard/:projectId/vmware/*",
+  "/dashboard/:projectId/vmware",
+  "/dashboard/:projectId/vmware/:id",
+  "/dashboard/:projectId/vmware/:id/hosts",
+  "/dashboard/:projectId/vmware/:id/hosts/:subModelId",
+  "/dashboard/:projectId/vmware/:id/virtual-machines",
+  "/dashboard/:projectId/vmware/:id/virtual-machines/:subModelId",
+  "/dashboard/:projectId/vmware/:id/datastores",
+  "/dashboard/:projectId/vmware/:id/datastores/:subModelId",
+  "/dashboard/:projectId/vmware/:id/clusters",
+  "/dashboard/:projectId/vmware/:id/clusters/:subModelId",
+  "/dashboard/:projectId/vmware/:id/resource-pools",
+  "/dashboard/:projectId/vmware/:id/insights",
+  "/dashboard/:projectId/vmware/:id/recommendations",
+  "/dashboard/:projectId/vmware/:id/metrics",
+  "/dashboard/:projectId/vmware/:id/logs",
+  "/dashboard/:projectId/vmware/:id/incidents",
+  "/dashboard/:projectId/vmware/:id/alerts",
+  "/dashboard/:projectId/vmware/:id/scheduled-maintenance",
+  "/dashboard/:projectId/vmware/:id/owners",
+  "/dashboard/:projectId/vmware/:id/feed",
+  "/dashboard/:projectId/vmware/:id/audit-logs",
+  "/dashboard/:projectId/vmware/:id/settings",
+  "/dashboard/:projectId/vmware/:id/delete",
+  "/dashboard/:projectId/vmware/:id/documentation",
+  "/dashboard/:projectId/vmware/documentation",
+  "/dashboard/:projectId/vmware/settings/owner-rules",
+  "/dashboard/:projectId/vmware/settings/label-rules",
+  "/dashboard/:projectId/vmware/archived",
   "/dashboard/:projectId/iot/*",
   "/dashboard/:projectId/iot",
   "/dashboard/:projectId/iot/:id",

package/Tests/UI/Utils/DashboardStackingLayers.test.ts

@@ -0,0 +1,197 @@
+import { describe, expect, test } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+import DashboardStackingLayers, {
+  DASHBOARD_CANVAS_ISOLATION,
+} from "../../../UI/Utils/DashboardStackingLayers";
+
+/*
+ * github.com/OneUptime/oneuptime/issues/3660.
+ *
+ * A dashboard tile that had been clicked once painted over the toolbar's
+ * auto-refresh menu, so opening the picker produced a blank white rectangle.
+ * Nothing was misconfigured: the canvas raised the selected tile to 20 so it
+ * would clear the tiles it overlaps, the toolbar menu asked for 10, and
+ * because neither box lived inside a stacking context of its own those two
+ * unrelated numbers were resolved against each other in the ROOT stacking
+ * context. 20 beat 10.
+ *
+ * So the numbers alone were never the fix and raising the menu alone would
+ * never have been either - the drag code elevates a tile to 60 while it is
+ * being moved, which outranks the menu, the Modal layer and everything else
+ * the page has. What makes the values safe is the canvas isolating itself, so
+ * that "above my neighbours on the board" stops being a claim about the page.
+ *
+ * This file pins the arithmetic. The DOM half - that the canvas really does
+ * isolate, and that a selected tile therefore cannot be compared with the menu
+ * at all - is asserted against real rendered elements in
+ * Common/Tests/App/Dashboard/DashboardToolbarPopupLayering.test.tsx, and the
+ * sources are pinned in App/Tests/Dashboard/DashboardCanvasLayering.test.ts.
+ */
+
+const COMMON_ROOT: string = path.join(__dirname, "..", "..", "..");
+
+function readCommonCode(...relativeParts: Array<string>): string {
+  return fs.readFileSync(path.join(COMMON_ROOT, ...relativeParts), "utf8");
+}
+
+/*
+ * The shell sticks its header at this layer. Read out of MasterPage rather
+ * than written down here, so moving the header moves the assertions with it.
+ */
+function appHeaderZIndex(): number {
+  const source: string = readCommonCode(
+    "UI",
+    "Components",
+    "MasterPage",
+    "MasterPage.tsx",
+  );
+
+  const match: RegExpMatchArray | null = source.match(
+    /makeTopSectionUnstick \? "" : "sticky top-0 z-(\d+)"/,
+  );
+
+  if (!match || match[1] === undefined) {
+    throw new Error(
+      "MasterPage no longer sticks its top section with a single `sticky top-0 z-N` class. Issue #3660 depends on dashboard widgets never competing with that layer - if the shell's layering changed, update this test to match.",
+    );
+  }
+
+  return Number(match[1]);
+}
+
+/* The layer every other anchored menu in the app already uses. */
+function moreMenuZIndex(): number {
+  const source: string = readCommonCode(
+    "UI",
+    "Components",
+    "MoreMenu",
+    "MoreMenu.tsx",
+  );
+
+  const match: RegExpMatchArray | null = source.match(
+    /absolute right-0 z-(\d+) mt-2 w-56 origin-top-right/,
+  );
+
+  if (!match || match[1] === undefined) {
+    throw new Error(
+      "MoreMenu's panel no longer declares its layer as a single `z-N` class in the class list this test anchors on. The dashboard toolbar's own menu is meant to sit on the same layer - re-point this reader before changing either.",
+    );
+  }
+
+  return Number(match[1]);
+}
+
+/*
+ * The layer every dialog in the app opens at - including the widget settings
+ * dialog the canvas itself renders, and the Add Widget / Variables / discard
+ * dialogs the toolbar opens while a board is being edited. Those are the
+ * overlays a widget mid-drag is actually in a position to cover.
+ */
+function modalZIndex(): number {
+  const source: string = readCommonCode(
+    "UI",
+    "Components",
+    "Modal",
+    "Modal.tsx",
+  );
+
+  const match: RegExpMatchArray | null = source.match(
+    /<div className="relative z-(\d+)">/,
+  );
+
+  if (!match || match[1] === undefined) {
+    throw new Error(
+      "Modal's root no longer declares its layer as a single `relative z-N` class. Re-point this reader before changing either Modal or the dashboard's scale.",
+    );
+  }
+
+  return Number(match[1]);
+}
+
+describe("dashboard stacking layers (issue #3660)", () => {
+  describe("the order the board is painted in", () => {
+    test("the drop placeholder sits under the widget being dragged onto it", () => {
+      expect(DashboardStackingLayers.canvasPlaceholder).toBeLessThan(
+        DashboardStackingLayers.canvasDraggingComponent,
+      );
+    });
+
+    test("the drop placeholder sits under the selected widget", () => {
+      /*
+       * The placeholder is a hint about where the card is going. Painting it
+       * over the card would hide the thing being positioned.
+       */
+      expect(DashboardStackingLayers.canvasPlaceholder).toBeLessThan(
+        DashboardStackingLayers.canvasSelectedComponent,
+      );
+    });
+
+    test("a widget under an active gesture outranks the merely selected one", () => {
+      /*
+       * Selection persists; a drag is momentary and has to clear whatever it
+       * is crossing, including the card that was selected before the grab.
+       */
+      expect(DashboardStackingLayers.canvasSelectedComponent).toBeLessThan(
+        DashboardStackingLayers.canvasDraggingComponent,
+      );
+    });
+  });
+
+  describe("the toolbar's menus", () => {
+    test("open above a selected widget - the bug in the report", () => {
+      expect(DashboardStackingLayers.toolbarPopup).toBeGreaterThan(
+        DashboardStackingLayers.canvasSelectedComponent,
+      );
+    });
+
+    test("sit on the same layer as every other anchored menu in the app", () => {
+      /*
+       * The auto-refresh menu is hand-rolled rather than a MoreMenu, which is
+       * the only reason it could drift to a different layer in the first
+       * place. Two menus in one toolbar disagreeing about their layer is a
+       * bug waiting for the first time they overlap.
+       */
+      expect(DashboardStackingLayers.toolbarPopup).toBe(moreMenuZIndex());
+    });
+
+    test("clear the app's sticky header", () => {
+      expect(DashboardStackingLayers.toolbarPopup).toBeGreaterThan(
+        appHeaderZIndex(),
+      );
+    });
+  });
+
+  describe("why the canvas has to isolate", () => {
+    test("it does isolate", () => {
+      expect(DASHBOARD_CANVAS_ISOLATION).toBe("isolate");
+    });
+
+    test("a dragged widget would otherwise outrank every dialog the app opens", () => {
+      /*
+       * This is the assertion that stops #3660 being "fixed" by raising the
+       * menu and deleting the boundary. Dragging happens in edit mode, and
+       * edit mode is full of things this number would cover in a shared
+       * stacking context: the widget settings dialog the canvas renders, the
+       * Add Widget and Variables dialogs, the discard confirmation. The
+       * elevation is held for a further 260ms after the drop, so this is not
+       * only about the frames the pointer is down for.
+       */
+      expect(DashboardStackingLayers.canvasDraggingComponent).toBeGreaterThan(
+        modalZIndex(),
+      );
+    });
+
+    test("a selected widget would otherwise outrank the app's sticky header", () => {
+      /*
+       * The unreported half of the same bug: scroll a board with a tile
+       * selected and the tile rides up over the navbar. Lowering the raise
+       * instead would put the selection ring and the resize handles back
+       * underneath the neighbours they are meant to overlap.
+       */
+      expect(
+        DashboardStackingLayers.canvasSelectedComponent,
+      ).toBeGreaterThanOrEqual(appHeaderZIndex());
+    });
+  });
+});