@oneuptime/common 14.0.7 → 14.0.8

package/Tests/Types/StatusPage/SubscriberNotificationPreview.test.ts

@@ -0,0 +1,196 @@
+import { describe, expect, test } from "@jest/globals";
+import { JSONObject } from "../../../Types/JSON";
+import IncidentSubscriberAudience from "../../../Types/StatusPage/IncidentSubscriberAudience";
+import SubscriberNotificationPreview, {
+  SubscriberEmailTemplateChoiceReason,
+  SubscriberNotificationPreviewEvent,
+  SubscriberNotificationPreviewNothingSentReason,
+  SubscriberNotificationPreviewResult,
+} from "../../../Types/StatusPage/SubscriberNotificationPreview";
+
+/*
+ * The preview's shape, shared by the server that answers and the dashboard
+ * that shows it: what travels (and nothing else - no address), how the
+ * dashboard reads an answer defensively, and the sample unsubscribe link.
+ */
+
+const SITE_1: string = "b0000000-0000-4000-8000-000000000001";
+
+function result(): SubscriberNotificationPreviewResult {
+  return {
+    event: SubscriberNotificationPreviewEvent.IncidentPublicNoteCreated,
+    nothingSentReason: null,
+    statusPages: [
+      {
+        statusPageId: SITE_1,
+        name: "Site 01",
+        subscriberCounts: {
+          ...IncidentSubscriberAudience.getEmptyCounts(),
+          email: 41,
+          sms: 3,
+        },
+        subject: "[Update Incident] Checkout",
+        html: "<p>Checkout</p>",
+        templateChoice: {
+          usesCustomTemplate: false,
+          reason:
+            SubscriberEmailTemplateChoiceReason.CustomTemplateNeedsCustomSmtp,
+          customTemplateName: "Branded",
+        },
+      },
+    ],
+    audience: {
+      hasMonitors: true,
+      isScoped: true,
+      isHiddenFromStatusPages: false,
+      statusPages: [
+        {
+          statusPageId: SITE_1,
+          name: "Site 01",
+          subscriberCounts: {
+            ...IncidentSubscriberAudience.getEmptyCounts(),
+            email: 41,
+            sms: 3,
+          },
+        },
+      ],
+      hiddenStatusPageCount: 2,
+      excludedStatusPages: [],
+      selectedStatusPagesNotListingMonitors: [],
+    },
+  };
+}
+
+describe("SubscriberNotificationPreview", () => {
+  test("an answer survives the trip to the dashboard", () => {
+    const json: JSONObject = JSON.parse(
+      JSON.stringify(SubscriberNotificationPreview.toJSON(result())),
+    ) as JSONObject;
+
+    expect(SubscriberNotificationPreview.fromJSON(json)).toEqual(result());
+  });
+
+  test("only these fields travel for each page: no address, no mail settings", () => {
+    const json: JSONObject = SubscriberNotificationPreview.toJSON(result());
+    const page: JSONObject = (json["statusPages"] as Array<JSONObject>)[0]!;
+
+    expect(Object.keys(json).sort()).toEqual(
+      ["audience", "event", "nothingSentReason", "statusPages"].sort(),
+    );
+    expect(Object.keys(page).sort()).toEqual(
+      [
+        "html",
+        "name",
+        "statusPageId",
+        "subject",
+        "subscriberCounts",
+        "templateChoice",
+      ].sort(),
+    );
+  });
+
+  test("a malformed answer reads as nothing rather than breaking the dialog", () => {
+    const parsed: SubscriberNotificationPreviewResult =
+      SubscriberNotificationPreview.fromJSON({
+        event: "Unknown",
+        nothingSentReason: "Nope",
+        statusPages: [
+          null,
+          "x",
+          {
+            statusPageId: SITE_1,
+            subscriberCounts: { email: "12", sms: -4, slack: "lots" },
+            templateChoice: { reason: "Made up", customTemplateName: 7 },
+          },
+        ],
+      } as unknown as JSONObject);
+
+    expect(parsed.event).toBe(
+      SubscriberNotificationPreviewEvent.IncidentCreated,
+    );
+    expect(parsed.nothingSentReason).toBeNull();
+    expect(parsed.statusPages).toEqual([
+      {
+        statusPageId: SITE_1,
+        name: "",
+        subscriberCounts: {
+          ...IncidentSubscriberAudience.getEmptyCounts(),
+          email: 12,
+        },
+        subject: "",
+        html: "",
+        templateChoice: {
+          usesCustomTemplate: false,
+          reason: SubscriberEmailTemplateChoiceReason.NoCustomTemplate,
+          customTemplateName: undefined,
+        },
+      },
+    ]);
+    expect(parsed.audience.statusPages).toEqual([]);
+  });
+
+  test("a reason nothing will be sent is read back", () => {
+    expect(
+      SubscriberNotificationPreview.fromJSON({
+        event: "IncidentCreated",
+        nothingSentReason: "NoMonitors",
+      }).nothingSentReason,
+    ).toBe(SubscriberNotificationPreviewNothingSentReason.NoMonitors);
+  });
+
+  test("requests travel with their dates as ISO strings, and a test names its page", () => {
+    expect(
+      SubscriberNotificationPreview.requestToJSON({
+        event: SubscriberNotificationPreviewEvent.IncidentPublicNoteCreated,
+        incidentId: "a0000000-0000-4000-8000-00000000000a",
+        note: "Update",
+        postedAt: new Date("2026-09-27T10:30:00.000Z"),
+        statusPageId: SITE_1,
+      }),
+    ).toEqual({
+      event: "IncidentPublicNoteCreated",
+      incidentId: "a0000000-0000-4000-8000-00000000000a",
+      note: "Update",
+      postedAt: "2026-09-27T10:30:00.000Z",
+      statusPageId: SITE_1,
+    });
+
+    expect(
+      SubscriberNotificationPreview.requestToJSON({
+        event: SubscriberNotificationPreviewEvent.IncidentCreated,
+        incident: {
+          title: "Down",
+          description: "",
+          incidentSeverityId: null,
+          monitorIds: ["c0000000-0000-4000-8000-000000000001"],
+          statusPageIds: [],
+          labelIds: [],
+          customFields: { Impact: "High" },
+          isPrivate: false,
+          shouldStatusPageSubscribersBeNotifiedOnIncidentCreated: true,
+        },
+      }),
+    ).toEqual({
+      event: "IncidentCreated",
+      incident: {
+        title: "Down",
+        description: "",
+        incidentSeverityId: null,
+        monitorIds: ["c0000000-0000-4000-8000-000000000001"],
+        statusPageIds: [],
+        labelIds: [],
+        customFields: { Impact: "High" },
+        isPrivate: false,
+        shouldStatusPageSubscribersBeNotifiedOnIncidentCreated: true,
+      },
+    });
+  });
+
+  test("the preview's unsubscribe link names no subscription", () => {
+    expect(
+      SubscriberNotificationPreview.getPreviewUnsubscribeUrl(
+        "https://status.acme.com",
+      ),
+    ).toBe("https://status.acme.com/unsubscribe/preview");
+  });
+});

