@oneuptime/common 11.5.8 → 11.5.10

package/Tests/Server/Services/NetworkDeviceOwnerServices.test.ts

@@ -0,0 +1,260 @@
+import { afterEach, describe, expect, test } from "@jest/globals";
+import NetworkDeviceOwnerUserService, {
+  NetworkDeviceOwners,
+} from "../../../Server/Services/NetworkDeviceOwnerUserService";
+import NetworkDeviceOwnerTeamService from "../../../Server/Services/NetworkDeviceOwnerTeamService";
+import NetworkDeviceOwnerUser from "../../../Models/DatabaseModels/NetworkDeviceOwnerUser";
+import NetworkDeviceOwnerTeam from "../../../Models/DatabaseModels/NetworkDeviceOwnerTeam";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorSteps from "../../../Types/Monitor/MonitorSteps";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * getDeviceOwnersForMonitor fans a NetworkDevice's owner users/teams into
+ * monitor-created incidents/alerts and the owner-added notification job. The
+ * device id lives buried in monitor step config, so these tests pin the step
+ * selection rules (prefer the step that produced the probe response, fall
+ * back to the first device-referencing step), the no-device fast path that
+ * must not touch the database, and the shape/filtering of the returned id
+ * arrays. Database access is mocked at the findBy level.
+ */
+
+const DEVICE_A: string = "8f2c1f0e-0000-4000-8000-0000000000aa";
+const DEVICE_B: string = "8f2c1f0e-0000-4000-8000-0000000000bb";
+
+function buildStep(networkDeviceId?: string): MonitorStep {
+  const step: MonitorStep = new MonitorStep();
+
+  if (networkDeviceId) {
+    step.data = {
+      ...step.data,
+      networkDeviceMonitor: {
+        networkDeviceId: networkDeviceId,
+      },
+    } as MonitorStep["data"];
+  }
+
+  return step;
+}
+
+function buildMonitor(steps: Array<MonitorStep>): Monitor {
+  const monitorSteps: MonitorSteps = new MonitorSteps();
+  monitorSteps.data = {
+    monitorStepsInstanceArray: steps,
+    defaultMonitorStatusId: undefined,
+  };
+
+  const monitor: Monitor = new Monitor();
+  monitor.monitorSteps = monitorSteps;
+
+  return monitor;
+}
+
+function ownerUserRow(userId?: ObjectID): NetworkDeviceOwnerUser {
+  const row: NetworkDeviceOwnerUser = new NetworkDeviceOwnerUser();
+  if (userId) {
+    row.userId = userId;
+  }
+  return row;
+}
+
+function ownerTeamRow(teamId?: ObjectID): NetworkDeviceOwnerTeam {
+  const row: NetworkDeviceOwnerTeam = new NetworkDeviceOwnerTeam();
+  if (teamId) {
+    row.teamId = teamId;
+  }
+  return row;
+}
+
+function mockOwnerRows(options?: {
+  users?: Array<NetworkDeviceOwnerUser> | undefined;
+  teams?: Array<NetworkDeviceOwnerTeam> | undefined;
+}): {
+  userFindBy: jest.SpyInstance;
+  teamFindBy: jest.SpyInstance;
+} {
+  const userFindBy: jest.SpyInstance = jest
+    .spyOn(NetworkDeviceOwnerUserService, "findBy")
+    .mockResolvedValue(options?.users || []);
+  const teamFindBy: jest.SpyInstance = jest
+    .spyOn(NetworkDeviceOwnerTeamService, "findBy")
+    .mockResolvedValue(options?.teams || []);
+
+  return { userFindBy: userFindBy, teamFindBy: teamFindBy };
+}
+
+function queriedDeviceId(spy: jest.SpyInstance): string | undefined {
+  return spy.mock.calls[0]?.[0]?.query?.networkDeviceId?.toString();
+}
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("NetworkDeviceOwnerUserService.getDeviceOwnersForMonitor — no-device fast path", () => {
+  test("a monitor with no steps returns empty owners without touching the database", async () => {
+    const { userFindBy, teamFindBy } = mockOwnerRows();
+
+    const owners: NetworkDeviceOwners =
+      await NetworkDeviceOwnerUserService.getDeviceOwnersForMonitor({
+        monitor: buildMonitor([]),
+      });
+
+    expect(owners).toEqual({ ownerUserIds: [], ownerTeamIds: [] });
+    expect(userFindBy).not.toHaveBeenCalled();
+    expect(teamFindBy).not.toHaveBeenCalled();
+  });
+
+  test("a monitor with no monitorSteps object at all behaves the same", async () => {
+    const { userFindBy, teamFindBy } = mockOwnerRows();
+
+    const owners: NetworkDeviceOwners =
+      await NetworkDeviceOwnerUserService.getDeviceOwnersForMonitor({
+        monitor: new Monitor(),
+      });
+
+    expect(owners).toEqual({ ownerUserIds: [], ownerTeamIds: [] });
+    expect(userFindBy).not.toHaveBeenCalled();
+    expect(teamFindBy).not.toHaveBeenCalled();
+  });
+
+  test("steps that reference no device return empty owners without queries", async () => {
+    const { userFindBy, teamFindBy } = mockOwnerRows();
+
+    const owners: NetworkDeviceOwners =
+      await NetworkDeviceOwnerUserService.getDeviceOwnersForMonitor({
+        monitor: buildMonitor([buildStep(), buildStep()]),
+      });
+
+    expect(owners).toEqual({ ownerUserIds: [], ownerTeamIds: [] });
+    expect(userFindBy).not.toHaveBeenCalled();
+    expect(teamFindBy).not.toHaveBeenCalled();
+  });
+});
+
+describe("NetworkDeviceOwnerUserService.getDeviceOwnersForMonitor — step selection", () => {
+  test("the step that produced the probe response is preferred", async () => {
+    const stepA: MonitorStep = buildStep(DEVICE_A);
+    const stepB: MonitorStep = buildStep(DEVICE_B);
+    const { userFindBy, teamFindBy } = mockOwnerRows();
+
+    await NetworkDeviceOwnerUserService.getDeviceOwnersForMonitor({
+      monitor: buildMonitor([stepA, stepB]),
+      monitorStepId: stepB.id.toString(),
+    });
+
+    expect(queriedDeviceId(userFindBy)).toBe(DEVICE_B);
+    expect(queriedDeviceId(teamFindBy)).toBe(DEVICE_B);
+  });
+
+  test("a monitorStepId matching no step falls back to the first device-referencing step", async () => {
+    const stepA: MonitorStep = buildStep(DEVICE_A);
+    const stepB: MonitorStep = buildStep(DEVICE_B);
+    const { userFindBy } = mockOwnerRows();
+
+    await NetworkDeviceOwnerUserService.getDeviceOwnersForMonitor({
+      monitor: buildMonitor([stepA, stepB]),
+      monitorStepId: ObjectID.generate().toString(),
+    });
+
+    expect(queriedDeviceId(userFindBy)).toBe(DEVICE_A);
+  });
+
+  test("a matching step without device config falls back to the device-referencing step", async () => {
+    const stepWithoutDevice: MonitorStep = buildStep();
+    const stepWithDevice: MonitorStep = buildStep(DEVICE_B);
+    const { userFindBy } = mockOwnerRows();
+
+    await NetworkDeviceOwnerUserService.getDeviceOwnersForMonitor({
+      monitor: buildMonitor([stepWithoutDevice, stepWithDevice]),
+      monitorStepId: stepWithoutDevice.id.toString(),
+    });
+
+    expect(queriedDeviceId(userFindBy)).toBe(DEVICE_B);
+  });
+
+  test("callers without a step id pick up owners from the first device-referencing step", async () => {
+    const stepWithoutDevice: MonitorStep = buildStep();
+    const stepWithDevice: MonitorStep = buildStep(DEVICE_A);
+    const { userFindBy } = mockOwnerRows();
+
+    await NetworkDeviceOwnerUserService.getDeviceOwnersForMonitor({
+      monitor: buildMonitor([stepWithoutDevice, stepWithDevice]),
+    });
+
+    expect(queriedDeviceId(userFindBy)).toBe(DEVICE_A);
+  });
+});
+
+describe("NetworkDeviceOwnerUserService.getDeviceOwnersForMonitor — returned owners", () => {
+  test("owner user and team ids come back from the mocked rows", async () => {
+    const userId1: ObjectID = ObjectID.generate();
+    const userId2: ObjectID = ObjectID.generate();
+    const teamId: ObjectID = ObjectID.generate();
+
+    mockOwnerRows({
+      users: [ownerUserRow(userId1), ownerUserRow(userId2)],
+      teams: [ownerTeamRow(teamId)],
+    });
+
+    const owners: NetworkDeviceOwners =
+      await NetworkDeviceOwnerUserService.getDeviceOwnersForMonitor({
+        monitor: buildMonitor([buildStep(DEVICE_A)]),
+      });
+
+    expect(owners.ownerUserIds.map(String)).toEqual([
+      userId1.toString(),
+      userId2.toString(),
+    ]);
+    expect(owners.ownerTeamIds.map(String)).toEqual([teamId.toString()]);
+  });
+
+  test("rows missing their user/team id are filtered out of the result", async () => {
+    const userId: ObjectID = ObjectID.generate();
+    const teamId: ObjectID = ObjectID.generate();
+
+    mockOwnerRows({
+      users: [ownerUserRow(), ownerUserRow(userId)],
+      teams: [ownerTeamRow(teamId), ownerTeamRow()],
+    });
+
+    const owners: NetworkDeviceOwners =
+      await NetworkDeviceOwnerUserService.getDeviceOwnersForMonitor({
+        monitor: buildMonitor([buildStep(DEVICE_A)]),
+      });
+
+    expect(owners.ownerUserIds.map(String)).toEqual([userId.toString()]);
+    expect(owners.ownerTeamIds.map(String)).toEqual([teamId.toString()]);
+  });
+
+  test("a device with no owners at all yields empty arrays (not undefined)", async () => {
+    const { userFindBy, teamFindBy } = mockOwnerRows();
+
+    const owners: NetworkDeviceOwners =
+      await NetworkDeviceOwnerUserService.getDeviceOwnersForMonitor({
+        monitor: buildMonitor([buildStep(DEVICE_A)]),
+        monitorStepId: undefined,
+      });
+
+    expect(owners.ownerUserIds).toEqual([]);
+    expect(owners.ownerTeamIds).toEqual([]);
+    // The device IS referenced, so both ownership tables are consulted once.
+    expect(userFindBy).toHaveBeenCalledTimes(1);
+    expect(teamFindBy).toHaveBeenCalledTimes(1);
+  });
+
+  test("both queries are scoped to the referenced device id", async () => {
+    const { userFindBy, teamFindBy } = mockOwnerRows();
+
+    await NetworkDeviceOwnerUserService.getDeviceOwnersForMonitor({
+      monitor: buildMonitor([buildStep(DEVICE_A)]),
+    });
+
+    expect(queriedDeviceId(userFindBy)).toBe(DEVICE_A);
+    expect(queriedDeviceId(teamFindBy)).toBe(DEVICE_A);
+    expect(
+      userFindBy.mock.calls[0]?.[0]?.query?.networkDeviceId,
+    ).toBeInstanceOf(ObjectID);
+  });
+});

