@oneuptime/common 13.0.7 → 13.0.8

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

@@ -1,5 +1,12 @@
 import "@testing-library/jest-dom";
-import { afterEach, describe, expect, jest, test } from "@jest/globals";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
 import {
   cleanup,
   fireEvent,
@@ -93,6 +100,25 @@ jest.mock("react-i18next", () => {
   };
 });
 
+/*
+ * axios is a pass-through spy: every call still goes to the real axios, so
+ * nothing else in this file behaves differently. Only the lapsed-session
+ * regression below scripts it, to drive the REAL browser client (not the mock
+ * above) through a 401, a refresh and a replay.
+ */
+jest.mock("axios", () => {
+  const actualAxios: (...args: Array<unknown>) => unknown = jest.requireActual(
+    "axios",
+  ) as (...args: Array<unknown>) => unknown;
+
+  return Object.assign(
+    jest.fn((...args: Array<unknown>): unknown => {
+      return actualAxios(...args);
+    }),
+    actualAxios,
+  );
+});
+
 import EscalationRules from "../../../../App/FeatureSet/Dashboard/src/Components/OnCallPolicy/EscalationRule/EscalationRules";
 import {
   ResponderGroupRef,
@@ -125,9 +151,24 @@ import {
   parseReadinessSummary,
 } from "../../../../App/FeatureSet/Dashboard/src/Components/OnCallPolicy/Readiness/ReadinessTypes";
 import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import HTTPMethod from "../../../Types/API/HTTPMethod";
 import HTTPResponse from "../../../Types/API/HTTPResponse";
+import Route from "../../../Types/API/Route";
+import URL from "../../../Types/API/URL";
 import { JSONObject } from "../../../Types/JSON";
 import ObjectID from "../../../Types/ObjectID";
+import { APP_API_URL, IDENTITY_URL } from "../../../UI/Config";
+import type RealBaseAPI from "../../../UI/Utils/API/API";
+import Navigation from "../../../UI/Utils/Navigation";
+import User from "../../../UI/Utils/User";
+import FakeAxiosServer, {
+  FakeTransport,
+  SentRequest,
+} from "../../UI/Utils/API/FakeAxiosServer";
+import axios from "axios";
+import fs from "fs";
+import type { SpyInstance } from "jest-mock";
+import path from "path";
 
 const USER_ALEX: string = "aaaaaaaa-1111-4111-8111-111111111111";
 const USER_SAM: string = "bbbbbbbb-2222-4222-8222-222222222222";
@@ -1624,6 +1665,240 @@ describe("Sending the reminder", () => {
   });
 });
 
