@oneuptime/common 14.0.13 → 14.0.14

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

@@ -1,3 +1,5 @@
+/** @timezone UTC */
+
 import {
   afterEach,
   beforeEach,
@@ -8,30 +10,41 @@ import {
 } from "@jest/globals";
 import "@testing-library/jest-dom";
 import {
-  act,
   cleanup,
   fireEvent,
-  render,
   RenderResult,
   screen,
+  within,
 } from "@testing-library/react";
-import React from "react";
+import React, { ReactElement } from "react";
 import getJestMockFunction, { MockFunction } from "../../MockType";
+import {
+  flush,
+  NOTIFY_FLAG,
+  NOTIFYING_DESCRIPTION,
+  notifyCheckbox,
+  notifyDescription,
+  openNoteDialog,
+  postedModelType,
+  postedPayload,
+  postNote,
+  renderAndSettle,
+  UNTICKED_ON_NOTIFYING_EVENT_DESCRIPTION,
+  writeNote,
+} from "./FeedNoteDialogHelpers";
 
 /*
  * An incident declared without notifying status page subscribers (the box
  * unticked, or a private incident) should not have its first public note be
- * what tells them. The feed's "Add Public Note" form now starts with
- * "Notify Status Page Subscribers" off for such an incident. The flag is
- * seeded through initialValues as well as the field's defaultValue, because
- * the form drops a false defaultValue, and the request should carry what the
- * user saw rather than leave the choice to the server. These tests pin both,
- * the checkbox copy, and that nothing changes for an incident that did
- * notify.
+ * what tells them. The Incident Feed's "Add Public Note" opens the incident's
+ * Notes page composer in a dialog, and its "Notify status page subscribers"
+ * starts unticked on such an incident, says why, and the note is posted with
+ * an explicit false - never left out for the server to decide. Nothing
+ * changes for an incident that did notify, or for private notes.
  */
 
 const getListMock: MockFunction = getJestMockFunction();
-const modalRenderMock: MockFunction = getJestMockFunction();
+const createMock: MockFunction = getJestMockFunction();
 
 jest.mock("react-i18next", () => {
   return {
@@ -52,30 +65,80 @@ jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
       getList: (...args: Array<any>) => {
         return getListMock(...args);
       },
+      create: (...args: Array<any>) => {
+        return createMock(...args);
+      },
+      getCommonHeaders: (): Record<string, string> => {
+        return {};
+      },
     },
   };
 });
 