package/Tests/Server/Services/StatusPageServiceMcp.test.ts

@@ -0,0 +1,223 @@
+/**
+ * StatusPageService MCP gate tests.
+ *
+ * resolveStatusPageIdOrNull and isMcpServerEnabled back the unauthenticated
+ * public status page MCP tools, so their contract is security-relevant:
+ * - a status page that does not exist and one that has MCP turned off must be
+ *   indistinguishable to the caller (otherwise the tools become a status page
+ *   enumeration oracle)
+ * - a database failure must propagate rather than collapse into "disabled", so
+ *   an outage is reported as an error instead of being silently reported as an
+ *   owner's privacy choice
+ *
+ * Both services' findOneBy are spied on, so no database is touched.
+ */
+
+import StatusPageService from "../../../Server/Services/StatusPageService";
+import StatusPageDomainService from "../../../Server/Services/StatusPageDomainService";
+import StatusPage from "../../../Models/DatabaseModels/StatusPage";
+import StatusPageDomain from "../../../Models/DatabaseModels/StatusPageDomain";
+import ObjectID from "../../../Types/ObjectID";
+import { afterEach, describe, expect, test, jest } from "@jest/globals";
+
+const VALID_UUID: string = "550e8400-e29b-41d4-a716-446655440000";
+const DOMAIN: string = "status.company.com";
+
+function statusPageDomainWith(statusPageId: ObjectID | null): StatusPageDomain {
+  return {
+    statusPageId: statusPageId ?? undefined,
+  } as unknown as StatusPageDomain;
+}
+
+function statusPageRow(): StatusPage {
+  return { _id: VALID_UUID } as unknown as StatusPage;
+}
+
+function spyOnStatusPageFindOneBy(): jest.SpyInstance {
+  return jest.spyOn(
+    StatusPageService,
+    "findOneBy",
+  ) as unknown as jest.SpyInstance;
+}
+
+function spyOnDomainFindOneBy(): jest.SpyInstance {
+  return jest.spyOn(
+    StatusPageDomainService,
+    "findOneBy",
+  ) as unknown as jest.SpyInstance;
+}
+
+describe("StatusPageService MCP gate", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("resolveStatusPageIdOrNull", () => {
+    test("resolves a UUID without querying the domain table", async () => {
+      const domainSpy: jest.SpyInstance = spyOnDomainFindOneBy();
+
+      const result: ObjectID | null =
+        await StatusPageService.resolveStatusPageIdOrNull(VALID_UUID);
+
+      expect(result?.toString()).toBe(VALID_UUID);
+      expect(domainSpy).not.toHaveBeenCalled();
+    });
+
+    test("looks a domain up by fullDomain, requiring a verified domain", async () => {
+      const statusPageId: ObjectID = new ObjectID(VALID_UUID);
+      const domainSpy: jest.SpyInstance =
+        spyOnDomainFindOneBy().mockResolvedValue(
+          statusPageDomainWith(statusPageId) as never,
+        );
+
+      const result: ObjectID | null =
+        await StatusPageService.resolveStatusPageIdOrNull(DOMAIN);
+
+      expect(result?.toString()).toBe(VALID_UUID);
+
+      const args: Record<string, any> = domainSpy.mock.calls[0]![0] as Record<
+        string,
+        any
+      >;
+
+      expect(args["query"]["fullDomain"]).toBe(DOMAIN);
+      expect(args["query"]["domain"]).toEqual({ isVerified: true });
+      expect(args["props"]["isRoot"]).toBe(true);
+    });
+
+    test("returns null when the domain is not registered", async () => {
+      spyOnDomainFindOneBy().mockResolvedValue(null as never);
+
+      await expect(
+        StatusPageService.resolveStatusPageIdOrNull(DOMAIN),
+      ).resolves.toBeNull();
+    });
+
+    test("returns null when the domain row carries no status page", async () => {
+      spyOnDomainFindOneBy().mockResolvedValue(
+        statusPageDomainWith(null) as never,
+      );
+
+      await expect(
+        StatusPageService.resolveStatusPageIdOrNull(DOMAIN),
+      ).resolves.toBeNull();
+    });
+
+    test("returns null for an empty identifier without querying", async () => {
+      const domainSpy: jest.SpyInstance = spyOnDomainFindOneBy();
+
+      await expect(
+        StatusPageService.resolveStatusPageIdOrNull(""),
+      ).resolves.toBeNull();
+      expect(domainSpy).not.toHaveBeenCalled();
+    });
+
+    test("returns null for a malformed UUID rather than throwing", async () => {
+      await expect(
+        StatusPageService.resolveStatusPageIdOrNull("not-a-uuid"),
+      ).resolves.toBeNull();
+    });
+
+    test("returns null for a dotless hostname", async () => {
+      /*
+       * The dot is the discriminator, mirroring resolveStatusPageIdOrThrow in
+       * StatusPageAPI. "localhost" therefore goes down the UUID path and fails
+       * there. Pinned so the two resolvers cannot silently diverge.
+       */
+      await expect(
+        StatusPageService.resolveStatusPageIdOrNull("localhost"),
+      ).resolves.toBeNull();
+    });
+  });
+
+  describe("isMcpServerEnabled", () => {
+    test("is true when a UUID matches a status page with MCP enabled", async () => {
+      spyOnStatusPageFindOneBy().mockResolvedValue(statusPageRow() as never);
+
+      await expect(
+        StatusPageService.isMcpServerEnabled(VALID_UUID),
+      ).resolves.toBe(true);
+    });
+
+    test("is false when the status page has MCP disabled", async () => {
+      /*
+       * The enableMcpServer predicate is in the query, so a gated page simply
+       * does not match.
+       */
+      spyOnStatusPageFindOneBy().mockResolvedValue(null as never);
+
+      await expect(
+        StatusPageService.isMcpServerEnabled(VALID_UUID),
+      ).resolves.toBe(false);
+    });
+
+    test("folds the flag into the query and reads as root", async () => {
+      const spy: jest.SpyInstance =
+        spyOnStatusPageFindOneBy().mockResolvedValue(statusPageRow() as never);
+
+      await StatusPageService.isMcpServerEnabled(VALID_UUID);
+
+      const args: Record<string, any> = spy.mock.calls[0]![0] as Record<
+        string,
+        any
+      >;
+
+      expect(args["query"]["enableMcpServer"]).toBe(true);
+      expect(args["query"]["_id"].toString()).toBe(VALID_UUID);
+      expect(args["props"]["isRoot"]).toBe(true);
+    });
+
+    test("resolves a domain and then checks the flag", async () => {
+      spyOnDomainFindOneBy().mockResolvedValue(
+        statusPageDomainWith(new ObjectID(VALID_UUID)) as never,
+      );
+      const pageSpy: jest.SpyInstance =
+        spyOnStatusPageFindOneBy().mockResolvedValue(statusPageRow() as never);
+
+      await expect(StatusPageService.isMcpServerEnabled(DOMAIN)).resolves.toBe(
+        true,
+      );
+      expect(pageSpy).toHaveBeenCalledTimes(1);
+    });
+
+    test("is false for an unknown status page, without a second query", async () => {
+      spyOnDomainFindOneBy().mockResolvedValue(null as never);
+      const pageSpy: jest.SpyInstance = spyOnStatusPageFindOneBy();
+
+      await expect(StatusPageService.isMcpServerEnabled(DOMAIN)).resolves.toBe(
+        false,
+      );
+      expect(pageSpy).not.toHaveBeenCalled();
+    });
+
+    test("is false for an unresolvable identifier", async () => {
+      await expect(
+        StatusPageService.isMcpServerEnabled("not-a-uuid"),
+      ).resolves.toBe(false);
+    });
+
+    test("propagates a status page query failure instead of reporting disabled", async () => {
+      /*
+       * Fails closed either way, but the caller reports an error rather than
+       * telling the agent the owner turned MCP off.
+       */
+      spyOnStatusPageFindOneBy().mockRejectedValue(
+        new Error("connection terminated") as never,
+      );
+
+      await expect(
+        StatusPageService.isMcpServerEnabled(VALID_UUID),
+      ).rejects.toThrow("connection terminated");
+    });
+
+    test("propagates a domain query failure", async () => {
+      spyOnDomainFindOneBy().mockRejectedValue(
+        new Error("connection terminated") as never,
+      );
+
+      await expect(
+        StatusPageService.isMcpServerEnabled(DOMAIN),
+      ).rejects.toThrow("connection terminated");
+    });
+  });
+});

