@oneuptime/common 14.0.13 → 14.0.14

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

@@ -0,0 +1,255 @@
+import FormsCopy from "../../../../App/FeatureSet/Dashboard/src/Components/FormBuilder/FormsCopy";
+import {
+  clearLogoAltTextWithoutLogo,
+  FORM_BRANDING_SELECT,
+  FORM_FAVICON_UPLOAD,
+  FORM_LOGO_UPLOAD,
+  FormBrandingValues,
+  getFormBrandingItems,
+  getFormBrandingPreview,
+  getFormBrandingSummary,
+  getFormBrandingUpload,
+  readFormBrandingValues,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/FormBuilder/Branding/FormBrandingValues";
+import File from "../../../Models/DatabaseModels/File";
+import Form from "../../../Models/DatabaseModels/Form";
+import MimeType from "../../../Types/File/MimeType";
+import {
+  FORM_FAVICON_IMAGE,
+  FORM_FAVICON_IMAGE_TYPES,
+  FORM_FAVICON_MAX_BYTES,
+  FORM_LOGO_IMAGE,
+  FORM_LOGO_IMAGE_TYPES,
+  FORM_LOGO_MAX_BYTES,
+  PublicFormBranding,
+} from "../../../Types/Form/FormBranding";
+import ObjectID from "../../../Types/ObjectID";
+import { FoldedSectionItem } from "../../../UI/Components/FoldedSection/FoldedSectionItem";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * What the Build page's Branding section reads and says about a form's
+ * branding, apart from drawing it: the columns it reads, the image types it
+ * offers to upload, and - folded - which of the logo and the favicon are the
+ * form's own and what the OneUptime defaults do meanwhile. It draws them by
+ * the public page's own rules, so an image the page would not draw is shown
+ * as the OneUptime one the page falls back to.
+ */
+
+const PNG: Buffer = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a]);
+
+function image(fileType: string, bytes: Buffer = PNG): File {
+  const file: File = new File();
+  file._id = "f1000000-0000-4000-8000-000000000001";
+  file.name = "logo.png";
+  file.fileType = fileType as MimeType;
+  file.file = bytes;
+  return file;
+}
+
+function itemsOf(values: FormBrandingValues): Array<string> {
+  return getFormBrandingItems(getFormBrandingPreview(values)).map(
+    (item: FoldedSectionItem): string => {
+      return `${item.title}${item.isSet ? " (set)" : ""}`;
+    },
+  );
+}
+
+describe("what the section reads", () => {
+  test("the alt text, and each image's id, name, type and bytes", () => {
+    expect(FORM_BRANDING_SELECT).toEqual({
+      logoAltText: true,
+      logoFile: { _id: true, file: true, fileType: true, name: true },
+      faviconFile: { _id: true, file: true, fileType: true, name: true },
+    });
+  });
+
+  test("offers to upload exactly the image types and size the server takes, per image", () => {
+    expect(FORM_LOGO_UPLOAD).toEqual({
+      fileTypes: [...FORM_LOGO_IMAGE_TYPES],
+      maxFileSizeInBytes: FORM_LOGO_MAX_BYTES,
+    });
+    expect(FORM_FAVICON_UPLOAD).toEqual({
+      fileTypes: [...FORM_FAVICON_IMAGE_TYPES],
+      maxFileSizeInBytes: FORM_FAVICON_MAX_BYTES,
+    });
+    expect(getFormBrandingUpload(FORM_LOGO_IMAGE)).toEqual(FORM_LOGO_UPLOAD);
+    expect(getFormBrandingUpload(FORM_FAVICON_IMAGE)).toEqual(
+      FORM_FAVICON_UPLOAD,
+    );
+
+    // A logo of 512 KB, a favicon of 128 KB - and only the favicon an ICO.
+    expect(FORM_LOGO_UPLOAD.maxFileSizeInBytes).toBe(512 * 1024);
+    expect(FORM_FAVICON_UPLOAD.maxFileSizeInBytes).toBe(128 * 1024);
+    expect(FORM_LOGO_UPLOAD.fileTypes).not.toContain(MimeType.ico);
+    expect(FORM_FAVICON_UPLOAD.fileTypes).toContain(MimeType.ico);
+  });
+
+  test("reads a form's branding, or none", () => {
+    const logo: File = image(MimeType.png);
+    const form: Form = new Form();
+    form.logoFile = logo;
+    form.logoAltText = "Acme Inc.";
+
+    expect(readFormBrandingValues(form)).toEqual({
+      logoFile: logo,
+      logoAltText: "Acme Inc.",
+      faviconFile: null,
+    });
+    expect(readFormBrandingValues(null)).toEqual({
+      logoFile: null,
+      logoAltText: null,
+      faviconFile: null,
+    });
+  });
+});
+
+describe("drawn by the public page's rules", () => {
+  test("an image the page would draw, base64", () => {
+    const preview: PublicFormBranding = getFormBrandingPreview({
+      logoFile: image(MimeType.png),
+      logoAltText: "Acme Inc.",
+      faviconFile: image(MimeType.svg),
+    });
+
+    expect(preview).toEqual({
+      logo: { type: "image/png", data: PNG.toString("base64") },
+      logoAltText: "Acme Inc.",
+      favicon: { type: "image/svg+xml", data: PNG.toString("base64") },
+    });
+  });
+
+  test("an image it would not draw is the OneUptime one it falls back to", () => {
+    expect(
+      getFormBrandingPreview({
+        logoFile: image(MimeType.pdf),
+        logoAltText: "Acme Inc.",
+        faviconFile: image(
+          MimeType.png,
+          Buffer.alloc(FORM_FAVICON_MAX_BYTES + 1),
+        ),
+      }),
+    ).toEqual({});
+    expect(
+      getFormBrandingPreview({
+        logoFile: image(MimeType.png, Buffer.alloc(FORM_LOGO_MAX_BYTES + 1)),
+      }),
+    ).toEqual({});
+  });
+
+  test("an ICO is drawn as the favicon, never as the logo", () => {
+    expect(
+      getFormBrandingPreview({
+        logoFile: image(MimeType.ico),
+        logoAltText: "Acme Inc.",
+        faviconFile: image(MimeType.ico),
+      }),
+    ).toEqual({
+      favicon: { type: "image/x-icon", data: PNG.toString("base64") },
+    });
+  });
+});
+
+describe("saving: what a logo says goes with the logo", () => {
+  function formWith(data: Partial<Form>): Form {
+    const form: Form = new Form();
+    form.logoAltText = "Acme Inc.";
+    Object.assign(form, data);
+    return form;
+  }
+
+  test("keeps the alt text while the form has a logo, either spelling", () => {
+    const withRelation: Form = formWith({ logoFile: image(MimeType.png) });
+    const withId: Form = formWith({
+      logoFileId: new ObjectID("f1000000-0000-4000-8000-000000000001"),
+    });
+
+    expect(clearLogoAltTextWithoutLogo(withRelation).logoAltText).toBe(
+      "Acme Inc.",
+    );
+    expect(clearLogoAltTextWithoutLogo(withId).logoAltText).toBe("Acme Inc.");
+  });
+
+  test("clears it - null, so the save clears the column - once the logo is gone", () => {
+    for (const cleared of [
+      formWith({}),
+      formWith({ logoFile: null as unknown as File }),
+      formWith({
+        logoFile: undefined,
+        logoFileId: undefined,
+      } as unknown as Partial<Form>),
+    ]) {
+      const saved: Form = clearLogoAltTextWithoutLogo(cleared);
+
+      expect(saved).toBe(cleared);
+      expect(Object.prototype.hasOwnProperty.call(saved, "logoAltText")).toBe(
+        true,
+      );
+      expect(saved.logoAltText).toBeNull();
+    }
+  });
+
+  test("leaves the favicon alone", () => {
+    const favicon: File = image(MimeType.ico);
+    const saved: Form = clearLogoAltTextWithoutLogo(
+      formWith({ faviconFile: favicon }),
+    );
+
+    expect(saved.faviconFile).toBe(favicon);
+    expect(saved.logoAltText).toBeNull();
+  });
+});
+
+describe("folded, what the section says", () => {
+  test("lists the logo and the favicon, the form's own ones as set", () => {
+    expect(itemsOf({})).toEqual(["Logo", "Favicon"]);
+    expect(itemsOf({ logoFile: image(MimeType.png) })).toEqual([
+      "Logo (set)",
+      "Favicon",
+    ]);
+    expect(itemsOf({ faviconFile: image(MimeType.png) })).toEqual([
+      "Logo",
+      "Favicon (set)",
+    ]);
+    expect(
+      itemsOf({
+        logoFile: image(MimeType.png),
+        faviconFile: image(MimeType.png),
+      }),
+    ).toEqual(["Logo (set)", "Favicon (set)"]);
+  });
+
+  test("says what the OneUptime defaults do, while they are in force", () => {
+    const summaryOf: (values: FormBrandingValues) => string | undefined = (
+      values: FormBrandingValues,
+    ): string | undefined => {
+      return getFormBrandingSummary(getFormBrandingPreview(values));
+    };
+
+    expect(summaryOf({})).toBe(FormsCopy.brandingSummaryDefault);
+    expect(summaryOf({ faviconFile: image(MimeType.png) })).toBe(
+      FormsCopy.brandingSummaryDefaultLogo,
+    );
+    expect(summaryOf({ logoFile: image(MimeType.png) })).toBe(
+      FormsCopy.brandingSummaryDefaultFavicon,
+    );
+    expect(
+      summaryOf({
+        logoFile: image(MimeType.png),
+        faviconFile: image(MimeType.png),
+      }),
+    ).toBeUndefined();
+  });
+
+  test("the sentences name the OneUptime defaults", () => {
+    expect(FormsCopy.brandingSummaryDefault).toBe(
+      "The form shows the OneUptime logo and favicon until you upload your own.",
+    );
+    expect(FormsCopy.brandingSummaryDefaultLogo).toBe(
+      "The form shows the OneUptime logo until you upload yours.",
+    );
+    expect(FormsCopy.brandingSummaryDefaultFavicon).toBe(
+      "The form shows the OneUptime favicon until you upload yours.",
+    );
+  });
+});

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

