@oneuptime/common 14.0.6 → 14.0.7

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

@@ -0,0 +1,420 @@
+import DatabaseConfig from "../../../Server/DatabaseConfig";
+import AlertFeedService from "../../../Server/Services/AlertFeedService";
+import AlertService from "../../../Server/Services/AlertService";
+import IncidentFeedService from "../../../Server/Services/IncidentFeedService";
+import IncidentService from "../../../Server/Services/IncidentService";
+import ScheduledMaintenanceFeedService from "../../../Server/Services/ScheduledMaintenanceFeedService";
+import ScheduledMaintenanceService from "../../../Server/Services/ScheduledMaintenanceService";
+import AlertWorkspaceMessages from "../../../Server/Utils/Workspace/WorkspaceMessages/Alert";
+import IncidentWorkspaceMessages from "../../../Server/Utils/Workspace/WorkspaceMessages/Incident";
+import ScheduledMaintenanceWorkspaceMessages from "../../../Server/Utils/Workspace/WorkspaceMessages/ScheduledMaintenance";
+import Alert from "../../../Models/DatabaseModels/Alert";
+import Incident from "../../../Models/DatabaseModels/Incident";
+import ScheduledMaintenance from "../../../Models/DatabaseModels/ScheduledMaintenance";
+import URL from "../../../Types/API/URL";
+import { JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+
+/*
+ * The "🌎 Resources Affected" section of an alert's, incident's or scheduled
+ * maintenance event's feed items named monitors (and SLOs) only, while the
+ * dashboard's Affected Resources cards beside it list hosts, clusters,
+ * container hosts, databases, services and so on too. An incident attached
+ * to a host and a Kubernetes cluster had no section at all. These pin the
+ * section to the card: every relation, in the card's order, held to the
+ * record's own project, with the monitor bullet unchanged.
+ */
+
+const DASHBOARD: string = "https://oneuptime.example/dashboard";
+const PROJECT_ID: ObjectID = new ObjectID(
+  "0193c0de-eeee-4aaa-8bbb-000000000001",
+);
+const OTHER_PROJECT_ID: ObjectID = new ObjectID(
+  "0193c0de-eeee-4aaa-8bbb-000000000009",
+);
+const RECORD_ID: ObjectID = new ObjectID(
+  "0193c0de-eeee-4aaa-8bbb-000000000002",
+);
+
+const MONITOR_ID: string = "0193c0de-eeee-4aaa-8bbb-0000000000a1";
+const HOST_ID: string = "0193c0de-eeee-4aaa-8bbb-0000000000b1";
+const FOREIGN_HOST_ID: string = "0193c0de-eeee-4aaa-8bbb-0000000000b9";
+const CLUSTER_ID: string = "0193c0de-eeee-4aaa-8bbb-0000000000d1";
+const DATABASE_ID: string = "0193c0de-eeee-4aaa-8bbb-0000000000d2";
+const SERVICE_ID: string = "0193c0de-eeee-4aaa-8bbb-0000000000e1";
+const SLO_ID: string = "0193c0de-eeee-4aaa-8bbb-0000000000c1";
+const SITE_ID: string = "0193c0de-eeee-4aaa-8bbb-0000000000f1";
+
+const HEADER: string = "🌎 **Resources Affected**:\n";
+
+function link(route: string, id: string): string {
+  return `${DASHBOARD}/${PROJECT_ID.toString()}/${route}/${id}`;
+}
+
+function related(
+  id: string,
+  name: string,
+  projectId: ObjectID = PROJECT_ID,
+): JSONObject {
+  return { _id: id, name, projectId: projectId as unknown as JSONObject };
+}
+
+/*
+ * Answers each per-relation read from `relations`, as the database would:
+ * one row for the record, carrying only the relation that was selected.
+ */
+function answerRelationReads(
+  service: { findAllBy: unknown },
+  relations: JSONObject,
+): jest.SpyInstance {
+  return jest
+    .spyOn(service as typeof IncidentService, "findAllBy")
+    .mockImplementation((async (findAllBy: {
+      select: JSONObject;
+    }): Promise<Array<JSONObject>> => {
+      const row: JSONObject = {
+        _id: RECORD_ID.toString(),
+        projectId: PROJECT_ID as unknown as JSONObject,
+      };
+
+      for (const column of Object.keys(findAllBy.select)) {
+        if (column !== "_id" && column !== "projectId") {
+          row[column] = relations[column] || null;
+        }
+      }
+
+      return [row];
+    }) as never);
+}
+
+// The bullets under the header, or null when there is no section.
+function sectionLines(markdown: string, header: string): Array<string> | null {
+  const start: number = markdown.indexOf(header);
+
+  if (start === -1) {
+    return null;
+  }
+
+  const lines: Array<string> = markdown
+    .slice(start + header.length)
+    .replace(/^\n+/, "")
+    .split("\n");
+  const end: number = lines.indexOf("");
+
+  return end === -1 ? lines : lines.slice(0, end);
+}
+
+function postedMarkdown(spy: jest.SpyInstance): string {
+  expect(spy).toHaveBeenCalledTimes(1);
+
+  return (spy.mock.calls[0]![0] as { feedInfoInMarkdown: string })
+    .feedInfoInMarkdown;
+}
+
+beforeEach(() => {
+  jest
+    .spyOn(DatabaseConfig, "getDashboardUrl")
+    .mockImplementation(async (): Promise<URL> => {
+      return URL.fromString(DASHBOARD);
+    });
+
+  jest
+    .spyOn(IncidentWorkspaceMessages, "getIncidentCreateMessageBlocks")
+    .mockResolvedValue([] as never);
+  jest
+    .spyOn(AlertWorkspaceMessages, "getAlertCreateMessageBlocks")
+    .mockResolvedValue([] as never);
+  jest
+    .spyOn(
+      ScheduledMaintenanceWorkspaceMessages,
+      "getScheduledMaintenanceCreateMessageBlocks",
+    )
+    .mockResolvedValue([] as never);
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("incident created feed item", () => {
+  type CreateIncidentFeedAsyncFunction = (incident: Incident) => Promise<void>;
+
+  let feedItem: jest.SpyInstance;
+
+  beforeEach(() => {
+    feedItem = jest
+      .spyOn(IncidentFeedService, "createIncidentFeedItem")
+      .mockResolvedValue(undefined as never);
+  });
+
+  async function createFeed(relations: JSONObject): Promise<string> {
+    answerRelationReads(IncidentService, relations);
+
+    const incident: Incident = new Incident();
+    incident._id = RECORD_ID.toString();
+    incident.projectId = PROJECT_ID;
+    incident.incidentNumber = 3;
+    incident.title = "Checkout is down";
+
+    await (
+      IncidentService as unknown as {
+        createIncidentFeedAsync: CreateIncidentFeedAsyncFunction;
+      }
+    ).createIncidentFeedAsync(incident);
+
+    return postedMarkdown(feedItem);
+  }
+
+  test("names every resource the Affected Resources card lists, in its order", async () => {
+    const markdown: string = await createFeed({
+      serviceLevelObjectives: [related(SLO_ID, "Checkout availability")],
+      services: [related(SERVICE_ID, "checkout")],
+      databaseServers: [related(DATABASE_ID, "orders")],
+      kubernetesClusters: [related(CLUSTER_ID, "prod")],
+      hosts: [related(HOST_ID, "web")],
+      monitors: [related(MONITOR_ID, "checkout-web")],
+    });
+
+    expect(sectionLines(markdown, HEADER)).toEqual([
+      `- [checkout-web](${link("monitors", MONITOR_ID)})`,
+      `- [Host web](${link("host", HOST_ID)})`,
+      `- [Kubernetes Cluster prod](${link("kubernetes", CLUSTER_ID)})`,
+      `- [Database orders](${link("databases", DATABASE_ID)})`,
+      `- [Service checkout](${link("service", SERVICE_ID)})`,
+      `- [SLO Checkout availability](${link("slos", SLO_ID)})`,
+    ]);
+  });
+
+  test("an incident on a host alone - no monitors - still has a section", async () => {
+    const markdown: string = await createFeed({
+      hosts: [related(HOST_ID, "web")],
+    });
+
+    expect(sectionLines(markdown, HEADER)).toEqual([
+      `- [Host web](${link("host", HOST_ID)})`,
+    ]);
+  });
+
+  test("another project's host, linked before the write guard, is not named", async () => {
+    const markdown: string = await createFeed({
+      hosts: [
+        related(
+          FOREIGN_HOST_ID,
+          "payments-db-of-another-project",
+          OTHER_PROJECT_ID,
+        ),
+        related(HOST_ID, "web"),
+      ],
+    });
+
+    expect(sectionLines(markdown, HEADER)).toEqual([
+      `- [Host web](${link("host", HOST_ID)})`,
+    ]);
+    expect(markdown).not.toContain("payments-db-of-another-project");
+    expect(markdown).not.toContain(FOREIGN_HOST_ID);
+  });
+
+  test("a host name an agent reported cannot inject markdown", async () => {
+    const markdown: string = await createFeed({
+      hosts: [
+        related(
+          HOST_ID,
+          "web](https://evil.example) ![p](https://t.example/p.gif)",
+        ),
+      ],
+    });
+
+    expect(markdown).not.toContain("](https://evil.example)");
+    expect(markdown).not.toContain("![p](");
+  });
+
+  test("an incident linked to nothing has no section", async () => {
+    expect(sectionLines(await createFeed({}), HEADER)).toBeNull();
+  });
+});
+
+describe("alert created feed item", () => {
+  type CreateAlertFeedAsyncFunction = (alertId: ObjectID) => Promise<void>;
+
+  let feedItem: jest.SpyInstance;
+
+  beforeEach(() => {
+    feedItem = jest
+      .spyOn(AlertFeedService, "createAlertFeedItem")
+      .mockResolvedValue(undefined as never);
+  });
+
+  async function createFeed(relations: JSONObject): Promise<string> {
+    answerRelationReads(AlertService, relations);
+
+    const alert: Alert = new Alert();
+    alert._id = RECORD_ID.toString();
+    alert.projectId = PROJECT_ID;
+    alert.alertNumber = 4;
+    alert.title = "Checkout is slow";
+
+    jest.spyOn(AlertService, "findOneById").mockResolvedValue(alert as never);
+
+    await (
+      AlertService as unknown as {
+        createAlertFeedAsync: CreateAlertFeedAsyncFunction;
+      }
+    ).createAlertFeedAsync(RECORD_ID);
+
+    return postedMarkdown(feedItem);
+  }
+
+  test("names the monitor first, then everything else the card lists", async () => {
+    const markdown: string = await createFeed({
+      monitor: related(MONITOR_ID, "checkout-web"),
+      kubernetesClusters: [related(CLUSTER_ID, "prod")],
+      services: [related(SERVICE_ID, "checkout")],
+    });
+
+    expect(sectionLines(markdown, HEADER)).toEqual([
+      `- [checkout-web](${link("monitors", MONITOR_ID)})`,
+      `- [Kubernetes Cluster prod](${link("kubernetes", CLUSTER_ID)})`,
+      `- [Service checkout](${link("service", SERVICE_ID)})`,
+    ]);
+  });
+
+  test("an SLO burn-rate alert on a service names both", async () => {
+    const markdown: string = await createFeed({
+      monitor: null,
+      services: [related(SERVICE_ID, "checkout")],
+      serviceLevelObjectives: [related(SLO_ID, "Checkout availability")],
+    });
+
+    expect(sectionLines(markdown, HEADER)).toEqual([
+      `- [Service checkout](${link("service", SERVICE_ID)})`,
+      `- [SLO Checkout availability](${link("slos", SLO_ID)})`,
+    ]);
+  });
+
+  test("another project's monitor is not named", async () => {
+    const markdown: string = await createFeed({
+      monitor: related(MONITOR_ID, "someone-elses-monitor", OTHER_PROJECT_ID),
+    });
+
+    expect(sectionLines(markdown, HEADER)).toBeNull();
+    expect(markdown).not.toContain("someone-elses-monitor");
+  });
+});
+
+describe("scheduled maintenance feed items", () => {
+  let feedItem: jest.SpyInstance;
+
+  beforeEach(() => {
+    feedItem = jest
+      .spyOn(
+        ScheduledMaintenanceFeedService,
+        "createScheduledMaintenanceFeedItem",
+      )
+      .mockResolvedValue(undefined as never);
+  });
+
+  test("the created item names monitors and network sites", async () => {
+    type CreateFeedFunction = (
+      scheduledMaintenance: ScheduledMaintenance,
+    ) => Promise<void>;
+
+    answerRelationReads(ScheduledMaintenanceService, {
+      networkSites: [related(SITE_ID, "London DC")],
+      monitors: [related(MONITOR_ID, "checkout-web")],
+    });
+
+    const event: ScheduledMaintenance = new ScheduledMaintenance();
+    event._id = RECORD_ID.toString();
+    event.projectId = PROJECT_ID;
+    event.scheduledMaintenanceNumber = 5;
+    event.title = "Database upgrade";
+
+    await (
+      ScheduledMaintenanceService as unknown as {
+        createScheduledMaintenanceFeedAsync: CreateFeedFunction;
+      }
+    ).createScheduledMaintenanceFeedAsync(event);
+
+    expect(sectionLines(postedMarkdown(feedItem), HEADER)).toEqual([
+      `- [checkout-web](${link("monitors", MONITOR_ID)})`,
+      `- [Network Site London DC](${link("network-sites/view", SITE_ID)})`,
+    ]);
+  });
+
+  describe("the updated item", () => {
+    type OnUpdateSuccessFunction = (
+      onUpdate: JSONObject,
+      updatedItemIds: Array<ObjectID>,
+    ) => Promise<JSONObject>;
+
+    const UPDATED_HEADER: string = "**Resources Affected**:\n";
+
+    async function update(data: JSONObject): Promise<void> {
+      await (
+        ScheduledMaintenanceService as unknown as {
+          onUpdateSuccess: OnUpdateSuccessFunction;
+        }
+      ).onUpdateSuccess(
+        {
+          updateBy: {
+            query: { _id: RECORD_ID.toString() },
+            data: data,
+            props: { tenantId: PROJECT_ID, userId: undefined },
+          },
+          carryForward: null,
+        },
+        [RECORD_ID],
+      );
+    }
+
+    test("editing the hosts alone lists what the event now affects", async () => {
+      const reads: jest.SpyInstance = answerRelationReads(
+        ScheduledMaintenanceService,
+        {
+          monitors: [related(MONITOR_ID, "checkout-web")],
+          hosts: [related(HOST_ID, "web")],
+        },
+      );
+
+      await update({ hosts: [{ _id: HOST_ID }] });
+
+      expect(sectionLines(postedMarkdown(feedItem), UPDATED_HEADER)).toEqual([
+        `- [checkout-web](${link("monitors", MONITOR_ID)})`,
+        `- [Host web](${link("host", HOST_ID)})`,
+      ]);
+
+      // Read back as root, inside the tenant's project.
+      for (const call of reads.mock.calls) {
+        const args: { query: JSONObject; props: JSONObject } = call[0];
+
+        expect(args.query["projectId"]).toBe(PROJECT_ID);
+        expect(args.props).toEqual({ isRoot: true });
+      }
+    });
+
+    test("another project's monitor put in the payload is not named", async () => {
+      answerRelationReads(ScheduledMaintenanceService, {
+        monitors: [
+          related(MONITOR_ID, "someone-elses-monitor", OTHER_PROJECT_ID),
+        ],
+      });
+
+      await update({ monitors: [{ _id: MONITOR_ID }] });
+
+      expect(feedItem).not.toHaveBeenCalled();
+    });
+
+    test("clearing the lists, as before, writes no section and reads nothing", async () => {
+      const reads: jest.SpyInstance = answerRelationReads(
+        ScheduledMaintenanceService,
+        {},
+      );
+
+      await update({ monitors: [], hosts: [] });
+
+      expect(reads).not.toHaveBeenCalled();
+      expect(feedItem).not.toHaveBeenCalled();
+    });
+  });
+});

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

@@ -3,7 +3,6 @@ import AlertFeedService from "../../../Server/Services/AlertFeedService";
 import AlertService from "../../../Server/Services/AlertService";
 import IncidentFeedService from "../../../Server/Services/IncidentFeedService";
 import IncidentService from "../../../Server/Services/IncidentService";
-import MonitorService from "../../../Server/Services/MonitorService";
 import ProductAnalytics from "../../../Server/Utils/ProductAnalytics";
 import AlertWorkspaceMessages from "../../../Server/Utils/Workspace/WorkspaceMessages/Alert";
 import IncidentWorkspaceMessages from "../../../Server/Utils/Workspace/WorkspaceMessages/Incident";
@@ -26,6 +25,11 @@ import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
  *
  * The same markdown is posted to Slack and Teams, and the feed renders it
  * without safe mode, so a hostile SLO name is checked end to end here too.
+ *
+ * The feed builders read those relations themselves, one per query, through
+ * LinkedAffectedResources; the fixtures below answer each of those reads the
+ * way the database would. Every other relation the section now lists is
+ * covered in LinkedAffectedResourcesCreatedFeed.test.ts.
  */
 
 const DASHBOARD: string = "https://oneuptime.example/dashboard";
@@ -52,8 +56,40 @@ type OnCreateSuccessFunction = (
   createdItem: Incident,
 ) => Promise<Incident>;
 
+/*
+ * Answers the feed builder's per-relation reads from `record`: one row
+ * carrying only the relation that was selected, as the database would.
+ */
+function answerRelationReads(
+  service: { findAllBy: unknown },
+  record: Incident | Alert,
+): jest.SpyInstance {
+  return jest
+    .spyOn(service as typeof IncidentService, "findAllBy")
+    .mockImplementation((async (findAllBy: {
+      select: JSONObject;
+    }): Promise<Array<JSONObject>> => {
+      const row: JSONObject = {
+        _id: record._id!,
+        projectId: record.projectId as unknown as JSONObject,
+      };
+
+      for (const column of Object.keys(findAllBy.select)) {
+        if (column !== "_id" && column !== "projectId") {
+          row[column] = (record as unknown as JSONObject)[column]!;
+        }
+      }
+
+      return [row];
+    }) as never);
+}
+
+let incidentRelationReads: jest.SpyInstance | undefined;
+
 // The feed writers are private; they are reached the way the create hooks reach them.
 function createIncidentFeed(incident: Incident): Promise<void> {
+  incidentRelationReads = answerRelationReads(IncidentService, incident);
+
   return (
     IncidentService as unknown as {
       createIncidentFeedAsync: CreateIncidentFeedAsyncFunction;
@@ -97,6 +133,8 @@ function buildMonitor(id: string, name: string): Monitor {
   const monitor: Monitor = new Monitor();
   monitor._id = id;
   monitor.name = name;
+  // The relation reads select it; a monitor of no known project is not named.
+  monitor.projectId = PROJECT_ID;
   return monitor;
 }
 
@@ -163,7 +201,6 @@ function resourcesAffectedLines(markdown: string): Array<string> | null {
 
 let incidentFeedItem: jest.SpyInstance;
 let alertFeedItem: jest.SpyInstance;
-let dashboardUrlLookup: jest.SpyInstance;
 
 function postedMarkdown(spy: jest.SpyInstance): string {
   expect(spy).toHaveBeenCalledTimes(1);
@@ -177,22 +214,12 @@ beforeEach(() => {
    * A fresh URL per call: URL.addRoute mutates, so a shared instance would
    * hide a builder that forgot to copy it.
    */
-  dashboardUrlLookup = jest
+  jest
     .spyOn(DatabaseConfig, "getDashboardUrl")
     .mockImplementation(async (): Promise<URL> => {
       return URL.fromString(DASHBOARD);
     });
 
-  jest
-    .spyOn(MonitorService, "getMonitorLinkInDashboard")
-    .mockImplementation(
-      async (projectId: ObjectID, monitorId: ObjectID): Promise<URL> => {
-        return URL.fromString(
-          `${DASHBOARD}/${projectId.toString()}/monitors/${monitorId.toString()}`,
-        );
-      },
-    );
-
   jest
     .spyOn(IncidentWorkspaceMessages, "getIncidentCreateMessageBlocks")
     .mockResolvedValue([] as never);
@@ -246,7 +273,7 @@ describe("incident created feed item", () => {
     ]);
   });
 
-  test("a monitors-only incident reads exactly as before, without a dashboard lookup for SLOs", async () => {
+  test("a monitors-only incident reads exactly as before", async () => {
     await createIncidentFeed(
       buildIncident({ monitors: [buildMonitor(MONITOR_ID, "checkout-web")] }),
     );
@@ -254,7 +281,6 @@ describe("incident created feed item", () => {
     expect(resourcesAffectedLines(postedMarkdown(incidentFeedItem))).toEqual([
       `- [checkout-web](${monitorLink(MONITOR_ID)})`,
     ]);
-    expect(dashboardUrlLookup).not.toHaveBeenCalled();
   });
 
   test("an incident with neither monitors nor SLOs has no Resources Affected section", async () => {
@@ -328,7 +354,31 @@ describe("incident created feed item", () => {
     expect(resourcesAffectedLines(postedMarkdown(incidentFeedItem))).toBeNull();
   });
 
-  test("onCreateSuccess reads the incident's SLOs for the feed item", async () => {
+  test("reads the incident's SLOs with their project, as root", async () => {
+    await createIncidentFeed(buildIncident({}));
+
+    const sloRead: JSONObject | undefined = incidentRelationReads!.mock.calls
+      .map((call: Array<unknown>): JSONObject => {
+        return call[0] as JSONObject;
+      })
+      .find((findAllBy: JSONObject): boolean => {
+        return Boolean(
+          (findAllBy["select"] as JSONObject)["serviceLevelObjectives"],
+        );
+      });
+
+    /*
+     * projectId too: the read runs as root, and the feed names only SLOs of
+     * the record's own project.
+     */
+    expect(
+      (sloRead!["select"] as JSONObject)["serviceLevelObjectives"],
+    ).toEqual({ _id: true, name: true, projectId: true });
+    expect(sloRead!["props"]).toEqual({ isRoot: true });
+    expect((sloRead!["query"] as JSONObject)["projectId"]).toBe(PROJECT_ID);
+  });
+
+  test("onCreateSuccess leaves the relations to the feed builder's own reads", async () => {
     jest.spyOn(ProductAnalytics, "captureForUser").mockImplementation((() => {
       // no analytics in tests
     }) as never);
@@ -362,45 +412,52 @@ describe("incident created feed item", () => {
     ).select;
 
     /*
-     * projectId too: the read runs as root, and the feed names only SLOs of
-     * the record's own project.
+     * Joining every many-to-many relation into this one read would return
+     * the product of their sizes; LinkedAffectedResources reads them one at
+     * a time instead.
      */
-    expect(select["serviceLevelObjectives"]).toEqual({
-      name: true,
-      _id: true,
-      projectId: true,
-    });
-    // The monitors the section already listed are still read.
-    expect(select["monitors"]).toEqual({ name: true, _id: true });
+    expect(select["monitors"]).toBeUndefined();
+    expect(select["serviceLevelObjectives"]).toBeUndefined();
+    expect(select["projectId"]).toBe(true);
   });
 });
 
 describe("alert created feed item", () => {
+  let alertRelationReads: jest.SpyInstance;
+
   function mockAlertRow(alert: Alert): jest.SpyInstance {
+    alertRelationReads = answerRelationReads(AlertService, alert);
+
     return jest
       .spyOn(AlertService, "findOneById")
       .mockResolvedValue(alert as never);
   }
 
-  test("reads the alert's SLOs alongside its monitor", async () => {
-    const findOneById: jest.SpyInstance = mockAlertRow(buildAlert({}));
+  test("reads the alert's SLOs alongside its monitor, with their project", async () => {
+    mockAlertRow(buildAlert({}));
 
     await createAlertFeed(ALERT_ID);
 
-    const select: JSONObject = (
-      findOneById.mock.calls[0]![0] as { select: JSONObject }
-    ).select;
+    const selects: Array<JSONObject> = alertRelationReads.mock.calls.map(
+      (call: Array<unknown>): JSONObject => {
+        return (call[0] as { select: JSONObject }).select;
+      },
+    );
 
     /*
-     * projectId too: the read runs as root, and the feed names only SLOs of
-     * the record's own project.
+     * projectId too: the reads run as root, and the feed names only
+     * resources of the record's own project.
      */
-    expect(select["serviceLevelObjectives"]).toEqual({
-      name: true,
+    expect(selects).toContainEqual({
+      _id: true,
+      projectId: true,
+      serviceLevelObjectives: { _id: true, name: true, projectId: true },
+    });
+    expect(selects).toContainEqual({
       _id: true,
       projectId: true,
+      monitor: { _id: true, name: true, projectId: true },
     });
-    expect(select["monitor"]).toEqual({ name: true, _id: true });
   });
 
   test("a burn-rate alert with no monitor names its SLO under Resources Affected", async () => {
@@ -446,7 +503,6 @@ describe("alert created feed item", () => {
     expect(resourcesAffectedLines(postedMarkdown(alertFeedItem))).toEqual([
       `- [checkout-web](${monitorLink(MONITOR_ID)})`,
     ]);
-    expect(dashboardUrlLookup).not.toHaveBeenCalled();
   });
 
   test("an alert with neither monitor nor SLOs has no Resources Affected section", async () => {