@oneuptime/common 13.0.6 → 13.0.8

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/OnCallCalendarFeedSideMenus.test.tsx

@@ -115,11 +115,19 @@ describe("On-Call Duty side menu - Calendar Feeds item", () => {
       return link.title;
     });
 
+    /*
+     * The two views of the schedules come first - the list and the timeline
+     * of all of them - and the feeds that export them follow directly.
+     */
     expect(titles).toContain("On-Call Schedules");
+    expect(titles).toContain("Schedule Timeline");
     expect(titles).toContain("Calendar Feeds");
-    expect(titles.indexOf("Calendar Feeds")).toBe(
+    expect(titles.indexOf("Schedule Timeline")).toBe(
       titles.indexOf("On-Call Schedules") + 1,
     );
+    expect(titles.indexOf("Calendar Feeds")).toBe(
+      titles.indexOf("Schedule Timeline") + 1,
+    );
 
     const calendarFeeds: MenuLink | undefined = links.find(
       (link: MenuLink): boolean => {

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

@@ -311,38 +311,46 @@ describe("Pay as you go creation notices", () => {
   });
 
   describe("creating a telemetry ingestion key off the Free plan", () => {
-    it("asks for nothing extra on a paid plan", async () => {
-      getJestSpyOn(ProjectUtil, "getCurrentPlan").mockReturnValue(
-        PlanType.Growth,
-      );
-
-      renderIngestionKeyForm();
-
-      await userEvent.type(
-        await screen.findByTestId(
-          "ingestion-key-name",
-          {},
-          { timeout: WAIT_TIMEOUT },
-        ),
-        "Production",
-      );
+    it.each([PlanType.Growth, PlanType.Scale, PlanType.Enterprise])(
+      "creates a key on the %s plan without checking for a payment method",
+      async (plan: PlanType) => {
+        getJestSpyOn(ProjectUtil, "getCurrentPlan").mockReturnValue(plan);
+        jest
+          .spyOn(BaseAPI, "get")
+          .mockResolvedValue({ data: { isAllowed: false } } as any);
+
+        renderIngestionKeyForm();
+
+        await userEvent.type(
+          await screen.findByTestId(
+            "ingestion-key-name",
+            {},
+            { timeout: WAIT_TIMEOUT },
+          ),
+          "Production",
+        );
 
-      expect(
-        screen.queryByTestId("telemetry-pay-as-you-go-consent"),
-      ).not.toBeInTheDocument();
-      expect(
-        screen.queryByRole("region", { name: "Telemetry pricing" }),
-      ).not.toBeInTheDocument();
+        expect(
+          screen.queryByTestId("telemetry-pay-as-you-go-consent"),
+        ).not.toBeInTheDocument();
+        expect(
+          screen.queryByRole("region", { name: "Telemetry pricing" }),
+        ).not.toBeInTheDocument();
+        expect(
+          screen.queryByText(/Add a payment method/),
+        ).not.toBeInTheDocument();
 
-      await userEvent.click(screen.getByText("Create Ingestion Key"));
+        await userEvent.click(screen.getByText("Create Ingestion Key"));
 
-      await waitFor(
-        () => {
-          expect(createOrUpdateMock).toHaveBeenCalled();
-        },
-        { timeout: WAIT_TIMEOUT },
-      );
-    });
+        await waitFor(
+          () => {
+            expect(createOrUpdateMock).toHaveBeenCalledTimes(1);
+          },
+          { timeout: WAIT_TIMEOUT },
+        );
+        expect(BaseAPI.get).not.toHaveBeenCalled();
+      },
+    );
 
     it("asks for nothing extra on a self-hosted install", async () => {
       config.billingEnabled = false;
@@ -411,21 +419,29 @@ describe("Pay as you go creation notices", () => {
   });
 
   describe("creating a monitor off the Free plan", () => {
-    it("advances without a warning or acknowledgement on a paid plan", async () => {
-      getJestSpyOn(ProjectUtil, "getCurrentPlan").mockReturnValue(
-        PlanType.Growth,
-      );
-      renderMonitorPage(MonitorType.Website);
+    it.each([PlanType.Growth, PlanType.Scale, PlanType.Enterprise])(
+      "advances on the %s plan without a payment method or billing warning",
+      async (plan: PlanType) => {
+        getJestSpyOn(ProjectUtil, "getCurrentPlan").mockReturnValue(plan);
+        jest
+          .spyOn(BaseAPI, "get")
+          .mockResolvedValue({ data: { isAllowed: false } } as any);
+        renderMonitorPage(MonitorType.Website);
 
-      await advanceMonitorInfo();
+        await advanceMonitorInfo();
 
-      expect(
-        screen.queryByTestId("monitor-pay-as-you-go-card"),
-      ).not.toBeInTheDocument();
-      expect(
-        screen.queryByTestId("monitor-pay-as-you-go-consent"),
-      ).not.toBeInTheDocument();
-    });
+        expect(
+          screen.queryByTestId("monitor-pay-as-you-go-card"),
+        ).not.toBeInTheDocument();
+        expect(
+          screen.queryByTestId("monitor-pay-as-you-go-consent"),
+        ).not.toBeInTheDocument();
+        expect(
+          screen.queryByText(/Add a payment method/),
+        ).not.toBeInTheDocument();
+        expect(BaseAPI.get).not.toHaveBeenCalled();
+      },
+    );
 
     it("advances without a warning or acknowledgement on a self-hosted install", async () => {
       config.billingEnabled = false;

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

@@ -759,18 +759,55 @@ describe("Pay as you go notices", () => {
       expect(container).toBeEmptyDOMElement();
     });
 
-    it("renders nothing off the Free plan", () => {
-      setPlan(PlanType.Growth);
+    it("keeps a Free plan batch locked when no payment method is available", async () => {
+      const onChange: MockFunction = getJestMockFunction();
+      jest
+        .spyOn(BaseAPI, "get")
+        .mockResolvedValue({ data: { isAllowed: false } } as any);
 
-      const { container }: { container: HTMLElement } = render(
+      render(
         <MonitorBatchPayAsYouGoConsent
           monitorTypes={[MonitorType.Kubernetes]}
           value={false}
-          onChange={() => {}}
+          onChange={onChange as (value: boolean) => void}
         />,
       );
 
-      expect(container).toBeEmptyDOMElement();
+      expect(
+        await screen.findByText(/Add a payment method before using/),
+      ).toBeInTheDocument();
+      const consent: HTMLElement = screen.getByTestId(
+        "monitor-batch-pay-as-you-go-consent",
+      );
+      expect(consent).toBeDisabled();
+      await userEvent.click(consent);
+      expect(onChange).not.toHaveBeenCalled();
+      expect(BaseAPI.get).toHaveBeenCalledTimes(1);
     });
+
+    it.each([PlanType.Growth, PlanType.Scale, PlanType.Enterprise])(
+      "does not check or require a payment method for a %s plan batch",
+      (plan: PlanType) => {
+        setPlan(plan);
+        jest
+          .spyOn(BaseAPI, "get")
+          .mockResolvedValue({ data: { isAllowed: false } } as any);
+
+        const { container }: { container: HTMLElement } = render(
+          <MonitorBatchPayAsYouGoConsent
+            monitorTypes={[
+              MonitorType.Kubernetes,
+              MonitorType.Website,
+              MonitorType.Manual,
+            ]}
+            value={false}
+            onChange={() => {}}
+          />,
+        );
+
+        expect(container).toBeEmptyDOMElement();
+        expect(BaseAPI.get).not.toHaveBeenCalled();
+      },
+    );
   });
 });

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

@@ -92,8 +92,9 @@ interface ResourceAuditMenuCase {
   name: string;
   menu: () => ReactElement;
   auditPage: PageMap;
+  auditSection: string;
   sections: Array<string>;
-  advancedLinks: Array<ExpectedLink>;
+  auditSectionLinks: Array<ExpectedLink>;
 }
 
 const RESOURCE_CASES: Array<ResourceAuditMenuCase> = [
@@ -103,6 +104,7 @@ const RESOURCE_CASES: Array<ResourceAuditMenuCase> = [
       return <IncidentSideMenu modelId={MODEL_ID} />;
     },
     auditPage: PageMap.INCIDENT_VIEW_AUDIT_LOGS,
+    auditSection: "Advanced",
     sections: [
       "Overview",
       "Investigation",
@@ -111,7 +113,7 @@ const RESOURCE_CASES: Array<ResourceAuditMenuCase> = [
       "Notes",
       "Advanced",
     ],
-    advancedLinks: [
+    auditSectionLinks: [
       {
         title: "Custom Fields",
         page: PageMap.INCIDENT_VIEW_CUSTOM_FIELDS,
@@ -129,8 +131,9 @@ const RESOURCE_CASES: Array<ResourceAuditMenuCase> = [
       );
     },
     auditPage: PageMap.MONITOR_VIEW_AUDIT_LOGS,
+    auditSection: "Advanced",
     sections: ["Overview", "Activity", "Configuration", "Advanced"],
-    advancedLinks: [
+    auditSectionLinks: [
       { title: "Owners", page: PageMap.MONITOR_VIEW_OWNERS },
       { title: "Custom Fields", page: PageMap.MONITOR_VIEW_CUSTOM_FIELDS },
       { title: "Settings", page: PageMap.MONITOR_VIEW_SETTINGS },
@@ -144,8 +147,9 @@ const RESOURCE_CASES: Array<ResourceAuditMenuCase> = [
       return <SloSideMenu modelId={MODEL_ID} />;
     },
     auditPage: PageMap.SLO_VIEW_AUDIT_LOGS,
-    sections: ["SLO", "Advanced"],
-    advancedLinks: [
+    auditSection: "Management",
+    sections: ["Overview", "Activity", "Configuration", "Management"],
+    auditSectionLinks: [
       { title: "Owners", page: PageMap.SLO_VIEW_OWNERS },
       { title: "Settings", page: PageMap.SLO_VIEW_SETTINGS },
       { title: "Audit Logs", page: PageMap.SLO_VIEW_AUDIT_LOGS },
@@ -158,6 +162,7 @@ const RESOURCE_CASES: Array<ResourceAuditMenuCase> = [
       return <StatusPageSideMenu modelId={MODEL_ID} />;
     },
     auditPage: PageMap.STATUS_PAGE_VIEW_AUDIT_LOGS,
+    auditSection: "Advanced",
     sections: [
       "Basic",
       "Resources",
@@ -168,7 +173,7 @@ const RESOURCE_CASES: Array<ResourceAuditMenuCase> = [
       "AI",
       "Advanced",
     ],
-    advancedLinks: [
+    auditSectionLinks: [
       { title: "Embedded Status", page: PageMap.STATUS_PAGE_VIEW_EMBEDDED },
       { title: "Reports", page: PageMap.STATUS_PAGE_VIEW_REPORTS },
       {
@@ -228,11 +233,11 @@ describe.each(RESOURCE_CASES)(
       expect(sectionTitlesInOrder()).not.toContain("Settings");
     });
 
-    test("keeps every Advanced destination in the expected order", async () => {
+    test("keeps every destination in the audit section in the expected order", async () => {
       await renderAuditPage(resource);
 
-      expect(linksIn("Advanced")).toEqual(
-        resource.advancedLinks.map((link: ExpectedLink): MenuLink => {
+      expect(linksIn(resource.auditSection)).toEqual(
+        resource.auditSectionLinks.map((link: ExpectedLink): MenuLink => {
           return {
             title: link.title,
             href: resourceRoute(link.page),
@@ -259,25 +264,29 @@ describe.each(RESOURCE_CASES)(
       });
     });
 
-    test("marks Audit Logs active and expands Advanced", async () => {
+    test("marks Audit Logs active and expands its section", async () => {
       const auditPath: string = await renderAuditPage(resource);
       const auditLogAnchor: HTMLAnchorElement | undefined = Array.from(
-        sectionRoot("Advanced").querySelectorAll<HTMLAnchorElement>("a"),
+        sectionRoot(resource.auditSection).querySelectorAll<HTMLAnchorElement>(
+          "a",
+        ),
       ).find((anchor: HTMLAnchorElement): boolean => {
         return anchor.getAttribute("href") === auditPath;
       });
 
       expect(auditLogAnchor).toBeDefined();
       expect(auditLogAnchor).toHaveClass("bg-indigo-50", "text-indigo-700");
-      expect(isExpanded("Advanced")).toBe(true);
+      expect(isExpanded(resource.auditSection)).toBe(true);
     });
 
-    test("names Audit Logs as an Advanced page in the mobile summary", async () => {
+    test("names the Audit Logs section in the mobile summary", async () => {
       setViewportWidth(MOBILE_WIDTH);
 
       await renderAuditPage(resource);
 
-      expect(mobileSummaryText()).toContain("Advanced / Audit Logs");
+      expect(mobileSummaryText()).toContain(
+        `${resource.auditSection} / Audit Logs`,
+      );
     });
 
     test("retains a visible label and icon for every destination", async () => {
@@ -296,20 +305,18 @@ describe.each(RESOURCE_CASES)(
 );
 
 /*
- * The SLO section follows what an SLO is made of: the monitors it measures
- * and the rules that attach them, its burn-rate rules and metrics, what it
- * raised, then its feed. Charts is deliberately absent - its history lives in
- * Metrics, and its route only survives for bookmarks.
+ * SLO performance and activity precede configuration. Charts remains absent:
+ * its history lives in Metrics, and its route only survives for bookmarks.
  */
 const SLO_SECTION_LINKS: Array<ExpectedLink> = [
   { title: "Overview", page: PageMap.SLO_VIEW },
-  { title: "Monitors", page: PageMap.SLO_VIEW_MONITORS },
-  { title: "Monitor Rules", page: PageMap.SLO_VIEW_MONITOR_RULES },
-  { title: "Burn Rate Rules", page: PageMap.SLO_VIEW_BURN_RATE_RULES },
   { title: "Metrics", page: PageMap.SLO_VIEW_METRICS },
-  { title: "Alerts", page: PageMap.SLO_VIEW_ALERTS },
   { title: "Incidents", page: PageMap.SLO_VIEW_INCIDENTS },
+  { title: "Alerts", page: PageMap.SLO_VIEW_ALERTS },
   { title: "Feed", page: PageMap.SLO_VIEW_FEED },
+  { title: "Monitors", page: PageMap.SLO_VIEW_MONITORS },
+  { title: "Monitor Rules", page: PageMap.SLO_VIEW_MONITOR_RULES },
+  { title: "Burn Rate Rules", page: PageMap.SLO_VIEW_BURN_RATE_RULES },
 ];
 
 describe("SLO resource menu", () => {
@@ -324,7 +331,11 @@ describe("SLO resource menu", () => {
 
     await renderAuditPage(slo!);
 
-    expect(linksIn("SLO")).toEqual(
+    expect([
+      ...linksIn("Overview"),
+      ...linksIn("Activity"),
+      ...linksIn("Configuration"),
+    ]).toEqual(
       SLO_SECTION_LINKS.map((link: ExpectedLink): MenuLink => {
         return {
           title: link.title,