@@ -57,6 +57,9 @@ jest.mock("../../../UI/Components/Markdown.tsx/LazyMarkdownViewer", () => {
 });
 
 import FormPreviewModal from "../../../../App/FeatureSet/Dashboard/src/Components/FormBuilder/Builder/FormPreviewModal";
+import { FormBrandingValues } from "../../../../App/FeatureSet/Dashboard/src/Components/FormBuilder/Branding/FormBrandingValues";
+import File from "../../../Models/DatabaseModels/File";
+import MimeType from "../../../Types/File/MimeType";
 import QuestionCard from "../../../../App/FeatureSet/Dashboard/src/Components/FormBuilder/Builder/QuestionCard";
 import QuestionPalette, {
   PaletteItem,
@@ -662,7 +665,10 @@ describe("the preview", () => {
     onClose = getJestMockFunction();
   });
 
-  async function renderPreview(fields: Array<FormField>): Promise<void> {
+  async function renderPreview(
+    fields: Array<FormField>,
+    branding?: FormBrandingValues,
+  ): Promise<void> {
     await act(async () => {
       render(
         <FormPreviewModal
@@ -677,6 +683,7 @@ describe("the preview", () => {
             ],
           }}
           defaultOptionValues={{ incidentSeverityId: SEVERITY_ID }}
+          branding={branding}
           onClose={() => {
             onClose();
           }}
@@ -778,6 +785,36 @@ describe("the preview", () => {
     });
   });
 
+  test("draws the OneUptime logo over the form's name, as the page does without one", async () => {
+    await renderPreview([TITLE]);
+
+    const logo: HTMLElement = within(
+      screen.getByTestId("form-preview"),
+    ).getByTestId("form-logo");
+
+    expect(logo).toHaveAttribute("data-logo", "oneuptime");
+    expect(logo).toHaveAttribute("alt", "OneUptime");
+  });
+
+  test("draws the form's own logo, with its alt text, as the page does", async () => {
+    const logo: File = new File();
+    logo.fileType = MimeType.png;
+    logo.file = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
+
+    await renderPreview([TITLE], { logoFile: logo, logoAltText: "Acme Inc." });
+
+    const drawn: HTMLElement = within(
+      screen.getByTestId("form-preview"),
+    ).getByTestId("form-logo");
+
+    expect(drawn).toHaveAttribute("data-logo", "form");
+    expect(drawn).toHaveAttribute(
+      "src",
+      `data:image/png;base64,${Buffer.from([0x89, 0x50, 0x4e, 0x47]).toString("base64")}`,
+    );
+    expect(drawn).toHaveAttribute("alt", "Acme Inc.");
+  });
+
   test("Close closes it", async () => {
     await renderPreview([TITLE]);
 

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

@@ -30,7 +30,10 @@ import { getJestSpyOn } from "../../Spy";
  *
  * The network, the permission gate, the preview and the name-and-description
  * dialog are stubbed (each has tests of its own); the builder's state rules
- * are FormBuilderState.test.ts's.
+ * are FormBuilderState.test.ts's. Over the questions sits the form's folded
+ * Branding section (FormBrandingSection.test.tsx draws it on its own): here,
+ * what the builder reads for it, hands it and its preview, and does once
+ * its dialog saved.
  */
 
 const getItemMock: MockFunction = getJestMockFunction();
@@ -142,6 +145,9 @@ jest.mock("../../../UI/Utils/Project", () => {
 ).__formBuilderDetailDialogs = recordedDetailDialogs;
 
 import FormBuilder from "../../../../App/FeatureSet/Dashboard/src/Components/FormBuilder/Builder/FormBuilder";
+import { FORM_BRANDING_SELECT } from "../../../../App/FeatureSet/Dashboard/src/Components/FormBuilder/Branding/FormBrandingValues";
+import File from "../../../Models/DatabaseModels/File";
+import MimeType from "../../../Types/File/MimeType";
 import FormsCopy from "../../../../App/FeatureSet/Dashboard/src/Components/FormBuilder/FormsCopy";
 import Form from "../../../Models/DatabaseModels/Form";
 import CustomFieldType from "../../../Types/CustomField/CustomFieldType";
@@ -186,6 +192,19 @@ interface StoredForm {
   targetType: FormTargetType;
   fields: Array<FormField>;
   targetSettings?: Record<string, unknown> | undefined;
+  logoFile?: File | undefined;
+  logoAltText?: string | undefined;
+  faviconFile?: File | undefined;
+}
+
+// A logo, as the API returns one: its id, name, type and bytes.
+function storedImage(bytes: Array<number>): File {
+  const file: File = new File();
+  file._id = "f1000000-0000-4000-8000-000000000001";
+  file.name = "logo.png";
+  file.fileType = MimeType.png;
+  file.file = Buffer.from(bytes);
+  return file;
 }
 
 let stored: StoredForm | null | Error;
@@ -245,6 +264,15 @@ beforeEach(() => {
     form.targetType = stored.targetType;
     form.fields = JSON.parse(JSON.stringify(stored.fields));
     form.targetSettings = (stored.targetSettings || {}) as never;
+    if (stored.logoFile) {
+      form.logoFile = stored.logoFile;
+    }
+    if (stored.logoAltText) {
+      form.logoAltText = stored.logoAltText;
+    }
+    if (stored.faviconFile) {
+      form.faviconFile = stored.faviconFile;
+    }
     return form;
   });
 
@@ -329,7 +357,7 @@ async function click(element: HTMLElement): Promise<void> {
 }
 
 describe("loading", () => {
-  test("reads the form's name, description, target, questions and settings", async () => {
+  test("reads the form's name, description, target, questions, settings and branding", async () => {
     await renderBuilder();
 
     const request: Record<string, unknown> = getItemMock.mock
@@ -343,6 +371,8 @@ describe("loading", () => {
       targetType: true,
       fields: true,
       targetSettings: true,
+      // In the same request: the Branding section's.
+      ...FORM_BRANDING_SELECT,
     });
     expect(loadCustomFieldsMock).toHaveBeenCalledWith(FormTargetType.Incident);
   });
@@ -804,6 +834,150 @@ describe("Preview and the name and description", () => {
   });
 });
 
+describe("the Branding section", () => {
+  const LOGO_BYTES: Array<number> = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a];
+
+  test("sits folded over the questions", async () => {
+    await renderBuilder();
+
+    const branding: HTMLElement = screen.getByTestId("form-branding");
+
+    expect(
+      within(branding).getByTestId("folded-section-header"),
+    ).toHaveAttribute("aria-expanded", "false");
+    // Before the questions, as the logo is before them on the form's page.
+    expect(
+      branding.compareDocumentPosition(screen.getByTestId("form-canvas")) &
+        Node.DOCUMENT_POSITION_FOLLOWING,
+    ).toBeTruthy();
+  });
+
+  test("is handed the form's branding, and so is Preview", async () => {
+    (stored as StoredForm).logoFile = storedImage(LOGO_BYTES);
+    (stored as StoredForm).logoAltText = "Acme Inc.";
+
+    await renderBuilder();
+
+    expect(
+      within(screen.getByTestId("form-branding")).getAllByTestId(
+        "folded-section-item",
+      )[0],
+    ).toHaveAttribute("data-item-set", "true");
+
+    await click(cardButton(FormsCopy.preview));
+
+    const preview: Record<string, unknown> =
+      recordedPreviews[recordedPreviews.length - 1]!;
+    const branding: Record<string, unknown> = preview["branding"] as Record<
+      string,
+      unknown
+    >;
+
+    expect((branding["logoFile"] as File).fileType).toBe(MimeType.png);
+    expect(branding["logoAltText"]).toBe("Acme Inc.");
+    expect(branding["faviconFile"]).toBeNull();
+  });
+
+  test("once its dialog saved, reads only the branding again, and keeps the draft of the questions", async () => {
+    await renderBuilder();
+
+    await click(screen.getByTestId("form-palette-question-Text"));
+    await click(
+      within(screen.getByTestId("form-branding")).getByTestId(
+        "folded-section-header",
+      ),
+    );
+    await click(screen.getByTestId("form-branding-edit"));
+
+    const dialog: Record<string, unknown> =
+      recordedDetailDialogs[recordedDetailDialogs.length - 1]!;
+
+    expect(dialog["title"]).toBe(FormsCopy.editBranding);
+
+    (stored as StoredForm).logoFile = storedImage(LOGO_BYTES);
+    getItemMock.mockClear();
+
+    await act(async () => {
+      (dialog["onSuccess"] as (form: Form) => void)(new Form());
+    });
+
+    await waitFor(() => {
+      expect(
+        within(screen.getByTestId("form-branding-logo")).getByTestId(
+          "form-logo",
+        ),
+      ).toHaveAttribute("data-logo", "form");
+    });
+
+    expect(getItemMock).toHaveBeenCalledTimes(1);
+    expect(
+      (getItemMock.mock.calls[0]![0] as Record<string, unknown>)["select"],
+    ).toEqual(FORM_BRANDING_SELECT);
+    // The draft is untouched.
+    expect(questionIds()).toHaveLength(defaultFields().length + 1);
+    expect(status()).toHaveTextContent(FormsCopy.unsavedChanges);
+  });
+
+  test("a re-read that fails is said in the Branding section, never over the questions, and the next one clears it", async () => {
+    await renderBuilder();
+
+    await click(
+      within(screen.getByTestId("form-branding")).getByTestId(
+        "folded-section-header",
+      ),
+    );
+    await click(screen.getByTestId("form-branding-edit"));
+
+    const failing: Record<string, unknown> =
+      recordedDetailDialogs[recordedDetailDialogs.length - 1]!;
+
+    getItemMock.mockRejectedValueOnce(new Error("The network went away."));
+
+    await act(async () => {
+      (failing["onSuccess"] as (form: Form) => void)(new Form());
+    });
+
+    await waitFor(() => {
+      expect(
+        within(screen.getByTestId("form-branding")).getByTestId(
+          "form-branding-error",
+        ),
+      ).toHaveTextContent("The network went away.");
+    });
+    expect(
+      screen.queryByTestId("form-builder-save-error"),
+    ).not.toBeInTheDocument();
+
+    // Saved again, and read again: the error is gone.
+    await click(screen.getByTestId("form-branding-edit"));
+
+    const succeeding: Record<string, unknown> =
+      recordedDetailDialogs[recordedDetailDialogs.length - 1]!;
+
+    await act(async () => {
+      (succeeding["onSuccess"] as (form: Form) => void)(new Form());
+    });
+
+    await waitFor(() => {
+      expect(
+        screen.queryByTestId("form-branding-error"),
+      ).not.toBeInTheDocument();
+    });
+  });
+
+  test("someone who may not edit the form sees it without Edit Branding", async () => {
+    gate = {
+      isAllowed: false,
+      disabledReason: "You need the Edit Form permission.",
+    };
+
+    await renderBuilder();
+
+    expect(screen.getByTestId("form-branding")).toBeInTheDocument();
+    expect(screen.queryByTestId("form-branding-edit")).not.toBeInTheDocument();
+  });
+});
+
 describe("someone who may not edit the form", () => {
   test("sees the questions, why they cannot change them, and nothing to change them with", async () => {
     gate = {

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

@@ -23,8 +23,9 @@ import { getJestSpyOn } from "../../Spy";
 /*
  * The On Submit page's mapping card: every field of what a submission
  * creates and where its value comes from, and Edit Settings - a stepped
- * dialog that saves from any step, keeps what was typed when a save is
- * refused, and starts on the stored settings each time it opens.
+ * dialog whose step list opens any step, with Save Changes on the last one
+ * only; it keeps what was typed when a save is refused, and starts on the
+ * stored settings each time it opens.
  *
  * The project's records the card reads, and the network, are stubbed; the
  * card, its rows and the dialog are the real ones.
@@ -220,6 +221,28 @@ function saveButton(): HTMLElement {
   return within(modal()).getByTestId("modal-footer-submit-button");
 }
 
+/*
+ * Save Changes is on the last step only. Every step is filled in already,
+ * so the step list opens the last one: then Save Changes.
+ */
+async function saveFromTheLastStep(): Promise<void> {
+  const steps: Array<HTMLElement> = within(
+    within(modal()).getByRole("navigation", { name: "Progress" }),
+  ).getAllByRole("listitem");
+
+  await act(async () => {
+    fireEvent.click(steps[steps.length - 1] as HTMLElement);
+  });
+
+  await waitFor(() => {
+    expect(saveButton()).toHaveTextContent(FormsCopy.saveChanges);
+  });
+
+  await act(async () => {
+    fireEvent.click(saveButton());
+  });
+}
+
 describe("the rows", () => {
   test("an incident form's card, row by row", async () => {
     await renderCard();
@@ -356,7 +379,7 @@ describe("the rows", () => {
 });
 
 describe("Edit Settings", () => {
-  test("opens on the stored settings, saving from the first step", async () => {
+  test("opens on the stored settings, and saves a change on the first step from the last", async () => {
     await renderCard({
       targetSettings: {
         defaultTitle: "Reported",
@@ -368,7 +391,10 @@ describe("Edit Settings", () => {
     await openSettings();
 
     expect(defaultTitleInput()).toHaveValue("Reported");
-    expect(saveButton()).toHaveTextContent(FormsCopy.saveChanges);
+    // Save Changes is on the last step only: a plain Next here.
+    expect(
+      within(modal()).queryByTestId("modal-footer-submit-button"),
+    ).not.toBeInTheDocument();
     expect(
       within(modal()).getByTestId("modal-footer-next-button"),
     ).toBeInTheDocument();
@@ -377,9 +403,7 @@ describe("Edit Settings", () => {
       target: { value: "  Reported through the form  " },
     });
 
-    await act(async () => {
-      fireEvent.click(saveButton());
-    });
+    await saveFromTheLastStep();
 
     await waitFor(() => {
       expect(updateByIdMock).toHaveBeenCalledTimes(1);
@@ -418,9 +442,7 @@ describe("Edit Settings", () => {
       target: { value: "Typed before the refusal" },
     });
 
-    await act(async () => {
-      fireEvent.click(saveButton());
-    });
+    await saveFromTheLastStep();
 
     await waitFor(() => {
       expect(
@@ -451,9 +473,7 @@ describe("Edit Settings", () => {
 
     fireEvent.change(defaultTitleInput(), { target: { value: "Abandoned" } });
 
-    await act(async () => {
-      fireEvent.click(saveButton());
-    });
+    await saveFromTheLastStep();
 
     await waitFor(() => {
       expect(within(modal()).getByText("Refused.")).toBeInTheDocument();

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

@@ -54,7 +54,7 @@ import {
   getFormSubmissionSubmitter,
 } from "../../../../App/FeatureSet/Dashboard/src/Components/FormBuilder/Submissions/FormSubmissionPresentation";
 import PageMap from "../../../../App/FeatureSet/Dashboard/src/Utils/PageMap";
-import { MOVED_INCIDENT_FORM_PATHS } from "../../../../App/FeatureSet/Dashboard/src/Routes/IncidentsRoutes";
+import { MOVED_INCIDENT_FORM_PATHS } from "../../../../App/FeatureSet/Dashboard/src/Routes/MovedPagePaths";
 import FormSubmission from "../../../Models/DatabaseModels/FormSubmission";
 import Incident from "../../../Models/DatabaseModels/Incident";
 import ScheduledMaintenance from "../../../Models/DatabaseModels/ScheduledMaintenance";