@oneuptime/common 12.0.31 → 12.0.33

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

@@ -1,3 +1,5 @@
+import fs from "fs";
+import path from "path";
 import ProjectService from "../../../Server/Services/ProjectService";
 import BillingService from "../../../Server/Services/BillingService";
 import MarketingEventUtil from "../../../Server/Utils/Marketing/MarketingEventUtil";
@@ -8,7 +10,7 @@ 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";
+import { describe, expect, it, afterEach, test } from "@jest/globals";
 
 /*
  * A project created directly on a paid plan never passes through changePlan,
@@ -121,9 +123,11 @@ describe("ProjectService project creation - subscription_started", () => {
   }
 
   /*
-   * The nine default-row seeders run after the conversion is captured and each
-   * one writes to a different table. None of them are what is under test, so
-   * they are stubbed out wholesale.
+   * The default-row seeders run after the conversion is captured and each one
+   * writes to a different table. None of them are what is under test, so they
+   * are stubbed out wholesale. This list must name every seeder in
+   * ProjectService.onCreateSuccess: one left off reaches a real repository and
+   * throws "Database not connected", failing the whole suite.
    */
   const DEFAULT_SEEDERS: Array<string> = [
     "addDefaultIncidentSeverity",
@@ -135,6 +139,7 @@ describe("ProjectService project creation - subscription_started", () => {
     "addDefaultAlertState",
     "addDefaultIncidentRoles",
     "addDefaultNetworkSiteTypes",
+    "addDefaultNetworkDeviceRoles",
   ];
 
   function setup(data?: {
@@ -516,4 +521,62 @@ describe("ProjectService project creation - subscription_started", () => {
       expect(emitOrder).toBeGreaterThan(writeOrder);
     });
   });
+
+  /*
+   * The list above is a hand-maintained mirror of the seeders
+   * onCreateSuccess runs, and nothing about adding a tenth seeder to the
+   * service makes this file fail to compile. When addDefaultNetworkDeviceRoles
+   * was added and this list was not updated, the unstubbed seeder reached a
+   * real repository and every test in this suite failed with "Database not
+   * connected" — on master, not in review.
+   *
+   * So the mirror is checked against its source. Read as text because
+   * onCreateSuccess is protected and the seeder batch is a statement inside
+   * it: there is nothing to enumerate at runtime without actually creating a
+   * project, which is the thing this suite stubs out.
+   */
+  describe("the stub list stays in step with the service", () => {
+    const PROJECT_SERVICE_SOURCE: string = fs.readFileSync(
+      path.join(__dirname, "../../../Server/Services/ProjectService.ts"),
+      "utf8",
+    );
+
+    function seedersInCreateHook(): Array<string> {
+      const start: number = PROJECT_SERVICE_SOURCE.indexOf(
+        "await Promise.all([",
+      );
+      expect(start).toBeGreaterThan(-1);
+
+      const block: string = PROJECT_SERVICE_SOURCE.slice(
+        start,
+        PROJECT_SERVICE_SOURCE.indexOf("]);", start),
+      );
+
+      return Array.from(
+        block.matchAll(/this\.(addDefault\w+)\(createdItem\)/g),
+        (match: RegExpMatchArray): string => {
+          return match[1]!;
+        },
+      );
+    }
+
+    test("every seeder the create hook runs is stubbed here", () => {
+      const inHook: Array<string> = seedersInCreateHook();
+
+      expect(inHook.length).toBeGreaterThan(0);
+      expect(DEFAULT_SEEDERS.slice().sort()).toEqual(inHook.slice().sort());
+    });
+
+    /*
+     * A stub for a seeder that no longer exists is dead weight, and
+     * jest.spyOn would throw on the missing method rather than skip it.
+     */
+    test("every seeder stubbed here is a real method on the service", () => {
+      for (const seeder of DEFAULT_SEEDERS) {
+        expect(
+          typeof (ProjectService as unknown as Record<string, unknown>)[seeder],
+        ).toBe("function");
+      }
+    });
+  });
 });

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

