@oneuptime/common 14.0.6 → 14.0.8

package/Tests/App/Dashboard/EventNotesPages.test.tsx

@@ -41,6 +41,7 @@ type RecordedFeedProps = {
     generate: (data: { template?: string }) => Promise<string>;
   };
   siblingRoute?: { toString: () => string };
+  templateVariables?: () => Promise<Record<string, string>>;
 };
 
 let feedRenders: Array<RecordedFeedProps> = [];
@@ -136,6 +137,7 @@ import ScheduledMaintenanceInternalNote from "../../../Models/DatabaseModels/Sch
 import ScheduledMaintenanceNoteTemplate from "../../../Models/DatabaseModels/ScheduledMaintenanceNoteTemplate";
 import ScheduledMaintenancePublicNote from "../../../Models/DatabaseModels/ScheduledMaintenancePublicNote";
 import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import Incident from "../../../Models/DatabaseModels/Incident";
 import HTTPResponse from "../../../Types/API/HTTPResponse";
 import Route from "../../../Types/API/Route";
 import ObjectID from "../../../Types/ObjectID";
@@ -169,6 +171,14 @@ interface NotePageCase {
       }
     | undefined;
   siblingPath?: string | undefined;
+  // Fills a picked template's {{incident.title}}-style placeholders.
+  fillsIncidentPlaceholders?: boolean | undefined;
+  /*
+   * Offers Resend for a note whose notification went out, confirmed with
+   * the incident's audience. Only the incident's public notes do; the
+   * episode and scheduled maintenance ones keep Retry after a failure only.
+   */
+  offersResend?: boolean | undefined;
 }
 
 const INCIDENTS: string = `/dashboard/${PROJECT_ID}/incidents`;
@@ -193,6 +203,8 @@ const PAGES: Array<NotePageCase> = [
       templates: PUBLIC_NOTE_TEMPLATES,
     },
     siblingPath: `${INCIDENTS}/${EVENT_ID}/internal-notes`,
+    fillsIncidentPlaceholders: true,
+    offersResend: true,
   },
   {
     name: "incident private notes",
@@ -211,6 +223,7 @@ const PAGES: Array<NotePageCase> = [
       templates: INTERNAL_NOTE_TEMPLATES,
     },
     siblingPath: `${INCIDENTS}/${EVENT_ID}/public-notes`,
+    fillsIncidentPlaceholders: true,
   },
   {
     name: "alert private notes",
@@ -397,6 +410,42 @@ describe.each(PAGES)("$name", (page: NotePageCase) => {
     }
   });
 
+  if (page.offersResend) {
+    test("offers Resend, confirmed with who this incident's notes reach now", async () => {
+      await renderPage();
+
+      const resend: { audience?: ReactElement | undefined } | undefined = (
+        feed().subscriberNotifications as
+          | { resend?: { audience?: ReactElement | undefined } }
+          | undefined
+      )?.resend;
+
+      expect(resend).toBeDefined();
+
+      // The audience summary for this incident's current scope.
+      const audience: ReactElement = resend!.audience!;
+      const props: {
+        request: { incidentId: { toString: () => string } };
+        dataTestId?: string;
+      } = audience.props as {
+        request: { incidentId: { toString: () => string } };
+        dataTestId?: string;
+      };
+
+      expect(props.request.incidentId.toString()).toBe(EVENT_ID);
+      expect(props.dataTestId).toBe("incident-public-note-resend-audience");
+    });
+  } else if (page.visibility === "public") {
+    test("keeps Retry after a failure only: no Resend setting", async () => {
+      await renderPage();
+
+      expect(
+        (feed().subscriberNotifications as { resend?: unknown } | undefined)
+          ?.resend,
+      ).toBeUndefined();
+    });
+  }
+
   if (page.ai) {
     const ai: NonNullable<NotePageCase["ai"]> = page.ai;
 
@@ -437,6 +486,76 @@ describe.each(PAGES)("$name", (page: NotePageCase) => {
     });
   }
 
