@oneuptime/common 14.0.7 → 14.0.8

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

@@ -32,6 +32,7 @@ import getJestMockFunction, { MockFunction } from "../../MockType";
 const getListMock: MockFunction = getJestMockFunction();
 const getItemMock: MockFunction = getJestMockFunction();
 const updateByIdMock: MockFunction = getJestMockFunction();
+const createOrUpdateMock: MockFunction = getJestMockFunction();
 
 const recordedProps: Record<string, Array<Record<string, unknown>>> = {};
 const mountCounts: Record<string, number> = {};
@@ -92,6 +93,9 @@ jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
       updateById: (...args: Array<unknown>) => {
         return updateByIdMock(...args);
       },
+      createOrUpdate: (...args: Array<unknown>) => {
+        return createOrUpdateMock(...args);
+      },
     },
   };
 });
@@ -326,9 +330,15 @@ import Color from "../../../Types/Color";
 import OneUptimeDate from "../../../Types/Date";
 import ObjectID from "../../../Types/ObjectID";
 import StatusPageSubscriberNotificationStatus from "../../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
+import IncidentCreatedResend from "../../../Types/StatusPage/IncidentCreatedResend";
+import { FormType } from "../../../UI/Components/Forms/ModelForm";
+import SubscriberNotificationResendCopy from "../../../../App/FeatureSet/Dashboard/src/Components/StatusPageSubscribers/SubscriberNotificationResendCopy";
 import { DetailStyle } from "../../../UI/Components/Detail/Detail";
 import FormFieldSchemaType from "../../../UI/Components/Forms/Types/FormFieldSchemaType";
 import Navigation from "../../../UI/Utils/Navigation";
+import PermissionUtil from "../../../UI/Utils/Permission";
+import User from "../../../UI/Utils/User";
+import Permission from "../../../Types/Permission";
 
 const EVENT_ID: string = "11111111-1111-4111-8111-111111111111";
 const OTHER_EVENT_ID: string = "22222222-2222-4222-8222-222222222222";
@@ -378,6 +388,11 @@ function propsHistory<T>(key: string): Array<T> {
   return (recordedProps[key] || []) as unknown as Array<T>;
 }
 