+/*
+ * ---------------------------------------------------------------------------
+ * THE REMINDER AFTER THE SESSION LAPSED
+ * ---------------------------------------------------------------------------
+ *
+ * The customer's report, reproduced. The Dashboard was left open for more than
+ * fifteen minutes, so the browser had already dropped the access-token cookie
+ * (its maxAge is the JWT's lifetime) when "Send setup reminder" was pressed.
+ * The request reached the server with no credentials, and the reminder came
+ * back "You are not authorized to access this project's data." - a 422, which
+ * the browser client has no reason to treat as a lapsed session, so it never
+ * refreshed and the reminder was reported as failed.
+ *
+ * The server now answers a request with no credentials 401, and the client
+ * refreshes on a 401 and replays. These cases run requestSetupReminders
+ * through the REAL browser client rather than the API mock the rest of this
+ * file uses: the mock's post is pointed at the actual BaseAPI.post, and axios
+ * underneath it is scripted like a server.
+ */
+describe("Sending the reminder after the session lapsed", () => {
+  const SEND_URL: string = URL.fromString(APP_API_URL.toString())
+    .addRoute("/on-call-readiness/send-setup-reminder")
+    .toString();
+
+  const REFRESH_URL: string = URL.fromString(IDENTITY_URL.toString())
+    .addRoute("/refresh-token")
+    .toString();
+
+  const NO_CREDENTIALS_BODY: JSONObject = {
+    message: "Authentication required. Please log in to access this resource.",
+  };
+
+  const realBaseAPI: typeof RealBaseAPI = (
+    jest.requireActual("../../../UI/Utils/API/API") as {
+      default: typeof RealBaseAPI;
+    }
+  ).default;
+
+  const mockedAxios: FakeTransport = axios as unknown as FakeTransport;
+
+  let server: FakeAxiosServer;
+  let logoutSpy: SpyInstance<typeof User.logout>;
+  let navigateSpy: SpyInstance<typeof Navigation.navigate>;
+  let currentRouteSpy: SpyInstance<typeof Navigation.getCurrentRoute>;
+
+  beforeEach(() => {
+    server = new FakeAxiosServer(mockedAxios);
+
+    getCommonHeadersMock.mockReturnValue({ tenantid: PROJECT_ID.toString() });
+
+    postMock.mockImplementation((...args: Array<any>): Promise<unknown> => {
+      return realBaseAPI.post(args[0]);
+    });
+
+    logoutSpy = jest.spyOn(User, "logout").mockImplementation((): void => {});
+
+    navigateSpy = jest
+      .spyOn(Navigation, "navigate")
+      .mockImplementation((): void => {});
+
+    currentRouteSpy = jest
+      .spyOn(Navigation, "getCurrentRoute")
+      .mockReturnValue(
+        new Route(`/dashboard/${PROJECT_ID.toString()}/on-call-duty`),
+      );
+  });
+
+  afterEach(() => {
+    logoutSpy.mockRestore();
+    navigateSpy.mockRestore();
+    currentRouteSpy.mockRestore();
+
+    // Back to the pass-through the rest of this file runs on.
+    const actualAxios: (...args: Array<unknown>) => unknown =
+      jest.requireActual("axios") as (...args: Array<unknown>) => unknown;
+
+    mockedAxios.mockImplementation(((...args: Array<unknown>): unknown => {
+      return actualAxios(...args);
+    }) as never);
+  });
+
+  type SentFunction = () => Array<string>;
+
+  const sentOnTheWire: SentFunction = (): Array<string> => {
+    return server.sent.map((request: SentRequest): string => {
+      return `${request.method.toUpperCase()} ${request.url}`;
+    });
+  };
+
+  test("a reminder refused 401 is refreshed, replayed, and reported as SENT", async () => {
+    server
+      .on(HTTPMethod.POST, SEND_URL, [
+        { status: 401, data: NO_CREDENTIALS_BODY },
+        {
+          status: 200,
+          data: {
+            sentCount: 1,
+            results: [
+              { userId: USER_ALEX, outcome: "Sent", message: "Emailed." },
+            ],
+          },
+        },
+      ])
+      .on(HTTPMethod.POST, REFRESH_URL, [{ status: 200 }]);
+
+    const statuses: SetupReminderStatuses = await requestSetupReminders([
+      USER_ALEX,
+    ]);
+
+    // Not the "failed" / "not authorized" state from the customer's screenshot.
+    expect(statuses).toEqual({
+      [USER_ALEX]: { state: "sent", message: "Emailed." },
+    });
+
+    expect(sentOnTheWire()).toEqual([
+      `POST ${SEND_URL}`,
+      `POST ${REFRESH_URL}`,
+      `POST ${SEND_URL}`,
+    ]);
+
+    // The replay is the same reminder, for the same project, sent once more.
+    const replay: SentRequest = server.sent[2]!;
+
+    expect(replay.data).toEqual({ userIds: [USER_ALEX] });
+    expect(replay.data).toEqual(server.sent[0]!.data);
+    expect(replay.headers["tenantid"]).toBe(PROJECT_ID.toString());
+
+    // The lapse is invisible: nobody is logged out, nothing navigates.
+    expect(logoutSpy).not.toHaveBeenCalled();
+    expect(navigateSpy).not.toHaveBeenCalled();
+  });
+
+  test("a batch refused 401 is replayed as one batch, and each person is reported", async () => {
+    server
+      .on(HTTPMethod.POST, SEND_URL, [
+        { status: 401, data: NO_CREDENTIALS_BODY },
+        {
+          status: 200,
+          data: {
+            sentCount: 1,
+            results: [
+              { userId: USER_ALEX, outcome: "Sent", message: "Emailed." },
+              {
+                userId: USER_SAM,
+                outcome: "SkippedThrottled",
+                message: "Already reminded in the last 24 hours.",
+              },
+            ],
+          },
+        },
+      ])
+      .on(HTTPMethod.POST, REFRESH_URL, [{ status: 200 }]);
+
+    const statuses: SetupReminderStatuses = await requestSetupReminders([
+      USER_ALEX,
+      USER_SAM,
+    ]);
+
+    expect(statuses[USER_ALEX]).toEqual({ state: "sent", message: "Emailed." });
+    expect(statuses[USER_SAM]).toEqual({
+      state: "skipped",
+      message: "Already reminded in the last 24 hours.",
+    });
+    expect(server.requestsTo(HTTPMethod.POST, REFRESH_URL)).toHaveLength(1);
+    expect(server.requestsTo(HTTPMethod.POST, SEND_URL)).toHaveLength(2);
+  });
+
+  /*
+   * The symptom itself, kept as a contrast: had the server kept answering 422
+   * for a request with no credentials, the client could not have told it from
+   * a real permission refusal, and correctly would not have refreshed. The
+   * reminder stays failed. This is why the fix is a 401 on the server and not
+   * a wider net on the client.
+   */
+  test("the old 422 answer is terminal: no refresh, no replay, reported as failed", async () => {
+    server.on(HTTPMethod.POST, SEND_URL, [
+      {
+        status: 422,
+        data: {
+          message: "You are not authorized to access this project's data.",
+        },
+      },
+    ]);
+
+    const statuses: SetupReminderStatuses = await requestSetupReminders([
+      USER_ALEX,
+    ]);
+
+    expect(statuses[USER_ALEX]!.state).toBe("failed");
+    expect(sentOnTheWire()).toEqual([`POST ${SEND_URL}`]);
+    expect(logoutSpy).not.toHaveBeenCalled();
+  });
+
+  test("a session that cannot be refreshed reports the reminder as not sent and goes to login", async () => {
+    server
+      .on(HTTPMethod.POST, SEND_URL, [
+        { status: 401, data: NO_CREDENTIALS_BODY },
+      ])
+      .on(HTTPMethod.POST, REFRESH_URL, [{ status: 401 }]);
+
+    const statuses: SetupReminderStatuses = await requestSetupReminders([
+      USER_ALEX,
+    ]);
+
+    // A 401 is refused before any mail is sent, so "not sent" is certain.
+    expect(statuses[USER_ALEX]!.state).toBe("failed");
+    // Never replayed: the reminder was not sent twice behind the reader's back.
+    expect(server.requestsTo(HTTPMethod.POST, SEND_URL)).toHaveLength(1);
+    expect(logoutSpy).toHaveBeenCalled();
+    expect(navigateSpy).toHaveBeenCalledWith(new Route("/accounts/login"), {
+      forceNavigate: true,
+    });
+  });
+
+  /*
+   * The mock at the top of this file stands in for the refresh-aware client,
+   * so every other test here would pass just the same if the reminder were
+   * sent through the bare Common/Utils/API - which has no refresh at all. Pin
+   * the import itself.
+   */
+  test("the reminder is sent through the refresh-aware client", () => {
+    const source: string = fs.readFileSync(
+      path.join(
+        __dirname,
+        "../../../../App/FeatureSet/Dashboard/src/Components/OnCallPolicy/EscalationRule/EscalationRuleReadiness.tsx",
+      ),
+      "utf8",
+    );
+
+    expect(source).toMatch(/import API from "Common\/UI\/Utils\/API\/API";/);
+    expect(source).not.toMatch(/from "Common\/Utils\/API"/);
+  });
+});
+
 /*
  * ---------------------------------------------------------------------------
  * EXPANDING TEAMS AND SCHEDULES

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,