@oneuptime/common 13.0.6 → 13.0.7

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

@@ -0,0 +1,301 @@
+import {
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import "@testing-library/jest-dom";
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  within,
+} from "@testing-library/react";
+import { createInstance, i18n } from "i18next";
+import React from "react";
+import { I18nextProvider, initReactI18next } from "react-i18next";
+import DashboardNavbar from "../../../../App/FeatureSet/Dashboard/src/Components/NavBar/NavBar";
+import englishLocale from "../../../../App/FeatureSet/Dashboard/src/Locales/en.json";
+import frenchLocale from "../../../../App/FeatureSet/Dashboard/src/Locales/fr.json";
+import PageMap from "../../../../App/FeatureSet/Dashboard/src/Utils/PageMap";
+import Route from "../../../Types/API/Route";
+import Navigation from "../../../UI/Utils/Navigation";
+import {
+  DESKTOP_WIDTH,
+  PROJECT_ID,
+  goTo,
+  routeFor,
+  setViewportWidth,
+} from "./SideMenuHarness";
+
+/*
+ * Render the dashboard's actual NavBar, catalog, translations and search modal.
+ * Fixtures carrying their own aliases would let the shared search component
+ * pass while the real products still lacked the words users search for.
+ */
+const translation: i18n = createInstance();
+const ORIGINAL_WIDTH: number = window.innerWidth;
+const OTHER_PROJECT_ID: string = "7d2a1b3c-4d5e-4f60-9a7b-1c2d3e4f5a6b";
+
+const SEARCH_CASES: Array<[string, string, string]> = [
+  ["synthetic monitoring", "Monitors", PageMap.MONITORS],
+  ["statuspage", "Status Pages", PageMap.STATUS_PAGES],
+  ["outage", "Incidents", PageMap.INCIDENTS],
+  ["alarms", "Alerts", PageMap.ALERTS],
+  [
+    "planned downtime",
+    "Scheduled Maintenance",
+    PageMap.SCHEDULED_MAINTENANCE_EVENTS,
+  ],
+  ["syslog", "Logs", PageMap.LOGS],
+  ["prometheus", "Metrics", PageMap.METRICS],
+  ["error tracking", "Exceptions", PageMap.EXCEPTIONS],
+  ["genai", "AI / LLM", PageMap.LLM],
+  ["copilot", "Chat", PageMap.AI_COPILOT],
+  ["ai agents", "Tasks", PageMap.AI_AGENT_TASKS],
+  ["source code", "Code Repositories", PageMap.CODE_REPOSITORY],
+  ["dependency map", "Topology", PageMap.TOPOLOGY],
+  ["cmdb", "Inventory", PageMap.INVENTORY],
+  ["container monitoring", "Docker", PageMap.DOCKER_HOSTS],
+  ["rootless containers", "Podman", PageMap.PODMAN_HOSTS],
+  ["pve", "Proxmox", PageMap.PROXMOX_CLUSTERS],
+  ["vsphere", "VMware", PageMap.VMWARE_VCENTERS],
+  ["internet of things", "IoT", PageMap.IOT_FLEETS],
+  ["rados", "Ceph", PageMap.CEPH_CLUSTERS],
+  ["container orchestration", "Docker Swarm", PageMap.DOCKER_SWARM_CLUSTERS],
+  ["linux", "Hosts", PageMap.HOSTS],
+  ["widgets", "Dashboards", PageMap.DASHBOARDS],
+  ["integrations", "Workflows", PageMap.WORKFLOWS],
+  ["playbooks", "Runbooks", PageMap.RUNBOOKS],
+  ["teammates", "Users", PageMap.USERS],
+  ["departments", "Teams", PageMap.TEAMS],
+  ["api keys", "Project Settings", PageMap.SETTINGS],
+  ["RUM", "Real User Monitoring", PageMap.RUM_APPLICATIONS],
+  ["frontend", "Real User Monitoring", PageMap.RUM_APPLICATIONS],
+  ["front end", "Real User Monitoring", PageMap.RUM_APPLICATIONS],
+  ["web vitals", "Real User Monitoring", PageMap.RUM_APPLICATIONS],
+  ["session replay", "Real User Monitoring", PageMap.RUM_APPLICATIONS],
+  ["user experience", "Real User Monitoring", PageMap.RUM_APPLICATIONS],
+  ["k8s", "Kubernetes", PageMap.KUBERNETES_CLUSTERS],
+  ["kubectl", "Kubernetes", PageMap.KUBERNETES_CLUSTERS],
+  ["pods", "Kubernetes", PageMap.KUBERNETES_CLUSTERS],
+  ["apm", "Services", PageMap.SERVICES],
+  ["distributed tracing", "Traces", PageMap.TRACES],
+  ["spans", "Traces", PageMap.TRACES],
+  ["otel", "Traces", PageMap.TRACES],
+  ["opentelemetry", "Traces", PageMap.TRACES],
+  ["service level", "SLOs", PageMap.SLOS],
+  ["error budget", "SLOs", PageMap.SLOS],
+  ["siem", "Security Events", PageMap.SECURITY_EVENTS],
+  ["snmp", "Network", PageMap.NETWORK_OVERVIEW],
+  ["flamegraph", "Performance Profiles", PageMap.PROFILES],
+  ["lambda", "Serverless", PageMap.SERVERLESS_FUNCTIONS],
+  ["aws", "Cloud", PageMap.CLOUD_RESOURCES],
+  ["azure", "Cloud", PageMap.CLOUD_RESOURCES],
+  ["gcp", "Cloud", PageMap.CLOUD_RESOURCES],
+  ["oncall", "On-Call Duty", PageMap.ON_CALL_DUTY],
+  ["escalation", "On-Call Duty", PageMap.ON_CALL_DUTY],
+  ["rca", "Insights", PageMap.AI_INSIGHTS],
+];
+
+function navbar(): React.ReactElement {
+  return (
+    <I18nextProvider i18n={translation}>
+      <DashboardNavbar show={true} />
+    </I18nextProvider>
+  );
+}
+
+function openProducts(): void {
+  fireEvent.click(screen.getByRole("button", { name: "Products" }));
+  expect(screen.getByRole("dialog", { name: "Products menu" })).toBeVisible();
+}
+
+function queryFor(value: string): void {
+  fireEvent.change(screen.getByRole("combobox"), {
+    target: { value },
+  });
+}
+
+function productLink(pageMapKey: string): HTMLElement {
+  const href: string = routeFor(pageMapKey);
+  const link: HTMLElement | undefined = within(screen.getByRole("listbox"))
+    .queryAllByRole("link")
+    .find((candidate: HTMLElement): boolean => {
+      return candidate.getAttribute("href") === href;
+    });
+
+  if (!link) {
+    throw new Error(`Search did not expose the product at ${href}.`);
+  }
+
+  return link;
+}
+
+beforeAll(async () => {
+  Element.prototype.scrollIntoView = (): void => {};
+  await translation.use(initReactI18next).init({
+    lng: "en",
+    fallbackLng: "en",
+    resources: {
+      en: { translation: englishLocale },
+      fr: { translation: frenchLocale },
+    },
+    interpolation: { escapeValue: false },
+  });
+});
+
+describe("dashboard product search keywords", () => {
+  beforeEach(async () => {
+    window.localStorage.clear();
+    setViewportWidth(DESKTOP_WIDTH);
+    goTo(`/dashboard/${PROJECT_ID}/home`);
+    await translation.changeLanguage("en");
+    jest.spyOn(Navigation, "navigate").mockImplementation((): void => {});
+  });
+
+  afterEach(() => {
+    cleanup();
+    jest.restoreAllMocks();
+    window.localStorage.clear();
+    setViewportWidth(ORIGINAL_WIDTH);
+  });
+
+  test.each(SEARCH_CASES)(
+    "%j exposes %s at the current project's destination",
+    (query: string, title: string, pageMapKey: string) => {
+      render(navbar());
+      openProducts();
+
+      queryFor(query);
+
+      const link: HTMLElement = productLink(pageMapKey);
+      expect(link).toHaveTextContent(title);
+      expect(link).toHaveAttribute("href", expect.stringContaining(PROJECT_ID));
+      expect(link.getAttribute("href")).not.toContain(":projectId");
+    },
+  );
+
+  test.each([
+    ["  rUm  ", "Real User Monitoring", PageMap.RUM_APPLICATIONS],
+    [" K8S ", "Kubernetes", PageMap.KUBERNETES_CLUSTERS],
+  ])(
+    "%j narrows the real catalog to %s and opens it with Enter",
+    (query: string, title: string, pageMapKey: string) => {
+      render(navbar());
+      openProducts();
+
+      queryFor(query);
+
+      expect(screen.getAllByRole("option")).toHaveLength(1);
+      expect(screen.getByRole("option", { selected: true })).toHaveTextContent(
+        title,
+      );
+      fireEvent.keyDown(screen.getByRole("combobox"), { key: "Enter" });
+
+      expect(Navigation.navigate).toHaveBeenCalledWith(
+        new Route(routeFor(pageMapKey)),
+      );
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    },
+  );
+
+  test("a keyword result can be clicked and appears in recently visited products", () => {
+    render(navbar());
+    openProducts();
+    queryFor("k8s");
+
+    fireEvent.click(productLink(PageMap.KUBERNETES_CLUSTERS));
+
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    expect(Navigation.navigate).toHaveBeenCalledWith(
+      new Route(routeFor(PageMap.KUBERNETES_CLUSTERS)),
+    );
+
+    openProducts();
+
+    expect(screen.getByRole("combobox")).toHaveValue("");
+    expect(
+      screen.getByRole("heading", { name: "Recently visited" }),
+    ).toBeVisible();
+    expect(screen.getAllByRole("option")[0]).toHaveTextContent("Kubernetes");
+  });
+
+  test("a project switch refreshes keyword results to the newly selected project", () => {
+    const { rerender } = render(navbar());
+    openProducts();
+    queryFor("k8s");
+    expect(productLink(PageMap.KUBERNETES_CLUSTERS)).toHaveAttribute(
+      "href",
+      expect.stringContaining(PROJECT_ID),
+    );
+
+    goTo(`/dashboard/${OTHER_PROJECT_ID}/home`);
+    rerender(navbar());
+
+    expect(screen.getByRole("combobox")).toHaveValue("k8s");
+    const link: HTMLElement = productLink(PageMap.KUBERNETES_CLUSTERS);
+    expect(link).toHaveAttribute(
+      "href",
+      expect.stringContaining(OTHER_PROJECT_ID),
+    );
+    expect(link.getAttribute("href")).not.toContain(PROJECT_ID);
+
+    fireEvent.click(link);
+    expect(Navigation.navigate).toHaveBeenCalledWith(
+      new Route(routeFor(PageMap.KUBERNETES_CLUSTERS)),
+    );
+  });
+
+  test("aliases survive a language switch while visible titles are translated", async () => {
+    render(navbar());
+    openProducts();
+    queryFor("frontend");
+    expect(productLink(PageMap.RUM_APPLICATIONS)).toHaveTextContent(
+      "Real User Monitoring",
+    );
+
+    await act(async () => {
+      await translation.changeLanguage("fr");
+    });
+
+    expect(screen.getByRole("combobox")).toHaveValue("frontend");
+    expect(productLink(PageMap.RUM_APPLICATIONS)).toHaveTextContent(
+      "Surveillance des utilisateurs réels",
+    );
+    expect(screen.queryByText("Real User Monitoring")).not.toBeInTheDocument();
+
+    queryFor("utilisateurs réels");
+    expect(productLink(PageMap.RUM_APPLICATIONS)).toHaveTextContent(
+      "Surveillance des utilisateurs réels",
+    );
+
+    queryFor("k8s");
+    expect(productLink(PageMap.KUBERNETES_CLUSTERS)).toHaveTextContent(
+      "Kubernetes",
+    );
+  });
+
+  test("unrecognized text shows the dashboard's empty state and clearing restores the catalog", () => {
+    render(navbar());
+    openProducts();
+    const initialCount: number = screen.getAllByRole("option").length;
+
+    queryFor("no-such-product-12345");
+
+    expect(screen.getByText("No products found.")).toBeVisible();
+    expect(screen.queryAllByRole("option")).toHaveLength(0);
+
+    fireEvent.click(screen.getByRole("button", { name: "Clear search" }));
+
+    expect(screen.getByRole("combobox")).toHaveFocus();
+    expect(screen.getAllByRole("option")).toHaveLength(initialCount);
+    expect(productLink(PageMap.RUM_APPLICATIONS)).toBeVisible();
+    expect(productLink(PageMap.KUBERNETES_CLUSTERS)).toBeVisible();
+  });
+});

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