+// What the incident overview hands the notification status badge.
+type ResendStatusProps = {
+  onResendNotification: (options: { isToAllStatusPages: boolean }) => void;
+};
+
 function latestProps<T>(key: string): T {
   const history: Array<T> = propsHistory<T>(key);
 
@@ -534,6 +549,8 @@ const INCIDENT_CASE: PageCase = {
     "Declared By",
     "On-Call Duty Policies",
     "Subscriber Notification Status",
+    // The status pages the incident is limited to, read only.
+    "Status Page Scope",
     "Labels",
     "Incident Number",
     "Incident ID",
@@ -758,14 +775,22 @@ const itemRequestId: ItemRequestIdFunction = (args: Array<unknown>): string => {
   return (args[0] as { id: ObjectID }).id.toString();
 };
 
+// What the signed-in user may do; a project member unless a test says so.
+let currentPermissions: Array<Permission> = [Permission.ProjectMember];
+
 beforeEach(() => {
   currentEventId = EVENT_ID;
+  currentPermissions = [Permission.ProjectMember];
 
   jest
     .spyOn(Navigation, "getLastParamAsObjectID")
     .mockImplementation((): ObjectID => {
       return new ObjectID(currentEventId);
     });
+  jest.spyOn(PermissionUtil, "getAllPermissions").mockImplementation(() => {
+    return currentPermissions;
+  });
+  jest.spyOn(User, "isMasterAdmin").mockReturnValue(false);
 });
 
 afterEach(() => {
@@ -773,6 +798,7 @@ afterEach(() => {
   getListMock.mockReset();
   getItemMock.mockReset();
   updateByIdMock.mockReset();
+  createOrUpdateMock.mockReset();
 
   for (const key of Object.keys(recordedProps)) {
     delete recordedProps[key];
@@ -2107,9 +2133,9 @@ describe("incident-only behaviour", () => {
     const readsBefore: number = countItemReads();
 
     await act(async () => {
-      latestProps<{ onResendNotification: () => void }>(
+      latestProps<ResendStatusProps>(
         "SubscriberNotificationStatus",
-      ).onResendNotification();
+      ).onResendNotification({ isToAllStatusPages: false });
     });
 
     await waitFor(() => {
@@ -2119,6 +2145,7 @@ describe("incident-only behaviour", () => {
       ).toBe(!refresherBefore);
     });
 
+    // Retry: back to Pending, and the server keeps the record so it resumes.
     expect(updateByIdMock).toHaveBeenCalledTimes(1);
     expect(
       (updateByIdMock.mock.calls[0]![0] as { data: Record<string, unknown> })
@@ -2126,12 +2153,222 @@ describe("incident-only behaviour", () => {
     ).toEqual({
       subscriberNotificationStatusOnIncidentCreated:
         StatusPageSubscriberNotificationStatus.Pending,
-      subscriberNotificationStatusMessage: "Notification queued for resending",
+      subscriberNotificationStatusMessage:
+        IncidentCreatedResend.retryQueuedMessage,
     });
+    expect(createOrUpdateMock).not.toHaveBeenCalled();
     expect(countItemReads()).toBe(readsBefore);
     expect(mountCounts["InvestigationPanel"]).toBe(1);
   });
 
+  test("resending to every status page asks the server to, and re-reads only the details card", async () => {
+    serve(INCIDENT_CASE, {
+      timeline: REOPENED_TIMELINE,
+      title: "Checkout slow",
+    });
+    createOrUpdateMock.mockResolvedValue({});
+
+    INCIDENT_CASE.renderPage();
+    await waitForPage();
+
+    const refresherBefore: boolean | undefined =
+      latestProps<CardModelDetailProps>(
+        "CardModelDetail:Incident Details",
+      ).refresher;
+
+    renderStatusField();
+
+    await act(async () => {
+      latestProps<ResendStatusProps>(
+        "SubscriberNotificationStatus",
+      ).onResendNotification({ isToAllStatusPages: true });
+    });
+
+    await waitFor(() => {
+      expect(
+        latestProps<CardModelDetailProps>("CardModelDetail:Incident Details")
+          .refresher,
+      ).toBe(!refresherBefore);
+    });
+
+    expect(updateByIdMock).not.toHaveBeenCalled();
+    expect(createOrUpdateMock).toHaveBeenCalledTimes(1);
+
+    const request: {
+      model: Incident;
+      modelType: unknown;
+      formType: FormType;
+      miscDataProps: Record<string, unknown>;
+    } = createOrUpdateMock.mock.calls[0]![0] as {
+      model: Incident;
+      modelType: unknown;
+      formType: FormType;
+      miscDataProps: Record<string, unknown>;
+    };
+
+    expect(request.modelType).toBe(Incident);
+    expect(request.formType).toBe(FormType.Update);
+    expect(request.model._id?.toString()).toBe(EVENT_ID);
+    expect(request.model.subscriberNotificationStatusOnIncidentCreated).toBe(
+      StatusPageSubscriberNotificationStatus.Pending,
+    );
+    expect(request.miscDataProps).toEqual(
+      IncidentCreatedResend.getMiscDataProps(),
+    );
+  });
+
+  test("offers Resend after a success, confirmed with who this incident reaches now", async () => {
+    serve(INCIDENT_CASE, {
+      timeline: REOPENED_TIMELINE,
+      title: "Checkout slow",
+    });
+
+    INCIDENT_CASE.renderPage();
+    await waitForPage();
+
+    renderStatusField();
+
+    const confirmation: {
+      resendDescription: string;
+      retryDescription: string;
+      retryToAllStatusPagesLabel?: string;
+      retryToAllStatusPagesDescription?: string;
+      audience: ReactElement;
+    } = latestProps<{
+      resendConfirmation: {
+        resendDescription: string;
+        retryDescription: string;
+        retryToAllStatusPagesLabel?: string;
+        retryToAllStatusPagesDescription?: string;
+        audience: ReactElement;
+      };
+    }>("SubscriberNotificationStatus").resendConfirmation;
+
+    expect(confirmation.resendDescription).toBe(
+      SubscriberNotificationResendCopy.incidentCreatedResendDescription,
+    );
+    expect(confirmation.retryDescription).toBe(
+      SubscriberNotificationResendCopy.incidentCreatedRetryDescription,
+    );
+    expect(confirmation.retryToAllStatusPagesLabel).toBe(
+      SubscriberNotificationResendCopy.incidentCreatedRetryToAllStatusPagesLabel,
+    );
+    expect(confirmation.retryToAllStatusPagesDescription).toBe(
+      SubscriberNotificationResendCopy.incidentCreatedResendToAllStatusPagesDescription,
+    );
+
+    const audienceProps: {
+      request: { incidentId: { toString: () => string } };
+    } = confirmation.audience.props as {
+      request: { incidentId: { toString: () => string } };
+    };
+
+    expect(audienceProps.request.incidentId.toString()).toBe(EVENT_ID);
+    expect(audienceProps.request).not.toHaveProperty(
+      "excludeStatusPagesNotifiedOnCreation",
+    );
+  });
+
+  /*
+   * Retry resumes after the pages already sent it in full, so its
+   * confirmation's "Will notify" must not list them: it asks for the audience
+   * without them. Resend, and Retry to every page, keep the full one.
+   */
+  test("Retry's confirmation shows who Retry reaches: without the pages already sent it in full", async () => {
+    serve(INCIDENT_CASE, {
+      timeline: REOPENED_TIMELINE,
+      title: "Checkout slow",
+    });
+
+    INCIDENT_CASE.renderPage();
+    await waitForPage();
+
+    renderStatusField();
+
+    const confirmation: { retryAudience?: ReactElement } = latestProps<{
+      resendConfirmation: { retryAudience?: ReactElement };
+    }>("SubscriberNotificationStatus").resendConfirmation;
+
+    const retryAudienceProps: {
+      request: {
+        incidentId: { toString: () => string };
+        excludeStatusPagesNotifiedOnCreation?: boolean;
+      };
+    } = confirmation.retryAudience!.props as {
+      request: {
+        incidentId: { toString: () => string };
+        excludeStatusPagesNotifiedOnCreation?: boolean;
+      };
+    };
+
+    expect(retryAudienceProps.request.incidentId.toString()).toBe(EVENT_ID);
+    expect(
+      retryAudienceProps.request.excludeStatusPagesNotifiedOnCreation,
+    ).toBe(true);
+  });
+
+  /*
+   * Retry and Resend write the notification's status. A role that may not
+   * is offered neither - the details card used to offer them to everyone,
+   * read-only viewers included, and let the server refuse.
+   */
+  test.each([[[Permission.Viewer]], [[Permission.IncidentViewer]], [[]]])(
+    "a user with %j is offered neither Resend nor Retry",
+    async (permissions: Array<Permission>) => {
+      currentPermissions = permissions;
+      serve(INCIDENT_CASE, {
+        timeline: REOPENED_TIMELINE,
+        title: "Checkout slow",
+      });
+
+      INCIDENT_CASE.renderPage();
+      await waitForPage();
+
+      renderStatusField();
+
+      const statusProps: {
+        onResendNotification?: unknown;
+        resendConfirmation?: unknown;
+      } = latestProps<{
+        onResendNotification?: unknown;
+        resendConfirmation?: unknown;
+      }>("SubscriberNotificationStatus");
+
+      expect(statusProps.onResendNotification).toBeUndefined();
+      expect(statusProps.resendConfirmation).toBeUndefined();
+    },
+  );
+
+  test.each([
+    [[Permission.IncidentMember]],
+    [[Permission.EditProjectIncident]],
+  ])(
+    "a user with %j is offered them",
+    async (permissions: Array<Permission>) => {
+      currentPermissions = permissions;
+      serve(INCIDENT_CASE, {
+        timeline: REOPENED_TIMELINE,
+        title: "Checkout slow",
+      });
+
+      INCIDENT_CASE.renderPage();
+      await waitForPage();
+
+      renderStatusField();
+
+      const statusProps: {
+        onResendNotification?: unknown;
+        resendConfirmation?: unknown;
+      } = latestProps<{
+        onResendNotification?: unknown;
+        resendConfirmation?: unknown;
+      }>("SubscriberNotificationStatus");
+
+      expect(statusProps.onResendNotification).toBeDefined();
+      expect(statusProps.resendConfirmation).toBeDefined();
+    },
+  );
+
   /*
    * The details card is stubbed, so the status row is rendered here from the
    * card's latest props, the way the real card renders it on every page
@@ -2158,9 +2395,9 @@ describe("incident-only behaviour", () => {
 
   const resend: ResendFunction = async (): Promise<void> => {
     await act(async () => {
-      latestProps<{ onResendNotification: () => void }>(
+      latestProps<ResendStatusProps>(
         "SubscriberNotificationStatus",
-      ).onResendNotification();
+      ).onResendNotification({ isToAllStatusPages: false });
     });
     await flush();
   };

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

@@ -20,6 +20,7 @@ import getJestMockFunction, { MockFunction } from "../../MockType";
 
 const getListMock: MockFunction = getJestMockFunction();
 const modelFormModalMock: MockFunction = getJestMockFunction();
+const fetchNoteTemplateVariablesMock: MockFunction = getJestMockFunction();
 
 jest.mock("react-i18next", () => {
   return {
@@ -49,6 +50,19 @@ jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
   };
 });
 
+// The values a note template's placeholders are filled with.
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Incident/IncidentNoteTemplateVariables",
+  () => {
+    return {
+      __esModule: true,
+      fetchIncidentNoteTemplateVariables: (...args: Array<unknown>) => {
+        return fetchNoteTemplateVariablesMock(...args);
+      },
+    };
+  },
+);
+
 /*
  * The state-change modal is a full model form with its own API traffic. These
  * tests are about what the header hands it, so the stub records its props and
@@ -186,6 +200,7 @@ const listResult: (data: Array<unknown>) => ListResultShape = (
 
 interface FakeApiOptions {
   withTemplate?: boolean | undefined;
+  templateNote?: string | undefined;
 }
 
 const buildStates: () => Array<IncidentState> = (): Array<IncidentState> => {
@@ -228,7 +243,7 @@ const respondWith: (options?: FakeApiOptions) => void = (
       const template: IncidentNoteTemplate = new IncidentNoteTemplate();
       template.id = new ObjectID(TEMPLATE_ID);
       template.templateName = "Investigating update";
-      template.note = TEMPLATE_NOTE;
+      template.note = options.templateNote || TEMPLATE_NOTE;
       return Promise.resolve(listResult([template]));
     }
 
@@ -380,12 +395,15 @@ beforeEach(() => {
   project.id = new ObjectID(PROJECT_ID);
 
   jest.spyOn(ProjectUtil, "getCurrentProject").mockReturnValue(project);
+
+  fetchNoteTemplateVariablesMock.mockResolvedValue({} as never);
 });
 
 afterEach(() => {
   cleanup();
   getListMock.mockReset();
   modelFormModalMock.mockReset();
+  fetchNoteTemplateVariablesMock.mockReset();
   jest.restoreAllMocks();
 });
 
@@ -617,6 +635,78 @@ describe("ChangeIncidentState note template", () => {
     expect(fieldByKey(props, "publicNoteTemplate").showIf!()).toBe(false);
     expect(props.initialValues).toEqual({ [NOTIFY_FIELD_KEY]: false });
   });
+
+  test("a picked template's placeholders are filled with this incident's values", async () => {
+    fetchNoteTemplateVariablesMock.mockResolvedValue({
+      "incident.title": "Checkout latency above 2s",
+      "incident.severity": "Critical",
+    } as never);
+
+    await openModal(OPEN_CASES[0]!, false, {
+      withTemplate: true,
+      templateNote:
+        "Looking into {{incident.title}} ({{incident.severity}}). Owner: {{incident.owner}}",
+    });
+
+    // Read for this incident as the form opens.
+    await waitFor(() => {
+      expect(fetchNoteTemplateVariablesMock).toHaveBeenCalledTimes(1);
+    });
+    expect(
+      String(fetchNoteTemplateVariablesMock.mock.calls[0]![0] as ObjectID),
+    ).toBe(INCIDENT_ID);
+
+    const setNewFormValues: MockFunction = getJestMockFunction();
+
+    await waitFor(() => {
+      setNewFormValues.mockClear();
+      fieldByKey(lastModalProps(), "publicNoteTemplate").onChange!(
+        TEMPLATE_ID,
+        { [NOTIFY_FIELD_KEY]: false },
+        setNewFormValues,
+      );
+
+      expect(setNewFormValues).toHaveBeenCalledWith({
+        [NOTIFY_FIELD_KEY]: false,
+        publicNote:
+          "Looking into Checkout latency above 2s (Critical). Owner: {{incident.owner}}",
+      });
+    });
+  });
+
+  test("when the values cannot be read, the template goes in as written", async () => {
+    fetchNoteTemplateVariablesMock.mockRejectedValue(
+      new Error("No access.") as never,
+    );
+
+    await openModal(OPEN_CASES[0]!, false, {
+      withTemplate: true,
+      templateNote: "Looking into {{incident.title}}.",
+    });
+
+    await waitFor(() => {
+      expect(fetchNoteTemplateVariablesMock).toHaveBeenCalledTimes(1);
+    });
+
+    const setNewFormValues: MockFunction = getJestMockFunction();
+
+    fieldByKey(lastModalProps(), "publicNoteTemplate").onChange!(
+      TEMPLATE_ID,
+      { [NOTIFY_FIELD_KEY]: false },
+      setNewFormValues,
+    );
+
+    expect(setNewFormValues).toHaveBeenCalledWith({
+      [NOTIFY_FIELD_KEY]: false,
+      publicNote: "Looking into {{incident.title}}.",
+    });
+  });
+
+  test("with no templates to pick, nothing is read for them", async () => {
+    await openModal(OPEN_CASES[0]!, false);
+
+    expect(fetchNoteTemplateVariablesMock).not.toHaveBeenCalled();
+  });
 });
 
 describe("ChangeIncidentState: the default follows the page", () => {