@oneuptime/common 14.0.7 → 14.0.8

package/Tests/Types/SafeHtml.test.ts

@@ -0,0 +1,102 @@
+import SafeHtml from "../../Types/SafeHtml";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * SafeHtml marks a value that is already HTML. Everything else that meets an
+ * email body is plain text and is escaped, so these tests pin both halves:
+ * the escaping itself, and that only a real SafeHtml is recognised as HTML.
+ */
+
+describe("SafeHtml.escape", () => {
+  test("escapes the five characters that break out of HTML text or attributes", () => {
+    expect(SafeHtml.escape(`<a href="x" title='y'>&</a>`)).toBe(
+      "&lt;a href=&quot;x&quot; title=&#39;y&#39;&gt;&amp;&lt;/a&gt;",
+    );
+  });
+
+  test("escapes the ampersand first, so the other entities are not escaped twice", () => {
+    expect(SafeHtml.escape("<")).toBe("&lt;");
+    expect(SafeHtml.escape("&lt;")).toBe("&amp;lt;");
+  });
+
+  test("leaves ordinary text alone, including non-Latin text and emoji", () => {
+    for (const text of [
+      "Checkout API is degraded",
+      "Zahlungen fallen aus – Region Süd",
+      "決済が失敗しています",
+      "🚨 Outage",
+      "",
+    ]) {
+      expect(SafeHtml.escape(text)).toBe(text);
+    }
+  });
+
+  test("a script tag reads as text", () => {
+    expect(SafeHtml.escape("<script>alert(1)</script>")).toBe(
+      "&lt;script&gt;alert(1)&lt;/script&gt;",
+    );
+  });
+});
+
+describe("SafeHtml values", () => {
+  test("fromTrustedHtml keeps the markup as it is", () => {
+    const html: SafeHtml = SafeHtml.fromTrustedHtml(
+      "<p>Failover <strong>done</strong></p>",
+    );
+
+    expect(html.toHtml()).toBe("<p>Failover <strong>done</strong></p>");
+    expect(html.toString()).toBe("<p>Failover <strong>done</strong></p>");
+    expect(`${html}`).toBe("<p>Failover <strong>done</strong></p>");
+  });
+
+  test("fromPlainText escapes", () => {
+    expect(SafeHtml.fromPlainText(`Tom & "Jerry" <b>`).toHtml()).toBe(
+      "Tom &amp; &quot;Jerry&quot; &lt;b&gt;",
+    );
+  });
+
+  test("a missing value is empty, never the text 'undefined' or 'null'", () => {
+    expect(SafeHtml.fromTrustedHtml(undefined).toHtml()).toBe("");
+    expect(SafeHtml.fromTrustedHtml(null).toHtml()).toBe("");
+    expect(SafeHtml.fromPlainText(undefined).toHtml()).toBe("");
+    expect(SafeHtml.fromPlainText(null).toHtml()).toBe("");
+  });
+
+  test("isSafeHtml recognises only SafeHtml values", () => {
+    expect(SafeHtml.isSafeHtml(SafeHtml.fromTrustedHtml("<b>x</b>"))).toBe(
+      true,
+    );
+    expect(SafeHtml.isSafeHtml(SafeHtml.fromPlainText("x"))).toBe(true);
+
+    for (const value of [
+      "<b>x</b>",
+      "",
+      undefined,
+      null,
+      0,
+      {},
+      { html: "<b>x</b>" },
+      {
+        toHtml: (): string => {
+          return "<b>x</b>";
+        },
+      },
+      ["<b>x</b>"],
+    ]) {
+      expect(SafeHtml.isSafeHtml(value)).toBe(false);
+    }
+  });
+
+  /*
+   * An object that went through JSON (a job payload, a queue) is no longer a
+   * SafeHtml, and must not be mistaken for one: it would be escaped, or
+   * dropped, but never inserted as HTML.
+   */
+  test("a value that went through JSON is not HTML any more", () => {
+    const roundTripped: unknown = JSON.parse(
+      JSON.stringify(SafeHtml.fromTrustedHtml("<b>x</b>")),
+    );
+
+    expect(SafeHtml.isSafeHtml(roundTripped)).toBe(false);
+  });
+});

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