package/Tests/Server/Services/TelemetryExceptionAIFixReadiness.test.ts

@@ -1,7 +1,8 @@
-import TelemetryExceptionService, {
+import TelemetryExceptionService from "../../../Server/Services/TelemetryExceptionService";
+import {
   AIFixReadiness,
   AIFixReadinessCheck,
-} from "../../../Server/Services/TelemetryExceptionService";
+} from "../../../Types/AI/AIFixReadiness";
 import FixRunBudget from "../../../Server/Utils/AI/CodeFix/FixRunBudget";
 import LlmProviderService from "../../../Server/Services/LlmProviderService";
 import ProjectService from "../../../Server/Services/ProjectService";
@@ -19,7 +20,8 @@ import AIAgent, {
 import BadDataException from "../../../Types/Exception/BadDataException";
 import ObjectID from "../../../Types/ObjectID";
 import OneUptimeDate from "../../../Types/Date";
-import { describe, expect, test, afterEach } from "@jest/globals";
+import AIService from "../../../Server/Services/AIService";
+import { describe, expect, test, afterEach, beforeEach } from "@jest/globals";
 
 /*
  * "Fix with AI Agent" readiness: every prerequisite is checked BEFORE a task
@@ -121,7 +123,24 @@ function getCheck(readiness: AIFixReadiness, id: string): AIFixReadinessCheck {
   return check!;
 }
 
+/*
+ * The llmProvider check also gates on the daily autonomous token budget
+ * (AI_CODE_FIX_FEATURE is autonomous, so executeWithLogging enforces it).
+ * Default it to unset — these suites are about the other fail conditions.
+ */
+function mockBudgetNotExhausted(): void {
+  jest.spyOn(AIService, "getAutonomousDailyBudgetStatus").mockResolvedValue({
+    exhausted: false,
+    limitInTokens: null,
+    usedTokensToday: 0,
+  });
+}
+
 describe("TelemetryExceptionService.getAIFixReadiness", () => {
+  beforeEach(() => {
+    mockBudgetNotExhausted();
+  });
+
   afterEach(() => {
     jest.restoreAllMocks();
   });
@@ -237,6 +256,10 @@ describe("TelemetryExceptionService.getAIFixReadiness", () => {
  * and free-global providers consume no balance and must never require one.
  */
 describe("TelemetryExceptionService.getAIFixReadiness — AI balance gate", () => {
+  beforeEach(() => {
+    mockBudgetNotExhausted();
+  });
+
   afterEach(() => {
     jest.restoreAllMocks();
   });

package/Tests/Server/Services/TelemetryExceptionCodeFixRun.test.ts

@@ -1,4 +1,5 @@
 import TelemetryExceptionService from "../../../Server/Services/TelemetryExceptionService";
+import AIService from "../../../Server/Services/AIService";
 import FixRunBudget from "../../../Server/Utils/AI/CodeFix/FixRunBudget";
 import LlmProviderService from "../../../Server/Services/LlmProviderService";
 import ServiceService from "../../../Server/Services/ServiceService";
@@ -79,6 +80,17 @@ function mockReadinessOk(): void {
     name: "agent",
     connectionStatus: AIAgentConnectionStatus.Connected,
   } as unknown as AIAgent);
+  /*
+   * The llmProvider check also gates on the daily autonomous token budget
+   * (AI_CODE_FIX_FEATURE is autonomous, so executeWithLogging enforces it).
+   * Default it to unset — this suite is about the duplicate guard, and the
+   * budget has its own suite (AIServiceDailyBudget.test.ts).
+   */
+  jest.spyOn(AIService, "getAutonomousDailyBudgetStatus").mockResolvedValue({
+    exhausted: false,
+    limitInTokens: null,
+    usedTokensToday: 0,
+  });
 }
 
 describe("TelemetryExceptionService.createCodeFixRunForException", () => {

package/Tests/Server/Types/Markdown.test.ts

@@ -0,0 +1,106 @@
+import Markdown from "../../../Server/Types/Markdown";
+
+/*
+ * slugify turns a heading into the `id` the docs renderer emits, and therefore
+ * into the target every in-page `](#anchor)` link has to match. These tests pin
+ * the two properties that are easy to break by accident:
+ *
+ *   - non-ASCII scripts must survive (they used to be stripped to an empty id,
+ *     which silently 404'd every anchor in the ru/ja/ko/hi/zh docs), and
+ *   - existing English ids must not move, because they are published URLs.
+ */
+describe("Markdown.slugify", () => {
+  describe("English headings keep their existing ids", () => {
+    test.each([
+      [
+        "Reducing the Volume of Data Collected",
+        "reducing-the-volume-of-data-collected",
+      ],
+      ["Filtering by Log Severity", "filtering-by-log-severity"],
+      ["Step 1 — Install the Collector", "step-1-install-the-collector"],
+      ["What's New?", "whats-new"],
+      ["Namespace Filtering", "namespace-filtering"],
+    ])("%s", (heading: string, expected: string) => {
+      expect(Markdown.slugify(heading)).toBe(expected);
+    });
+  });
+
+  /*
+   * \p{L}/\p{N} do not match "_", so it is listed explicitly in the character
+   * class. The old `\w` matched it. These are real headings — dropping the
+   * underscore would change ids that are already linked to.
+   */
+  describe("underscores are preserved", () => {
+    test.each([
+      [
+        "`ceph_health_status` is 1 but no incident fires",
+        "ceph_health_status-is-1-but-no-incident-fires",
+      ],
+      [
+        "Counters like `pve_network_receive_bytes` only ever grow",
+        "counters-like-pve_network_receive_bytes-only-ever-grow",
+      ],
+    ])("%s", (heading: string, expected: string) => {
+      expect(Markdown.slugify(heading)).toBe(expected);
+    });
+  });
+
+  describe("non-Latin scripts produce a usable id, not an empty one", () => {
+    test.each([
+      ["Фильтрация по важности логов", "фильтрация-по-важности-логов"],
+      ["ログの重大度によるフィルタリング", "ログの重大度によるフィルタリング"],
+      ["按日志严重性过滤", "按日志严重性过滤"],
+      ["로그 심각도별 필터링", "로그-심각도별-필터링"],
+      [
+        "लॉग गंभीरता के अनुसार फ़िल्टर करना",
+        "लॉग-गंभीरता-के-अनुसार-फ़िल्टर-करना",
+      ],
+    ])("%s", (heading: string, expected: string) => {
+      const slug: string = Markdown.slugify(heading);
+      expect(slug).not.toBe("");
+      expect(slug).toBe(expected);
+    });
+  });
+
+  describe("accented Latin keeps the accented letter", () => {
+    test.each([
+      [
+        "Filtrage par gravité des journaux",
+        "filtrage-par-gravité-des-journaux",
+      ],
+      [
+        "Reduktion af mængden af indsamlede data",
+        "reduktion-af-mængden-af-indsamlede-data",
+      ],
+      ["Fehlerbehebung für Größen", "fehlerbehebung-für-größen"],
+    ])("%s", (heading: string, expected: string) => {
+      expect(Markdown.slugify(heading)).toBe(expected);
+    });
+  });
+
+  describe("markup and punctuation are still stripped", () => {
+    test("strips inline HTML tags", () => {
+      expect(Markdown.slugify("A <em>heading</em> here")).toBe(
+        "a-heading-here",
+      );
+    });
+
+    test("strips HTML entities", () => {
+      expect(Markdown.slugify("Tom &amp; Jerry")).toBe("tom-jerry");
+    });
+
+    test("strips punctuation but keeps hyphens", () => {
+      expect(Markdown.slugify("Set up SSO (SAML): step-by-step!")).toBe(
+        "set-up-sso-saml-step-by-step",
+      );
+    });
+
+    test("collapses whitespace runs and trims leading/trailing hyphens", () => {
+      expect(Markdown.slugify("  spaced   out  ")).toBe("spaced-out");
+    });
+
+    test("emoji are dropped rather than becoming part of the id", () => {
+      expect(Markdown.slugify("🚀 Getting Started")).toBe("getting-started");
+    });
+  });
+});