@@ -0,0 +1,214 @@
+import NetworkSiteTypeService from "../../../Server/Services/NetworkSiteTypeService";
+import ProjectService from "../../../Server/Services/ProjectService";
+import NetworkSiteType from "../../../Models/DatabaseModels/NetworkSiteType";
+import Project from "../../../Models/DatabaseModels/Project";
+import DefaultNetworkSiteType from "../../../Types/NetworkSite/DefaultNetworkSiteType";
+import {
+  DefaultNetworkSiteTypeCreationOrder,
+  DefaultNetworkSiteTypeParent,
+} from "../../../Types/NetworkSite/DefaultNetworkSiteTypeHierarchy";
+import ObjectID from "../../../Types/ObjectID";
+import LIMIT_MAX from "../../../Types/Database/LimitMax";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
+import { afterEach, describe, expect, it } from "@jest/globals";
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+
+function typeId(index: number): ObjectID {
+  return new ObjectID(
+    `aaaaaaaa-aaaa-4aaa-8aaa-${index.toString().padStart(12, "0")}`,
+  );
+}
+
+function project(): Project {
+  const project: Project = new Project();
+  project.id = PROJECT_ID;
+  return project;
+}
+
+function existingType(
+  name: DefaultNetworkSiteType,
+  index: number,
+): NetworkSiteType {
+  const networkSiteType: NetworkSiteType = new NetworkSiteType();
+  networkSiteType.id = typeId(index);
+  networkSiteType.name = name;
+  networkSiteType.projectId = PROJECT_ID;
+  return networkSiteType;
+}
+
+function mockCreatesWithIds(startingIndex: number = 1): jest.SpyInstance {
+  let index: number = startingIndex;
+
+  return jest
+    .spyOn(NetworkSiteTypeService, "create")
+    .mockImplementation(async (createBy: any) => {
+      createBy.data.id = typeId(index);
+      index++;
+      return createBy.data;
+    });
+}
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("ProjectService default Network Site Type hierarchy", () => {
+  it("creates defaults parent-first with the explicit hierarchy and sibling orders", async () => {
+    jest.spyOn(NetworkSiteTypeService, "findBy").mockResolvedValue([]);
+    const createSpy: jest.SpyInstance = mockCreatesWithIds();
+
+    await ProjectService.addDefaultNetworkSiteTypes(project());
+
+    const created: Array<NetworkSiteType> = createSpy.mock.calls.map(
+      (call: Array<any>) => {
+        return call[0].data as NetworkSiteType;
+      },
+    );
+    const byName: Map<DefaultNetworkSiteType, NetworkSiteType> = new Map(
+      created.map((networkSiteType: NetworkSiteType) => {
+        return [
+          networkSiteType.name as DefaultNetworkSiteType,
+          networkSiteType,
+        ];
+      }),
+    );
+
+    expect(
+      created.map((networkSiteType: NetworkSiteType) => {
+        return networkSiteType.name;
+      }),
+    ).toEqual(DefaultNetworkSiteTypeCreationOrder);
+
+    for (const name of DefaultNetworkSiteTypeCreationOrder) {
+      const networkSiteType: NetworkSiteType = byName.get(name)!;
+      const parentName: DefaultNetworkSiteType | null =
+        DefaultNetworkSiteTypeParent[name];
+
+      expect(networkSiteType.projectId).toEqual(PROJECT_ID);
+      expect(networkSiteType.isUnitLevel).toBe(
+        name === DefaultNetworkSiteType.Unit,
+      );
+
+      if (parentName) {
+        expect(networkSiteType.parentNetworkSiteTypeId).toEqual(
+          byName.get(parentName)!.id,
+        );
+        expect(networkSiteType.order).toBe(1);
+      } else {
+        expect(networkSiteType.parentNetworkSiteTypeId).toBeUndefined();
+      }
+    }
+
+    expect(byName.get(DefaultNetworkSiteType.AccountType)!.order).toBe(1);
+    expect(byName.get(DefaultNetworkSiteType.DataCenter)!.order).toBe(2);
+    expect(byName.get(DefaultNetworkSiteType.Other)!.order).toBe(3);
+  });
+
+  it("can seed legacy defaults without pre-empting the concrete-tree backfill", async () => {
+    jest.spyOn(NetworkSiteTypeService, "findBy").mockResolvedValue([]);
+    const createSpy: jest.SpyInstance = mockCreatesWithIds();
+
+    await ProjectService.addDefaultNetworkSiteTypes(project(), {
+      setParentRelationships: false,
+    });
+
+    const created: Array<NetworkSiteType> = createSpy.mock.calls.map(
+      (call: Array<any>) => {
+        return call[0].data as NetworkSiteType;
+      },
+    );
+
+    expect(created).toHaveLength(DefaultNetworkSiteTypeCreationOrder.length);
+    expect(
+      created.every((networkSiteType: NetworkSiteType): boolean => {
+        return !networkSiteType.parentNetworkSiteTypeId;
+      }),
+    ).toBe(true);
+    expect(
+      created.map((networkSiteType: NetworkSiteType) => {
+        return networkSiteType.order;
+      }),
+    ).toEqual([1, 2, 3, 4, 5, 6, 7]);
+  });
+
+  it("is idempotent when every default already exists", async () => {
+    jest.spyOn(NetworkSiteTypeService, "findBy").mockResolvedValue(
+      DefaultNetworkSiteTypeCreationOrder.map(
+        (name: DefaultNetworkSiteType, index: number) => {
+          return existingType(name, index + 1);
+        },
+      ),
+    );
+    const createSpy: jest.SpyInstance = jest.spyOn(
+      NetworkSiteTypeService,
+      "create",
+    );
+
+    await ProjectService.addDefaultNetworkSiteTypes(project());
+
+    expect(createSpy).not.toHaveBeenCalled();
+  });
+
+  it("reads every type page before deciding which defaults are missing", async () => {
+    const customType: NetworkSiteType = new NetworkSiteType(typeId(98));
+    customType.name = "Custom type";
+    customType.projectId = PROJECT_ID;
+    const existingUnit: NetworkSiteType = existingType(
+      DefaultNetworkSiteType.Unit,
+      99,
+    );
+    const findSpy: jest.SpyInstance = jest
+      .spyOn(NetworkSiteTypeService, "findBy")
+      .mockResolvedValueOnce(
+        Array.from({ length: LIMIT_MAX }, () => {
+          return customType;
+        }),
+      )
+      .mockResolvedValueOnce([existingUnit]);
+    const createSpy: jest.SpyInstance = mockCreatesWithIds();
+
+    await ProjectService.addDefaultNetworkSiteTypes(project());
+
+    expect(findSpy).toHaveBeenCalledTimes(2);
+    expect(findSpy.mock.calls[0]![0]).toEqual(
+      expect.objectContaining({
+        skip: 0,
+        limit: LIMIT_MAX,
+        sort: { _id: SortOrder.Ascending },
+      }),
+    );
+    expect(findSpy.mock.calls[1]![0]).toEqual(
+      expect.objectContaining({ skip: LIMIT_MAX, limit: LIMIT_MAX }),
+    );
+    expect(
+      createSpy.mock.calls.some((call: Array<any>): boolean => {
+        return call[0].data.name === DefaultNetworkSiteType.Unit;
+      }),
+    ).toBe(false);
+  });
+
+  it("resolves a newly created child against an existing default parent", async () => {
+    const existingAccount: NetworkSiteType = existingType(
+      DefaultNetworkSiteType.AccountType,
+      99,
+    );
+    jest
+      .spyOn(NetworkSiteTypeService, "findBy")
+      .mockResolvedValue([existingAccount]);
+    const createSpy: jest.SpyInstance = mockCreatesWithIds(1);
+
+    await ProjectService.addDefaultNetworkSiteTypes(project());
+
+    const region: NetworkSiteType = createSpy.mock.calls.find(
+      (call: Array<any>) => {
+        return call[0].data.name === DefaultNetworkSiteType.Region;
+      },
+    )![0].data;
+
+    expect(region.parentNetworkSiteTypeId).toEqual(existingAccount.id);
+    expect(createSpy).toHaveBeenCalledTimes(6);
+  });
+});

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