@@ -0,0 +1,419 @@
+import { JSONObject } from "../../../Types/JSON";
+import IncidentCreatedRenotify, {
+  IncidentCreatedRenotifyState,
+} from "../../../Types/StatusPage/IncidentCreatedRenotify";
+import SubscriberUpdateNotification from "../../../Types/StatusPage/SubscriberUpdateNotification";
+import StatusPageSubscriberNotificationStatus from "../../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Publishing a hidden incident can tell status page subscribers it was
+ * created - but only when the editor asks for it on that publish, and only for
+ * an incident whose 'created' notification was skipped. This file is the one
+ * place that decides both, for the dashboard and the server alike, and a false
+ * positive here emails every subscriber of a status page about a "new"
+ * incident.
+ */
+
+describe("IncidentCreatedRenotify.isRequested", () => {
+  test("uses a stable misc data key the dashboard and the API share", () => {
+    expect(IncidentCreatedRenotify.miscDataKey).toBe(
+      "notifySubscribersOfIncidentCreatedOnPublish",
+    );
+  });
+
+  test("does not reuse the update-notification key, so the two asks cannot be confused", () => {
+    expect(IncidentCreatedRenotify.miscDataKey).not.toBe(
+      SubscriberUpdateNotification.miscDataKey,
+    );
+  });
+
+  test("is true for the boolean the dashboard form sends", () => {
+    expect(
+      IncidentCreatedRenotify.isRequested({
+        notifySubscribersOfIncidentCreatedOnPublish: true,
+      }),
+    ).toBe(true);
+  });
+
+  test('is true for the string "true" a hand-written API request may send', () => {
+    expect(
+      IncidentCreatedRenotify.isRequested({
+        notifySubscribersOfIncidentCreatedOnPublish: "true",
+      }),
+    ).toBe(true);
+  });
+
+  test("round-trips the misc data props it builds", () => {
+    expect(
+      IncidentCreatedRenotify.isRequested(
+        IncidentCreatedRenotify.getMiscDataProps(),
+      ),
+    ).toBe(true);
+    expect(IncidentCreatedRenotify.getMiscDataProps()).toEqual({
+      notifySubscribersOfIncidentCreatedOnPublish: true,
+    });
+  });
+
+  test("returns a fresh object each time so callers cannot share state", () => {
+    const first: JSONObject = IncidentCreatedRenotify.getMiscDataProps();
+    first["notifySubscribersOfIncidentCreatedOnPublish"] = false;
+
+    expect(IncidentCreatedRenotify.getMiscDataProps()).toEqual({
+      notifySubscribersOfIncidentCreatedOnPublish: true,
+    });
+  });
+
+  test.each([
+    ["false", false],
+    ['the string "false"', "false"],
+    ["the number 1", 1],
+    ['the string "1"', "1"],
+    ['the string "yes"', "yes"],
+    ['the string "TRUE"', "TRUE"],
+    ["null", null],
+    ["an object", { value: true }],
+    ["an array", [true]],
+    ["an empty string", ""],
+  ] as Array<[string, unknown]>)(
+    "is false when the flag is %s",
+    (_label: string, value: unknown) => {
+      expect(
+        IncidentCreatedRenotify.isRequested({
+          notifySubscribersOfIncidentCreatedOnPublish: value,
+        } as JSONObject),
+      ).toBe(false);
+    },
+  );
+
+  test.each([
+    ["undefined", undefined],
+    ["null", null],
+    ["an empty object", {}],
+    ["a string", "notifySubscribersOfIncidentCreatedOnPublish"],
+  ] as Array<[string, unknown]>)(
+    "is false when the misc data props are %s",
+    (_label: string, value: unknown) => {
+      expect(
+        IncidentCreatedRenotify.isRequested(value as JSONObject | undefined),
+      ).toBe(false);
+    },
+  );
+
+  test("is false when only the update-notification key is sent", () => {
+    expect(
+      IncidentCreatedRenotify.isRequested(
+        SubscriberUpdateNotification.getMiscDataProps(),
+      ),
+    ).toBe(false);
+  });
+});
+
+const PAGE_A: string = "0b5e0c8e-1f53-4f55-9a52-6a0c1e0f0b01";
+const PAGE_B: string = "0b5e0c8e-1f53-4f55-9a52-6a0c1e0f0b02";
+
+// A hidden incident whose 'created' notification the worker skipped.
+function hiddenSkippedIncident(): IncidentCreatedRenotifyState {
+  return {
+    isVisibleOnStatusPage: false,
+    isPrivate: false,
+    subscriberNotificationStatusOnIncidentCreated:
+      StatusPageSubscriberNotificationStatus.Skipped,
+    shouldStatusPageSubscribersBeNotifiedOnIncidentCreated: true,
+  };
+}
+
+describe("IncidentCreatedRenotify.canRenotifyOnPublish", () => {
+  test("allows a hidden, skipped incident that is set to notify subscribers", () => {
+    expect(
+      IncidentCreatedRenotify.canRenotifyOnPublish(hiddenSkippedIncident()),
+    ).toBe(true);
+  });
+
+  test("treats a missing visibility as hidden, as the worker does", () => {
+    expect(
+      IncidentCreatedRenotify.canRenotifyOnPublish({
+        ...hiddenSkippedIncident(),
+        isVisibleOnStatusPage: null,
+      }),
+    ).toBe(true);
+    expect(
+      IncidentCreatedRenotify.canRenotifyOnPublish({
+        ...hiddenSkippedIncident(),
+        isVisibleOnStatusPage: undefined,
+      }),
+    ).toBe(true);
+  });
+
+  test("treats a missing private flag as not private", () => {
+    expect(
+      IncidentCreatedRenotify.canRenotifyOnPublish({
+        ...hiddenSkippedIncident(),
+        isPrivate: null,
+      }),
+    ).toBe(true);
+  });
+
+  test("refuses an incident that is already visible: it is not being published", () => {
+    expect(
+      IncidentCreatedRenotify.canRenotifyOnPublish({
+        ...hiddenSkippedIncident(),
+        isVisibleOnStatusPage: true,
+      }),
+    ).toBe(false);
+  });
+
+  test("refuses a private incident: it is hidden from every status page", () => {
+    expect(
+      IncidentCreatedRenotify.canRenotifyOnPublish({
+        ...hiddenSkippedIncident(),
+        isPrivate: true,
+      }),
+    ).toBe(false);
+  });
+
+  test.each([
+    ["off", false],
+    ["unknown", undefined],
+    ["null", null],
+  ] as Array<[string, boolean | undefined | null]>)(
+    "refuses when notifying subscribers on creation is %s",
+    (_label: string, value: boolean | undefined | null) => {
+      expect(
+        IncidentCreatedRenotify.canRenotifyOnPublish({
+          ...hiddenSkippedIncident(),
+          shouldStatusPageSubscribersBeNotifiedOnIncidentCreated: value,
+        }),
+      ).toBe(false);
+    },
+  );
+
+  test.each([
+    StatusPageSubscriberNotificationStatus.Pending,
+    StatusPageSubscriberNotificationStatus.InProgress,
+    StatusPageSubscriberNotificationStatus.Success,
+    StatusPageSubscriberNotificationStatus.Failed,
+  ])(
+    "refuses when the 'created' notification is %s",
+    (status: StatusPageSubscriberNotificationStatus) => {
+      expect(
+        IncidentCreatedRenotify.canRenotifyOnPublish({
+          ...hiddenSkippedIncident(),
+          subscriberNotificationStatusOnIncidentCreated: status,
+        }),
+      ).toBe(false);
+    },
+  );
+
+  test("refuses when the 'created' notification status is unknown", () => {
+    expect(
+      IncidentCreatedRenotify.canRenotifyOnPublish({
+        ...hiddenSkippedIncident(),
+        subscriberNotificationStatusOnIncidentCreated: undefined,
+      }),
+    ).toBe(false);
+  });
+
+  describe("an incident told before it was hidden", () => {
+    // Visible and told on Site A, hidden, then Site B added to its scope.
+    function hiddenWithPageAddedWhileHidden(
+      overrides: Partial<IncidentCreatedRenotifyState> = {},
+    ): IncidentCreatedRenotifyState {
+      return {
+        isVisibleOnStatusPage: false,
+        isPrivate: false,
+        subscriberNotificationStatusOnIncidentCreated:
+          StatusPageSubscriberNotificationStatus.Success,
+        shouldStatusPageSubscribersBeNotifiedOnIncidentCreated: true,
+        statusPages: [{ _id: PAGE_A }, { _id: PAGE_B }],
+        statusPagesNotifiedOnCreation: [PAGE_A],
+        ...overrides,
+      };
+    }
+
+    test.each([
+      StatusPageSubscriberNotificationStatus.Success,
+      StatusPageSubscriberNotificationStatus.Failed,
+    ])(
+      "offers it when a page of its scope was never told (%s)",
+      (status: StatusPageSubscriberNotificationStatus) => {
+        expect(
+          IncidentCreatedRenotify.canRenotifyOnPublish(
+            hiddenWithPageAddedWhileHidden({
+              subscriberNotificationStatusOnIncidentCreated: status,
+            }),
+          ),
+        ).toBe(true);
+      },
+    );
+
+    test("does not offer it when every page of its scope was told", () => {
+      expect(
+        IncidentCreatedRenotify.canRenotifyOnPublish(
+          hiddenWithPageAddedWhileHidden({
+            statusPagesNotifiedOnCreation: [PAGE_B, PAGE_A.toUpperCase()],
+          }),
+        ),
+      ).toBe(false);
+    });
+
+    test("does not offer it for an unscoped incident: nothing was added to a scope", () => {
+      expect(
+        IncidentCreatedRenotify.canRenotifyOnPublish(
+          hiddenWithPageAddedWhileHidden({ statusPages: [] }),
+        ),
+      ).toBe(false);
+    });
+
+    test("does not offer it without a record: it went out before the record existed, to every page", () => {
+      for (const record of [null, undefined]) {
+        expect(
+          IncidentCreatedRenotify.canRenotifyOnPublish(
+            hiddenWithPageAddedWhileHidden({
+              statusPagesNotifiedOnCreation: record,
+            }),
+          ),
+        ).toBe(false);
+      }
+    });
+
+    test.each([
+      StatusPageSubscriberNotificationStatus.Pending,
+      StatusPageSubscriberNotificationStatus.InProgress,
+    ])(
+      "does not offer it while it is %s: it is on its way",
+      (status: StatusPageSubscriberNotificationStatus) => {
+        expect(
+          IncidentCreatedRenotify.canRenotifyOnPublish(
+            hiddenWithPageAddedWhileHidden({
+              subscriberNotificationStatusOnIncidentCreated: status,
+            }),
+          ),
+        ).toBe(false);
+      },
+    );
+
+    test("the same rules as a skipped incident: not when visible, private or set not to notify", () => {
+      for (const overrides of [
+        { isVisibleOnStatusPage: true },
+        { isPrivate: true },
+        { shouldStatusPageSubscribersBeNotifiedOnIncidentCreated: false },
+      ] as Array<Partial<IncidentCreatedRenotifyState>>) {
+        expect(
+          IncidentCreatedRenotify.canRenotifyOnPublish(
+            hiddenWithPageAddedWhileHidden(overrides),
+          ),
+        ).toBe(false);
+      }
+    });
+
+    test("hasUntoldStatusPages is false for a skipped incident: nobody was told, and the skip covers it", () => {
+      expect(
+        IncidentCreatedRenotify.hasUntoldStatusPages(
+          hiddenWithPageAddedWhileHidden({
+            subscriberNotificationStatusOnIncidentCreated:
+              StatusPageSubscriberNotificationStatus.Skipped,
+          }),
+        ),
+      ).toBe(false);
+    });
+
+    test("the checkbox explains which case it is", () => {
+      expect(
+        IncidentCreatedRenotify.getFormFieldDescription(
+          hiddenWithPageAddedWhileHidden(),
+        ),
+      ).toBe(IncidentCreatedRenotify.untoldStatusPagesFormFieldDescription);
+      expect(
+        IncidentCreatedRenotify.getFormFieldDescription(
+          hiddenSkippedIncident(),
+        ),
+      ).toBe(IncidentCreatedRenotify.formFieldDescription);
+    });
+  });
+});
+
+describe("IncidentCreatedRenotify.isTickedByDefault", () => {
+  test("is ticked while the incident is unresolved", () => {
+    expect(
+      IncidentCreatedRenotify.isTickedByDefault({ isResolved: false }),
+    ).toBe(true);
+  });
+
+  test("is ticked when the state is not known, since a new incident is unresolved", () => {
+    expect(
+      IncidentCreatedRenotify.isTickedByDefault({ isResolved: undefined }),
+    ).toBe(true);
+    expect(
+      IncidentCreatedRenotify.isTickedByDefault({ isResolved: null }),
+    ).toBe(true);
+  });
+
+  test("is unticked once the incident is resolved", () => {
+    expect(
+      IncidentCreatedRenotify.isTickedByDefault({ isResolved: true }),
+    ).toBe(false);
+  });
+});
+
+describe("IncidentCreatedRenotify.isHiddenFromStatusPagesSkip", () => {
+  test("recognises the reason the worker writes", () => {
+    expect(
+      IncidentCreatedRenotify.isHiddenFromStatusPagesSkip({
+        status: StatusPageSubscriberNotificationStatus.Skipped,
+        message: IncidentCreatedRenotify.hiddenFromStatusPagesMessage,
+      }),
+    ).toBe(true);
+  });
+
+  test("does not relabel other skip reasons", () => {
+    expect(
+      IncidentCreatedRenotify.isHiddenFromStatusPagesSkip({
+        status: StatusPageSubscriberNotificationStatus.Skipped,
+        message:
+          "No monitors are attached to this incident. Skipping notifications to subscribers.",
+      }),
+    ).toBe(false);
+    expect(
+      IncidentCreatedRenotify.isHiddenFromStatusPagesSkip({
+        status: StatusPageSubscriberNotificationStatus.Skipped,
+        message: undefined,
+      }),
+    ).toBe(false);
+  });
+
+  test("only applies to a skipped status", () => {
+    expect(
+      IncidentCreatedRenotify.isHiddenFromStatusPagesSkip({
+        status: StatusPageSubscriberNotificationStatus.Failed,
+        message: IncidentCreatedRenotify.hiddenFromStatusPagesMessage,
+      }),
+    ).toBe(false);
+  });
+});
+
+describe("IncidentCreatedRenotify copy", () => {
+  test("says what the checkbox does", () => {
+    expect(IncidentCreatedRenotify.formFieldTitle).toBe(
+      "Notify subscribers that this incident was created",
+    );
+    expect(IncidentCreatedRenotify.hiddenFromStatusPagesLabel).toBe(
+      "Skipped: hidden from status pages",
+    );
+  });
+
+  test("keeps the strings free of template placeholders, so no locale can break them", () => {
+    for (const value of [
+      IncidentCreatedRenotify.formFieldTitle,
+      IncidentCreatedRenotify.formFieldDescription,
+      IncidentCreatedRenotify.untoldStatusPagesFormFieldDescription,
+      IncidentCreatedRenotify.hiddenFromStatusPagesLabel,
+      IncidentCreatedRenotify.hiddenFromStatusPagesMessage,
+      IncidentCreatedRenotify.queuedMessage,
+    ]) {
+      expect(value).not.toMatch(/{{|}}/);
+      expect(value.trim()).toBe(value);
+      expect(value.length).toBeGreaterThan(0);
+    }
+  });
+});

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

