@oneuptime/common 12.0.25 → 12.0.27

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

@@ -1,6 +1,7 @@
 import NetworkSiteService from "../../../Server/Services/NetworkSiteService";
 import NetworkSiteStatusTimelineService from "../../../Server/Services/NetworkSiteStatusTimelineService";
 import NetworkDeviceService from "../../../Server/Services/NetworkDeviceService";
+import NetworkSiteMaintenanceSuppression from "../../../Server/Utils/NetworkSite/NetworkSiteMaintenanceSuppression";
 import MonitorService from "../../../Server/Services/MonitorService";
 import MonitorStatusService from "../../../Server/Services/MonitorStatusService";
 import NetworkSite from "../../../Models/DatabaseModels/NetworkSite";
@@ -15,6 +16,12 @@ import UpdateBy from "../../../Server/Types/Database/UpdateBy";
 import DeleteBy from "../../../Server/Types/Database/DeleteBy";
 import { OnDelete, OnUpdate } from "../../../Server/Types/Database/Hooks";
 import { FindOperator } from "typeorm";
+import DeviceReachabilityUtil from "../../../Utils/NetworkDevice/DeviceReachabilityUtil";
+import {
+  DEVICE_HEALTH_GROUP_COLUMNS,
+  DeviceHealthGroup,
+} from "../../../Server/Utils/NetworkDevice/DeviceHealthAggregation";
+import { AggregateColumn } from "../../../Server/Types/Database/AggregateBy";
 import { describe, expect, it, afterEach } from "@jest/globals";
 
 /*
@@ -90,21 +97,97 @@ describe("NetworkSiteService.recomputeRollupForSite", () => {
     updateColumns: jest.SpyInstance;
     timelineUpdateBy: jest.SpyInstance;
     timelineCreate: jest.SpyInstance;
-    deviceFindBy: jest.SpyInstance;
+    deviceHealthGroups: jest.SpyInstance;
     descendantSiteIds: jest.SpyInstance;
+    maintainedSiteIds: jest.SpyInstance;
+  }
+
+  /*
+   * The rollup no longer reads device ROWS — it asks Postgres to bucket the
+   * subtree by the facts the reachability rule reads, and classifies the
+   * buckets. So a test still describes its scenario as devices (which is what
+   * the scenario IS), and this turns them into the buckets the database would
+   * have returned for exactly those devices.
+   *
+   * The staleness predicate is the one thing SQL evaluates rather than the
+   * shared util, so it is computed here from that util's own window rather
+   * than a hard-coded number — the same arrangement, for the same reason, as
+   * Common/Tests/Server/Utils/NetworkDevice/DeviceHealthAggregation.test.ts.
+   */
+  function toHealthGroups(
+    devices: Array<NetworkDevice>,
+  ): Array<DeviceHealthGroup> {
+    const now: number = Date.now();
+
+    return devices.map((device: NetworkDevice): DeviceHealthGroup => {
+      const contactTimes: Array<number> = [
+        device.lastPolledAt,
+        device.lastSeenAt,
+      ]
+        .filter((value: Date | undefined): value is Date => {
+          return Boolean(value);
+        })
+        .map((value: Date): number => {
+          return new Date(value).getTime();
+        });
+
+      const lastContactAt: number | null =
+        contactTimes.length > 0 ? Math.max(...contactTimes) : null;
+
+      const staleWindowInMinutes: number =
+        DeviceReachabilityUtil.getStaleWindowInMinutes(
+          device.pollingIntervalInMinutes,
+        );
+
+      return {
+        siteId: null,
+        monitorStatusId: device.currentMonitorStatusId?.toString() ?? null,
+        monitoringMethod: device.monitoringMethod ?? null,
+        isReachable:
+          device.isReachable === undefined ? null : device.isReachable,
+        hasBeenPolled: Boolean(device.lastPolledAt),
+        hasBeenSeen: Boolean(device.lastSeenAt),
+        /*
+         * Guarded exactly as the SQL is: staleness is only computed for the
+         * one branch of the reachability rule that can read it.
+         */
+        isStale:
+          (device.isReachable === undefined || device.isReachable === null) &&
+          Boolean(device.lastSeenAt) &&
+          lastContactAt !== null &&
+          lastContactAt < now - staleWindowInMinutes * 60 * 1000,
+        hasDownInterfaces: (device.interfacesDown || 0) > 0,
+        deviceCount: 1,
+        interfacesDownTotal: device.interfacesDown || 0,
+      };
+    });
   }
 
   function setupRollup(data: {
     site: NetworkSite | null;
     devices: Array<NetworkDevice>;
+    // Site ids an ongoing maintenance window is currently silencing.
+    maintainedSiteIds?: Array<ObjectID> | undefined;
   }): RollupSpies {
     jest.spyOn(NetworkSiteService, "findOneById").mockResolvedValue(data.site);
     const descendantSiteIds: jest.SpyInstance = jest
       .spyOn(NetworkSiteService, "getDescendantSiteIds")
       .mockResolvedValue([]);
-    const deviceFindBy: jest.SpyInstance = jest
-      .spyOn(NetworkDeviceService, "findBy")
-      .mockResolvedValue(data.devices);
+    const deviceHealthGroups: jest.SpyInstance = jest
+      .spyOn(NetworkDeviceService, "getHealthGroupsForSites")
+      .mockResolvedValue(toHealthGroups(data.devices));
+    const maintainedSiteIds: jest.SpyInstance = jest
+      .spyOn(
+        NetworkSiteMaintenanceSuppression,
+        "getSiteIdsUnderOngoingMaintenance",
+      )
+      .mockResolvedValue(
+        new Set<string>(
+          (data.maintainedSiteIds || []).map((id: ObjectID) => {
+            return id.toString();
+          }),
+        ),
+      );
     jest
       .spyOn(MonitorStatusService, "findBy")
       .mockResolvedValue(fakeStatuses());
@@ -123,8 +206,9 @@ describe("NetworkSiteService.recomputeRollupForSite", () => {
       updateColumns,
       timelineUpdateBy,
       timelineCreate,
-      deviceFindBy,
+      deviceHealthGroups,
       descendantSiteIds,
+      maintainedSiteIds,
     };
   }
 
@@ -254,11 +338,35 @@ describe("NetworkSiteService.recomputeRollupForSite", () => {
   });
 
   /*
-   * The rollup reads four columns and the query has to fetch all four. A
-   * missing `isReachable` here compiles, runs, and silently drops the whole
-   * subtree back onto the legacy freshness path.
+   * The rollup reads four columns, and the hazard has moved from a `select`
+   * to a GROUP BY: a fact the rule reads that the grouping does not is a fact
+   * two devices can disagree on inside one bucket, and the bucket then gets
+   * one verdict for both. A missing `isReachable` still compiles, still runs,
+   * and still silently drops the whole subtree onto the legacy freshness path
+   * — it just does it one layer down now.
    */
-  it("selects every column the reachability rule reads", async () => {
+  it("groups by every column the reachability rule reads", async () => {
+    const expressions: string = DEVICE_HEALTH_GROUP_COLUMNS.map(
+      (column: AggregateColumn): string => {
+        return column.expression;
+      },
+    ).join(" ");
+
+    expect(expressions).toContain("isReachable");
+    expect(expressions).toContain("lastPolledAt");
+    expect(expressions).toContain("lastSeenAt");
+    expect(expressions).toContain("pollingIntervalInMinutes");
+    expect(expressions).toContain("currentMonitorStatusId");
+  });
+
+  /*
+   * Every device in the subtree is classified against ONE instant, passed in
+   * rather than read from the database's clock. Two devices measured against
+   * two different "now"s can disagree about staleness by a whole polling
+   * interval, and the rollup would then flip between runs with nothing
+   * having changed.
+   */
+  it("classifies the whole subtree against one instant", async () => {
     const spies: RollupSpies = setupRollup({
       site: fakeSite({ currentMonitorStatusId: OPERATIONAL_STATUS_ID }),
       devices: [],
@@ -266,13 +374,8 @@ describe("NetworkSiteService.recomputeRollupForSite", () => {
 
     await NetworkSiteService.recomputeRollupForSite(SITE_ID);
 
-    const select: Record<string, unknown> =
-      spies.deviceFindBy.mock.calls[0]![0].select;
-
-    expect(select["isReachable"]).toBe(true);
-    expect(select["lastPolledAt"]).toBe(true);
-    expect(select["lastSeenAt"]).toBe(true);
-    expect(select["pollingIntervalInMinutes"]).toBe(true);
+    const args: any = spies.deviceHealthGroups.mock.calls[0]![0];
+    expect(args.now).toBeInstanceOf(Date);
   });
 
   it("does nothing when the site does not exist", async () => {
@@ -286,11 +389,13 @@ describe("NetworkSiteService.recomputeRollupForSite", () => {
   });
 
   /*
-   * An archived device is decommissioned: it keeps its siteId but must not
-   * vote. Without this filter an archived, never-monitored device hits the
-   * freshness fallback and pins its whole ancestor chain Offline forever.
+   * The bucketing query is scoped to the site's own project and to its own
+   * subtree — one statement, not one per site, and never another tenant's
+   * devices. (The archived-device filter lives inside
+   * getHealthGroupsForSites and is pinned by
+   * App/Tests/BaseAPI/NetworkSiteHierarchyDeviceRollup.test.ts.)
    */
-  it("excludes archived devices from the subtree scan", async () => {
+  it("buckets the subtree's devices in one project-scoped call", async () => {
     const spies: RollupSpies = setupRollup({
       site: fakeSite({ currentMonitorStatusId: OPERATIONAL_STATUS_ID }),
       devices: [],
@@ -298,10 +403,46 @@ describe("NetworkSiteService.recomputeRollupForSite", () => {
 
     await NetworkSiteService.recomputeRollupForSite(SITE_ID);
 
-    expect(spies.deviceFindBy).toHaveBeenCalledTimes(1);
-    const deviceQuery: any = spies.deviceFindBy.mock.calls[0]![0].query;
-    expect(deviceQuery.isArchived).toBe(false);
-    expect(deviceQuery.projectId.toString()).toBe(PROJECT_ID.toString());
+    expect(spies.deviceHealthGroups).toHaveBeenCalledTimes(1);
+    const groupArgs: any = spies.deviceHealthGroups.mock.calls[0]![0];
+    expect(groupArgs.projectId.toString()).toBe(PROJECT_ID.toString());
+    /*
+     * The archived filter moved into getHealthGroupsForSites with the query.
+     * Asserted there — NetworkDeviceService's own suite pins that the method
+     * really does send `isArchived: false`.
+     */
+    expect(
+      groupArgs.siteIds.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    ).toEqual([SITE_ID.toString()]);
+  });
+
+  /*
+   * Issue #3431. A rollup must not fail because the maintenance lookup did —
+   * the util already degrades to "nothing suppressed", and this pins that
+   * the engine treats that as an ordinary answer rather than a reason to
+   * skip the run.
+   */
+  it("rolls up normally when nothing is under maintenance", async () => {
+    const spies: RollupSpies = setupRollup({
+      site: fakeSite({ currentMonitorStatusId: OPERATIONAL_STATUS_ID }),
+      devices: [
+        {
+          id: DEVICE_ID,
+          currentMonitorStatusId: OFFLINE_STATUS_ID,
+        },
+      ] as unknown as Array<NetworkDevice>,
+      maintainedSiteIds: [],
+    });
+
+    await NetworkSiteService.recomputeRollupForSite(SITE_ID);
+
+    expect(spies.maintainedSiteIds).toHaveBeenCalledTimes(1);
+    const updateArgs: any = spies.updateColumns.mock.calls[0]![0];
+    expect(updateArgs.data.currentMonitorStatusId.toString()).toBe(
+      OFFLINE_STATUS_ID.toString(),
+    );
   });
 
   it("scopes the descendant lookup to the site's own project", async () => {

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

@@ -10,6 +10,7 @@ import logger from "../../../Server/Utils/Logger";
 import MarketingEventUtil from "../../../Server/Utils/Marketing/MarketingEventUtil";
 import ProductAnalytics from "../../../Server/Utils/ProductAnalytics";
 import { MarketingEvent } from "../../../Types/Marketing/MarketingEvent";
+import { resolveEmittedMarketingEvent } from "../Utils/Marketing/EmittedMarketingEvent";
 import { describe, expect, it, afterEach } from "@jest/globals";
 
 /*
@@ -715,7 +716,7 @@ describe("ProjectService.changePlan", () => {
 
       const emittedTypes: Array<string> = emitInBackground.mock.calls.map(
         (call: Array<unknown>) => {
-          return (call[0] as MarketingEvent).eventType as string;
+          return resolveEmittedMarketingEvent(call[0]).eventType as string;
         },
       );
 
@@ -774,8 +775,9 @@ describe("ProjectService.changePlan", () => {
         paymentProviderPlanId: NEW_PLAN_ID,
       });
 
-      const event: MarketingEvent = emitInBackground.mock
-        .calls[0]![0] as MarketingEvent;
+      const event: MarketingEvent = resolveEmittedMarketingEvent(
+        emitInBackground.mock.calls[0]![0],
+      );
 
       expect(event.eventId).toBe(
         `subscription_upgraded:${PROJECT_ID.toString()}:${event.occurredAt}`,

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

@@ -5,6 +5,7 @@ import ProductAnalytics from "../../../Server/Utils/ProductAnalytics";
 import Project from "../../../Models/DatabaseModels/Project";
 import SubscriptionPlan from "../../../Types/Billing/SubscriptionPlan";
 import { MarketingEvent } from "../../../Types/Marketing/MarketingEvent";
+import { resolveEmittedMarketingEvent } from "../Utils/Marketing/EmittedMarketingEvent";
 import { JSONObject } from "../../../Types/JSON";
 import ObjectID from "../../../Types/ObjectID";
 import { describe, expect, it, afterEach } from "@jest/globals";
@@ -202,7 +203,9 @@ describe("ProjectService project creation - subscription_started", () => {
   }
 
   function getEmittedEvent(spies: CreateSpies): MarketingEvent {
-    return spies.emitInBackground.mock.calls[0]![0] as MarketingEvent;
+    return resolveEmittedMarketingEvent(
+      spies.emitInBackground.mock.calls[0]![0],
+    );
   }
 
   function getEmittedData(spies: CreateSpies): JSONObject {
@@ -298,7 +301,7 @@ describe("ProjectService project creation - subscription_started", () => {
 
       const emittedTypes: Array<string> = spies.emitInBackground.mock.calls.map(
         (call: Array<unknown>) => {
-          return (call[0] as MarketingEvent).eventType as string;
+          return resolveEmittedMarketingEvent(call[0]).eventType as string;
         },
       );
 

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

@@ -0,0 +1,304 @@
+import { beforeEach, describe, expect, jest, test } from "@jest/globals";
+
+/*
+ * PasswordHash carries a pre-existing TS5.9 diagnostic that fails any suite
+ * whose runtime require graph reaches it, and DatabaseService imports it.
+ */
+jest.mock("../../../Server/Utils/PasswordHash", () => {
+  return {
+    __esModule: true,
+    default: {
+      hash: jest.fn(),
+      verify: jest.fn(),
+      generateSalt: jest.fn(),
+      needsUpgrade: jest.fn(),
+      applyPepper: jest.fn(),
+    },
+  };
+});
+
+import KubernetesClusterService from "../../../Server/Services/KubernetesClusterService";
+import KubernetesClusterFeedService from "../../../Server/Services/KubernetesClusterFeedService";
+import UserService from "../../../Server/Services/UserService";
+import KubernetesCluster from "../../../Models/DatabaseModels/KubernetesCluster";
+import { KubernetesClusterFeedEventType } from "../../../Models/DatabaseModels/KubernetesClusterFeed";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * The two questions this whole feature exists to answer, pinned on the one
+ * family that exercises both paths hardest:
+ *
+ *   "who created this cluster?"  and  "was it created automatically?"
+ *
+ * A Kubernetes cluster appears in a project one of two ways - somebody adds it
+ * from the dashboard, or the collector reports telemetry for a cluster that is
+ * not there yet and ingest registers it. Nothing on the overview page
+ * distinguishes those, and the difference is exactly what somebody looking at
+ * an unfamiliar cluster wants to know.
+ *
+ * The signal is whether an acting user is attached to the create: ingest
+ * creates with root props and no user. That is a subtle thing to get right and
+ * a very easy thing to break, because both branches produce a perfectly
+ * plausible-looking feed item.
+ *
+ * The update half is pinned here too, and it matters just as much: these rows
+ * take a liveness write roughly once a minute per resource, forever. A feed
+ * that recorded those would bury the handful of real events under thousands of
+ * "was updated" entries within a day.
+ */
+
+const CLUSTER_ID: ObjectID = ObjectID.generate();
+const PROJECT_ID: ObjectID = ObjectID.generate();
+const ACTING_USER_ID: ObjectID = ObjectID.generate();
+
+interface FeedCall {
+  kubernetesClusterId: ObjectID;
+  projectId: ObjectID;
+  kubernetesClusterFeedEventType: KubernetesClusterFeedEventType;
+  feedInfoInMarkdown: string;
+  moreInformationInMarkdown?: string | undefined;
+  userId?: ObjectID | undefined;
+}
+
+let feedCalls: Array<FeedCall> = [];
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const service: any = KubernetesClusterService as any;
+
+function cluster(overrides: Partial<KubernetesCluster>): KubernetesCluster {
+  const model: KubernetesCluster = new KubernetesCluster(CLUSTER_ID);
+  model.projectId = PROJECT_ID;
+  model.name = "prod-us-east";
+  Object.assign(model, overrides);
+  return model;
+}
+
+beforeEach(() => {
+  feedCalls = [];
+
+  jest
+    .spyOn(KubernetesClusterFeedService, "createKubernetesClusterFeedItem")
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    .mockImplementation((data: any): Promise<void> => {
+      feedCalls.push(data as FeedCall);
+      return Promise.resolve();
+    });
+
+  jest
+    .spyOn(KubernetesClusterService, "getKubernetesClusterMarkdownLink")
+    .mockImplementation((): Promise<string> => {
+      return Promise.resolve(
+        "[Kubernetes Cluster prod-us-east](https://example.com/cluster)",
+      );
+    });
+
+  jest
+    .spyOn(UserService, "getUserMarkdownString")
+    .mockImplementation((): Promise<string> => {
+      return Promise.resolve("Jane Doe (jane@example.com)");
+    });
+});
+
+describe("KubernetesCluster creation feed", () => {
+  test("attributes a dashboard create to the user who made it", async () => {
+    await service.writeKubernetesClusterCreatedFeed(
+      cluster({ clusterIdentifier: "prod-us-east" }),
+      { createBy: { props: { userId: ACTING_USER_ID } } },
+    );
+
+    expect(feedCalls.length).toBe(1);
+    expect(feedCalls[0]!.kubernetesClusterFeedEventType).toBe(
+      KubernetesClusterFeedEventType.KubernetesClusterCreated,
+    );
+    expect(feedCalls[0]!.feedInfoInMarkdown).toContain("Jane Doe");
+    expect(feedCalls[0]!.moreInformationInMarkdown).toContain(
+      "**Automatically created from telemetry**: No.",
+    );
+    expect(feedCalls[0]!.userId).toBe(ACTING_USER_ID);
+  });
+
+  test("says telemetry discovered it when ingest created it", async () => {
+    await service.writeKubernetesClusterCreatedFeed(
+      cluster({ clusterIdentifier: "prod-us-east" }),
+      { createBy: { props: { isRoot: true } } },
+    );
+
+    expect(feedCalls.length).toBe(1);
+    expect(feedCalls[0]!.moreInformationInMarkdown).toContain(
+      "**Automatically created from telemetry**: Yes.",
+    );
+    // Nobody to attribute it to, so nobody is named.
+    expect(feedCalls[0]!.userId).toBeUndefined();
+    expect(feedCalls[0]!.moreInformationInMarkdown).toContain("`prod-us-east`");
+  });
+
+  test("prefers the row's own createdByUserId over the request's", async () => {
+    const rowUserId: ObjectID = ObjectID.generate();
+
+    await service.writeKubernetesClusterCreatedFeed(
+      cluster({ createdByUserId: rowUserId }),
+      { createBy: { props: { userId: ACTING_USER_ID } } },
+    );
+
+    expect(feedCalls[0]!.userId).toBe(rowUserId);
+  });
+
+  test("writes nothing for a row with no project", async () => {
+    const model: KubernetesCluster = new KubernetesCluster(CLUSTER_ID);
+
+    await service.writeKubernetesClusterCreatedFeed(model, {
+      createBy: { props: {} },
+    });
+
+    expect(feedCalls.length).toBe(0);
+  });
+
+  test("onCreateSuccess writes the feed without being able to fail the create", async () => {
+    jest
+      .spyOn(service, "writeKubernetesClusterCreatedFeed")
+      .mockImplementation((): Promise<void> => {
+        return Promise.reject(new Error("feed write blew up"));
+      });
+
+    const createdItem: KubernetesCluster = cluster({});
+
+    await expect(
+      service.onCreateSuccess({ createBy: { props: {} } }, createdItem),
+    ).resolves.toBe(createdItem);
+
+    expect(service.writeKubernetesClusterCreatedFeed).toHaveBeenCalled();
+  });
+});
+
+describe("KubernetesCluster update feed", () => {
+  beforeEach(() => {
+    jest
+      .spyOn(KubernetesClusterService, "findOneById")
+      .mockImplementation((): Promise<KubernetesCluster | null> => {
+        return Promise.resolve(cluster({}));
+      });
+  });
+
+  test("stays silent for a heartbeat", async () => {
+    await service.writeKubernetesClusterUpdatedFeed(
+      {
+        updateBy: {
+          data: {
+            lastSeenAt: new Date(),
+            otelCollectorStatus: "connected",
+            agentVersion: "1.2.3",
+            nodeCount: 9,
+          },
+          props: {},
+        },
+      },
+      [CLUSTER_ID],
+    );
+
+    expect(feedCalls.length).toBe(0);
+  });
+
+  test("records a rename and names the field", async () => {
+    await service.writeKubernetesClusterUpdatedFeed(
+      {
+        updateBy: {
+          data: { name: "prod-eu-west", lastSeenAt: new Date() },
+          props: { userId: ACTING_USER_ID },
+        },
+      },
+      [CLUSTER_ID],
+    );
+
+    expect(feedCalls.length).toBe(1);
+    expect(feedCalls[0]!.kubernetesClusterFeedEventType).toBe(
+      KubernetesClusterFeedEventType.KubernetesClusterUpdated,
+    );
+    expect(feedCalls[0]!.moreInformationInMarkdown).toContain("`name`");
+    expect(feedCalls[0]!.moreInformationInMarkdown).not.toContain(
+      "`lastSeenAt`",
+    );
+    expect(feedCalls[0]!.userId).toBe(ACTING_USER_ID);
+  });
+
+  test("archiving and restoring get their own events", async () => {
+    await service.writeKubernetesClusterUpdatedFeed(
+      { updateBy: { data: { isArchived: true }, props: {} } },
+      [CLUSTER_ID],
+    );
+
+    expect(
+      feedCalls.map((call: FeedCall) => {
+        return call.kubernetesClusterFeedEventType;
+      }),
+    ).toEqual([KubernetesClusterFeedEventType.KubernetesClusterArchived]);
+
+    feedCalls = [];
+
+    await service.writeKubernetesClusterUpdatedFeed(
+      { updateBy: { data: { isArchived: false }, props: {} } },
+      [CLUSTER_ID],
+    );
+
+    expect(
+      feedCalls.map((call: FeedCall) => {
+        return call.kubernetesClusterFeedEventType;
+      }),
+    ).toEqual([KubernetesClusterFeedEventType.KubernetesClusterRestored]);
+  });
+
+  test("an archive that also renames records both, and not as one muddled entry", async () => {
+    await service.writeKubernetesClusterUpdatedFeed(
+      {
+        updateBy: {
+          data: { isArchived: true, name: "retired-cluster" },
+          props: {},
+        },
+      },
+      [CLUSTER_ID],
+    );
+
+    expect(
+      feedCalls.map((call: FeedCall) => {
+        return call.kubernetesClusterFeedEventType;
+      }),
+    ).toEqual([
+      KubernetesClusterFeedEventType.KubernetesClusterArchived,
+      KubernetesClusterFeedEventType.KubernetesClusterUpdated,
+    ]);
+
+    /*
+     * The "updated" item must not claim isArchived as one of the changed
+     * fields - the archive item already says that, in plain words.
+     */
+    expect(feedCalls[1]!.moreInformationInMarkdown).toContain("`name`");
+    expect(feedCalls[1]!.moreInformationInMarkdown).not.toContain(
+      "`isArchived`",
+    );
+  });
+
+  test("writes one item per updated row on a bulk update", async () => {
+    const secondId: ObjectID = ObjectID.generate();
+
+    await service.writeKubernetesClusterUpdatedFeed(
+      { updateBy: { data: { isArchived: true }, props: {} } },
+      [CLUSTER_ID, secondId],
+    );
+
+    expect(feedCalls.length).toBe(2);
+  });
+
+  test("skips a row it can no longer resolve a project for", async () => {
+    jest
+      .spyOn(KubernetesClusterService, "findOneById")
+      .mockImplementation((): Promise<KubernetesCluster | null> => {
+        return Promise.resolve(null);
+      });
+
+    await service.writeKubernetesClusterUpdatedFeed(
+      { updateBy: { data: { name: "gone" }, props: {} } },
+      [CLUSTER_ID],
+    );
+
+    expect(feedCalls.length).toBe(0);
+  });
+});