@oneuptime/common 14.0.6 → 14.0.8

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

@@ -17,7 +17,7 @@ import {
   waitFor,
   within,
 } from "@testing-library/react";
-import React, { ReactElement, ReactNode } from "react";
+import React, { FunctionComponent, ReactElement, ReactNode } from "react";
 import getJestMockFunction, { MockFunction } from "../../MockType";
 
 /*
@@ -32,6 +32,7 @@ import getJestMockFunction, { MockFunction } from "../../MockType";
 const getListMock: MockFunction = getJestMockFunction();
 const getItemMock: MockFunction = getJestMockFunction();
 const updateByIdMock: MockFunction = getJestMockFunction();
+const createOrUpdateMock: MockFunction = getJestMockFunction();
 
 const recordedProps: Record<string, Array<Record<string, unknown>>> = {};
 const mountCounts: Record<string, number> = {};
@@ -92,6 +93,9 @@ jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
       updateById: (...args: Array<unknown>) => {
         return updateByIdMock(...args);
       },
+      createOrUpdate: (...args: Array<unknown>) => {
+        return createOrUpdateMock(...args);
+      },
     },
   };
 });
@@ -318,6 +322,7 @@ import IncidentState from "../../../Models/DatabaseModels/IncidentState";
 import IncidentStateTimeline from "../../../Models/DatabaseModels/IncidentStateTimeline";
 import Monitor from "../../../Models/DatabaseModels/Monitor";
 import Probe from "../../../Models/DatabaseModels/Probe";
+import ServiceLevelObjective from "../../../Models/DatabaseModels/ServiceLevelObjective";
 import AIRunHumanVerdict from "../../../Types/AI/AIRunHumanVerdict";
 import AIRunStatus from "../../../Types/AI/AIRunStatus";
 import Route from "../../../Types/API/Route";
@@ -325,8 +330,15 @@ import Color from "../../../Types/Color";
 import OneUptimeDate from "../../../Types/Date";
 import ObjectID from "../../../Types/ObjectID";
 import StatusPageSubscriberNotificationStatus from "../../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
+import IncidentCreatedResend from "../../../Types/StatusPage/IncidentCreatedResend";
+import { FormType } from "../../../UI/Components/Forms/ModelForm";
+import SubscriberNotificationResendCopy from "../../../../App/FeatureSet/Dashboard/src/Components/StatusPageSubscribers/SubscriberNotificationResendCopy";
 import { DetailStyle } from "../../../UI/Components/Detail/Detail";
+import FormFieldSchemaType from "../../../UI/Components/Forms/Types/FormFieldSchemaType";
 import Navigation from "../../../UI/Utils/Navigation";
+import PermissionUtil from "../../../UI/Utils/Permission";
+import User from "../../../UI/Utils/User";
+import Permission from "../../../Types/Permission";
 
 const EVENT_ID: string = "11111111-1111-4111-8111-111111111111";
 const OTHER_EVENT_ID: string = "22222222-2222-4222-8222-222222222222";
@@ -376,6 +388,11 @@ function propsHistory<T>(key: string): Array<T> {
   return (recordedProps[key] || []) as unknown as Array<T>;
 }
 
+// What the incident overview hands the notification status badge.
+type ResendStatusProps = {
+  onResendNotification: (options: { isToAllStatusPages: boolean }) => void;
+};
+
 function latestProps<T>(key: string): T {
   const history: Array<T> = propsHistory<T>(key);
 
@@ -532,6 +549,8 @@ const INCIDENT_CASE: PageCase = {
     "Declared By",
     "On-Call Duty Policies",
     "Subscriber Notification Status",
+    // The status pages the incident is limited to, read only.
+    "Status Page Scope",
     "Labels",
     "Incident Number",
     "Incident ID",
@@ -756,14 +775,22 @@ const itemRequestId: ItemRequestIdFunction = (args: Array<unknown>): string => {
   return (args[0] as { id: ObjectID }).id.toString();
 };
 
+// What the signed-in user may do; a project member unless a test says so.
+let currentPermissions: Array<Permission> = [Permission.ProjectMember];
+
 beforeEach(() => {
   currentEventId = EVENT_ID;
+  currentPermissions = [Permission.ProjectMember];
 
   jest
     .spyOn(Navigation, "getLastParamAsObjectID")
     .mockImplementation((): ObjectID => {
       return new ObjectID(currentEventId);
     });
+  jest.spyOn(PermissionUtil, "getAllPermissions").mockImplementation(() => {
+    return currentPermissions;
+  });
+  jest.spyOn(User, "isMasterAdmin").mockReturnValue(false);
 });
 
 afterEach(() => {
@@ -771,6 +798,7 @@ afterEach(() => {
   getListMock.mockReset();
   getItemMock.mockReset();
   updateByIdMock.mockReset();
+  createOrUpdateMock.mockReset();
 
   for (const key of Object.keys(recordedProps)) {
     delete recordedProps[key];
@@ -1849,6 +1877,90 @@ describe.each([
   });
 });
 
+/*
+ * The Affected Resources card. CardModelDetail is stubbed, so the card's
+ * display field is read from its latest props and rendered here the way the
+ * real card renders it. AffectedResourcesDisplay is stubbed for the page too,
+ * so the element its getElement returns is re-rendered with the real
+ * display: what is asserted is what a reader of the card would see.
+ */
+interface ResourcesFormFieldProps {
+  field?: Record<string, unknown>;
+  fieldType?: FormFieldSchemaType;
+  showIf?: (values: unknown) => boolean;
+  getCustomElement?: (values: unknown, elementProps: unknown) => ReactElement;
+}
+
+interface ResourcesCardProps {
+  cardProps: { description?: string };
+  formFields: Array<ResourcesFormFieldProps>;
+  modelDetailProps: { fields: Array<DetailFieldProps> };
+}
+
+type ResourcesCardFunction = () => ResourcesCardProps;
+
+const resourcesCard: ResourcesCardFunction = (): ResourcesCardProps => {
+  return latestProps<ResourcesCardProps>("CardModelDetail:Affected Resources");
+};
+
+type ResourcesDisplayFieldFunction = () => DetailFieldProps;
+
+const resourcesDisplayField: ResourcesDisplayFieldFunction =
+  (): DetailFieldProps => {
+    const displayField: DetailFieldProps | undefined =
+      resourcesCard().modelDetailProps.fields.find(
+        (field: DetailFieldProps): boolean => {
+          return Boolean(field.getElement);
+        },
+      );
+
+    if (!displayField) {
+      throw new Error("The Affected Resources card has no display field");
+    }
+
+    return displayField;
+  };
+
+type RenderResourcesDisplayFunction = (item: Incident | Alert) => RenderResult;
+
+const renderResourcesDisplay: RenderResourcesDisplayFunction = (
+  item: Incident | Alert,
+): RenderResult => {
+  const RealAffectedResourcesDisplay: FunctionComponent<
+    Record<string, unknown>
+  > = (
+    jest.requireActual(
+      "../../../../App/FeatureSet/Dashboard/src/Components/AffectedResources/AffectedResourcesDisplay",
+    ) as { default: FunctionComponent<Record<string, unknown>> }
+  ).default;
+
+  const display: ReactElement = resourcesDisplayField().getElement!(item);
+
+  return render(
+    <RealAffectedResourcesDisplay
+      {...(display.props as Record<string, unknown>)}
+    />,
+  );
+};
+
+type NamedMonitorFunction = (name: string) => Monitor;
+
+const namedMonitor: NamedMonitorFunction = (name: string): Monitor => {
+  const monitor: Monitor = new Monitor();
+  monitor.id = new ObjectID(MONITOR_ID);
+  monitor.name = name;
+  return monitor;
+};
+
+type NamedSloFunction = (name: string) => ServiceLevelObjective;
+
+const namedSlo: NamedSloFunction = (name: string): ServiceLevelObjective => {
+  const slo: ServiceLevelObjective = new ServiceLevelObjective();
+  slo.id = new ObjectID("dddddddd-dddd-4ddd-8ddd-ddddddddddd1");
+  slo.name = name;
+  return slo;
+};
+
 describe("incident-only behaviour", () => {
   test("the header names who declared the incident once the details card has read it", async () => {
     serve(INCIDENT_CASE, {
@@ -2021,9 +2133,9 @@ describe("incident-only behaviour", () => {
     const readsBefore: number = countItemReads();
 
     await act(async () => {
-      latestProps<{ onResendNotification: () => void }>(
+      latestProps<ResendStatusProps>(
         "SubscriberNotificationStatus",
-      ).onResendNotification();
+      ).onResendNotification({ isToAllStatusPages: false });
     });
 
     await waitFor(() => {
@@ -2033,6 +2145,7 @@ describe("incident-only behaviour", () => {
       ).toBe(!refresherBefore);
     });
 
+    // Retry: back to Pending, and the server keeps the record so it resumes.
     expect(updateByIdMock).toHaveBeenCalledTimes(1);
     expect(
       (updateByIdMock.mock.calls[0]![0] as { data: Record<string, unknown> })
@@ -2040,12 +2153,222 @@ describe("incident-only behaviour", () => {
     ).toEqual({
       subscriberNotificationStatusOnIncidentCreated:
         StatusPageSubscriberNotificationStatus.Pending,
-      subscriberNotificationStatusMessage: "Notification queued for resending",
+      subscriberNotificationStatusMessage:
+        IncidentCreatedResend.retryQueuedMessage,
     });
+    expect(createOrUpdateMock).not.toHaveBeenCalled();
     expect(countItemReads()).toBe(readsBefore);
     expect(mountCounts["InvestigationPanel"]).toBe(1);
   });
 
+  test("resending to every status page asks the server to, and re-reads only the details card", async () => {
+    serve(INCIDENT_CASE, {
+      timeline: REOPENED_TIMELINE,
+      title: "Checkout slow",
+    });
+    createOrUpdateMock.mockResolvedValue({});
+
+    INCIDENT_CASE.renderPage();
+    await waitForPage();
+
+    const refresherBefore: boolean | undefined =
+      latestProps<CardModelDetailProps>(
+        "CardModelDetail:Incident Details",
+      ).refresher;
+
+    renderStatusField();
+
+    await act(async () => {
+      latestProps<ResendStatusProps>(
+        "SubscriberNotificationStatus",
+      ).onResendNotification({ isToAllStatusPages: true });
+    });
+
+    await waitFor(() => {
+      expect(
+        latestProps<CardModelDetailProps>("CardModelDetail:Incident Details")
+          .refresher,
+      ).toBe(!refresherBefore);
+    });
+
+    expect(updateByIdMock).not.toHaveBeenCalled();
+    expect(createOrUpdateMock).toHaveBeenCalledTimes(1);
+
+    const request: {
+      model: Incident;
+      modelType: unknown;
+      formType: FormType;
+      miscDataProps: Record<string, unknown>;
+    } = createOrUpdateMock.mock.calls[0]![0] as {
+      model: Incident;
+      modelType: unknown;
+      formType: FormType;
+      miscDataProps: Record<string, unknown>;
+    };
+
+    expect(request.modelType).toBe(Incident);
+    expect(request.formType).toBe(FormType.Update);
+    expect(request.model._id?.toString()).toBe(EVENT_ID);
+    expect(request.model.subscriberNotificationStatusOnIncidentCreated).toBe(
+      StatusPageSubscriberNotificationStatus.Pending,
+    );
+    expect(request.miscDataProps).toEqual(
+      IncidentCreatedResend.getMiscDataProps(),
+    );
+  });
+
+  test("offers Resend after a success, confirmed with who this incident reaches now", async () => {
+    serve(INCIDENT_CASE, {
+      timeline: REOPENED_TIMELINE,
+      title: "Checkout slow",
+    });
+
+    INCIDENT_CASE.renderPage();
+    await waitForPage();
+
+    renderStatusField();
+
+    const confirmation: {
+      resendDescription: string;
+      retryDescription: string;
+      retryToAllStatusPagesLabel?: string;
+      retryToAllStatusPagesDescription?: string;
+      audience: ReactElement;
+    } = latestProps<{
+      resendConfirmation: {
+        resendDescription: string;
+        retryDescription: string;
+        retryToAllStatusPagesLabel?: string;
+        retryToAllStatusPagesDescription?: string;
+        audience: ReactElement;
+      };
+    }>("SubscriberNotificationStatus").resendConfirmation;
+
+    expect(confirmation.resendDescription).toBe(
+      SubscriberNotificationResendCopy.incidentCreatedResendDescription,
+    );
+    expect(confirmation.retryDescription).toBe(
+      SubscriberNotificationResendCopy.incidentCreatedRetryDescription,
+    );
+    expect(confirmation.retryToAllStatusPagesLabel).toBe(
+      SubscriberNotificationResendCopy.incidentCreatedRetryToAllStatusPagesLabel,
+    );
+    expect(confirmation.retryToAllStatusPagesDescription).toBe(
+      SubscriberNotificationResendCopy.incidentCreatedResendToAllStatusPagesDescription,
+    );
+
+    const audienceProps: {
+      request: { incidentId: { toString: () => string } };
+    } = confirmation.audience.props as {
+      request: { incidentId: { toString: () => string } };
+    };
+
+    expect(audienceProps.request.incidentId.toString()).toBe(EVENT_ID);
+    expect(audienceProps.request).not.toHaveProperty(
+      "excludeStatusPagesNotifiedOnCreation",
+    );
+  });
+
+  /*
+   * Retry resumes after the pages already sent it in full, so its
+   * confirmation's "Will notify" must not list them: it asks for the audience
+   * without them. Resend, and Retry to every page, keep the full one.
+   */
+  test("Retry's confirmation shows who Retry reaches: without the pages already sent it in full", async () => {
+    serve(INCIDENT_CASE, {
+      timeline: REOPENED_TIMELINE,
+      title: "Checkout slow",
+    });
+
+    INCIDENT_CASE.renderPage();
+    await waitForPage();
+
+    renderStatusField();
+
+    const confirmation: { retryAudience?: ReactElement } = latestProps<{
+      resendConfirmation: { retryAudience?: ReactElement };
+    }>("SubscriberNotificationStatus").resendConfirmation;
+
+    const retryAudienceProps: {
+      request: {
+        incidentId: { toString: () => string };
+        excludeStatusPagesNotifiedOnCreation?: boolean;
+      };
+    } = confirmation.retryAudience!.props as {
+      request: {
+        incidentId: { toString: () => string };
+        excludeStatusPagesNotifiedOnCreation?: boolean;
+      };
+    };
+
+    expect(retryAudienceProps.request.incidentId.toString()).toBe(EVENT_ID);
+    expect(
+      retryAudienceProps.request.excludeStatusPagesNotifiedOnCreation,
+    ).toBe(true);
+  });
+
+  /*
+   * Retry and Resend write the notification's status. A role that may not
+   * is offered neither - the details card used to offer them to everyone,
+   * read-only viewers included, and let the server refuse.
+   */
+  test.each([[[Permission.Viewer]], [[Permission.IncidentViewer]], [[]]])(
+    "a user with %j is offered neither Resend nor Retry",
+    async (permissions: Array<Permission>) => {
+      currentPermissions = permissions;
+      serve(INCIDENT_CASE, {
+        timeline: REOPENED_TIMELINE,
+        title: "Checkout slow",
+      });
+
+      INCIDENT_CASE.renderPage();
+      await waitForPage();
+
+      renderStatusField();
+
+      const statusProps: {
+        onResendNotification?: unknown;
+        resendConfirmation?: unknown;
+      } = latestProps<{
+        onResendNotification?: unknown;
+        resendConfirmation?: unknown;
+      }>("SubscriberNotificationStatus");
+
+      expect(statusProps.onResendNotification).toBeUndefined();
+      expect(statusProps.resendConfirmation).toBeUndefined();
+    },
+  );
+
+  test.each([
+    [[Permission.IncidentMember]],
+    [[Permission.EditProjectIncident]],
+  ])(
+    "a user with %j is offered them",
+    async (permissions: Array<Permission>) => {
+      currentPermissions = permissions;
+      serve(INCIDENT_CASE, {
+        timeline: REOPENED_TIMELINE,
+        title: "Checkout slow",
+      });
+
+      INCIDENT_CASE.renderPage();
+      await waitForPage();
+
+      renderStatusField();
+
+      const statusProps: {
+        onResendNotification?: unknown;
+        resendConfirmation?: unknown;
+      } = latestProps<{
+        onResendNotification?: unknown;
+        resendConfirmation?: unknown;
+      }>("SubscriberNotificationStatus");
+
+      expect(statusProps.onResendNotification).toBeDefined();
+      expect(statusProps.resendConfirmation).toBeDefined();
+    },
+  );
+
   /*
    * The details card is stubbed, so the status row is rendered here from the
    * card's latest props, the way the real card renders it on every page
@@ -2072,9 +2395,9 @@ describe("incident-only behaviour", () => {
 
   const resend: ResendFunction = async (): Promise<void> => {
     await act(async () => {
-      latestProps<{ onResendNotification: () => void }>(
+      latestProps<ResendStatusProps>(
         "SubscriberNotificationStatus",
-      ).onResendNotification();
+      ).onResendNotification({ isToAllStatusPages: false });
     });
     await flush();
   };
@@ -2301,6 +2624,42 @@ describe("incident-only behaviour", () => {
       })?.value,
     ).toBe("Probe AP");
   });
+
+  /*
+   * The alert card's counterpart: Incident.monitors is ManyToMany and was
+   * always read and shown here, so the two cards agree on what an affected
+   * monitor looks like.
+   */
+  test("the Affected Resources card reads the incident's monitors and lists them under Monitors", async () => {
+    serve(INCIDENT_CASE, {
+      timeline: REOPENED_TIMELINE,
+      title: "Checkout slow",
+    });
+
+    INCIDENT_CASE.renderPage();
+    await waitForPage();
+
+    expect(resourcesDisplayField().field?.["monitors"]).toEqual({
+      name: true,
+      _id: true,
+    });
+
+    const incident: Incident = new Incident();
+    incident.monitors = [namedMonitor("Developer portal")];
+
+    const view: RenderResult = renderResourcesDisplay(incident);
+    const grid: HTMLElement = within(view.container).getByTestId(
+      "affected-resources-grid",
+    );
+
+    expect(within(view.container).queryByText("No resources affected.")).toBe(
+      null,
+    );
+    expect(within(grid).getByText("Monitors")).toBeInTheDocument();
+    expect(within(grid).getByTestId("monitor-element")).toHaveTextContent(
+      "Developer portal",
+    );
+  });
 });
 
 describe("alert-only behaviour", () => {
@@ -2447,4 +2806,173 @@ describe("alert-only behaviour", () => {
       ).toEqual(["Created"]);
     }
   });
+
+  /*
+   * An alert is raised on one monitor (Alert.monitor, singular, set when the
+   * alert is created), and the alert's "created" feed item lists that
+   * monitor under Resources Affected. The Affected Resources card used to
+   * hide monitors and never read the relation, so an alert raised on the
+   * "Developer portal" monitor said "No resources affected." right beside a
+   * feed item naming that monitor.
+   */
+  describe("the Affected Resources card", () => {
+    beforeEach(async () => {
+      serve(ALERT_CASE, {
+        timeline: REOPENED_TIMELINE,
+        title: "Checkout slow",
+      });
+
+      ALERT_CASE.renderPage();
+      await waitForPage();
+    });
+
+    test("reads the alert's monitor alongside the other resources", () => {
+      const select: Record<string, unknown> =
+        resourcesDisplayField().field || {};
+
+      expect(select["monitor"]).toEqual({ name: true, _id: true });
+      expect(select).toEqual(
+        expect.objectContaining({
+          hosts: { name: true, _id: true },
+          services: { name: true, _id: true, serviceColor: true },
+          serviceLevelObjectives: { name: true, _id: true },
+        }),
+      );
+    });
+
+    test("lists the monitor an alert was raised on under Monitors, never 'No resources affected.'", () => {
+      const alert: Alert = new Alert();
+      alert.monitor = namedMonitor("Developer portal");
+
+      const view: RenderResult = renderResourcesDisplay(alert);
+
+      expect(
+        within(view.container).queryByText("No resources affected."),
+      ).toBeNull();
+
+      const grid: HTMLElement = within(view.container).getByTestId(
+        "affected-resources-grid",
+      );
+
+      expect(grid.children).toHaveLength(1);
+      expect(within(grid).getByText("Monitors")).toBeInTheDocument();
+      expect(
+        within(grid).getByTestId("affected-resource-item"),
+      ).toHaveAttribute("title", "Developer portal");
+      expect(within(grid).getByTestId("monitor-element")).toHaveTextContent(
+        "Developer portal",
+      );
+      expect(within(view.container).getByText("1 resource")).toBeVisible();
+    });
+
+    test("shows both the monitor and an SLO, the monitor first", () => {
+      const alert: Alert = new Alert();
+      alert.monitor = namedMonitor("Developer portal");
+      alert.serviceLevelObjectives = [namedSlo("Checkout availability")];
+
+      const view: RenderResult = renderResourcesDisplay(alert);
+      const grid: HTMLElement = within(view.container).getByTestId(
+        "affected-resources-grid",
+      );
+      const categories: Array<HTMLElement> = Array.from(
+        grid.children,
+      ) as Array<HTMLElement>;
+
+      expect(categories).toHaveLength(2);
+      expect(within(categories[0]!).getByText("Monitors")).toBeVisible();
+      expect(
+        within(categories[0]!).getByTestId("monitor-element"),
+      ).toHaveTextContent("Developer portal");
+      expect(within(categories[1]!).getByText("SLOs")).toBeVisible();
+      expect(
+        within(categories[1]!).getByText("Checkout availability"),
+      ).toBeVisible();
+      expect(within(view.container).getByText("2 resources")).toBeVisible();
+      expect(
+        within(view.container).getByText("across 2 categories"),
+      ).toBeVisible();
+    });
+
+    test("an alert with no monitor and nothing else is still 'No resources affected.'", () => {
+      const view: RenderResult = renderResourcesDisplay(new Alert());
+
+      expect(
+        within(view.container).getByText("No resources affected."),
+      ).toBeVisible();
+      expect(
+        within(view.container).queryByTestId("affected-resources-grid"),
+      ).toBeNull();
+      expect(within(view.container).queryByTestId("monitor-element")).toBe(
+        null,
+      );
+    });
+
+    /*
+     * The monitor is shown, never edited: ModelForm loads and saves only the
+     * fields registered here, so leaving the monitor out means saving the
+     * card can neither move the alert to another monitor nor clear it.
+     */
+    test("its edit form never loads the monitor, so saving cannot change or clear it", () => {
+      const formFields: Array<ResourcesFormFieldProps> =
+        resourcesCard().formFields;
+      const keysOf: (field: ResourcesFormFieldProps) => Array<string> = (
+        field: ResourcesFormFieldProps,
+      ): Array<string> => {
+        return Object.keys(field.field || {});
+      };
+
+      const formKeys: Array<string> = formFields.flatMap(keysOf);
+
+      expect(formKeys).not.toContain("monitor");
+      expect(formKeys).not.toContain("monitors");
+
+      const visibleFields: Array<ResourcesFormFieldProps> = formFields.filter(
+        (field: ResourcesFormFieldProps): boolean => {
+          return !field.showIf || field.showIf({});
+        },
+      );
+      const hiddenFields: Array<ResourcesFormFieldProps> = formFields.filter(
+        (field: ResourcesFormFieldProps): boolean => {
+          return Boolean(field.showIf) && !field.showIf!({});
+        },
+      );
+
+      // The one visible field is the resource picker, registered on hosts.
+      expect(visibleFields.map(keysOf)).toEqual([["hosts"]]);
+      expect(visibleFields[0]!.fieldType).toBe(
+        FormFieldSchemaType.CustomComponent,
+      );
+      // Hidden registrations so the form still loads the other relations.
+      expect(hiddenFields.flatMap(keysOf)).toEqual([
+        "kubernetesClusters",
+        "dockerHosts",
+        "podmanHosts",
+        "proxmoxClusters",
+        "vmwareVCenters",
+        "cephClusters",
+        "dockerSwarmClusters",
+        "iotFleets",
+        "databaseServers",
+        "services",
+      ]);
+
+      // The picker it renders offers no monitors to attach either.
+      render(visibleFields[0]!.getCustomElement!({}, {}));
+
+      const picker: { monitors?: unknown; resourceTypes?: Array<string> } =
+        latestProps<{ monitors?: unknown; resourceTypes?: Array<string> }>(
+          "AffectedResourcesPicker",
+        );
+
+      expect(picker.monitors).toBeUndefined();
+      expect(picker.resourceTypes).toContain("Host");
+      expect(picker.resourceTypes).not.toContain("Monitor");
+    });
+
+    test("says it covers monitors", () => {
+      expect(resourcesCard().cardProps.description).toBe(
+        "Monitors, services, infrastructure and SLOs this alert affects.",
+      );
+    });
+  });
 });