@@ -0,0 +1,118 @@
+import { JSONObject } from "../../../Types/JSON";
+import IncidentCreatedRenotify from "../../../Types/StatusPage/IncidentCreatedRenotify";
+import IncidentCreatedResend from "../../../Types/StatusPage/IncidentCreatedResend";
+import IncidentScopeAddedPagesNotification from "../../../Types/StatusPage/IncidentScopeAddedPagesNotification";
+import StatusPageSubscriberNotificationStatus from "../../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
+import SubscriberUpdateNotification from "../../../Types/StatusPage/SubscriberUpdateNotification";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * 'Resend to all pages' for the notification that an incident was created:
+ * the request that empties the record of status pages already told, so the
+ * notification reaches every page again. A false positive emails every
+ * subscriber of every page a second time, so only a real yes counts, and only
+ * for a notification that went out.
+ */
+
+describe("IncidentCreatedResend.isRequested", () => {
+  test("uses a stable misc data key the dashboard and the API share", () => {
+    expect(IncidentCreatedResend.miscDataKey).toBe(
+      "resendIncidentCreatedToAllStatusPages",
+    );
+  });
+
+  test("does not reuse any other notification request's key", () => {
+    expect([
+      SubscriberUpdateNotification.miscDataKey,
+      IncidentCreatedRenotify.miscDataKey,
+      IncidentScopeAddedPagesNotification.miscDataKey,
+    ]).not.toContain(IncidentCreatedResend.miscDataKey);
+  });
+
+  test.each([
+    ["the boolean the dashboard sends", true],
+    ['the string "true" a hand-written API request may send', "true"],
+  ])("is true for %s", (_label: string, value: unknown) => {
+    expect(
+      IncidentCreatedResend.isRequested({
+        resendIncidentCreatedToAllStatusPages: value,
+      } as JSONObject),
+    ).toBe(true);
+  });
+
+  test.each([
+    ["no misc data props", undefined],
+    ["null", null],
+    ["empty misc data props", {}],
+    ["an explicit no", { resendIncidentCreatedToAllStatusPages: false }],
+    ['the string "false"', { resendIncidentCreatedToAllStatusPages: "false" }],
+    ["the number 1", { resendIncidentCreatedToAllStatusPages: 1 }],
+    [
+      "another request's key",
+      { notifySubscribersOfIncidentCreatedOnPublish: true },
+    ],
+  ] as Array<[string, JSONObject | undefined | null]>)(
+    "is false for %s",
+    (_label: string, miscDataProps: JSONObject | undefined | null) => {
+      expect(IncidentCreatedResend.isRequested(miscDataProps)).toBe(false);
+    },
+  );
+
+  test("round-trips the misc data props it builds, a fresh object each time", () => {
+    const first: JSONObject = IncidentCreatedResend.getMiscDataProps();
+
+    expect(first).toEqual({ resendIncidentCreatedToAllStatusPages: true });
+    expect(IncidentCreatedResend.isRequested(first)).toBe(true);
+
+    first["resendIncidentCreatedToAllStatusPages"] = false;
+
+    expect(IncidentCreatedResend.getMiscDataProps()).toEqual({
+      resendIncidentCreatedToAllStatusPages: true,
+    });
+  });
+});
+
+describe("IncidentCreatedResend.getRefusalReason", () => {
+  test.each([
+    StatusPageSubscriberNotificationStatus.Success,
+    StatusPageSubscriberNotificationStatus.Failed,
+  ])(
+    "a notification that went out (%s) may be sent to every page again",
+    (status: StatusPageSubscriberNotificationStatus) => {
+      expect(IncidentCreatedResend.getRefusalReason(status)).toBeNull();
+    },
+  );
+
+  test.each([
+    StatusPageSubscriberNotificationStatus.Pending,
+    StatusPageSubscriberNotificationStatus.InProgress,
+  ])(
+    "one that is %s is on its way",
+    (status: StatusPageSubscriberNotificationStatus) => {
+      expect(IncidentCreatedResend.getRefusalReason(status)).toBe(
+        IncidentCreatedResend.inFlightRefusalMessage,
+      );
+    },
+  );
+
+  test.each([StatusPageSubscriberNotificationStatus.Skipped, undefined, null])(
+    "one that is %s was never sent to anyone",
+    (status: StatusPageSubscriberNotificationStatus | undefined | null) => {
+      expect(IncidentCreatedResend.getRefusalReason(status)).toBe(
+        IncidentCreatedResend.skippedRefusalMessage,
+      );
+    },
+  );
+});
+
+describe("IncidentCreatedResend messages", () => {
+  test("the queued messages say who each one reaches", () => {
+    expect(IncidentCreatedResend.queuedMessage).toContain("every status page");
+    expect(IncidentCreatedResend.retryQueuedMessage).toContain(
+      "not sent it in full",
+    );
+    expect(IncidentCreatedResend.retryQueuedMessage).toContain(
+      "already reached are not sent it again",
+    );
+  });
+});