@oneuptime/common 14.0.6 → 14.0.8

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

@@ -0,0 +1,201 @@
+import StatusPageSubscriberService from "../../../Server/Services/StatusPageSubscriberService";
+import Dictionary from "../../../Types/Dictionary";
+import ObjectID from "../../../Types/ObjectID";
+import { IncidentSubscriberAudienceCounts } from "../../../Types/StatusPage/IncidentSubscriberAudience";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+/*
+ * StatusPageSubscriberService.countActiveSubscribersByChannel: the counts the
+ * audience summary shows before an incident or a public note is sent.
+ *
+ * These tests stub the database driver and pin down the query's contract:
+ * it counts (never reads an address), it is pinned to the project, it counts
+ * only the subscribers the jobs send to, and it reads the rows back into
+ * per-page, per-channel numbers. StatusPageSubscriberAudienceCountsPostgres
+ * runs the same query against a real Postgres.
+ */
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "10000000-0000-4000-8000-000000000001",
+);
+const PAGE_A: string = "b0000000-0000-4000-8000-00000000000a";
+const PAGE_B: string = "b0000000-0000-4000-8000-00000000000b";
+
+let query: MockFunction;
+
+beforeEach(() => {
+  query = getJestMockFunction();
+  query.mockResolvedValue([] as never);
+
+  jest.spyOn(StatusPageSubscriberService, "getRepository").mockReturnValue({
+    manager: {
+      query: query,
+    },
+  } as never);
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+function sql(): string {
+  return (query.mock.calls[0]![0] as string).replace(/\s+/g, " ");
+}
+
+function params(): Array<unknown> {
+  return query.mock.calls[0]![1] as Array<unknown>;
+}
+
+describe("StatusPageSubscriberService.countActiveSubscribersByChannel", () => {
+  test("no status pages: no query at all", async () => {
+    const counts: Dictionary<IncidentSubscriberAudienceCounts> =
+      await StatusPageSubscriberService.countActiveSubscribersByChannel({
+        projectId: PROJECT_ID,
+        statusPageIds: [],
+      });
+
+    expect(counts).toEqual({});
+    expect(query).not.toHaveBeenCalled();
+  });
+
+  test("one aggregate query, grouped by status page", async () => {
+    await StatusPageSubscriberService.countActiveSubscribersByChannel({
+      projectId: PROJECT_ID,
+      statusPageIds: [new ObjectID(PAGE_A), new ObjectID(PAGE_B)],
+    });
+
+    expect(query).toHaveBeenCalledTimes(1);
+    expect(sql()).toContain('FROM "StatusPageSubscriber"');
+    expect(sql()).toContain('GROUP BY "statusPageId"');
+  });
+
+  test("it counts and never selects an address", async () => {
+    await StatusPageSubscriberService.countActiveSubscribersByChannel({
+      projectId: PROJECT_ID,
+      statusPageIds: [new ObjectID(PAGE_A)],
+    });
+
+    // Everything between SELECT and FROM is the statusPageId and counts.
+    const selected: string = sql().split(" FROM ")[0]!;
+    const columns: Array<string> = selected
+      .replace(/^ ?SELECT /, "")
+      .split(/,(?![^(]*\))/)
+      .map((column: string): string => {
+        return column.trim();
+      });
+
+    expect(columns).toHaveLength(6);
+    expect(columns[0]).toBe('"statusPageId"::text AS "statusPageId"');
+
+    for (const column of columns.slice(1)) {
+      expect(column).toMatch(
+        /^COUNT\(\*\) FILTER \(WHERE .+\)::text AS "\w+"$/,
+      );
+    }
+  });
+
+  test("only the subscribers the jobs send to: confirmed, subscribed, not deleted", async () => {
+    await StatusPageSubscriberService.countActiveSubscribersByChannel({
+      projectId: PROJECT_ID,
+      statusPageIds: [new ObjectID(PAGE_A)],
+    });
+
+    expect(sql()).toContain('"isUnsubscribed" = false');
+    expect(sql()).toContain('"isSubscriptionConfirmed" = true');
+    expect(sql()).toContain('"deletedAt" IS NULL');
+  });
+
+  test("pinned to the project, with the page ids as a bound parameter", async () => {
+    await StatusPageSubscriberService.countActiveSubscribersByChannel({
+      projectId: PROJECT_ID,
+      statusPageIds: [
+        new ObjectID(PAGE_A.toUpperCase()),
+        new ObjectID(PAGE_A),
+        new ObjectID(PAGE_B),
+      ],
+    });
+
+    expect(sql()).toContain('"projectId" = $1');
+    expect(sql()).toContain('"statusPageId" = ANY($2::uuid[])');
+    expect(params()).toEqual([PROJECT_ID.toString(), [PAGE_A, PAGE_B]]);
+  });
+
+  test("reads the rows back as numbers, keyed by the lower-cased page id", async () => {
+    query.mockResolvedValue([
+      {
+        statusPageId: PAGE_A.toUpperCase(),
+        email: "41",
+        sms: "3",
+        slack: "0",
+        microsoftTeams: "1",
+        webhook: "2",
+      },
+      {
+        statusPageId: PAGE_B,
+        email: "18",
+        sms: "0",
+        slack: "0",
+        microsoftTeams: "0",
+        webhook: "0",
+      },
+    ] as never);
+
+    const counts: Dictionary<IncidentSubscriberAudienceCounts> =
+      await StatusPageSubscriberService.countActiveSubscribersByChannel({
+        projectId: PROJECT_ID,
+        statusPageIds: [new ObjectID(PAGE_A), new ObjectID(PAGE_B)],
+      });
+
+    expect(counts).toEqual({
+      [PAGE_A]: {
+        email: 41,
+        sms: 3,
+        slack: 0,
+        microsoftTeams: 1,
+        webhook: 2,
+      },
+      [PAGE_B]: {
+        email: 18,
+        sms: 0,
+        slack: 0,
+        microsoftTeams: 0,
+        webhook: 0,
+      },
+    });
+  });
+
+  test("a garbled count reads as zero", async () => {
+    query.mockResolvedValue([
+      {
+        statusPageId: PAGE_A,
+        email: "abc",
+        sms: null,
+        slack: "-2",
+        microsoftTeams: undefined,
+        webhook: "7",
+      },
+    ] as never);
+
+    const counts: Dictionary<IncidentSubscriberAudienceCounts> =
+      await StatusPageSubscriberService.countActiveSubscribersByChannel({
+        projectId: PROJECT_ID,
+        statusPageIds: [new ObjectID(PAGE_A)],
+      });
+
+    expect(counts[PAGE_A]).toEqual({
+      email: 0,
+      sms: 0,
+      slack: 0,
+      microsoftTeams: 0,
+      webhook: 7,
+    });
+  });
+});

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

@@ -0,0 +1,271 @@
+import Entities from "../../../Models/DatabaseModels/Index";
+import PostgresAppInstance from "../../../Server/Infrastructure/PostgresDatabase";
+import StatusPageSubscriberService from "../../../Server/Services/StatusPageSubscriberService";
+import Dictionary from "../../../Types/Dictionary";
+import ObjectID from "../../../Types/ObjectID";
+import { IncidentSubscriberAudienceCounts } from "../../../Types/StatusPage/IncidentSubscriberAudience";
+import { DataSource } from "typeorm";
+
+/*
+ * StatusPageSubscriberService.countActiveSubscribersByChannel against a
+ * migrated Postgres: the per-page, per-channel counts the audience summary
+ * shows before an incident or a public note is sent.
+ *
+ * Opt in with RUN_POSTGRES_SUBSCRIBER_AUDIENCE_COUNT_TESTS=true against a
+ * database the registered migrations have been applied to, e.g.
+ *
+ *   RUN_POSTGRES_SUBSCRIBER_AUDIENCE_COUNT_TESTS=true \
+ *   SUBSCRIBER_AUDIENCE_COUNT_TEST_DATABASE_HOST=127.0.0.1 \
+ *   SUBSCRIBER_AUDIENCE_COUNT_TEST_DATABASE_PORT=5400 \
+ *   DATABASE_PASSWORD=... npx jest Tests/Server/Services/StatusPageSubscriberAudienceCountsPostgres.test.ts
+ *
+ * CI runs it in .github/workflows/postgres-schema-drift.yaml, right after that
+ * job has applied every registered migration to an empty database.
+ *
+ * The query is hand-written SQL (COUNT(*) FILTER ..., = ANY($2::uuid[])), so
+ * only a real driver can judge it. It runs against a structure-only clone of
+ * the migrated StatusPageSubscriber table (LIKE ... INCLUDING ALL) in a
+ * uniquely named schema that is dropped afterwards; every row is synthetic.
+ */
+const describePostgres: typeof describe =
+  process.env["RUN_POSTGRES_SUBSCRIBER_AUDIENCE_COUNT_TESTS"] === "true"
+    ? describe
+    : describe.skip;
+
+describePostgres("subscriber audience counts against Postgres", () => {
+  const schema: string = `subscriber_audience_${ObjectID.generate()
+    .toString()
+    .replace(/-/g, "")}`;
+
+  const projectId: ObjectID = ObjectID.generate();
+  const otherProjectId: ObjectID = ObjectID.generate();
+  const pageA: ObjectID = ObjectID.generate();
+  const pageB: ObjectID = ObjectID.generate();
+  const pageC: ObjectID = ObjectID.generate();
+
+  let database: DataSource;
+
+  interface SubscriberRow {
+    projectId?: ObjectID;
+    statusPageId: ObjectID;
+    email?: string | null;
+    phone?: string | null;
+    webhook?: string | null;
+    slack?: string | null;
+    teams?: string | null;
+    isUnsubscribed?: boolean;
+    isSubscriptionConfirmed?: boolean;
+    isDeleted?: boolean;
+  }
+
+  async function seed(row: SubscriberRow): Promise<void> {
+    await database.query(
+      `INSERT INTO "${schema}"."StatusPageSubscriber"
+         ("_id", "projectId", "statusPageId", "subscriberEmail", "subscriberPhone",
+          "subscriberWebhook", "slackIncomingWebhookUrl", "microsoftTeamsIncomingWebhookUrl",
+          "isUnsubscribed", "isSubscriptionConfirmed", "deletedAt", "version")
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, 1)`,
+      [
+        ObjectID.generate().toString(),
+        (row.projectId || projectId).toString(),
+        row.statusPageId.toString(),
+        row.email ?? null,
+        row.phone ?? null,
+        row.webhook ?? null,
+        row.slack ?? null,
+        row.teams ?? null,
+        row.isUnsubscribed ?? false,
+        row.isSubscriptionConfirmed ?? true,
+        row.isDeleted ? new Date() : null,
+      ],
+    );
+  }
+
+  function countFor(
+    statusPageIds: Array<ObjectID>,
+    forProjectId: ObjectID = projectId,
+  ): Promise<Dictionary<IncidentSubscriberAudienceCounts>> {
+    return StatusPageSubscriberService.countActiveSubscribersByChannel({
+      projectId: forProjectId,
+      statusPageIds: statusPageIds,
+    });
+  }
+
+  beforeAll(async () => {
+    database = new DataSource({
+      type: "postgres",
+      host:
+        process.env["SUBSCRIBER_AUDIENCE_COUNT_TEST_DATABASE_HOST"] ||
+        "localhost",
+      port: Number(
+        process.env["SUBSCRIBER_AUDIENCE_COUNT_TEST_DATABASE_PORT"] || "5400",
+      ),
+      username: process.env["DATABASE_USERNAME"] || "postgres",
+      password: process.env["DATABASE_PASSWORD"] || "password",
+      database:
+        process.env["SUBSCRIBER_AUDIENCE_COUNT_TEST_DATABASE_NAME"] ||
+        process.env["DATABASE_NAME"] ||
+        "oneuptimedb",
+      entities: Entities,
+      schema,
+      synchronize: false,
+      extra: { options: `-c search_path=${schema},public` },
+    });
+    await database.initialize();
+    await database.query(`CREATE SCHEMA "${schema}"`);
+    await database.query(
+      `CREATE TABLE "${schema}"."StatusPageSubscriber" (LIKE public."StatusPageSubscriber" INCLUDING ALL)`,
+    );
+
+    jest.spyOn(PostgresAppInstance, "isConnected").mockReturnValue(true);
+    jest.spyOn(PostgresAppInstance, "getDataSource").mockReturnValue(database);
+  });
+
+  beforeEach(async () => {
+    await database.query(`DELETE FROM "${schema}"."StatusPageSubscriber"`);
+  });
+
+  afterAll(async () => {
+    jest.restoreAllMocks();
+    if (database?.isInitialized) {
+      await database.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
+      await database.destroy();
+    }
+  });
+
+  test("the harness reads the clone, not public", async () => {
+    await seed({ statusPageId: pageA, email: "a@example.com" });
+
+    const rows: Array<{ count: string }> = await database.query(
+      `SELECT COUNT(*)::text AS "count" FROM "StatusPageSubscriber" WHERE "statusPageId" = $1`,
+      [pageA.toString()],
+    );
+
+    expect(rows[0]!.count).toBe("1");
+  });
+
+  test("counts each channel of each page", async () => {
+    await seed({ statusPageId: pageA, email: "one@example.com" });
+    await seed({ statusPageId: pageA, email: "two@example.com" });
+    await seed({
+      statusPageId: pageA,
+      email: "three@example.com",
+      phone: "+15550100",
+    });
+    await seed({ statusPageId: pageA, phone: "+15550101" });
+    await seed({ statusPageId: pageA, webhook: "https://hooks.example.com/1" });
+    await seed({
+      statusPageId: pageA,
+      slack: "https://hooks.slack.com/services/T/B/x",
+    });
+    await seed({
+      statusPageId: pageB,
+      teams: "https://example.webhook.office.com/x",
+    });
+    await seed({ statusPageId: pageB, email: "four@example.com" });
+
+    const counts: Dictionary<IncidentSubscriberAudienceCounts> = await countFor(
+      [pageA, pageB],
+    );
+
+    expect(counts).toEqual({
+      [pageA.toString().toLowerCase()]: {
+        email: 3,
+        sms: 2,
+        slack: 1,
+        microsoftTeams: 0,
+        webhook: 1,
+      },
+      [pageB.toString().toLowerCase()]: {
+        email: 1,
+        sms: 0,
+        slack: 0,
+        microsoftTeams: 1,
+        webhook: 0,
+      },
+    });
+  });
+
+  test("only confirmed, still-subscribed, not deleted subscribers count", async () => {
+    await seed({ statusPageId: pageA, email: "counted@example.com" });
+    await seed({
+      statusPageId: pageA,
+      email: "unsubscribed@example.com",
+      isUnsubscribed: true,
+    });
+    await seed({
+      statusPageId: pageA,
+      email: "unconfirmed@example.com",
+      isSubscriptionConfirmed: false,
+    });
+    await seed({
+      statusPageId: pageA,
+      email: "deleted@example.com",
+      isDeleted: true,
+    });
+
+    const counts: Dictionary<IncidentSubscriberAudienceCounts> = await countFor(
+      [pageA],
+    );
+
+    expect(counts[pageA.toString().toLowerCase()]!.email).toBe(1);
+  });
+
+  test("an empty or blank value is no channel", async () => {
+    await seed({ statusPageId: pageA, email: "", phone: "   " });
+    await seed({ statusPageId: pageA, webhook: "https://hooks.example.com/1" });
+
+    const counts: Dictionary<IncidentSubscriberAudienceCounts> = await countFor(
+      [pageA],
+    );
+
+    expect(counts[pageA.toString().toLowerCase()]).toEqual({
+      email: 0,
+      sms: 0,
+      slack: 0,
+      microsoftTeams: 0,
+      webhook: 1,
+    });
+  });
+
+  test("only the pages asked about, and only in the project asked about", async () => {
+    await seed({ statusPageId: pageA, email: "a@example.com" });
+    await seed({ statusPageId: pageC, email: "c@example.com" });
+    // Another project's subscriber on the same page id is never counted.
+    await seed({
+      projectId: otherProjectId,
+      statusPageId: pageA,
+      email: "theirs@example.com",
+    });
+
+    expect(await countFor([pageA])).toEqual({
+      [pageA.toString().toLowerCase()]: {
+        email: 1,
+        sms: 0,
+        slack: 0,
+        microsoftTeams: 0,
+        webhook: 0,
+      },
+    });
+
+    expect(await countFor([pageA], otherProjectId)).toEqual({
+      [pageA.toString().toLowerCase()]: {
+        email: 1,
+        sms: 0,
+        slack: 0,
+        microsoftTeams: 0,
+        webhook: 0,
+      },
+    });
+  });
+
+  test("a page with no active subscriber has no entry", async () => {
+    await seed({
+      statusPageId: pageB,
+      email: "gone@example.com",
+      isUnsubscribed: true,
+    });
+
+    expect(await countFor([pageA, pageB])).toEqual({});
+  });
+});

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

@@ -0,0 +1,200 @@
+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 ProjectSmtpConfigService from "../../../Server/Services/ProjectSmtpConfigService";
+import StatusPageService from "../../../Server/Services/StatusPageService";
+import StatusPageSubscriberNotificationTemplateService, {
+  Service as StatusPageSubscriberNotificationTemplateServiceClass,
+} from "../../../Server/Services/StatusPageSubscriberNotificationTemplateService";
+import StatusPageSubscriberService from "../../../Server/Services/StatusPageSubscriberService";
+import Hostname from "../../../Types/API/Hostname";
+import HTTPResponse from "../../../Types/API/HTTPResponse";
+import Protocol from "../../../Types/API/Protocol";
+import Email from "../../../Types/Email";
+import EmailTemplateType from "../../../Types/Email/EmailTemplateType";
+import { JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import StatusPageSubscriberNotificationEventType from "../../../Types/StatusPage/StatusPageSubscriberNotificationEventType";
+import StatusPageSubscriberNotificationMethod from "../../../Types/StatusPage/StatusPageSubscriberNotificationMethod";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+/*
+ * The subscription confirmation and "you have subscribed" emails can use a
+ * status page's custom email template. Its body is HTML, so the status
+ * page's name - which a project member typed - and the links are escaped
+ * into it; the subject is plain text and keeps them as written.
+ */
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "10000000-0000-4000-8000-000000000001",
+);
+const STATUS_PAGE_ID: ObjectID = new ObjectID(
+  "20000000-0000-4000-8000-000000000002",
+);
+const SUBSCRIBER_ID: ObjectID = new ObjectID(
+  "30000000-0000-4000-8000-000000000003",
+);
+
+const STATUS_PAGE_URL: string = "https://status.acme.com";
+const HOSTILE_PAGE_NAME: string =
+  '<a href="https://evil.example/login">Acme</a> & "Status"';
+const HOSTILE_PAGE_NAME_HTML: string =
+  "&lt;a href=&quot;https://evil.example/login&quot;&gt;Acme&lt;/a&gt; &amp; &quot;Status&quot;";
+
+const BODY: string =
+  '<h1>{{statusPageName}}</h1><a href="{{statusPageUrl}}">Open</a>';
+const SUBJECT: string = "Welcome to {{statusPageName}}";
+
+function mock(fn: unknown): jest.Mock {
+  return fn as unknown as jest.Mock;
+}
+
+function subscriber(): StatusPageSubscriber {
+  const row: StatusPageSubscriber = new StatusPageSubscriber();
+  row._id = SUBSCRIBER_ID.toString();
+  row.statusPageId = STATUS_PAGE_ID;
+  row.projectId = PROJECT_ID;
+  row.subscriberEmail = new Email("subscriber@example.com");
+  row.subscriptionConfirmationToken = "123456";
+  row.unsubscribeToken = "a".repeat(64);
+  return row;
+}
+
+function statusPage(): StatusPage {
+  const page: StatusPage = new StatusPage();
+  page._id = STATUS_PAGE_ID.toString();
+  page.projectId = PROJECT_ID;
+  page.name = "acme-internal";
+  page.pageTitle = HOSTILE_PAGE_NAME;
+  page.isPublicStatusPage = true;
+  const smtpConfig: ProjectSmtpConfig = new ProjectSmtpConfig();
+  smtpConfig._id = "50000000-0000-4000-8000-000000000005";
+  page.smtpConfig = smtpConfig;
+  return page;
+}
+
+function sentMail(): Array<{
+  templateType: EmailTemplateType;
+  subject: string;
+  vars: JSONObject;
+}> {
+  return mock(MailService.sendMail).mock.calls.map((call: Array<unknown>) => {
+    return call[0] as {
+      templateType: EmailTemplateType;
+      subject: string;
+      vars: JSONObject;
+    };
+  });
+}
+
+describe("status page subscription emails with a custom email template", () => {
+  beforeEach(() => {
+    jest
+      .spyOn(StatusPageSubscriberService, "findOneBy")
+      .mockResolvedValue(subscriber());
+    jest.spyOn(StatusPageService, "findOneBy").mockResolvedValue(statusPage());
+    jest
+      .spyOn(StatusPageService, "getStatusPageURL")
+      .mockResolvedValue(STATUS_PAGE_URL);
+    jest
+      .spyOn(DatabaseConfig, "getHost")
+      .mockResolvedValue(new Hostname("oneuptime.com"));
+    jest
+      .spyOn(DatabaseConfig, "getHttpProtocol")
+      .mockResolvedValue(Protocol.HTTPS);
+    jest
+      .spyOn(ProjectSmtpConfigService, "toEmailServer")
+      .mockReturnValue(undefined);
+    jest
+      .spyOn(MailService, "sendMail")
+      .mockResolvedValue(new HTTPResponse<JSONObject>(200, {}, {}));
+    jest
+      .spyOn(
+        StatusPageSubscriberNotificationTemplateService,
+        "getTemplateForStatusPage",
+      )
+      .mockImplementation(
+        async (data: {
+          eventType: StatusPageSubscriberNotificationEventType;
+          notificationMethod: StatusPageSubscriberNotificationMethod;
+        }): Promise<StatusPageSubscriberNotificationTemplate | null> => {
+          const template: StatusPageSubscriberNotificationTemplate =
+            new StatusPageSubscriberNotificationTemplate();
+          template.eventType = data.eventType;
+          template.notificationMethod = data.notificationMethod;
+          template.templateBody = BODY;
+          template.emailSubject = SUBJECT;
+          return template;
+        },
+      );
+    jest.spyOn(
+      StatusPageSubscriberNotificationTemplateServiceClass,
+      "compileEmailBodyTemplate",
+    );
+    jest.spyOn(
+      StatusPageSubscriberNotificationTemplateServiceClass,
+      "compileTemplate",
+    );
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test.each([
+    {
+      name: "the confirmation email",
+      send: (): Promise<void> => {
+        return StatusPageSubscriberService.sendConfirmSubscriptionEmail({
+          subscriberId: SUBSCRIBER_ID,
+        });
+      },
+    },
+    {
+      name: "the you-have-subscribed email",
+      send: (): Promise<void> => {
+        return StatusPageSubscriberService.sendYouHaveSubscribedEmail({
+          subscriberId: SUBSCRIBER_ID,
+        });
+      },
+    },
+  ])(
+    "$name escapes the page name in the body and keeps it as written in the subject",
+    async ({ send }: { send: () => Promise<void> }) => {
+      await send();
+
+      expect(sentMail()).toHaveLength(1);
+      expect(sentMail()[0]!.templateType).toBe(EmailTemplateType.BlankTemplate);
+      expect(sentMail()[0]!.vars["body"]).toBe(
+        `<h1>${HOSTILE_PAGE_NAME_HTML}</h1><a href="${STATUS_PAGE_URL}">Open</a>`,
+      );
+      expect(sentMail()[0]!.subject).toBe(`Welcome to ${HOSTILE_PAGE_NAME}`);
+
+      // The body went through the HTML compile, the subject through the text one.
+      expect(
+        mock(
+          StatusPageSubscriberNotificationTemplateServiceClass.compileEmailBodyTemplate,
+        ).mock.calls.map((call: Array<unknown>): unknown => {
+          return call[0];
+        }),
+      ).toEqual([BODY]);
+      expect(
+        mock(
+          StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate,
+        ).mock.calls.map((call: Array<unknown>): unknown => {
+          return call[0];
+        }),
+      ).toEqual([SUBJECT]);
+    },
+  );
+});