-/* Keep the test about the note forms, not markdown parsing or timeline chrome. */
-jest.mock("../../../UI/Components/Feed/Feed", () => {
+jest.mock("../../../UI/Utils/Project", () => {
   return {
     __esModule: true,
-    default: (): React.ReactElement => {
-      return React.createElement("div", { "data-testid": "rendered-feed" });
+    default: {
+      getCurrentProjectId: (): unknown => {
+        const ObjectIDClass: any = jest.requireActual(
+          "../../../Types/ObjectID",
+        ) as any;
+        return new ObjectIDClass.default(
+          "10000000-0000-4000-8000-000000000001",
+        );
+      },
+      getCurrentProject: (): null => {
+        return null;
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/User", () => {
+  return {
+    __esModule: true,
+    default: {
+      isMasterAdmin: (): boolean => {
+        return true;
+      },
+      getUserId: (): null => {
+        return null;
+      },
     },
   };
 });
 
-jest.mock("../../../UI/Components/ModelFormModal/ModelFormModal", () => {
+jest.mock("../../../UI/Components/Markdown.tsx/MarkdownEditor", () => {
+  const ReactModule: typeof React = jest.requireActual("react") as typeof React;
   return {
     __esModule: true,
-    default: (props: { title: string }): React.ReactElement => {
-      modalRenderMock(props);
-      return React.createElement(
-        "div",
-        { "data-testid": "note-modal" },
-        props.title,
+    default: (props: {
+      initialValue?: string;
+      onChange?: (value: string) => void;
+    }): ReactElement => {
+      const [value, setValue] = ReactModule.useState<string>(
+        props.initialValue || "",
       );
+      return (
+        <textarea
+          aria-label="Note text"
+          value={value}
+          onChange={(event: React.ChangeEvent<HTMLTextAreaElement>) => {
+            setValue(event.target.value);
+            props.onChange?.(event.target.value);
+          }}
+        />
+      );
+    },
+  };
+});
+
+/* Keep the test about the notes, not markdown parsing or timeline chrome. */
+jest.mock("../../../UI/Components/Feed/Feed", () => {
+  return {
+    __esModule: true,
+    default: (): React.ReactElement => {
+      return React.createElement("div", { "data-testid": "rendered-feed" });
     },
   };
 });
@@ -92,122 +155,61 @@ jest.mock(
   },
 );
 
+// Who the note reaches and its preview read the server; not under test here.
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Incident/SubscriberAudienceSummary",
+  () => {
+    return {
+      __esModule: true,
+      default: (): null => {
+        return null;
+      },
+    };
+  },
+);
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Incident/SubscriberNotificationPreviewButton",
+  () => {
+    return {
+      __esModule: true,
+      default: (): null => {
+        return null;
+      },
+    };
+  },
+);
+
 import IncidentFeedElement from "../../../../App/FeatureSet/Dashboard/src/Components/Incident/IncidentFeed";
 import IncidentInternalNote from "../../../Models/DatabaseModels/IncidentInternalNote";
 import IncidentPublicNote from "../../../Models/DatabaseModels/IncidentPublicNote";
 import { DEFAULT_LIMIT } from "../../../Types/Database/LimitMax";
+import OneUptimeDate from "../../../Types/Date";
 import ObjectID from "../../../Types/ObjectID";
 import PublicNoteSubscriberNotificationDefault from "../../../Types/StatusPage/PublicNoteSubscriberNotificationDefault";
-import FormFieldSchemaType from "../../../UI/Components/Forms/Types/FormFieldSchemaType";
-
-interface NoteField {
-  field: Record<string, boolean>;
-  fieldType: FormFieldSchemaType;
-  title: string;
-  description?: string | undefined;
-  defaultValue?: unknown;
-  required?: boolean | undefined;
-}
-
-interface NoteModalProps {
-  name: string;
-  title: string;
-  modelType: unknown;
-  initialValues?: Record<string, unknown> | undefined;
-  onBeforeCreate: (model: unknown) => Promise<unknown>;
-  formProps: {
-    fields: Array<NoteField>;
-  };
-}
 
 const INCIDENT_ID: string = "66666666-6666-4666-8666-666666666666";
-const NOTIFY_FIELD_KEY: string =
-  "shouldStatusPageSubscribersBeNotifiedOnNoteCreated";
-const ORIGINAL_DESCRIPTION: string =
-  "Should status page subscribers be notified when this note is posted?";
-const PUBLIC_NOTE_TITLE: string = "Add Public Note to this Incident";
-const PRIVATE_NOTE_TITLE: string = "Add Private Note to this Incident";
-
-async function flush(): Promise<void> {
-  await act(async () => {
-    for (let i: number = 0; i < 10; i++) {
-      await Promise.resolve();
-    }
-  });
-}
+const NOW: Date = new Date("2026-09-14T18:20:00.000Z");
 
-function renderFeed(
+function feed(
   notifyStatusPageSubscribersByDefault?: boolean | undefined,
-): RenderResult {
-  return render(
+): ReactElement {
+  return (
     <IncidentFeedElement
       incidentId={new ObjectID(INCIDENT_ID)}
       refreshToken={0}
       notifyStatusPageSubscribersByDefault={
         notifyStatusPageSubscribersByDefault
       }
-    />,
-  );
-}
-
-function lastModalProps(): NoteModalProps {
-  const calls: Array<Array<NoteModalProps>> = modalRenderMock.mock
-    .calls as Array<Array<NoteModalProps>>;
-
-  return calls[calls.length - 1]![0]!;
-}
-
-function modalPropsWithTitle(title: string): NoteModalProps {
-  const calls: Array<Array<NoteModalProps>> = modalRenderMock.mock
-    .calls as Array<Array<NoteModalProps>>;
-
-  const matching: Array<NoteModalProps> = calls
-    .map((call: Array<NoteModalProps>): NoteModalProps => {
-      return call[0]!;
-    })
-    .filter((props: NoteModalProps): boolean => {
-      return props.title === title;
-    });
-
-  if (matching.length === 0) {
-    throw new Error(`No modal titled "${title}" was rendered`);
-  }
-
-  return matching[matching.length - 1]!;
-}
-
-function notifyField(props: NoteModalProps): NoteField {
-  const field: NoteField | undefined = props.formProps.fields.find(
-    (candidate: NoteField): boolean => {
-      return Boolean(candidate.field[NOTIFY_FIELD_KEY]);
-    },
+    />
   );
-
-  if (!field) {
-    throw new Error("The public note form has no notify subscribers field");
-  }
-
-  return field;
 }
 
-async function chooseAction(text: string): Promise<void> {
-  const trigger: HTMLElement = screen
-    .getByText("Actions")
-    .closest('[aria-haspopup="menu"]') as HTMLElement;
-
-  fireEvent.click(trigger);
-  fireEvent.click(await screen.findByRole("menuitem", { name: text }));
-  await flush();
-}
-
-async function openPublicNoteModal(
+async function openPublicNote(
   notifyStatusPageSubscribersByDefault?: boolean | undefined,
-): Promise<NoteModalProps> {
-  renderFeed(notifyStatusPageSubscribersByDefault);
-  await flush();
-  await chooseAction("Add Public Note");
-
-  return modalPropsWithTitle(PUBLIC_NOTE_TITLE);
+): Promise<HTMLElement> {
+  await renderAndSettle(feed(notifyStatusPageSubscribersByDefault));
+  return await openNoteDialog("Add Public Note");
 }
 
 beforeEach(() => {
@@ -218,255 +220,185 @@ beforeEach(() => {
     skip: 0,
     limit: DEFAULT_LIMIT,
   } as never);
+  createMock.mockImplementation(async (...args: Array<any>) => {
+    return { data: args[0].model };
+  });
+  jest.spyOn(OneUptimeDate, "getCurrentDate").mockImplementation(() => {
+    return new Date(NOW.getTime());
+  });
 });
 
 afterEach(() => {
   cleanup();
   getListMock.mockReset();
-  modalRenderMock.mockReset();
+  createMock.mockReset();
+  jest.restoreAllMocks();
 });
 
-describe("IncidentFeed public note: incident declared without notifying subscribers", () => {
-  test("seeds the form value with notify off, so a false flag is actually sent", async () => {
-    const props: NoteModalProps = await openPublicNoteModal(false);
-
-    expect(props.modelType).toBe(IncidentPublicNote);
-    expect(props.name).toBe("create-incident-public-note");
-    expect(props.initialValues).toEqual({
-      [NOTIFY_FIELD_KEY]: false,
-    });
-    expect(props.initialValues![NOTIFY_FIELD_KEY]).toBe(false);
-  });
-
-  test("starts the notify checkbox unticked", async () => {
-    const field: NoteField = notifyField(await openPublicNoteModal(false));
+describe("Incident Feed public note: incident declared without notifying subscribers", () => {
+  test("starts 'Notify status page subscribers' unticked", async () => {
+    const dialog: HTMLElement = await openPublicNote(false);
 
-    expect(field.fieldType).toBe(FormFieldSchemaType.Checkbox);
-    expect(field.title).toBe("Notify Status Page Subscribers");
-    expect(field.required).toBe(false);
-    expect(field.defaultValue).toBe(false);
+    expect(notifyCheckbox(dialog)).not.toBeChecked();
   });
 
-  test("explains why the checkbox starts unticked", async () => {
-    const field: NoteField = notifyField(await openPublicNoteModal(false));
+  test("explains why the box starts unticked", async () => {
+    const dialog: HTMLElement = await openPublicNote(false);
 
-    expect(field.description).toBe(
+    expect(notifyDescription(dialog)).toBe(
       PublicNoteSubscriberNotificationDefault.quietIncidentDescription,
     );
-    expect(field.description).toBe(
+    expect(notifyDescription(dialog)).toBe(
       "Unticked by default because status page subscribers were not notified when this incident was declared.",
     );
-    expect(field.description).not.toBe(ORIGINAL_DESCRIPTION);
   });
 
-  test("leaves the other public note fields as they were", async () => {
-    const props: NoteModalProps = await openPublicNoteModal(false);
-
-    expect(
-      props.formProps.fields.map((field: NoteField): string => {
-        return field.title;
-      }),
-    ).toEqual([
-      "Public Note",
-      "Attachments",
-      "Posted At",
-      "Notify Status Page Subscribers",
-    ]);
-    expect(props.formProps.fields[0]!.required).toBe(true);
-    expect(props.formProps.fields[0]!.fieldType).toBe(
-      FormFieldSchemaType.Markdown,
-    );
+  test("posts an explicit false when the box is left unticked", async () => {
+    const dialog: HTMLElement = await openPublicNote(false);
+
+    writeNote(dialog, "We have identified the cause.");
+    await postNote(dialog);
+
+    const payload: Record<string, unknown> = postedPayload(createMock);
+    expect(postedModelType(createMock)).toBe(IncidentPublicNote);
+    expect(Object.keys(payload)).toContain(NOTIFY_FLAG);
+    expect(payload[NOTIFY_FLAG]).toBe(false);
   });
 
-  test("still attaches the note to this incident before it is created", async () => {
-    const props: NoteModalProps = await openPublicNoteModal(false);
-    const note: IncidentPublicNote = new IncidentPublicNote();
+  test("ticking the box notifies after all", async () => {
+    const dialog: HTMLElement = await openPublicNote(false);
 
-    const created: IncidentPublicNote = (await props.onBeforeCreate(
-      note,
-    )) as IncidentPublicNote;
+    fireEvent.click(notifyCheckbox(dialog));
+    expect(notifyCheckbox(dialog)).toBeChecked();
+    expect(notifyDescription(dialog)).toBe(NOTIFYING_DESCRIPTION);
 
-    expect(created).toBe(note);
-    expect(created.incidentId?.toString()).toBe(INCIDENT_ID);
-    // The form's own choice is not overridden on the way out.
-    expect(created.shouldStatusPageSubscribersBeNotifiedOnNoteCreated).toBe(
-      undefined,
-    );
+    writeNote(dialog, "Telling them now.");
+    await postNote(dialog);
+
+    expect(postedPayload(createMock)[NOTIFY_FLAG]).toBe(true);
   });
 
-  test("onBeforeCreate never rewrites a flag the user set", async () => {
-    const props: NoteModalProps = await openPublicNoteModal(false);
-    const note: IncidentPublicNote = new IncidentPublicNote();
-    note.shouldStatusPageSubscribersBeNotifiedOnNoteCreated = true;
+  test("attaches the note to this incident, posted now", async () => {
+    const dialog: HTMLElement = await openPublicNote(false);
 
-    const created: IncidentPublicNote = (await props.onBeforeCreate(
-      note,
-    )) as IncidentPublicNote;
+    writeNote(dialog, "Attached to the incident.");
+    await postNote(dialog);
 
-    expect(created.shouldStatusPageSubscribersBeNotifiedOnNoteCreated).toBe(
-      true,
-    );
-    expect(created.incidentId?.toString()).toBe(INCIDENT_ID);
+    const payload: Record<string, unknown> = postedPayload(createMock);
+    expect(payload["incidentId"]).toMatchObject({ value: INCIDENT_ID });
+    expect(payload["postedAt"]).toMatchObject({ value: NOW.toISOString() });
   });
 });
 
-describe("IncidentFeed public note: incident declared with subscribers notified", () => {
-  test("seeds the form value with notify on", async () => {
-    const props: NoteModalProps = await openPublicNoteModal(true);
+describe("Incident Feed public note: incident declared with subscribers notified", () => {
+  test("starts the box ticked, saying the note will notify", async () => {
+    const dialog: HTMLElement = await openPublicNote(true);
 
-    expect(props.initialValues).toEqual({
-      [NOTIFY_FIELD_KEY]: true,
-    });
+    expect(notifyCheckbox(dialog)).toBeChecked();
+    expect(notifyDescription(dialog)).toBe(NOTIFYING_DESCRIPTION);
   });
 
-  test("starts the checkbox ticked with the original description", async () => {
-    const field: NoteField = notifyField(await openPublicNoteModal(true));
+  test("posts true when the box is left ticked", async () => {
+    const dialog: HTMLElement = await openPublicNote(true);
 
-    expect(field.defaultValue).toBe(true);
-    expect(field.description).toBe(ORIGINAL_DESCRIPTION);
-    expect(field.description).not.toBe(
-      PublicNoteSubscriberNotificationDefault.quietIncidentDescription,
-    );
-  });
+    writeNote(dialog, "An update.");
+    await postNote(dialog);
 
-  test("attaches the note to this incident before it is created", async () => {
-    const props: NoteModalProps = await openPublicNoteModal(true);
+    expect(postedPayload(createMock)[NOTIFY_FLAG]).toBe(true);
+  });
 
-    const created: IncidentPublicNote = (await props.onBeforeCreate(
-      new IncidentPublicNote(),
-    )) as IncidentPublicNote;
+  test("unticking says the note still goes on the status page, and posts false", async () => {
+    const dialog: HTMLElement = await openPublicNote(true);
 
-    expect(created.incidentId?.toString()).toBe(INCIDENT_ID);
-  });
-});
+    fireEvent.click(notifyCheckbox(dialog));
+    expect(notifyDescription(dialog)).toBe(
+      UNTICKED_ON_NOTIFYING_EVENT_DESCRIPTION,
+    );
+    expect(notifyDescription(dialog)).not.toBe(
+      PublicNoteSubscriberNotificationDefault.quietIncidentDescription,
+    );
 
-describe("IncidentFeed public note: no default passed (backwards compatible)", () => {
-  test("seeds the form value with notify on", async () => {
-    const props: NoteModalProps = await openPublicNoteModal(undefined);
+    writeNote(dialog, "A small fix.");
+    await postNote(dialog);
 
-    expect(props.initialValues).toEqual({
-      [NOTIFY_FIELD_KEY]: true,
-    });
+    expect(postedPayload(createMock)[NOTIFY_FLAG]).toBe(false);
   });
+});
 
-  test("starts the checkbox ticked with the original description", async () => {
-    const field: NoteField = notifyField(await openPublicNoteModal(undefined));
+describe("Incident Feed public note: no default passed (backwards compatible)", () => {
+  test("starts the box ticked", async () => {
+    const dialog: HTMLElement = await openPublicNote(undefined);
 
-    expect(field.defaultValue).toBe(true);
-    expect(field.description).toBe(ORIGINAL_DESCRIPTION);
+    expect(notifyCheckbox(dialog)).toBeChecked();
   });
 
   test("a feed rendered without the prop at all behaves the same", async () => {
-    render(<IncidentFeedElement incidentId={new ObjectID(INCIDENT_ID)} />);
-    await flush();
-    await chooseAction("Add Public Note");
-
-    const props: NoteModalProps = modalPropsWithTitle(PUBLIC_NOTE_TITLE);
+    await renderAndSettle(
+      <IncidentFeedElement incidentId={new ObjectID(INCIDENT_ID)} />,
+    );
+    const dialog: HTMLElement = await openNoteDialog("Add Public Note");
 
-    expect(props.initialValues).toEqual({ [NOTIFY_FIELD_KEY]: true });
-    expect(notifyField(props).defaultValue).toBe(true);
-    expect(notifyField(props).description).toBe(ORIGINAL_DESCRIPTION);
+    expect(notifyCheckbox(dialog)).toBeChecked();
   });
 });
 
-describe("IncidentFeed public note: the default follows the page", () => {
+describe("Incident Feed public note: the default follows the page", () => {
   /*
    * The page passes the flag once the incident has loaded, and again after a
-   * refresh. The next form opened must use the current value.
+   * refresh. The next dialog opened must use the current value.
    */
-  test("a form opened after the default turns off starts unticked", async () => {
-    const view: RenderResult = renderFeed(true);
-    await flush();
+  test("a dialog opened after the default turns off starts unticked", async () => {
+    const view: RenderResult = await renderAndSettle(feed(true));
 
-    view.rerender(
-      <IncidentFeedElement
-        incidentId={new ObjectID(INCIDENT_ID)}
-        refreshToken={0}
-        notifyStatusPageSubscribersByDefault={false}
-      />,
-    );
+    view.rerender(feed(false));
     await flush();
-    await chooseAction("Add Public Note");
-
-    const props: NoteModalProps = modalPropsWithTitle(PUBLIC_NOTE_TITLE);
+    const dialog: HTMLElement = await openNoteDialog("Add Public Note");
 
-    expect(props.initialValues).toEqual({ [NOTIFY_FIELD_KEY]: false });
-    expect(notifyField(props).defaultValue).toBe(false);
-    expect(notifyField(props).description).toBe(
+    expect(notifyCheckbox(dialog)).not.toBeChecked();
+    expect(notifyDescription(dialog)).toBe(
       PublicNoteSubscriberNotificationDefault.quietIncidentDescription,
     );
   });
 
-  test("a form opened after the default turns back on starts ticked", async () => {
-    const view: RenderResult = renderFeed(false);
-    await flush();
+  test("a dialog opened after the default turns back on starts ticked", async () => {
+    const view: RenderResult = await renderAndSettle(feed(false));
 
-    view.rerender(
-      <IncidentFeedElement
-        incidentId={new ObjectID(INCIDENT_ID)}
-        refreshToken={0}
-        notifyStatusPageSubscribersByDefault={true}
-      />,
-    );
+    view.rerender(feed(true));
     await flush();
-    await chooseAction("Add Public Note");
-
-    const props: NoteModalProps = modalPropsWithTitle(PUBLIC_NOTE_TITLE);
+    const dialog: HTMLElement = await openNoteDialog("Add Public Note");
 
-    expect(props.initialValues).toEqual({ [NOTIFY_FIELD_KEY]: true });
-    expect(notifyField(props).defaultValue).toBe(true);
-    expect(notifyField(props).description).toBe(ORIGINAL_DESCRIPTION);
+    expect(notifyCheckbox(dialog)).toBeChecked();
+    expect(notifyDescription(dialog)).toBe(NOTIFYING_DESCRIPTION);
   });
 });
 
-describe("IncidentFeed private note is unaffected", () => {
+describe("Incident Feed private note is unaffected", () => {
   test.each([
     ["off", false],
     ["on", true],
     ["not passed", undefined],
   ])(
-    "with the default %s, the private note form seeds no notify value and has no notify field",
+    "with the default %s, the private note has no notify box and posts no flag",
     async (_label: string, notifyByDefault: boolean | undefined) => {
-      renderFeed(notifyByDefault);
-      await flush();
-      await chooseAction("Add Private Note");
+      await renderAndSettle(feed(notifyByDefault));
+      const dialog: HTMLElement = await openNoteDialog("Add Private Note");
 
-      const props: NoteModalProps = lastModalProps();
-
-      expect(props.title).toBe(PRIVATE_NOTE_TITLE);
-      expect(props.modelType).toBe(IncidentInternalNote);
-      expect(props.initialValues).toBeUndefined();
       expect(
-        props.formProps.fields.some((field: NoteField): boolean => {
-          return Boolean(field.field[NOTIFY_FIELD_KEY]);
+        within(dialog).queryByRole("checkbox", {
+          name: "Notify status page subscribers",
         }),
-      ).toBe(false);
-      expect(screen.queryByText(PUBLIC_NOTE_TITLE)).toBeNull();
-    },
-  );
-
-  test("the private note is still attached to this incident", async () => {
-    renderFeed(false);
-    await flush();
-    await chooseAction("Add Private Note");
-
-    const props: NoteModalProps = modalPropsWithTitle(PRIVATE_NOTE_TITLE);
-
-    const created: IncidentInternalNote = (await props.onBeforeCreate(
-      new IncidentInternalNote(),
-    )) as IncidentInternalNote;
-
-    expect(created.incidentId?.toString()).toBe(INCIDENT_ID);
-  });
-
-  test("the on-call policy form seeds no notify value either", async () => {
-    renderFeed(false);
-    await flush();
-    await chooseAction("Execute On-Call Policy");
+      ).toBeNull();
+      expect(
+        screen.queryByRole("dialog", { name: "Add Public Note" }),
+      ).toBeNull();
 
-    const props: NoteModalProps = lastModalProps();
+      writeNote(dialog, "For the team.");
+      await postNote(dialog);
 
-    expect(props.title).toBe("Execute On-Call Policy");
-    expect(props.initialValues).toBeUndefined();
-  });
+      const payload: Record<string, unknown> = postedPayload(createMock);
+      expect(postedModelType(createMock)).toBe(IncidentInternalNote);
+      expect(Object.keys(payload)).not.toContain(NOTIFY_FLAG);
+      expect(payload["incidentId"]).toMatchObject({ value: INCIDENT_ID });
+    },
+  );
 });