+  if (page.fillsIncidentPlaceholders) {
+    test("fills a picked template's placeholders from this incident", async () => {
+      await renderPage();
+
+      getItemMock.mockImplementation(async (...args: Array<unknown>) => {
+        const request: { modelType: unknown; id: ObjectID } = args[0] as {
+          modelType: unknown;
+          id: ObjectID;
+        };
+
+        if (request.modelType !== Incident) {
+          return null;
+        }
+
+        const incident: Incident = new Incident();
+        incident._id = request.id.toString();
+        incident.title = `Incident ${request.id.toString()}`;
+        return incident;
+      });
+      // The status pages and custom fields cannot be read here.
+      jest
+        .spyOn(API, "post")
+        .mockResolvedValue(
+          new HTTPErrorResponse(403, { message: "No access." }, {}),
+        );
+
+      expect(typeof feed().templateVariables).toBe("function");
+
+      const variables: Record<string, string> =
+        await feed().templateVariables!();
+
+      expect(variables["incident.title"]).toBe(`Incident ${EVENT_ID}`);
+
+      const incidentRequest: { select: Record<string, unknown> } =
+        getItemMock.mock.calls
+          .map((call: Array<unknown>) => {
+            return call[0] as {
+              modelType: unknown;
+              id: ObjectID;
+              select: Record<string, unknown>;
+            };
+          })
+          .find(
+            (request: {
+              modelType: unknown;
+              id: ObjectID;
+              select: Record<string, unknown>;
+            }) => {
+              return (
+                request.modelType === Incident &&
+                request.id.toString() === EVENT_ID &&
+                Boolean(request.select["title"])
+              );
+            },
+          )!;
+
+      expect(incidentRequest.select).toMatchObject({
+        title: true,
+        customFields: true,
+        labels: { name: true },
+      });
+    });
+  } else {
+    test("leaves template placeholders as written", async () => {
+      await renderPage();
+
+      expect(feed().templateVariables).toBeUndefined();
+    });
+  }
+
   test("a new event gets a new feed, so no draft follows you there", async () => {
     const view: RenderResult = await renderPage();
 

package/Tests/App/Dashboard/EventNotesUtil.test.ts

@@ -37,6 +37,7 @@ import IncidentPublicNote from "../../../Models/DatabaseModels/IncidentPublicNot
 import User from "../../../Models/DatabaseModels/User";
 import Search from "../../../Types/BaseDatabase/Search";
 import IconProp from "../../../Types/Icon/IconProp";
+import { SubscriberNotificationResendAction } from "../../../Types/StatusPage/SubscriberNotificationResend";
 import Email from "../../../Types/Email";
 import Name from "../../../Types/Name";
 import ObjectID from "../../../Types/ObjectID";
@@ -346,6 +347,49 @@ describe("applyTemplateToDraft", () => {
       "We saw errors.\n\nInvestigating.",
     );
   });
+
+  describe("with values for the template's placeholders", () => {
+    const TEMPLATE: string =
+      "**Incident**: {{incident.title}} ({{incident.severity}})\n**Impact**: {{customFields.impact}}\n**Owner**: {{incident.owner}}";
+
+    const VARIABLES: Record<string, string> = {
+      "incident.title": "Payments are failing",
+      "incident.severity": "Critical",
+      "customFields.impact": "High",
+    };
+
+    test("fills the known placeholders and leaves the unknown ones as written", () => {
+      expect(applyTemplateToDraft("", TEMPLATE, VARIABLES)).toBe(
+        "**Incident**: Payments are failing (Critical)\n**Impact**: High\n**Owner**: {{incident.owner}}",
+      );
+    });
+
+    test("fills only the template, never what was already typed", () => {
+      expect(
+        applyTemplateToDraft(
+          "Seen as {{incident.title}} in the logs.",
+          "Update: {{incident.title}}",
+          VARIABLES,
+        ),
+      ).toBe(
+        "Seen as {{incident.title}} in the logs.\n\nUpdate: Payments are failing",
+      );
+    });
+
+    test("a placeholder whose value is empty is filled with nothing", () => {
+      expect(
+        applyTemplateToDraft("", "Labels: {{incident.labels}}.", {
+          "incident.labels": "",
+        }),
+      ).toBe("Labels: .");
+    });
+
+    test("no values, or none at all, leave the template as written", () => {
+      expect(applyTemplateToDraft("", TEMPLATE, {})).toBe(TEMPLATE);
+      expect(applyTemplateToDraft("", TEMPLATE, undefined)).toBe(TEMPLATE);
+      expect(applyTemplateToDraft("", TEMPLATE, null)).toBe(TEMPLATE);
+    });
+  });
 });
 
 describe("buildNotesQuery", () => {
@@ -407,42 +451,42 @@ describe("getPostedNotificationSummary", () => {
       "Subscribers notified",
       NoteNotificationTone.Success,
       IconProp.CheckCircle,
-      false,
+      null,
     ],
     [
       StatusPageSubscriberNotificationStatus.Pending,
       "Notifying subscribers soon",
       NoteNotificationTone.Pending,
       IconProp.Clock,
-      false,
+      null,
     ],
     [
       StatusPageSubscriberNotificationStatus.InProgress,
       "Notifying subscribers",
       NoteNotificationTone.Progress,
       IconProp.ArrowPath,
-      false,
+      null,
     ],
     [
       StatusPageSubscriberNotificationStatus.Failed,
       "Notification failed",
       NoteNotificationTone.Danger,
       IconProp.Error,
-      true,
+      SubscriberNotificationResendAction.Retry,
     ],
     [
       StatusPageSubscriberNotificationStatus.Skipped,
       "Subscribers not notified",
       NoteNotificationTone.Neutral,
       IconProp.BellSlash,
-      false,
+      null,
     ],
     [
       undefined,
       "Subscribers not notified",
       NoteNotificationTone.Neutral,
       IconProp.BellSlash,
-      false,
+      null,
     ],
   ])(
     "%s reads as %s",
@@ -451,7 +495,7 @@ describe("getPostedNotificationSummary", () => {
       label: string,
       tone: NoteNotificationTone,
       icon: IconProp,
-      isRetryable: boolean,
+      resendAction: SubscriberNotificationResendAction | null,
     ) => {
       const summary: NoteNotificationSummary = getPostedNotificationSummary(
         status,
@@ -462,7 +506,7 @@ describe("getPostedNotificationSummary", () => {
         label,
         tone,
         icon,
-        isRetryable,
+        resendAction,
         detail: null,
       });
     },
@@ -485,6 +529,61 @@ describe("getPostedNotificationSummary", () => {
       ).detail,
     ).toBeNull();
   });
+
+  describe("where Resend is offered (the incident's public notes)", () => {
+    test.each([
+      [
+        StatusPageSubscriberNotificationStatus.Success,
+        SubscriberNotificationResendAction.Resend,
+      ],
+      [
+        StatusPageSubscriberNotificationStatus.Failed,
+        SubscriberNotificationResendAction.Retry,
+      ],
+      [StatusPageSubscriberNotificationStatus.Skipped, null],
+      [StatusPageSubscriberNotificationStatus.Pending, null],
+      [StatusPageSubscriberNotificationStatus.InProgress, null],
+      [undefined, null],
+    ])(
+      "%s offers %s",
+      (
+        status: StatusPageSubscriberNotificationStatus | undefined,
+        resendAction: SubscriberNotificationResendAction | null,
+      ) => {
+        expect(
+          getPostedNotificationSummary(status, "message", {
+            isResendAfterSuccessOffered: true,
+          }).resendAction,
+        ).toBe(resendAction);
+      },
+    );
+
+    test("the label stays what happened, not what can be done about it", () => {
+      expect(
+        getPostedNotificationSummary(
+          StatusPageSubscriberNotificationStatus.Success,
+          undefined,
+          { isResendAfterSuccessOffered: true },
+        ).label,
+      ).toBe("Subscribers notified");
+    });
+
+    test("left off, a notification that went out cannot be sent again", () => {
+      for (const options of [
+        undefined,
+        {},
+        { isResendAfterSuccessOffered: false },
+      ]) {
+        expect(
+          getPostedNotificationSummary(
+            StatusPageSubscriberNotificationStatus.Success,
+            undefined,
+            options,
+          ).resendAction,
+        ).toBeNull();
+      }
+    });
+  });
 });
 
 describe("getUpdateNotificationSummary", () => {
@@ -494,27 +593,27 @@ describe("getUpdateNotificationSummary", () => {
   });
 
   test.each([
-    [StatusPageSubscriberNotificationStatus.Success, "Update sent", false],
-    [StatusPageSubscriberNotificationStatus.Pending, "Update queued", false],
+    [StatusPageSubscriberNotificationStatus.Success, "Update sent", null],
+    [StatusPageSubscriberNotificationStatus.Pending, "Update queued", null],
+    [StatusPageSubscriberNotificationStatus.InProgress, "Sending update", null],
     [
-      StatusPageSubscriberNotificationStatus.InProgress,
-      "Sending update",
-      false,
+      StatusPageSubscriberNotificationStatus.Failed,
+      "Update failed",
+      SubscriberNotificationResendAction.Retry,
     ],
-    [StatusPageSubscriberNotificationStatus.Failed, "Update failed", true],
-    [StatusPageSubscriberNotificationStatus.Skipped, "Update not sent", false],
+    [StatusPageSubscriberNotificationStatus.Skipped, "Update not sent", null],
   ])(
     "%s reads as %s",
     (
       status: StatusPageSubscriberNotificationStatus,
       label: string,
-      isRetryable: boolean,
+      resendAction: SubscriberNotificationResendAction | null,
     ) => {
       const summary: NoteNotificationSummary | null =
         getUpdateNotificationSummary(status, "message");
 
       expect(summary?.label).toBe(label);
-      expect(summary?.isRetryable).toBe(isRetryable);
+      expect(summary?.resendAction).toBe(resendAction);
       expect(summary?.detail).toBe("message");
     },
   );