package/Tests/Types/StatusPage/SubscriberNotificationResend.test.ts

@@ -0,0 +1,201 @@
+import StatusPageSubscriberNotificationStatus from "../../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
+import SubscriberNotificationResend, {
+  SubscriberNotificationResendAction,
+} from "../../../Types/StatusPage/SubscriberNotificationResend";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Which settled subscriber notifications can be sent again, and when the
+ * server refuses a public note's. The dashboard's buttons and the server's
+ * checks both read these, so a wrong answer either hides Resend where it
+ * works or offers it where the note would sit in Pending forever.
+ */
+
+const ALL_STATUSES: Array<StatusPageSubscriberNotificationStatus | undefined> =
+  [
+    StatusPageSubscriberNotificationStatus.Success,
+    StatusPageSubscriberNotificationStatus.Failed,
+    StatusPageSubscriberNotificationStatus.Skipped,
+    StatusPageSubscriberNotificationStatus.Pending,
+    StatusPageSubscriberNotificationStatus.InProgress,
+    undefined,
+  ];
+
+describe("SubscriberNotificationResend.getAction", () => {
+  test("a failed notification offers Retry, whether or not Resend is offered", () => {
+    for (const isResendAfterSuccessOffered of [true, false]) {
+      expect(
+        SubscriberNotificationResend.getAction({
+          status: StatusPageSubscriberNotificationStatus.Failed,
+          isResendAfterSuccessOffered,
+        }),
+      ).toBe(SubscriberNotificationResendAction.Retry);
+    }
+  });
+
+  test("a notification that went out offers Resend where the caller supports it", () => {
+    expect(
+      SubscriberNotificationResend.getAction({
+        status: StatusPageSubscriberNotificationStatus.Success,
+        isResendAfterSuccessOffered: true,
+      }),
+    ).toBe(SubscriberNotificationResendAction.Resend);
+  });
+
+  test("and nothing where it does not: the old Failed-only behaviour", () => {
+    expect(
+      SubscriberNotificationResend.getAction({
+        status: StatusPageSubscriberNotificationStatus.Success,
+        isResendAfterSuccessOffered: false,
+      }),
+    ).toBeNull();
+  });
+
+  test.each([
+    StatusPageSubscriberNotificationStatus.Skipped,
+    StatusPageSubscriberNotificationStatus.Pending,
+    StatusPageSubscriberNotificationStatus.InProgress,
+    undefined,
+    null,
+  ])(
+    "%s offers nothing: never sent, or on its way",
+    (status: StatusPageSubscriberNotificationStatus | undefined | null) => {
+      for (const isResendAfterSuccessOffered of [true, false]) {
+        expect(
+          SubscriberNotificationResend.getAction({
+            status,
+            isResendAfterSuccessOffered,
+          }),
+        ).toBeNull();
+      }
+    },
+  );
+
+  test("only Success and Failed ever offer anything", () => {
+    const offering: Array<StatusPageSubscriberNotificationStatus | undefined> =
+      ALL_STATUSES.filter(
+        (status: StatusPageSubscriberNotificationStatus | undefined) => {
+          return (
+            SubscriberNotificationResend.getAction({
+              status,
+              isResendAfterSuccessOffered: true,
+            }) !== null
+          );
+        },
+      );
+
+    expect(offering).toEqual([
+      StatusPageSubscriberNotificationStatus.Success,
+      StatusPageSubscriberNotificationStatus.Failed,
+    ]);
+  });
+});
+
+describe("SubscriberNotificationResend.getPublicNoteResendRefusal", () => {
+  test.each([
+    StatusPageSubscriberNotificationStatus.Success,
+    StatusPageSubscriberNotificationStatus.Failed,
+  ])(
+    "a note that notifies subscribers and is %s may be sent again",
+    (status: StatusPageSubscriberNotificationStatus) => {
+      expect(
+        SubscriberNotificationResend.getPublicNoteResendRefusal({
+          status,
+          shouldStatusPageSubscribersBeNotifiedOnNoteCreated: true,
+        }),
+      ).toBeNull();
+    },
+  );
+
+  test("a note posted without notifying subscribers never may: the job would never pick it up", () => {
+    for (const status of ALL_STATUSES) {
+      expect(
+        SubscriberNotificationResend.getPublicNoteResendRefusal({
+          status,
+          shouldStatusPageSubscribersBeNotifiedOnNoteCreated: false,
+        }),
+      ).toBe(SubscriberNotificationResend.notePostedWithoutNotifyingMessage);
+    }
+  });
+
+  test("a notification being sent right now may not: its send would overwrite the request", () => {
+    expect(
+      SubscriberNotificationResend.getPublicNoteResendRefusal({
+        status: StatusPageSubscriberNotificationStatus.InProgress,
+        shouldStatusPageSubscribersBeNotifiedOnNoteCreated: true,
+      }),
+    ).toBe(SubscriberNotificationResend.beingSentMessage);
+  });
+
+  test("a queued one may: nothing changes", () => {
+    expect(
+      SubscriberNotificationResend.getPublicNoteResendRefusal({
+        status: StatusPageSubscriberNotificationStatus.Pending,
+        shouldStatusPageSubscribersBeNotifiedOnNoteCreated: true,
+      }),
+    ).toBeNull();
+  });
+
+  test("a skip of a note that does notify (a hidden incident, no monitors) is looked at afresh", () => {
+    expect(
+      SubscriberNotificationResend.getPublicNoteResendRefusal({
+        status: StatusPageSubscriberNotificationStatus.Skipped,
+        shouldStatusPageSubscribersBeNotifiedOnNoteCreated: true,
+      }),
+    ).toBeNull();
+  });
+
+  test("an unread flag is not taken for a no", () => {
+    expect(
+      SubscriberNotificationResend.getPublicNoteResendRefusal({
+        status: StatusPageSubscriberNotificationStatus.Success,
+        shouldStatusPageSubscribersBeNotifiedOnNoteCreated: undefined,
+      }),
+    ).toBeNull();
+  });
+});
+
+describe("SubscriberNotificationResend.isPublicNoteResendRequested", () => {
+  test("an update writing Pending into the posted status asks for it", () => {
+    expect(
+      SubscriberNotificationResend.isPublicNoteResendRequested({
+        subscriberNotificationStatusOnNoteCreated:
+          StatusPageSubscriberNotificationStatus.Pending,
+      }),
+    ).toBe(true);
+  });
+
+  test.each([
+    StatusPageSubscriberNotificationStatus.Success,
+    StatusPageSubscriberNotificationStatus.Failed,
+    StatusPageSubscriberNotificationStatus.Skipped,
+    StatusPageSubscriberNotificationStatus.InProgress,
+  ])(
+    "writing %s does not",
+    (status: StatusPageSubscriberNotificationStatus) => {
+      expect(
+        SubscriberNotificationResend.isPublicNoteResendRequested({
+          subscriberNotificationStatusOnNoteCreated: status,
+        }),
+      ).toBe(false);
+    },
+  );
+
+  test("an edit that leaves the status alone does not", () => {
+    expect(SubscriberNotificationResend.isPublicNoteResendRequested({})).toBe(
+      false,
+    );
+    expect(
+      SubscriberNotificationResend.isPublicNoteResendRequested(undefined),
+    ).toBe(false);
+  });
+
+  test("retrying the update notification is not a resend of the post", () => {
+    expect(
+      SubscriberNotificationResend.isPublicNoteResendRequested({
+        subscriberNotificationStatusOnNoteUpdated:
+          StatusPageSubscriberNotificationStatus.Pending,
+      } as { subscriberNotificationStatusOnNoteCreated?: unknown }),
+    ).toBe(false);
+  });
+});