@@ -182,7 +182,16 @@ jest.mock("reactflow", () => {
         position: { x: number; y: number };
         data: { label: string; dimmed: boolean; footer?: string };
       }>;
-      edges: Array<{ id: string; label?: string; animated?: boolean }>;
+      edges: Array<{
+        id: string;
+        label?: string;
+        animated?: boolean;
+        labelShowBg?: boolean;
+        labelStyle?: React.CSSProperties;
+        labelBgStyle?: React.CSSProperties;
+        labelBgPadding?: [number, number];
+        labelBgBorderRadius?: number;
+      }>;
       onInit: (value: unknown) => void;
       onNodeClick: (event: React.MouseEvent, node: unknown) => void;
       onEdgeClick: (event: React.MouseEvent, edge: unknown) => void;
@@ -217,12 +226,35 @@ jest.mock("reactflow", () => {
             },
           )}
           {props.edges.map(
-            (edge: { id: string; label?: string; animated?: boolean }) => {
+            (edge: {
+              id: string;
+              label?: string;
+              animated?: boolean;
+              labelShowBg?: boolean;
+              labelStyle?: React.CSSProperties;
+              labelBgStyle?: React.CSSProperties;
+              labelBgPadding?: [number, number];
+              labelBgBorderRadius?: number;
+            }) => {
               return (
                 <button
                   key={edge.id}
                   data-testid={`map-edge-${edge.id}`}
                   data-animated={String(edge.animated)}
+                  data-label-show-background={String(edge.labelShowBg)}
+                  data-label-color={String(edge.labelStyle?.fill || "")}
+                  data-label-background={String(edge.labelBgStyle?.fill || "")}
+                  data-label-background-opacity={String(
+                    edge.labelBgStyle?.fillOpacity || "",
+                  )}
+                  data-label-border={String(edge.labelBgStyle?.stroke || "")}
+                  data-label-border-width={String(
+                    edge.labelBgStyle?.strokeWidth || "",
+                  )}
+                  data-label-padding={edge.labelBgPadding?.join(",") || ""}
+                  data-label-border-radius={String(
+                    edge.labelBgBorderRadius || "",
+                  )}
                   onClick={(event: React.MouseEvent) => {
                     props.onEdgeClick(event, edge);
                   }}
@@ -588,6 +620,46 @@ describe("connections", () => {
     );
   });
 
+  test("connection metric chips use theme-aware readable styling", async () => {
+    await renderGraph();
+
+    const expectReadableMetricChip: (connection: HTMLElement) => void = (
+      connection: HTMLElement,
+    ): void => {
+      expect(connection).toHaveAttribute("data-label-show-background", "true");
+      expect(connection).toHaveAttribute(
+        "data-label-color",
+        "var(--ou-text-secondary, #4b5563)",
+      );
+      expect(connection).toHaveAttribute(
+        "data-label-background",
+        "var(--ou-surface-primary, #ffffff)",
+      );
+      expect(connection).toHaveAttribute("data-label-background-opacity", "1");
+      expect(connection).toHaveAttribute(
+        "data-label-border",
+        "var(--ou-border-default, #e5e7eb)",
+      );
+      expect(connection).toHaveAttribute("data-label-border-width", "1");
+      expect(connection).toHaveAttribute("data-label-padding", "6,3");
+      expect(connection).toHaveAttribute("data-label-border-radius", "6");
+    };
+
+    const hoveredConnection: HTMLElement =
+      screen.getByTestId("map-edge-web->api");
+    fireEvent.mouseEnter(hoveredConnection);
+    expect(hoveredConnection).toHaveTextContent("600/min");
+    expectReadableMetricChip(hoveredConnection);
+
+    for (const metric of ["calls", "errors", "latency"]) {
+      fireEvent.change(
+        screen.getByRole("combobox", { name: "Connection labels" }),
+        { target: { value: metric } },
+      );
+      expectReadableMetricChip(screen.getByTestId("map-edge-api->postgres"));
+    }
+  });
+
   test("service and connection drawers are exclusive", async () => {
     await renderGraph();
     fireEvent.click(screen.getByTestId("map-node-api"));

package/Tests/App/Dashboard/TextClampLayoutHarness.ts

@@ -0,0 +1,224 @@
+import { jest } from "@jest/globals";
+import type { SpyInstance } from "jest-mock";
+import { act } from "react";
+
+/*
+ * A stand-in for the browser layout that DiscoveryScanStatusMessage measures.
+ *
+ * jsdom lays nothing out: every scrollHeight and clientHeight is 0, computed
+ * styles carry no Tailwind, and there is no ResizeObserver. This harness gives
+ * the message paragraph just enough of a layout to be measured the way a
+ * browser measures it:
+ *
+ * - the text wraps into ceil(length / charactersPerLine) lines, so the column's
+ *   width is a characters-per-line figure a test can change mid-test;
+ * - scrollHeight is the whole text's height, clamped or not;
+ * - clientHeight is the painted height, which `line-clamp-2` caps at two lines;
+ * - getComputedStyle reports the line-height the test chose;
+ * - ResizeObserver callbacks run when the test says the layout changed.
+ *
+ * Only the message paragraph is laid out — a <p> that carries an id, which is
+ * what the toggle's aria-controls points at. Everything else keeps jsdom's
+ * zeroes, so the rest of a rendered page behaves exactly as it did.
+ *
+ * The real-browser check of the same behaviour is E2E/Discovery.
+ */
+
+export const LINE_HEIGHT_IN_PIXELS: number = 20;
+
+export interface TextClampLayoutOptions {
+  charactersPerLine: number;
+  // False leaves the page without a ResizeObserver, as jsdom has.
+  withResizeObserver?: boolean | undefined;
+}
+
+export interface TextClampLayout {
+  setCharactersPerLine: (count: number) => void;
+  // The computed line-height, e.g. "20px" or "normal".
+  setLineHeight: (value: string) => void;
+  // A hidden element (display: none) has no size at all.
+  setHidden: (isHidden: boolean) => void;
+  // Runs every connected ResizeObserver, as the browser does after a reflow.
+  resize: () => void;
+  observedElements: () => Array<Element>;
+  connectedObserverCount: () => number;
+  createdObserverCount: () => number;
+  restore: () => void;
+}
+
+export function isMeasuredMessage(element: Element): boolean {
+  return element.tagName === "P" && element.id !== "";
+}
+
+export function installTextClampLayout(
+  options: TextClampLayoutOptions,
+): TextClampLayout {
+  let charactersPerLine: number = options.charactersPerLine;
+  let lineHeight: string = `${LINE_HEIGHT_IN_PIXELS}px`;
+  let isHidden: boolean = false;
+
+  const paintedLineHeight: () => number = (): number => {
+    const parsed: number = Number.parseFloat(lineHeight);
+    return Number.isFinite(parsed) && parsed > 0
+      ? parsed
+      : LINE_HEIGHT_IN_PIXELS;
+  };
+
+  const lineCount: (element: Element) => number = (
+    element: Element,
+  ): number => {
+    const length: number = (element.textContent || "").length;
+    return length === 0 ? 0 : Math.ceil(length / charactersPerLine);
+  };
+
+  const scrollHeight: SpyInstance<() => number> = jest
+    .spyOn(Element.prototype, "scrollHeight", "get")
+    .mockImplementation(function (this: Element): number {
+      if (!isMeasuredMessage(this) || isHidden) {
+        return 0;
+      }
+
+      return Math.round(lineCount(this) * paintedLineHeight());
+    });
+
+  const clientHeight: SpyInstance<() => number> = jest
+    .spyOn(Element.prototype, "clientHeight", "get")
+    .mockImplementation(function (this: Element): number {
+      if (!isMeasuredMessage(this) || isHidden) {
+        return 0;
+      }
+
+      const lines: number = this.classList.contains("line-clamp-2")
+        ? Math.min(lineCount(this), 2)
+        : lineCount(this);
+
+      return Math.round(lines * paintedLineHeight());
+    });
+
+  const originalGetComputedStyle: typeof window.getComputedStyle =
+    window.getComputedStyle.bind(window);
+
+  const getComputedStyle: SpyInstance<
+    (element: Element, pseudoElement?: string | null) => CSSStyleDeclaration
+  > = jest
+    .spyOn(window, "getComputedStyle")
+    .mockImplementation((element: Element, pseudoElement?: string | null) => {
+      const style: CSSStyleDeclaration = originalGetComputedStyle(
+        element,
+        pseudoElement,
+      );
+
+      if (!isMeasuredMessage(element)) {
+        return style;
+      }
+
+      return new Proxy(style, {
+        get: (target: CSSStyleDeclaration, property: string | symbol) => {
+          if (property === "lineHeight") {
+            return lineHeight;
+          }
+
+          const value: unknown = Reflect.get(target, property);
+
+          return typeof value === "function" ? value.bind(target) : value;
+        },
+      });
+    });
+
+  interface ObserverRecord {
+    instance: ResizeObserver;
+    callback: ResizeObserverCallback;
+    observed: Set<Element>;
+    isConnected: boolean;
+  }
+
+  const records: Array<ObserverRecord> = [];
+
+  class TestResizeObserver implements ResizeObserver {
+    private record: ObserverRecord;
+
+    public constructor(callback: ResizeObserverCallback) {
+      this.record = {
+        instance: this,
+        callback: callback,
+        observed: new Set<Element>(),
+        isConnected: true,
+      };
+      records.push(this.record);
+    }
+
+    public observe(target: Element): void {
+      this.record.observed.add(target);
+    }
+
+    public unobserve(target: Element): void {
+      this.record.observed.delete(target);
+    }
+
+    public disconnect(): void {
+      this.record.observed.clear();
+      this.record.isConnected = false;
+    }
+  }
+
+  const originalResizeObserver: PropertyDescriptor | undefined =
+    Object.getOwnPropertyDescriptor(window, "ResizeObserver");
+
+  if (options.withResizeObserver === false) {
+    delete (window as unknown as { ResizeObserver?: unknown }).ResizeObserver;
+  } else {
+    Object.defineProperty(window, "ResizeObserver", {
+      configurable: true,
+      writable: true,
+      value: TestResizeObserver,
+    });
+  }
+
+  const connected: () => Array<ObserverRecord> = (): Array<ObserverRecord> => {
+    return records.filter((record: ObserverRecord): boolean => {
+      return record.isConnected && record.observed.size > 0;
+    });
+  };
+
+  return {
+    setCharactersPerLine: (count: number): void => {
+      charactersPerLine = count;
+    },
+    setLineHeight: (value: string): void => {
+      lineHeight = value;
+    },
+    setHidden: (value: boolean): void => {
+      isHidden = value;
+    },
+    resize: (): void => {
+      act((): void => {
+        for (const record of connected()) {
+          record.callback([], record.instance);
+        }
+      });
+    },
+    observedElements: (): Array<Element> => {
+      return connected().flatMap((record: ObserverRecord): Array<Element> => {
+        return Array.from(record.observed);
+      });
+    },
+    connectedObserverCount: (): number => {
+      return connected().length;
+    },
+    createdObserverCount: (): number => {
+      return records.length;
+    },
+    restore: (): void => {
+      scrollHeight.mockRestore();
+      clientHeight.mockRestore();
+      getComputedStyle.mockRestore();
+
+      if (originalResizeObserver) {
+        Object.defineProperty(window, "ResizeObserver", originalResizeObserver);
+      } else {
+        delete (window as unknown as { ResizeObserver?: unknown })
+          .ResizeObserver;
+      }
+    },
+  };
+}

package/Tests/Models/InventoryItemNaming.test.ts

@@ -152,6 +152,16 @@ describe("the old name is gone from the source tree", () => {
       substring: './TelemetryEntity"',
       onlyUnder: path.join("Server", "Utils", "Telemetry"),
     },
+    /*
+     * The surviving OTel util's own test suite, cited by filename from its
+     * neighbours when they explain which suite covers what. It names the file
+     * that tests Utils/Telemetry/TelemetryEntity, never the renamed model, so
+     * it is scoped to the directory that suite lives in.
+     */
+    {
+      substring: "TelemetryEntity.test.ts",
+      onlyUnder: path.join("Tests", "Server", "Utils", "Telemetry"),
+    },
     { substring: "Jobs/TelemetryEntity/" },
     { substring: '"TelemetryEntity:' },
   ];
@@ -343,6 +353,50 @@ describe("the old name is gone from the source tree", () => {
     ).toBe(true);
   });
 
+  test("the OTel util's test suite can be named by its neighbours", () => {
+    const telemetryTestFile: string = path.join(
+      REPO_ROOT,
+      "Common",
+      "Tests",
+      "Server",
+      "Utils",
+      "Telemetry",
+      "Example.test.ts",
+    );
+    const uiFile: string = path.join(REPO_ROOT, "Common", "UI", "Example.ts");
+
+    expect(
+      hasStaleTelemetryEntityReference(
+        telemetryTestFile,
+        " * TelemetryEntity.test.ts covers the extractor against a hand-built",
+      ),
+    ).toBe(false);
+
+    /*
+     * Scoped, so the filename cannot become a way to smuggle the old name
+     * back in anywhere else, and so a bare use of it inside that same
+     * directory still fails.
+     */
+    expect(
+      hasStaleTelemetryEntityReference(
+        uiFile,
+        " * TelemetryEntity.test.ts covers the extractor.",
+      ),
+    ).toBe(true);
+    expect(
+      hasStaleTelemetryEntityReference(
+        telemetryTestFile,
+        "const value: TelemetryEntity = legacy;",
+      ),
+    ).toBe(true);
+    expect(
+      hasStaleTelemetryEntityReference(
+        telemetryTestFile,
+        "const value: TelemetryEntityService = legacy;",
+      ),
+    ).toBe(true);
+  });
+
   test.each(["Common", "App"])(
     "%s has no stale TelemetryEntity reference",
     (projectDirectory: string) => {