@@ -0,0 +1,369 @@
+import ScheduledMaintenance from "../../../Models/DatabaseModels/ScheduledMaintenance";
+import ProjectCallSMSConfig from "../../../Models/DatabaseModels/ProjectCallSMSConfig";
+import ProjectSmtpConfig from "../../../Models/DatabaseModels/ProjectSmtpConfig";
+import StatusPage from "../../../Models/DatabaseModels/StatusPage";
+import StatusPageSubscriber from "../../../Models/DatabaseModels/StatusPageSubscriber";
+import StatusPageSubscriberNotificationTemplate from "../../../Models/DatabaseModels/StatusPageSubscriberNotificationTemplate";
+import DatabaseConfig from "../../../Server/DatabaseConfig";
+import MailService from "../../../Server/Services/MailService";
+import ProjectCallSMSConfigService from "../../../Server/Services/ProjectCallSMSConfigService";
+import ProjectSmtpConfigService from "../../../Server/Services/ProjectSmtpConfigService";
+import ScheduledMaintenanceService from "../../../Server/Services/ScheduledMaintenanceService";
+import SmsService from "../../../Server/Services/SmsService";
+import StatusPageResourceService from "../../../Server/Services/StatusPageResourceService";
+import StatusPageService from "../../../Server/Services/StatusPageService";
+import StatusPageSubscriberNotificationTemplateService from "../../../Server/Services/StatusPageSubscriberNotificationTemplateService";
+import StatusPageSubscriberService from "../../../Server/Services/StatusPageSubscriberService";
+import Markdown from "../../../Server/Types/Markdown";
+import SlackUtil from "../../../Server/Utils/Workspace/Slack/Slack";
+import StatusPageSubscriberWebhookUtil from "../../../Server/Utils/StatusPageSubscriberWebhook";
+import Hostname from "../../../Types/API/Hostname";
+import HTTPResponse from "../../../Types/API/HTTPResponse";
+import Protocol from "../../../Types/API/Protocol";
+import URL from "../../../Types/API/URL";
+import OneUptimeDate from "../../../Types/Date";
+import { JSONObject } from "../../../Types/JSON";
+import Email from "../../../Types/Email";
+import Phone from "../../../Types/Phone";
+import ObjectID from "../../../Types/ObjectID";
+import StatusPageSubscriberNotificationMethod from "../../../Types/StatusPage/StatusPageSubscriberNotificationMethod";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+/*
+ * The other half of GitHub issue #3545.
+ *
+ * The worker jobs did not select `endsAt`, so this service received events
+ * with the end time missing and rendered `{{scheduledEndTime}}` as an empty
+ * string — while `{{scheduledStartTime}}` rendered fine, which is what made
+ * the bug look like a template problem rather than a query problem.
+ *
+ * The worker suites pin that `endsAt` now arrives. This suite pins the
+ * consequence: given an event that carries `endsAt`, every channel that
+ * advertises `{{scheduledEndTime}}` to template authors — custom email, SMS
+ * and Slack templates, plus the subscriber webhook payload — actually renders
+ * the end time; and given an event without one, they degrade to an empty
+ * string rather than printing "undefined" at a subscriber.
+ *
+ * Everything the service talks to is a `jest.spyOn`: no database, no mail
+ * server, no Slack. What is under test is this service's own rendering, driven
+ * through the real `compileTemplate`.
+ */
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+const STATUS_PAGE_ID: ObjectID = new ObjectID(
+  "22222222-2222-4222-8222-222222222222",
+);
+const SUBSCRIBER_ID: ObjectID = new ObjectID(
+  "33333333-3333-4333-8333-333333333333",
+);
+const EVENT_ID: ObjectID = new ObjectID("44444444-4444-4444-8444-444444444444");
+
+const STARTS_AT: Date = new Date("2024-03-04T06:08:00.000Z");
+const ENDS_AT: Date = new Date("2024-03-04T08:00:00.000Z");
+
+const TEMPLATE_BODY: string =
+  "Start: {{scheduledStartTime}} | End: {{scheduledEndTime}}";
+
+// What the template author expects to see rendered, in the service's own format.
+const EXPECTED_END: string =
+  OneUptimeDate.getDateAsUserFriendlyFormattedString(ENDS_AT);
+const EXPECTED_START: string =
+  OneUptimeDate.getDateAsUserFriendlyFormattedString(STARTS_AT);
+
+// Every outbound channel here resolves an HTTPResponse rather than throwing.
+function accepted(): HTTPResponse<JSONObject> {
+  return new HTTPResponse<JSONObject>(200, {}, {});
+}
+
+function scheduledEvent(endsAt?: Date): ScheduledMaintenance {
+  const event: ScheduledMaintenance = new ScheduledMaintenance();
+
+  event._id = EVENT_ID.toString();
+  event.projectId = PROJECT_ID;
+  event.title = "Quarterly database failover drill";
+  event.description = "Failing over the primary.";
+  event.startsAt = STARTS_AT;
+
+  if (endsAt) {
+    event.endsAt = endsAt;
+  }
+
+  const statusPage: StatusPage = new StatusPage();
+  statusPage._id = STATUS_PAGE_ID.toString();
+  event.statusPages = [statusPage];
+
+  return event;
+}
+
+function statusPageWithCustomProviders(): StatusPage {
+  const statusPage: StatusPage = new StatusPage();
+
+  statusPage._id = STATUS_PAGE_ID.toString();
+  statusPage.projectId = PROJECT_ID;
+  statusPage.name = "Acme Status";
+  statusPage.pageTitle = "Acme Status";
+  statusPage.isPublicStatusPage = true;
+  statusPage.showScheduledMaintenanceEventsOnStatusPage = true;
+  statusPage.allowSubscribersToChooseResources = false;
+  statusPage.allowSubscribersToChooseEventTypes = false;
+  statusPage.subscriberTimezones = [];
+
+  /*
+   * Custom email and SMS templates are only honoured when the status page
+   * brings its own SMTP/Twilio credentials, so both configs are required for
+   * this suite to exercise the custom-template path at all.
+   */
+  const smtpConfig: ProjectSmtpConfig = new ProjectSmtpConfig();
+  smtpConfig._id = "55555555-5555-4555-8555-555555555555";
+  statusPage.smtpConfig = smtpConfig;
+
+  const callSmsConfig: ProjectCallSMSConfig = new ProjectCallSMSConfig();
+  callSmsConfig._id = "66666666-6666-4666-8666-666666666666";
+  statusPage.callSmsConfig = callSmsConfig;
+
+  return statusPage;
+}
+
+function subscriberOnEveryChannel(): StatusPageSubscriber {
+  const subscriber: StatusPageSubscriber = new StatusPageSubscriber();
+
+  subscriber._id = SUBSCRIBER_ID.toString();
+  subscriber.statusPageId = STATUS_PAGE_ID;
+  subscriber.isUnsubscribed = false;
+  subscriber.isSubscribedToAllResources = true;
+  subscriber.isSubscribedToAllEventTypes = true;
+  subscriber.subscriberEmail = new Email("subscriber@example.com");
+  subscriber.subscriberPhone = new Phone("+15558675309");
+  subscriber.slackIncomingWebhookUrl = URL.fromString(
+    "https://hooks.slack.com/services/T/B/X",
+  );
+  subscriber.subscriberWebhook = URL.fromString(
+    "https://hooks.example.com/subscriber",
+  );
+
+  return subscriber;
+}
+
+function customTemplate(
+  method: StatusPageSubscriberNotificationMethod,
+): StatusPageSubscriberNotificationTemplate {
+  const template: StatusPageSubscriberNotificationTemplate =
+    new StatusPageSubscriberNotificationTemplate();
+
+  template._id = `template-${method}`;
+  template.templateBody = TEMPLATE_BODY;
+  template.emailSubject = "Window ends {{scheduledEndTime}}";
+  template.notificationMethod = method;
+
+  return template;
+}
+
+// The rendered body of the one custom email this run produced.
+function sentEmailBody(): string {
+  const call: Array<unknown> = (MailService.sendMail as unknown as jest.Mock)
+    .mock.calls[0]!;
+
+  return String((call[0] as { vars: { body: string } }).vars.body);
+}
+
+function sentEmailSubject(): string {
+  const call: Array<unknown> = (MailService.sendMail as unknown as jest.Mock)
+    .mock.calls[0]!;
+
+  return String((call[0] as { subject: string }).subject);
+}
+
+function sentSmsMessage(): string {
+  const call: Array<unknown> = (SmsService.sendSms as unknown as jest.Mock).mock
+    .calls[0]!;
+
+  return String((call[0] as { message: string }).message);
+}
+
+function sentSlackMessage(): string {
+  return String(
+    (SlackUtil.convertMarkdownToSlackRichText as unknown as jest.Mock).mock
+      .calls[0]![0],
+  );
+}
+
+function sentWebhookPayload(): Record<string, string> {
+  const call: Array<unknown> = (
+    StatusPageSubscriberWebhookUtil.sendWebhookNotification as unknown as jest.Mock
+  ).mock.calls[0]!;
+
+  return (call[0] as { payload: { data: Record<string, string> } }).payload
+    .data;
+}
+
+describe("scheduled maintenance subscriber notifications: {{scheduledEndTime}}", () => {
+  beforeEach(() => {
+    jest
+      .spyOn(DatabaseConfig, "getHost")
+      .mockResolvedValue(new Hostname("oneuptime.com"));
+    jest
+      .spyOn(DatabaseConfig, "getHttpProtocol")
+      .mockResolvedValue(Protocol.HTTPS);
+
+    jest
+      .spyOn(StatusPageResourceService, "findByMonitors")
+      .mockResolvedValue([]);
+
+    jest
+      .spyOn(StatusPageSubscriberService, "getStatusPagesToSendNotification")
+      .mockResolvedValue([statusPageWithCustomProviders()]);
+
+    jest
+      .spyOn(StatusPageSubscriberService, "getSubscribersByStatusPage")
+      .mockResolvedValue([subscriberOnEveryChannel()]);
+
+    jest
+      .spyOn(StatusPageService, "getStatusPageURL")
+      .mockResolvedValue("https://status.example.com");
+
+    jest
+      .spyOn(
+        StatusPageSubscriberNotificationTemplateService,
+        "getTemplateForStatusPage",
+      )
+      .mockImplementation(
+        async (data: {
+          notificationMethod: StatusPageSubscriberNotificationMethod;
+        }): Promise<StatusPageSubscriberNotificationTemplate | null> => {
+          return customTemplate(data.notificationMethod);
+        },
+      );
+
+    jest
+      .spyOn(ProjectSmtpConfigService, "toEmailServer")
+      .mockReturnValue(undefined);
+    jest
+      .spyOn(ProjectCallSMSConfigService, "toTwilioConfig")
+      .mockReturnValue(undefined);
+
+    jest
+      .spyOn(Markdown, "convertToHTML")
+      .mockImplementation(async (markdown: string): Promise<string> => {
+        return markdown;
+      });
+
+    jest.spyOn(MailService, "sendMail").mockResolvedValue(accepted());
+    jest.spyOn(SmsService, "sendSms").mockResolvedValue(accepted());
+    jest
+      .spyOn(SlackUtil, "sendMessageToChannelViaIncomingWebhook")
+      .mockResolvedValue(undefined as never);
+    jest
+      .spyOn(SlackUtil, "convertMarkdownToSlackRichText")
+      .mockImplementation((markdown: string): string => {
+        return markdown;
+      });
+    jest
+      .spyOn(StatusPageSubscriberWebhookUtil, "sendWebhookNotification")
+      .mockResolvedValue(accepted());
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("renders the end time in a custom email body", async () => {
+    await ScheduledMaintenanceService.notififySubscribersOnEventScheduled([
+      scheduledEvent(ENDS_AT),
+    ]);
+
+    /*
+     * Guards the fixture itself: an empty EXPECTED_END would make every
+     * assertion in this file pass on the very bug it exists to catch.
+     */
+    expect(EXPECTED_END).not.toBe("");
+
+    expect(MailService.sendMail).toHaveBeenCalledTimes(1);
+    expect(sentEmailBody()).toBe(
+      `Start: ${EXPECTED_START} | End: ${EXPECTED_END}`,
+    );
+  });
+
+  test("renders the end time in a custom email subject", async () => {
+    await ScheduledMaintenanceService.notififySubscribersOnEventScheduled([
+      scheduledEvent(ENDS_AT),
+    ]);
+
+    expect(sentEmailSubject()).toBe(`Window ends ${EXPECTED_END}`);
+  });
+
+  test("renders the end time in a custom SMS template", async () => {
+    await ScheduledMaintenanceService.notififySubscribersOnEventScheduled([
+      scheduledEvent(ENDS_AT),
+    ]);
+
+    expect(SmsService.sendSms).toHaveBeenCalledTimes(1);
+    expect(sentSmsMessage()).toBe(
+      `Start: ${EXPECTED_START} | End: ${EXPECTED_END}`,
+    );
+  });
+
+  test("renders the end time in a custom Slack template", async () => {
+    await ScheduledMaintenanceService.notififySubscribersOnEventScheduled([
+      scheduledEvent(ENDS_AT),
+    ]);
+
+    expect(sentSlackMessage()).toBe(
+      `Start: ${EXPECTED_START} | End: ${EXPECTED_END}`,
+    );
+  });
+
+  test("sends the end time in the subscriber webhook payload", async () => {
+    await ScheduledMaintenanceService.notififySubscribersOnEventScheduled([
+      scheduledEvent(ENDS_AT),
+    ]);
+
+    expect(sentWebhookPayload()["scheduledEndTime"]).toBe(EXPECTED_END);
+    expect(sentWebhookPayload()["scheduledStartTime"]).toBe(EXPECTED_START);
+  });
+
+  test("renders an empty end time — never 'undefined' — for an open-ended event", async () => {
+    /*
+     * An event with no end time is legitimate. The subscriber should see a
+     * blank, not the string "undefined": this is the behaviour the bug made
+     * universal, and it has to survive as the genuine no-end-time case.
+     */
+    await ScheduledMaintenanceService.notififySubscribersOnEventScheduled([
+      scheduledEvent(undefined),
+    ]);
+
+    expect(sentEmailBody()).toBe(`Start: ${EXPECTED_START} | End: `);
+    expect(sentSmsMessage()).toBe(`Start: ${EXPECTED_START} | End: `);
+    expect(sentWebhookPayload()["scheduledEndTime"]).toBe("");
+  });
+
+  test("renders each event's own end time when several are notified at once", async () => {
+    const laterEnd: Date = new Date("2024-03-05T09:30:00.000Z");
+
+    await ScheduledMaintenanceService.notififySubscribersOnEventScheduled([
+      scheduledEvent(ENDS_AT),
+      scheduledEvent(laterEnd),
+    ]);
+
+    const bodies: Array<string> = (
+      MailService.sendMail as unknown as jest.Mock
+    ).mock.calls.map((call: Array<unknown>) => {
+      return String((call[0] as { vars: { body: string } }).vars.body);
+    });
+
+    expect(bodies).toEqual([
+      `Start: ${EXPECTED_START} | End: ${EXPECTED_END}`,
+      `Start: ${EXPECTED_START} | End: ${OneUptimeDate.getDateAsUserFriendlyFormattedString(
+        laterEnd,
+      )}`,
+    ]);
+  });
+});