package/Tests/Types/StatusPage/SubscriberNotificationTemplateCompiler.test.ts

@@ -0,0 +1,277 @@
+import SafeHtml from "../../../Types/SafeHtml";
+import SubscriberNotificationTemplateCompiler from "../../../Types/StatusPage/SubscriberNotificationTemplateCompiler";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * A custom subscriber notification template is filled one of two ways,
+ * depending on what its channel renders:
+ *
+ *   - the body of an EMAIL template is HTML, so a plain value (a title, a
+ *     name, a URL) is escaped into it and only a SafeHtml value goes in as
+ *     markup;
+ *   - an email subject, SMS, Slack and Teams show text as written, so they
+ *     get every value unchanged.
+ */
+
+const TITLE_WITH_LINK: string =
+  '<a href="https://evil.example/reset">Reset your password</a>';
+const TITLE_WITH_SCRIPT: string = "<script>alert('x')</script>";
+const TITLE_WITH_QUOTES: string = `Payments "EU" & 'UK' down`;
+
+describe("SubscriberNotificationTemplateCompiler.compileEmailBodyTemplate", () => {
+  const compile: (
+    template: string,
+    variables: Record<string, string | SafeHtml>,
+  ) => string = (
+    template: string,
+    variables: Record<string, string | SafeHtml>,
+  ): string => {
+    return SubscriberNotificationTemplateCompiler.compileEmailBodyTemplate(
+      template,
+      variables,
+    );
+  };
+
+  test("escapes a plain value that holds a link", () => {
+    const body: string = compile("<h1>{{incidentTitle}}</h1>", {
+      incidentTitle: TITLE_WITH_LINK,
+    });
+
+    expect(body).toBe(
+      "<h1>&lt;a href=&quot;https://evil.example/reset&quot;&gt;Reset your password&lt;/a&gt;</h1>",
+    );
+    expect(body).not.toContain("<a ");
+  });
+
+  test("escapes a plain value that holds a script", () => {
+    const body: string = compile("<p>{{incidentTitle}}</p>", {
+      incidentTitle: TITLE_WITH_SCRIPT,
+    });
+
+    expect(body).toBe("<p>&lt;script&gt;alert(&#39;x&#39;)&lt;/script&gt;</p>");
+    expect(body).not.toContain("<script");
+  });
+
+  test("escapes quotes and ampersands, so a value cannot break out of an attribute", () => {
+    const body: string = compile(
+      `<a href="{{detailsUrl}}" title='{{incidentTitle}}'>Details</a>`,
+      {
+        detailsUrl: 'https://status.example.com/" onmouseover="alert(1)',
+        incidentTitle: TITLE_WITH_QUOTES,
+      },
+    );
+
+    expect(body).toBe(
+      `<a href="https://status.example.com/&quot; onmouseover=&quot;alert(1)" title='Payments &quot;EU&quot; &amp; &#39;UK&#39; down'>Details</a>`,
+    );
+  });
+
+  test("keeps the ampersands of a URL working: the attribute decodes them back", () => {
+    const body: string = compile(`<a href="{{detailsUrl}}">x</a>`, {
+      detailsUrl: "https://status.example.com/incidents/1?view=details&lang=en",
+    });
+
+    expect(body).toBe(
+      `<a href="https://status.example.com/incidents/1?view=details&amp;lang=en">x</a>`,
+    );
+  });
+
+  test("inserts a SafeHtml value as it is", () => {
+    const body: string = compile(
+      "<div>{{incidentDescription}}</div><div>{{resourcesAffected}}</div>",
+      {
+        incidentDescription: SafeHtml.fromTrustedHtml(
+          '<p>Card payments <strong>fail</strong> in <a href="https://acme.com/eu">Europe</a>.</p>',
+        ),
+        resourcesAffected: SafeHtml.fromTrustedHtml(
+          "Europe: Checkout API<br/>Americas: Payments &amp; Billing",
+        ),
+      },
+    );
+
+    expect(body).toBe(
+      '<div><p>Card payments <strong>fail</strong> in <a href="https://acme.com/eu">Europe</a>.</p></div>' +
+        "<div>Europe: Checkout API<br/>Americas: Payments &amp; Billing</div>",
+    );
+  });
+
+  test("escapes plain values and keeps HTML ones in the same template", () => {
+    const body: string = compile(
+      "<h1>{{incidentTitle}}</h1>{{incidentDescription}}<p>{{statusPageName}}</p>",
+      {
+        incidentTitle: TITLE_WITH_SCRIPT,
+        incidentDescription: SafeHtml.fromTrustedHtml("<p><em>ok</em></p>"),
+        statusPageName: "Acme <Status>",
+      },
+    );
+
+    expect(body).toBe(
+      "<h1>&lt;script&gt;alert(&#39;x&#39;)&lt;/script&gt;</h1><p><em>ok</em></p><p>Acme &lt;Status&gt;</p>",
+    );
+  });
+
+  test("the template's own HTML is sent as written: the admin who wrote it is trusted", () => {
+    const template: string =
+      '<table><tr><td style="color:red">{{incidentTitle}}</td></tr></table><a href="https://acme.com">Acme</a>';
+
+    expect(compile(template, { incidentTitle: "Down" })).toBe(
+      '<table><tr><td style="color:red">Down</td></tr></table><a href="https://acme.com">Acme</a>',
+    );
+  });
+
+  test("a placeholder with no variable is left as written", () => {
+    expect(
+      compile("Hello {{unknownVariable}} {{incidentTitle}}", {
+        incidentTitle: "Down",
+      }),
+    ).toBe("Hello {{unknownVariable}} Down");
+  });
+
+  test("a missing or empty value renders as nothing", () => {
+    expect(
+      compile("[{{a}}][{{b}}][{{c}}]", {
+        a: "",
+        b: undefined as unknown as string,
+        c: SafeHtml.fromTrustedHtml(""),
+      }),
+    ).toBe("[][][]");
+  });
+
+  test("placeholders inside a value are not expanded", () => {
+    expect(
+      compile("{{note}} | {{unsubscribeUrl}}", {
+        note: SafeHtml.fromTrustedHtml("<p>See {{unsubscribeUrl}}</p>"),
+        unsubscribeUrl: "https://status.example.com/u/1",
+      }),
+    ).toBe("<p>See {{unsubscribeUrl}}</p> | https://status.example.com/u/1");
+
+    expect(
+      compile("{{incidentTitle}} | {{unsubscribeUrl}}", {
+        incidentTitle: "Quoting {{unsubscribeUrl}}",
+        unsubscribeUrl: "https://status.example.com/u/1",
+      }),
+    ).toBe("Quoting {{unsubscribeUrl}} | https://status.example.com/u/1");
+  });
+
+  test.each([
+    ["$$", "Refunds of $$5 issued"],
+    ["$&", "Store $& Co"],
+    ["$`", "cost $` now"],
+    ["$'", "cost $' now"],
+  ])(
+    "inserts a value containing %s literally",
+    (_label: string, text: string) => {
+      expect(compile("Before {{note}} after", { note: text })).toBe(
+        `Before ${SafeHtml.escape(text)} after`,
+      );
+      expect(
+        compile("Before {{note}} after", {
+          note: SafeHtml.fromTrustedHtml(text),
+        }),
+      ).toBe(`Before ${text} after`);
+    },
+  );
+
+  test("does not read inherited properties as variables", () => {
+    expect(compile("{{toString}} {{constructor}}", {})).toBe(
+      "{{toString}} {{constructor}}",
+    );
+  });
+
+  test("a plain object that only looks like SafeHtml is escaped, not trusted", () => {
+    const lookalike: SafeHtml = {
+      toHtml: (): string => {
+        return "<b>trusted?</b>";
+      },
+      toString: (): string => {
+        return "<b>trusted?</b>";
+      },
+    } as unknown as SafeHtml;
+
+    expect(compile("{{x}}", { x: lookalike })).toBe(
+      "&lt;b&gt;trusted?&lt;/b&gt;",
+    );
+  });
+});
+
+describe("SubscriberNotificationTemplateCompiler.compileTemplate", () => {
+  /*
+   * An email subject, SMS, Slack and Teams do not render HTML: escaping would
+   * show the reader "&amp;" and "&lt;". They get every value as written.
+   */
+  test("inserts text channel values exactly as written, never escaped", () => {
+    expect(
+      SubscriberNotificationTemplateCompiler.compileTemplate(
+        "[Incident] {{incidentTitle}} on {{statusPageName}}",
+        {
+          incidentTitle: TITLE_WITH_QUOTES,
+          statusPageName: "Acme <Status>",
+        },
+      ),
+    ).toBe(`[Incident] Payments "EU" & 'UK' down on Acme <Status>`);
+  });
+
+  test("leaves an unknown placeholder alone and fills the known ones", () => {
+    expect(
+      SubscriberNotificationTemplateCompiler.compileTemplate(
+        "{{a}} {{ b }} {{c}}",
+        { a: "1", b: "2" },
+      ),
+    ).toBe("1 2 {{c}}");
+  });
+});
+
+describe("SubscriberNotificationTemplateCompiler.getPlaceholderNames", () => {
+  test("names exactly the placeholders the compile fills, each once", () => {
+    const templates: Array<string | null | undefined> = [
+      "<p>{{incidentTitle}} {{ customFields.root_cause }}</p>",
+      "{{customFields.root_cause}} {{incidentLabels}}",
+      null,
+      undefined,
+      "",
+      // Not placeholders the compile fills: left as written.
+      "{{customFields.root-cause}} {{ }} {{customFields.café}} {incidentTitle}",
+    ];
+
+    expect(
+      Array.from(
+        SubscriberNotificationTemplateCompiler.getPlaceholderNames(templates),
+      ),
+    ).toEqual(["incidentTitle", "customFields.root_cause", "incidentLabels"]);
+
+    // Every name it finds is one the compile replaces, and no other.
+    const variables: Record<string, string> = {};
+
+    for (const name of SubscriberNotificationTemplateCompiler.getPlaceholderNames(
+      templates,
+    )) {
+      variables[name] = "X";
+    }
+
+    const compiled: string = templates
+      .map((template: string | null | undefined): string => {
+        return SubscriberNotificationTemplateCompiler.compileTemplate(
+          template || "",
+          variables,
+        );
+      })
+      .join("\n");
+
+    expect(compiled).not.toContain("{{incidentTitle}}");
+    expect(compiled).not.toContain("customFields.root_cause");
+    expect(compiled).toContain("{{customFields.root-cause}}");
+  });
+
+  test("can be called again and again: no pattern state carries over", () => {
+    for (let i: number = 0; i < 3; i++) {
+      expect(
+        Array.from(
+          SubscriberNotificationTemplateCompiler.getPlaceholderNames([
+            "{{a}}",
+            "{{a}} {{b}}",
+          ]),
+        ),
+      ).toEqual(["a", "b"]);
+    }
+  });
+});