@oneuptime/common 14.0.12 → 14.0.14

package/Tests/Server/Services/IncidentFormPublicSubmission.test.ts

@@ -1,2520 +0,0 @@
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  jest,
-  test,
-} from "@jest/globals";
-
-/*
- * What a public submission turns into (IncidentFormService.submitPublicForm).
- *
- * A stranger's request becomes an incident that pages on-call, so every test
- * here pins exactly what reaches IncidentService.create - field by field,
- * with nothing extra - and what happens around it:
- *
- *   - the checks, in order: link, form on, plan, network, captcha (only when
- *     the instance has one on), the answers, the severity;
- *   - the incident: the form's project whatever the body says, the
- *     reporter's title and description, the severity (the reporter's choice
- *     when allowed, else the form's, else the template's, else a 400), the
- *     template id so IncidentService applies the template, the answers to
- *     the fields the form asks and to nothing else, never on a status page
- *     or to its subscribers - and the template's owners, for IncidentService
- *     to add once the incident's channels exist, and to notify;
- *   - afterwards: the submission recorded, the reporter named in a private
- *     note with every value Markdown-escaped - and a failure in either
- *     logged, never thrown, because the incident already stands;
- *   - the answer: the incident's number and the form's success message.
- *
- * Only the database and the captcha provider are stubbed.
- */
-
-jest.mock("../../../Server/Utils/Logger", () => {
-  return {
-    __esModule: true,
-    default: {
-      debug: jest.fn(),
-      info: jest.fn(),
-      warn: jest.fn(),
-      error: jest.fn(),
-    },
-    getLogAttributesFromRequest: jest.fn().mockReturnValue({}),
-  };
-});
-
-import Incident from "../../../Models/DatabaseModels/Incident";
-import IncidentCustomField from "../../../Models/DatabaseModels/IncidentCustomField";
-import IncidentForm from "../../../Models/DatabaseModels/IncidentForm";
-import IncidentFormSubmission from "../../../Models/DatabaseModels/IncidentFormSubmission";
-import IncidentInternalNote from "../../../Models/DatabaseModels/IncidentInternalNote";
-import IncidentSeverity from "../../../Models/DatabaseModels/IncidentSeverity";
-import IncidentTemplate from "../../../Models/DatabaseModels/IncidentTemplate";
-import IncidentTemplateOwnerTeam from "../../../Models/DatabaseModels/IncidentTemplateOwnerTeam";
-import IncidentTemplateOwnerUser from "../../../Models/DatabaseModels/IncidentTemplateOwnerUser";
-import Monitor from "../../../Models/DatabaseModels/Monitor";
-import IncidentFormRateLimit, {
-  INCIDENT_FORM_RATE_LIMIT_UNAVAILABLE_MESSAGE,
-  INCIDENT_FORM_TOTAL_RATE_LIMIT_MESSAGE,
-  IncidentFormCeilingException,
-} from "../../../Server/Middleware/IncidentFormRateLimit";
-import IncidentCustomFieldService from "../../../Server/Services/IncidentCustomFieldService";
-import IncidentFormService, {
-  INCIDENT_FORM_NETWORK_NOT_ALLOWED_MESSAGE,
-  INCIDENT_FORM_NOT_AVAILABLE_MESSAGE,
-  INCIDENT_FORM_NO_SEVERITY_MESSAGE,
-  INCIDENT_FORM_SUBMIT_FAILED_MESSAGE,
-  INCIDENT_FORM_TITLE_TOO_LONG_MESSAGE,
-  getIncidentFormReporterNote,
-  neutralizeIncidentFormReport,
-} from "../../../Server/Services/IncidentFormService";
-import IncidentFormSubmissionService from "../../../Server/Services/IncidentFormSubmissionService";
-import IncidentInternalNoteService from "../../../Server/Services/IncidentInternalNoteService";
-import IncidentService from "../../../Server/Services/IncidentService";
-import IncidentSeverityService from "../../../Server/Services/IncidentSeverityService";
-import IncidentTemplateOwnerTeamService from "../../../Server/Services/IncidentTemplateOwnerTeamService";
-import IncidentTemplateOwnerUserService from "../../../Server/Services/IncidentTemplateOwnerUserService";
-import IncidentTemplateService from "../../../Server/Services/IncidentTemplateService";
-import Markdown, { MarkdownContentType } from "../../../Server/Types/Markdown";
-import CaptchaUtil from "../../../Server/Utils/Captcha";
-import logger from "../../../Server/Utils/Logger";
-import SlackUtil from "../../../Server/Utils/Workspace/Slack/Slack";
-import CustomFieldMappingSourceResource from "../../../Types/CustomField/CustomFieldMappingSourceResource";
-import CustomFieldType from "../../../Types/CustomField/CustomFieldType";
-import Email from "../../../Types/Email";
-import BadDataException from "../../../Types/Exception/BadDataException";
-import Exception from "../../../Types/Exception/Exception";
-import ForbiddenException from "../../../Types/Exception/ForbiddenException";
-import NotFoundException from "../../../Types/Exception/NotFoundException";
-import ServerException from "../../../Types/Exception/ServerException";
-import ServiceUnavailableException from "../../../Types/Exception/ServiceUnavailableException";
-import {
-  IncidentFormFieldSetting,
-  PublicIncidentFormSubmissionResult,
-  ValidatedIncidentFormSubmission,
-  formatIncidentFormSubmissionErrors,
-} from "../../../Types/Incident/IncidentFormPublic";
-import { JSONObject } from "../../../Types/JSON";
-import ObjectID from "../../../Types/ObjectID";
-import {
-  hrefsOf,
-  renderAsDashboard,
-} from "../../Utils/Markdown/DashboardMarkdownRenderer";
-import { Lexer, Token, Tokens, marked } from "marked";
-
-type MockedFn = ReturnType<typeof jest.fn>;
-
-const PROJECT_ID: ObjectID = new ObjectID(
-  "5d7f3c0a-4c55-4d3e-9a3e-2d4a7d1c9f01",
-);
-const OTHER_PROJECT_ID: string = "5d7f3c0a-4c55-4d3e-9a3e-2d4a7d1c9f02";
-const FORM_ID: string = "a1b2c3d4-0000-4000-8000-0000000000f1";
-const SHARE_KEY: string = "7c9e6679-7425-40de-944b-e07fc1f90ae7";
-const OTHER_SHARE_KEY: string = "0f8fad5b-d9cb-469f-a165-70867728950e";
-const FORM_SEVERITY_ID: string = "b0000000-0000-4000-8000-0000000000f1";
-const MINOR_SEVERITY_ID: string = "b0000000-0000-4000-8000-0000000000f2";
-const TEMPLATE_ID: string = "c0000000-0000-4000-8000-0000000000f1";
-const INCIDENT_ID: string = "e0000000-0000-4000-8000-0000000000f1";
-const OWNER_USER_IDS: Array<string> = [
-  "f0000000-0000-4000-8000-0000000000a1",
-  "f0000000-0000-4000-8000-0000000000a2",
-];
-const OWNER_TEAM_ID: string = "f0000000-0000-4000-8000-0000000000b1";
-const CLIENT_IP: string = "203.0.113.7";
-const CAPTCHA_IP: string = "203.0.113.8";
-
-// A column read back from Postgres as NULL, which the model's types omit.
-function setNull(
-  model: IncidentForm | Incident | IncidentTemplate,
-  column: string,
-): void {
-  (model as unknown as Record<string, unknown>)[column] = null;
-}
-
-function buildForm(data: Partial<IncidentForm> = {}): IncidentForm {
-  const form: IncidentForm = new IncidentForm();
-  form._id = FORM_ID;
-  form.projectId = PROJECT_ID;
-  form.name = "Report a Problem";
-  form.isEnabled = true;
-  form.shareKey = new ObjectID(SHARE_KEY);
-  form.incidentSeverityId = new ObjectID(FORM_SEVERITY_ID);
-  form.allowReporterToChooseSeverity = false;
-  form.descriptionSetting = IncidentFormFieldSetting.Optional;
-  form.customFieldSettings = {};
-  form.isReporterDetailsRequired = true;
-  form.successMessage = "Thanks - **we are on it**.";
-  form.ipWhitelist = "";
-  Object.assign(form, data);
-  return form;
-}
-
-function withTemplate(data: Partial<IncidentForm> = {}): IncidentForm {
-  return buildForm({ incidentTemplateId: new ObjectID(TEMPLATE_ID), ...data });
-}
-
-function customField(data: {
-  name: string;
-  variableKey: string;
-  customFieldType: CustomFieldType;
-  sortOrder: number;
-  dropdownOptions?: string;
-}): IncidentCustomField {
-  const field: IncidentCustomField = new IncidentCustomField();
-  field._id = ObjectID.generate().toString();
-  field.projectId = PROJECT_ID;
-  field.name = data.name;
-  field.variableKey = data.variableKey;
-  field.customFieldType = data.customFieldType;
-  field.sortOrder = data.sortOrder;
-  field.showOnCreate = true;
-  field.isRequiredOnCreate = true;
-
-  if (data.dropdownOptions !== undefined) {
-    field.dropdownOptions = data.dropdownOptions;
-  }
-
-  return field;
-}
-
-const PROJECT_FIELDS: Array<IncidentCustomField> = [
-  customField({
-    name: "Impact",
-    variableKey: "impact",
-    customFieldType: CustomFieldType.Dropdown,
-    sortOrder: 1,
-    dropdownOptions: "Low\nHigh",
-  }),
-  customField({
-    name: "Region",
-    variableKey: "region",
-    customFieldType: CustomFieldType.Text,
-    sortOrder: 2,
-  }),
-  customField({
-    name: "Acknowledged",
-    variableKey: "acknowledged",
-    customFieldType: CustomFieldType.Boolean,
-    sortOrder: 3,
-  }),
-  customField({
-    name: "Secret Escalation Path",
-    variableKey: "secret_escalation_path",
-    customFieldType: CustomFieldType.Text,
-    sortOrder: 4,
-  }),
-  customField({
-    name: "Details",
-    variableKey: "details",
-    customFieldType: CustomFieldType.Markdown,
-    sortOrder: 5,
-  }),
-  customField({
-    name: "Notes",
-    variableKey: "notes",
-    customFieldType: CustomFieldType.LongText,
-    sortOrder: 6,
-  }),
-  customField({
-    name: "Systems",
-    variableKey: "systems",
-    customFieldType: CustomFieldType.MultiSelectDropdown,
-    sortOrder: 7,
-    dropdownOptions: "API\nWeb",
-  }),
-];
-
-const FORM_QUESTIONS: Record<string, string> = {
-  impact: "Required",
-  region: "Optional",
-  secret_escalation_path: "Hidden",
-};
-
-function severity(id: string, name: string, order: number): IncidentSeverity {
-  const row: IncidentSeverity = new IncidentSeverity();
-  row._id = id;
-  row.name = name;
-  row.order = order;
-  row.projectId = PROJECT_ID;
-  return row;
-}
-
-const PROJECT_SEVERITIES: Array<IncidentSeverity> = [
-  severity(FORM_SEVERITY_ID, "Critical", 1),
-  severity(MINOR_SEVERITY_ID, "Minor", 2),
-];
-
-function ownerUser(userId: string): IncidentTemplateOwnerUser {
-  const owner: IncidentTemplateOwnerUser = new IncidentTemplateOwnerUser();
-  owner.userId = new ObjectID(userId);
-  return owner;
-}
-
-function ownerTeam(teamId: string): IncidentTemplateOwnerTeam {
-  const owner: IncidentTemplateOwnerTeam = new IncidentTemplateOwnerTeam();
-  owner.teamId = new ObjectID(teamId);
-  return owner;
-}
-
-function templateWithSeverity(severityId: string | null): IncidentTemplate {
-  const template: IncidentTemplate = new IncidentTemplate();
-  template._id = TEMPLATE_ID;
-
-  if (severityId) {
-    template.incidentSeverityId = new ObjectID(severityId);
-  } else {
-    setNull(template, "incidentSeverityId");
-  }
-
-  return template;
-}
-
-const VALID_ANSWERS: JSONObject = {
-  title: "  Checkout is down  ",
-  description: "Every order fails\n\n    at step 3",
-  reporterName: "Jane Doe",
-  reporterEmail: "Jane.Doe@Example.com",
-};
-
-let storedForm: IncidentForm | null = null;
-let formFindOneBy: MockedFn;
-let customFieldFindBy: MockedFn;
-let severityFindBy: MockedFn;
-let templateFindOneBy: MockedFn;
-let incidentCreate: MockedFn;
-let addOwners: MockedFn;
-let ownerUserFindBy: MockedFn;
-let ownerTeamFindBy: MockedFn;
-let submissionCreate: MockedFn;
-let noteCreate: MockedFn;
-let captchaEnabled: MockedFn;
-let verifyCaptcha: MockedFn;
-let reserveFormSubmission: MockedFn;
-let createdIncident: Incident;
-
-beforeEach(() => {
-  storedForm = buildForm();
-
-  createdIncident = new Incident();
-  createdIncident._id = INCIDENT_ID;
-  createdIncident.projectId = PROJECT_ID;
-  createdIncident.incidentNumber = 42;
-  createdIncident.incidentNumberWithPrefix = "INC-42";
-
-  formFindOneBy = jest
-    .spyOn(IncidentFormService, "findOneBy")
-    .mockImplementation((async (findBy: {
-      query: { shareKey?: ObjectID };
-    }): Promise<IncidentForm | null> => {
-      if (
-        storedForm &&
-        findBy.query.shareKey?.toString() === storedForm.shareKey?.toString()
-      ) {
-        return storedForm;
-      }
-
-      return null;
-    }) as never) as unknown as MockedFn;
-
-  jest
-    .spyOn(IncidentFormService, "isProjectOnPlan")
-    .mockResolvedValue(true as never);
-
-  customFieldFindBy = jest
-    .spyOn(IncidentCustomFieldService, "findBy")
-    .mockResolvedValue(PROJECT_FIELDS as never) as unknown as MockedFn;
-
-  severityFindBy = jest
-    .spyOn(IncidentSeverityService, "findBy")
-    .mockResolvedValue(PROJECT_SEVERITIES as never) as unknown as MockedFn;
-
-  templateFindOneBy = jest
-    .spyOn(IncidentTemplateService, "findOneBy")
-    .mockResolvedValue(
-      templateWithSeverity(MINOR_SEVERITY_ID) as never,
-    ) as unknown as MockedFn;
-
-  incidentCreate = jest
-    .spyOn(IncidentService, "create")
-    .mockImplementation((async (): Promise<Incident> => {
-      return createdIncident;
-    }) as never) as unknown as MockedFn;
-
-  addOwners = jest
-    .spyOn(IncidentService, "addOwners")
-    .mockResolvedValue(undefined as never) as unknown as MockedFn;
-
-  ownerUserFindBy = jest
-    .spyOn(IncidentTemplateOwnerUserService, "findBy")
-    .mockResolvedValue(
-      OWNER_USER_IDS.map(ownerUser) as never,
-    ) as unknown as MockedFn;
-
-  ownerTeamFindBy = jest
-    .spyOn(IncidentTemplateOwnerTeamService, "findBy")
-    .mockResolvedValue([
-      ownerTeam(OWNER_TEAM_ID),
-    ] as never) as unknown as MockedFn;
-
-  submissionCreate = jest
-    .spyOn(IncidentFormSubmissionService, "create")
-    .mockImplementation((async (createBy: {
-      data: IncidentFormSubmission;
-    }): Promise<IncidentFormSubmission> => {
-      return createBy.data;
-    }) as never) as unknown as MockedFn;
-
-  noteCreate = jest
-    .spyOn(IncidentInternalNoteService, "create")
-    .mockImplementation((async (createBy: {
-      data: IncidentInternalNote;
-    }): Promise<IncidentInternalNote> => {
-      return createBy.data;
-    }) as never) as unknown as MockedFn;
-
-  captchaEnabled = jest
-    .spyOn(CaptchaUtil, "isCaptchaEnabled")
-    .mockReturnValue(false) as unknown as MockedFn;
-
-  verifyCaptcha = jest
-    .spyOn(CaptchaUtil, "verifyCaptcha")
-    .mockResolvedValue(undefined as never) as unknown as MockedFn;
-
-  /*
-   * The form's hourly ceiling is counted in Redis, which this suite has
-   * none of (left real, it would fail closed with a 503); what it is asked,
-   * and when, is pinned below.
-   */
-  reserveFormSubmission = jest
-    .spyOn(IncidentFormRateLimit, "reserveFormSubmission")
-    .mockResolvedValue(undefined as never) as unknown as MockedFn;
-});
-
-afterEach(() => {
-  jest.restoreAllMocks();
-  jest.clearAllMocks();
-});
-
-function submit(
-  data: {
-    answers?: unknown;
-    captchaToken?: string;
-    shareKey?: string | undefined;
-    clientIp?: string | undefined;
-  } = {},
-): Promise<PublicIncidentFormSubmissionResult> {
-  const request: { data: unknown; captchaToken?: string } = {
-    data: "answers" in data ? data.answers : VALID_ANSWERS,
-  };
-
-  if (data.captchaToken !== undefined) {
-    request.captchaToken = data.captchaToken;
-  }
-
-  return IncidentFormService.submitPublicForm({
-    shareKey: "shareKey" in data ? data.shareKey : SHARE_KEY,
-    request: request as never,
-    clientIp: "clientIp" in data ? data.clientIp : CLIENT_IP,
-    captchaRemoteIp: CAPTCHA_IP,
-  });
-}
-
-async function refusal(
-  promise: Promise<unknown>,
-): Promise<Exception | undefined> {
-  try {
-    await promise;
-  } catch (err) {
-    return err as Exception;
-  }
-
-  return undefined;
-}
-
-// The call IncidentService.create received.
-function createCall(): {
-  data: Incident;
-  props: Record<string, unknown>;
-  miscDataProps?: JSONObject | undefined;
-} {
-  expect(incidentCreate).toHaveBeenCalledTimes(1);
-
-  return incidentCreate.mock.calls[0]![0] as {
-    data: Incident;
-    props: Record<string, unknown>;
-    miscDataProps?: JSONObject | undefined;
-  };
-}
-
-/*
- * Every column set on the incident handed to IncidentService.create, as
- * plain values. Asserting this whole object, rather than a column or two,
- * is what proves nothing else in the request reached the incident. (Only
- * table columns: the model's own bookkeeping, such as isPermissionIf, is
- * never written.)
- */
-function createdColumns(): Record<string, unknown> {
-  const incident: Incident = createCall().data;
-  const columns: Record<string, unknown> = {};
-
-  for (const [key, value] of Object.entries(incident)) {
-    if (value === undefined || !incident.hasColumn(key)) {
-      continue;
-    }
-
-    columns[key] = value instanceof ObjectID ? value.toString() : value;
-  }
-
-  return columns;
-}
-
-const PLAIN_INCIDENT: Record<string, unknown> = {
-  projectId: PROJECT_ID.toString(),
-  title: "Checkout is down",
-  description: "Every order fails\n\n    at step 3",
-  incidentSeverityId: FORM_SEVERITY_ID,
-  customFields: {},
-  isVisibleOnStatusPage: false,
-  shouldStatusPageSubscribersBeNotifiedOnIncidentCreated: false,
-};
-
-describe("IncidentFormService.submitPublicForm - the incident it declares", () => {
-  test("a form without a template: exactly the reporter's incident, in the form's project, as root", async () => {
-    await submit();
-
-    expect(createdColumns()).toEqual(PLAIN_INCIDENT);
-    expect(createCall().props).toEqual({ isRoot: true });
-    expect(createCall().data).toBeInstanceOf(Incident);
-  });
-
-  test("a form with a template: the same, plus the template's id for IncidentService to apply", async () => {
-    storedForm = withTemplate();
-
-    await submit();
-
-    expect(createdColumns()).toEqual({
-      ...PLAIN_INCIDENT,
-      createdIncidentTemplateId: TEMPLATE_ID,
-    });
-    expect(typeof createCall().data.createdIncidentTemplateId).toBe("string");
-  });
-
-  /*
-   * IncidentService only applies a template when no state is given, so a
-   * state here would silently drop the template's monitors, owners' policies
-   * and everything else it sets.
-   */
-  test("never sets a state, so IncidentService's template branch runs", async () => {
-    storedForm = withTemplate();
-
-    await submit();
-
-    expect(createCall().data.currentIncidentStateId).toBeUndefined();
-    expect(createCall().data.currentIncidentState).toBeUndefined();
-  });
-
-  test("names no creating user: nobody signed in to send it", async () => {
-    await submit();
-
-    expect(createCall().data.createdByUserId).toBeUndefined();
-    expect(createCall().data.createdByUser).toBeUndefined();
-    expect(createCall().props["userId"]).toBeUndefined();
-    expect(createCall().props["tenantId"]).toBeUndefined();
-  });
-
-  test("keeps the incident off every status page, and quiet to their subscribers, whatever the template says", async () => {
-    storedForm = withTemplate();
-
-    await submit();
-
-    expect(createCall().data.isVisibleOnStatusPage).toBe(false);
-    expect(
-      createCall().data.shouldStatusPageSubscribersBeNotifiedOnIncidentCreated,
-    ).toBe(false);
-  });
-
-  /*
-   * The body is a stranger's. Nothing in it but the answers the form asks
-   * for may reach the incident - least of all which project it lands in.
-   */
-  test("ignores everything in the body the form does not ask for", async () => {
-    await submit({
-      answers: {
-        ...VALID_ANSWERS,
-        projectId: OTHER_PROJECT_ID,
-        currentIncidentStateId: ObjectID.generate().toString(),
-        isPrivate: true,
-        isVisibleOnStatusPage: true,
-        shouldStatusPageSubscribersBeNotifiedOnIncidentCreated: true,
-        createdByUserId: ObjectID.generate().toString(),
-        createdIncidentTemplateId: ObjectID.generate().toString(),
-        monitors: [{ _id: ObjectID.generate().toString() }],
-        rootCause: "planted",
-        incidentSeverityId: MINOR_SEVERITY_ID,
-      },
-    });
-
-    expect(createdColumns()).toEqual(PLAIN_INCIDENT);
-  });
-});
-
-describe("IncidentFormService.submitPublicForm - severity", () => {
-  test("uses the reporter's choice when the form lets them choose", async () => {
-    storedForm = buildForm({ allowReporterToChooseSeverity: true });
-
-    await submit({
-      answers: {
-        ...VALID_ANSWERS,
-        incidentSeverityId: MINOR_SEVERITY_ID.toUpperCase(),
-      },
-    });
-
-    expect(createdColumns()["incidentSeverityId"]).toBe(MINOR_SEVERITY_ID);
-    expect(createCall().data.incidentSeverityId).toBeInstanceOf(ObjectID);
-  });
-
-  test("checks the choice against the form's project's severities, read as root", async () => {
-    storedForm = buildForm({ allowReporterToChooseSeverity: true });
-
-    await submit({
-      answers: { ...VALID_ANSWERS, incidentSeverityId: MINOR_SEVERITY_ID },
-    });
-
-    const findBy: {
-      query: Record<string, unknown>;
-      props: Record<string, unknown>;
-    } = severityFindBy.mock.calls[0]![0] as never;
-
-    expect(findBy.query).toEqual({ projectId: PROJECT_ID });
-    expect(findBy.props).toEqual({ isRoot: true });
-  });
-
-  test("refuses a choice that is not one of the project's severities, declaring nothing", async () => {
-    storedForm = buildForm({ allowReporterToChooseSeverity: true });
-
-    const error: Exception | undefined = await refusal(
-      submit({
-        answers: {
-          ...VALID_ANSWERS,
-          incidentSeverityId: ObjectID.generate().toString(),
-        },
-      }),
-    );
-
-    expect(error).toBeInstanceOf(BadDataException);
-    expect(error?.code).toBe(400);
-    expect(error?.message).toBe(
-      "Severity must be one of the severities this form lists.",
-    );
-    expect(incidentCreate).not.toHaveBeenCalled();
-  });
-
-  test("uses the form's severity when the reporter may choose but did not", async () => {
-    storedForm = buildForm({ allowReporterToChooseSeverity: true });
-
-    await submit({ answers: { ...VALID_ANSWERS, incidentSeverityId: "" } });
-
-    expect(createdColumns()["incidentSeverityId"]).toBe(FORM_SEVERITY_ID);
-  });
-
-  test("ignores a choice, and reads no severities, when the form sets the severity", async () => {
-    await submit({
-      answers: { ...VALID_ANSWERS, incidentSeverityId: MINOR_SEVERITY_ID },
-    });
-
-    expect(createdColumns()["incidentSeverityId"]).toBe(FORM_SEVERITY_ID);
-    expect(severityFindBy).not.toHaveBeenCalled();
-  });
-
-  test("ignores even an invalid choice when the form does not offer one", async () => {
-    await submit({
-      answers: { ...VALID_ANSWERS, incidentSeverityId: "not-a-severity" },
-    });
-
-    expect(createdColumns()["incidentSeverityId"]).toBe(FORM_SEVERITY_ID);
-  });
-
-  /*
-   * Deleting the form's severity clears the column. With a template that
-   * has a severity, the incident is declared without one here and
-   * IncidentService's template branch fills it in.
-   */
-  test("leaves the severity to the template when the form's own was deleted", async () => {
-    storedForm = withTemplate();
-    setNull(storedForm, "incidentSeverityId");
-
-    await submit();
-
-    expect(createdColumns()).toEqual({
-      ...PLAIN_INCIDENT,
-      incidentSeverityId: undefined,
-      createdIncidentTemplateId: TEMPLATE_ID,
-    });
-    expect(createCall().data.incidentSeverityId).toBeUndefined();
-  });
-
-  test("looks the template's severity up in the form's project, as root", async () => {
-    storedForm = withTemplate();
-    setNull(storedForm, "incidentSeverityId");
-
-    await submit();
-
-    expect(templateFindOneBy).toHaveBeenCalledWith({
-      query: { _id: TEMPLATE_ID, projectId: PROJECT_ID },
-      select: { incidentSeverityId: true },
-      props: { isRoot: true },
-    });
-  });
-
-  test("does not read the template when the form has a severity", async () => {
-    storedForm = withTemplate();
-
-    await submit();
-
-    expect(templateFindOneBy).not.toHaveBeenCalled();
-  });
-
-  test.each([
-    [
-      "no template",
-      (): IncidentForm => {
-        return buildForm();
-      },
-      null,
-    ],
-    [
-      "a template without a severity",
-      (): IncidentForm => {
-        return withTemplate();
-      },
-      templateWithSeverity(null),
-    ],
-    [
-      "a template that is not in the form's project",
-      (): IncidentForm => {
-        return withTemplate();
-      },
-      null,
-    ],
-  ])(
-    "refuses, declaring nothing, when no severity is left: %s",
-    async (
-      _label: string,
-      form: () => IncidentForm,
-      template: IncidentTemplate | null,
-    ) => {
-      storedForm = form();
-      setNull(storedForm, "incidentSeverityId");
-      templateFindOneBy.mockResolvedValue(template as never);
-
-      const error: Exception | undefined = await refusal(submit());
-
-      expect(error).toBeInstanceOf(BadDataException);
-      expect(error?.code).toBe(400);
-      expect(error?.message).toBe(INCIDENT_FORM_NO_SEVERITY_MESSAGE);
-      expect(incidentCreate).not.toHaveBeenCalled();
-    },
-  );
-});
-
-describe("IncidentFormService.submitPublicForm - title and description", () => {
-  test("trims the title and keeps it on one line", async () => {
-    await submit({
-      answers: { ...VALID_ANSWERS, title: "\n Checkout\tis   down \r\n" },
-    });
-
-    expect(createCall().data.title).toBe("Checkout is down");
-  });
-
-  test.each([
-    ["missing", undefined],
-    ["blank", "   "],
-  ])(
-    "refuses a %s title, declaring nothing",
-    async (_label: string, title: string | undefined) => {
-      const answers: JSONObject = { ...VALID_ANSWERS };
-
-      if (title === undefined) {
-        delete answers["title"];
-      } else {
-        answers["title"] = title;
-      }
-
-      const error: Exception | undefined = await refusal(submit({ answers }));
-
-      expect(error).toBeInstanceOf(BadDataException);
-      expect(error?.message).toBe("Title is required.");
-      expect(incidentCreate).not.toHaveBeenCalled();
-    },
-  );
-
-  test("a hidden description question: whatever was sent is ignored, so a template's description can apply", async () => {
-    storedForm = withTemplate({
-      descriptionSetting: IncidentFormFieldSetting.Hidden,
-    });
-
-    // VALID_ANSWERS carries a description; the form does not ask for one.
-    await submit();
-
-    expect(createCall().data.description).toBeUndefined();
-  });
-
-  test.each([
-    ["left out", undefined],
-    ["empty", ""],
-    ["only whitespace", "  \n\n  "],
-  ])(
-    "an optional description %s is left undefined, not sent empty",
-    async (_label: string, description: string | undefined) => {
-      const answers: JSONObject = { ...VALID_ANSWERS };
-
-      if (description === undefined) {
-        delete answers["description"];
-      } else {
-        answers["description"] = description;
-      }
-
-      storedForm = withTemplate();
-
-      await submit({ answers });
-
-      expect(createCall().data.description).toBeUndefined();
-    },
-  );
-
-  test("a required description that is missing is refused, declaring nothing", async () => {
-    storedForm = buildForm({
-      descriptionSetting: IncidentFormFieldSetting.Required,
-    });
-
-    const answers: JSONObject = { ...VALID_ANSWERS };
-    delete answers["description"];
-
-    const error: Exception | undefined = await refusal(submit({ answers }));
-
-    expect(error).toBeInstanceOf(BadDataException);
-    expect(error?.message).toBe("Description is required.");
-    expect(incidentCreate).not.toHaveBeenCalled();
-  });
-
-  test("a required description that was written is declared as written", async () => {
-    storedForm = buildForm({
-      descriptionSetting: IncidentFormFieldSetting.Required,
-    });
-
-    await submit();
-
-    expect(createCall().data.description).toBe(
-      "Every order fails\n\n    at step 3",
-    );
-  });
-});
-
-describe("IncidentFormService.submitPublicForm - custom fields", () => {
-  test("stores the answers to the fields the form asks, and drops every other key", async () => {
-    storedForm = buildForm({ customFieldSettings: FORM_QUESTIONS });
-
-    await submit({
-      answers: {
-        ...VALID_ANSWERS,
-        customFields: {
-          Impact: "High",
-          Region: "  EU-West  ",
-          "Secret Escalation Path": "planted",
-          Acknowledged: true,
-          "No Such Field": "planted",
-        },
-      },
-    });
-
-    expect(createCall().data.customFields).toEqual({
-      Impact: "High",
-      Region: "EU-West",
-    });
-  });
-
-  test("reads the project's fields from the form's own project, as root", async () => {
-    storedForm = buildForm({ customFieldSettings: FORM_QUESTIONS });
-
-    await submit({
-      answers: { ...VALID_ANSWERS, customFields: { Impact: "Low" } },
-    });
-
-    const findBy: {
-      query: Record<string, unknown>;
-      props: Record<string, unknown>;
-    } = customFieldFindBy.mock.calls[0]![0] as never;
-
-    expect(findBy.query).toEqual({ projectId: PROJECT_ID });
-    expect(findBy.props).toEqual({ isRoot: true });
-  });
-
-  test("leaves an unanswered optional field out, so a template's value for it still applies", async () => {
-    storedForm = withTemplate({ customFieldSettings: FORM_QUESTIONS });
-
-    await submit({
-      answers: {
-        ...VALID_ANSWERS,
-        customFields: { Impact: "Low", Region: "" },
-      },
-    });
-
-    expect(createCall().data.customFields).toEqual({ Impact: "Low" });
-  });
-
-  test("refuses an unanswered required field, declaring nothing", async () => {
-    storedForm = buildForm({ customFieldSettings: FORM_QUESTIONS });
-
-    const error: Exception | undefined = await refusal(
-      submit({ answers: { ...VALID_ANSWERS, customFields: { Region: "EU" } } }),
-    );
-
-    expect(error).toBeInstanceOf(BadDataException);
-    expect(error?.message).toBe("Impact is required.");
-    expect(incidentCreate).not.toHaveBeenCalled();
-  });
-
-  test("refuses an answer that is not one of a dropdown's options", async () => {
-    storedForm = buildForm({ customFieldSettings: FORM_QUESTIONS });
-
-    const error: Exception | undefined = await refusal(
-      submit({
-        answers: { ...VALID_ANSWERS, customFields: { Impact: "Apocalyptic" } },
-      }),
-    );
-
-    expect(error).toBeInstanceOf(BadDataException);
-    expect(error?.message).toContain("Apocalyptic");
-    expect(incidentCreate).not.toHaveBeenCalled();
-  });
-
-  test("a required yes/no question must be ticked", async () => {
-    storedForm = buildForm({
-      customFieldSettings: { acknowledged: "Required" },
-    });
-
-    const error: Exception | undefined = await refusal(
-      submit({
-        answers: { ...VALID_ANSWERS, customFields: { Acknowledged: false } },
-      }),
-    );
-
-    expect(error?.message).toBe("Acknowledged must be checked.");
-
-    await submit({
-      answers: { ...VALID_ANSWERS, customFields: { Acknowledged: "true" } },
-    });
-
-    expect(createCall().data.customFields).toEqual({ Acknowledged: true });
-  });
-
-  /*
-   * One anonymous request of a million multi-select entries must not cost
-   * the shared API process seconds of work, nor come back (and be logged)
-   * as a refusal the size of the request.
-   */
-  test("refuses a multi-select answer of a million entries at once, with one short message, declaring nothing", async () => {
-    storedForm = buildForm({ customFieldSettings: { systems: "Optional" } });
-
-    const started: number = Date.now();
-
-    const error: Exception | undefined = await refusal(
-      submit({
-        answers: {
-          ...VALID_ANSWERS,
-          customFields: {
-            Systems: Array.from(
-              { length: 1_000_000 },
-              (_value: unknown, index: number): string => {
-                return `x${index}`;
-              },
-            ),
-          },
-        },
-      }),
-    );
-
-    expect(Date.now() - started).toBeLessThan(2000);
-    expect(error).toBeInstanceOf(BadDataException);
-    expect(error?.message).toBe("Systems cannot have more than 100 choices.");
-    expect(incidentCreate).not.toHaveBeenCalled();
-  });
-
-  /*
-   * Nothing the form's page sends is an object. Checked as an API write
-   * would check it, an object would be turned into text twice before it
-   * was refused - seconds of the server's time for one with a million
-   * keys - so it is refused before anything reads it.
-   */
-  test("refuses an object answer before reading it, with one short message, declaring nothing", async () => {
-    storedForm = buildForm({ customFieldSettings: FORM_QUESTIONS });
-
-    const answer: Record<string, string> = {};
-
-    for (let index: number = 0; index < 1_000_000; index++) {
-      answer[`k${index}`] = "EU";
-    }
-
-    const started: number = Date.now();
-
-    const error: Exception | undefined = await refusal(
-      submit({
-        answers: {
-          ...VALID_ANSWERS,
-          customFields: { Impact: "High", Region: answer },
-        },
-      }),
-    );
-
-    expect(Date.now() - started).toBeLessThan(2000);
-    expect(error).toBeInstanceOf(BadDataException);
-    expect(error?.message).toBe("Region takes one answer, not an object.");
-    expect(incidentCreate).not.toHaveBeenCalled();
-    expect(reserveFormSubmission).not.toHaveBeenCalled();
-  });
-
-  /*
-   * A field mapped from a monitor field takes the monitor's value once the
-   * incident has a monitor - and a form's incident gets its template's
-   * monitors. Such a question is not asked then, so it cannot be required,
-   * and an answer sent anyway is dropped like any the form does not ask.
-   */
-  describe("a field copied from a monitor", () => {
-    const VENDOR: IncidentCustomField = (() => {
-      const field: IncidentCustomField = customField({
-        name: "Vendor",
-        variableKey: "vendor",
-        customFieldType: CustomFieldType.Text,
-        sortOrder: 8,
-      });
-      field.mapFromResourceType = CustomFieldMappingSourceResource.Monitor;
-      field.mapFromCustomFieldName = "Vendor";
-      return field;
-    })();
-
-    function templateWithMonitor(): IncidentTemplate {
-      const template: IncidentTemplate =
-        templateWithSeverity(MINOR_SEVERITY_ID);
-      const monitor: Monitor = new Monitor();
-      monitor._id = "e1000000-0000-4000-8000-0000000000f1";
-      template.monitors = [monitor];
-      return template;
-    }
-
-    beforeEach(() => {
-      customFieldFindBy.mockResolvedValue([...PROJECT_FIELDS, VENDOR] as never);
-      templateFindOneBy.mockResolvedValue(templateWithMonitor() as never);
-    });
-
-    test("is not required when the form's template attaches a monitor, and an answer to it is dropped", async () => {
-      storedForm = withTemplate({
-        customFieldSettings: { vendor: "Required", region: "Optional" },
-      });
-
-      await submit({
-        answers: {
-          ...VALID_ANSWERS,
-          customFields: { Vendor: "Azure", Region: "EU" },
-        },
-      });
-
-      expect(createCall().data.customFields).toEqual({ Region: "EU" });
-    });
-
-    test("is still required, and kept, on a form without a template", async () => {
-      storedForm = buildForm({
-        customFieldSettings: { vendor: "Required" },
-      });
-
-      const error: Exception | undefined = await refusal(
-        submit({ answers: { ...VALID_ANSWERS, customFields: {} } }),
-      );
-
-      expect(error?.message).toBe("Vendor is required.");
-
-      await submit({
-        answers: { ...VALID_ANSWERS, customFields: { Vendor: "Azure" } },
-      });
-
-      expect(createCall().data.customFields).toEqual({ Vendor: "Azure" });
-      expect(templateFindOneBy).not.toHaveBeenCalled();
-    });
-  });
-
-  test("ignores custom field answers entirely, and reads no fields, when the form asks none", async () => {
-    await submit({
-      answers: {
-        ...VALID_ANSWERS,
-        customFields: { Impact: "High", Region: "EU" },
-      },
-    });
-
-    expect(createCall().data.customFields).toEqual({});
-    expect(customFieldFindBy).not.toHaveBeenCalled();
-  });
-});
-
-/*
- * A stranger's report is posted to the project's Slack and Teams channels
- * and rendered for every responder and in owners' emails, and nobody reads
- * it over first. What the incident stores must not act on its own there:
- * no Slack mention, no image fetched from the reporter's server, no mermaid
- * diagram run - while reading exactly as the reporter typed it.
- */
-describe("IncidentFormService.submitPublicForm - nothing the reporter wrote acts on its own", () => {
-  const WORD_JOINER: string = "\u2060";
-
-  function withoutJoiners(text: string | undefined): string {
-    return (text || "").split(WORD_JOINER).join("");
-  }
-
-  function lexedTokens(markdown: string): Array<Token> {
-    const tokens: Array<Token> = [];
-
-    marked.walkTokens(marked.lexer(markdown), (token: Token): void => {
-      tokens.push(token);
-    });
-
-    return tokens;
-  }
-
-  function expectNothingFetchedOrRun(markdown: string): void {
-    const tokens: Array<Token> = lexedTokens(markdown);
-
-    expect(
-      tokens.filter((token: Token): boolean => {
-        return token.type === "image";
-      }),
-    ).toEqual([]);
-    expect(
-      tokens.filter((token: Token): boolean => {
-        return (
-          token.type === "code" &&
-          ((token as Tokens.Code).lang || "")
-            .toLowerCase()
-            .startsWith("mermaid")
-        );
-      }),
-    ).toEqual([]);
-  }
-
-  function slackText(markdown: string): string {
-    return JSON.stringify(
-      SlackUtil.getMarkdownBlocks({
-        payloadMarkdownBlock: {
-          _type: "WorkspacePayloadMarkdown",
-          text: markdown,
-        },
-      }),
-    );
-  }
-
-  const LIVE_SLACK_SEQUENCE: RegExp = /<(![a-z]|@[A-Z0-9]|#C)/;
-
-  const HOSTILE_DESCRIPTION: string =
-    "<!here> every order fails <@U0123ABC>\n\n" +
-    "![](https://tracker.example/p.png)\n\n" +
-    "See ![shot][r]\n\n" +
-    "[r]: https://tracker.example/q.png\n\n" +
-    "```mermaid\ngraph TD\n  A-->B\n```\n\n" +
-    "[the checkout page](https://shop.example/checkout)";
-
-  test("the title and description keep their text, lose their mentions, images and diagrams", async () => {
-    await submit({
-      answers: {
-        ...VALID_ANSWERS,
-        title: "<!channel> Checkout is down",
-        description: HOSTILE_DESCRIPTION,
-      },
-    });
-
-    const created: Incident = createCall().data;
-
-    expect(created.title).not.toMatch(/<[!@#]/);
-    expect(withoutJoiners(created.title)).toBe("<!channel> Checkout is down");
-
-    expect(created.description).not.toMatch(/<[!@#]/);
-    expectNothingFetchedOrRun(created.description || "");
-    expect(slackText(created.description || "")).not.toMatch(
-      LIVE_SLACK_SEQUENCE,
-    );
-
-    // The reporter's link to the broken page still works.
-    expect(
-      lexedTokens(created.description || "")
-        .filter((token: Token): boolean => {
-          return token.type === "link";
-        })
-        .map((token: Token): string => {
-          return (token as Tokens.Link).href;
-        }),
-    ).toEqual([
-      "https://tracker.example/p.png",
-      "https://tracker.example/q.png",
-      "https://shop.example/checkout",
-    ]);
-  });
-
-  test("the unneutralised description really would have fetched, run and mentioned", () => {
-    const tokens: Array<Token> = lexedTokens(HOSTILE_DESCRIPTION);
-
-    expect(
-      tokens.filter((token: Token): boolean => {
-        return token.type === "image";
-      }),
-    ).toHaveLength(2);
-    expect(slackText(HOSTILE_DESCRIPTION)).toMatch(LIVE_SLACK_SEQUENCE);
-  });
-
-  /*
-   * The dashboard reads a description with another parser than marked
-   * (remark, with footnotes), and shows an image in each of these where
-   * marked sees code or a link definition. What is stored must hold no
-   * image syntax left open, whichever reading is right.
-   */
-  test("a description the renderers read differently still stores no image", async () => {
-    const description: string =
-      "[a]: https://x.example\n    ![x](https://tracker.example/p.png)\n\n" +
-      "See[^1]\n\n[^1]: ![y](https://tracker.example/q.png)";
-
-    // marked finds no image in it: the dashboard would have shown two.
-    expect(
-      lexedTokens(description).filter((token: Token): boolean => {
-        return token.type === "image";
-      }),
-    ).toEqual([]);
-
-    await submit({
-      answers: { ...VALID_ANSWERS, description: description },
-    });
-
-    const stored: string = createCall().data.description || "";
-
-    expect(stored).not.toMatch(/(^|[^\\])(\\\\)*!\[/);
-    expect(withoutJoiners(stored).replace(/\\!\[/g, "![")).toBe(description);
-  });
-
-  test("a Markdown answer is neutralised like the description, text answers lose their mentions, and choices are left as chosen", async () => {
-    storedForm = buildForm({
-      customFieldSettings: {
-        details: "Optional",
-        notes: "Optional",
-        region: "Optional",
-        impact: "Optional",
-      },
-    });
-
-    await submit({
-      answers: {
-        ...VALID_ANSWERS,
-        customFields: {
-          Details: "Screenshot: ![](https://tracker.example/p.png) <!here>",
-          Notes: "Ping <#C0123ABC> and <@U0123ABC>",
-          Region: "<!everyone> EU",
-          Impact: "High",
-        },
-      },
-    });
-
-    const customFields: JSONObject = createCall().data.customFields || {};
-
-    expectNothingFetchedOrRun(String(customFields["Details"]));
-    expect(String(customFields["Details"])).not.toMatch(/<[!@#]/);
-    expect(customFields["Notes"]).not.toMatch(/<[!@#]/);
-    expect(withoutJoiners(String(customFields["Notes"]))).toBe(
-      "Ping <#C0123ABC> and <@U0123ABC>",
-    );
-    expect(withoutJoiners(String(customFields["Region"]))).toBe(
-      "<!everyone> EU",
-    );
-    expect(customFields["Region"]).not.toMatch(/<[!@#]/);
-    expect(customFields["Impact"]).toBe("High");
-  });
-
-  test("ordinary answers are stored exactly as typed", async () => {
-    storedForm = buildForm({ customFieldSettings: FORM_QUESTIONS });
-
-    await submit({
-      answers: {
-        ...VALID_ANSWERS,
-        description: "Checkout fails at **step 3**:\n\n```\nError 502\n```",
-        customFields: { Impact: "High", Region: "EU-West (a < b)" },
-      },
-    });
-
-    expect(createCall().data.title).toBe("Checkout is down");
-    expect(createCall().data.description).toBe(
-      "Checkout fails at **step 3**:\n\n```\nError 502\n```",
-    );
-    expect(createCall().data.customFields).toEqual({
-      Impact: "High",
-      Region: "EU-West (a < b)",
-    });
-  });
-
-  /*
-   * Breaking a sequence adds an invisible character, and Incident.title is
-   * a varchar(500): a title the validator accepted can outgrow it.
-   */
-  test("refuses a title that no longer fits the incident once its mentions are broken, declaring nothing", async () => {
-    const title: string = "<!".repeat(250);
-
-    const error: Exception | undefined = await refusal(
-      submit({ answers: { ...VALID_ANSWERS, title: title } }),
-    );
-
-    expect(title.length).toBe(500);
-    expect(error).toBeInstanceOf(BadDataException);
-    expect(error?.message).toBe(INCIDENT_FORM_TITLE_TOO_LONG_MESSAGE);
-    expect(error?.message).toBe("Title cannot be more than 500 characters.");
-    expect(incidentCreate).not.toHaveBeenCalled();
-  });
-
-  test("refuses a title that no longer fits once its image syntax is broken, declaring nothing", async () => {
-    const title: string = "![".repeat(250);
-
-    const error: Exception | undefined = await refusal(
-      submit({ answers: { ...VALID_ANSWERS, title: title } }),
-    );
-
-    expect(error?.message).toBe(INCIDENT_FORM_TITLE_TOO_LONG_MESSAGE);
-    expect(incidentCreate).not.toHaveBeenCalled();
-    expect(reserveFormSubmission).not.toHaveBeenCalled();
-  });
-
-  /*
-   * The title is plain text, but much of OneUptime places it into Markdown
-   * as it is: a grouping rule makes it (its first 50 characters) the title
-   * of a new episode, whose feed items quote it, and so does the incident's
-   * own "Added to episode" item. So image syntax in it is broken as its
-   * mentions are - invisibly, so it reads as typed everywhere.
-   */
-  test("an image in the title is stored broken, so no feed that quotes the title shows it", async () => {
-    const typed: string =
-      "<!channel> ![](https://tracker.example/p.png) Checkout is down";
-
-    await submit({ answers: { ...VALID_ANSWERS, title: typed } });
-
-    const title: string = createCall().data.title || "";
-
-    expect(title).not.toMatch(/!\[|<[!@#]/);
-    expect(withoutJoiners(title)).toBe(typed);
-
-    const quoted: Array<string> = [
-      `#### Episode #1 Created\n\n**${title.substring(0, 50)}**\n\n`,
-      `**Incident INC-42** added to episode: ${title}`,
-      `Added to **Episode #1**: ${title.substring(0, 50)}`,
-    ];
-
-    for (const markdown of quoted) {
-      expectNothingFetchedOrRun(markdown);
-      expect(slackText(markdown)).not.toMatch(LIVE_SLACK_SEQUENCE);
-    }
-
-    for (const html of renderAsDashboard(quoted)) {
-      expect(html).not.toContain("<img");
-    }
-
-    // Unbroken, the same shapes really do show the image.
-    expect(
-      lexedTokens(`**Incident INC-42** added to episode: ${typed}`).filter(
-        (token: Token): boolean => {
-          return token.type === "image";
-        },
-      ),
-    ).toHaveLength(1);
-  });
-
-  test("the submission record keeps the reporter's name as typed", async () => {
-    await submit({
-      answers: { ...VALID_ANSWERS, reporterName: "<@U0123ABC>" },
-    });
-
-    const createBy: { data: IncidentFormSubmission } = submissionCreate.mock
-      .calls[0]![0] as never;
-
-    expect(createBy.data.reporterName).toBe("<@U0123ABC>");
-  });
-
-  test("the private note mentions nobody in Slack, whatever the names say", async () => {
-    storedForm = buildForm({ name: "<!channel> Reports" });
-
-    await submit({
-      answers: {
-        ...VALID_ANSWERS,
-        reporterName: "<@U0123ABC> <!here>",
-        reporterEmail: "#ops@corp.example",
-      },
-    });
-
-    const note: string = (
-      noteCreate.mock.calls[0]![0] as { data: IncidentInternalNote }
-    ).data.note!;
-
-    expect(note).not.toMatch(/<[!@#]/);
-    expect(slackText(note)).not.toMatch(LIVE_SLACK_SEQUENCE);
-    // The "#" escaped in the link, where it would begin a fragment.
-    expect(slackText(note)).toContain(
-      "<mailto:%23ops@corp.example|#ops@corp.example>",
-    );
-
-    const html: string = await Markdown.convertToHTML(
-      note,
-      MarkdownContentType.Email,
-    );
-
-    expect(html).toContain('href="mailto:%23ops@corp.example"');
-  });
-});
-
-describe("neutralizeIncidentFormReport", () => {
-  test("leaves the reporter's name and address, and an answer to a field it is not told about, alone", () => {
-    const report: ValidatedIncidentFormSubmission =
-      neutralizeIncidentFormReport({
-        answers: {
-          title: "<!here>",
-          reporterName: "<@U1>",
-          reporterEmail: "jane@example.com",
-          customFields: { Unlisted: "<!channel>" },
-        },
-        askedDefinitions: [],
-      });
-
-    expect(report.title).toBe("<\u2060!here>");
-    expect(report.reporterName).toBe("<@U1>");
-    expect(report.reporterEmail).toBe("jane@example.com");
-    expect(report.customFields).toEqual({ Unlisted: "<!channel>" });
-  });
-
-  test("treats a field of a type this version does not know as text, as the form asks it", () => {
-    const report: ValidatedIncidentFormSubmission =
-      neutralizeIncidentFormReport({
-        answers: {
-          title: "Down",
-          customFields: { Legacy: "<!channel>", Count: "3" },
-        },
-        askedDefinitions: [
-          { name: "Legacy", customFieldType: null },
-          { name: "Count", customFieldType: CustomFieldType.Number },
-        ],
-      });
-
-    expect(report.customFields).toEqual({
-      Legacy: "<\u2060!channel>",
-      Count: "3",
-    });
-  });
-
-  test("never mutates the validated answers", () => {
-    const answers: ValidatedIncidentFormSubmission = {
-      title: "<!here>",
-      description: "![x](https://t.example/p.png)",
-      customFields: { Notes: "<@U1>" },
-    };
-
-    neutralizeIncidentFormReport({
-      answers: answers,
-      askedDefinitions: [
-        { name: "Notes", customFieldType: CustomFieldType.LongText },
-      ],
-    });
-
-    expect(answers).toEqual({
-      title: "<!here>",
-      description: "![x](https://t.example/p.png)",
-      customFields: { Notes: "<@U1>" },
-    });
-  });
-
-  test("stores an answer to a field named __proto__ as an answer", () => {
-    const customFields: JSONObject = {};
-    Object.defineProperty(customFields, "__proto__", {
-      value: "<!here>",
-      enumerable: true,
-      writable: true,
-      configurable: true,
-    });
-
-    const report: ValidatedIncidentFormSubmission =
-      neutralizeIncidentFormReport({
-        answers: { title: "Down", customFields: customFields },
-        askedDefinitions: [
-          { name: "__proto__", customFieldType: CustomFieldType.Text },
-        ],
-      });
-
-    expect(Object.getPrototypeOf(report.customFields)).toBe(Object.prototype);
-    expect(
-      Object.getOwnPropertyDescriptor(report.customFields, "__proto__")?.value,
-    ).toBe("<\u2060!here>");
-  });
-});
-
-describe("IncidentFormService.submitPublicForm - the reporter", () => {
-  test.each([
-    ["no name", { reporterName: undefined }, "Your Name is required."],
-    ["no email", { reporterEmail: undefined }, "Your Email is required."],
-    [
-      "an address that is not one",
-      { reporterEmail: "jane at example" },
-      "Your Email is not a valid email address.",
-    ],
-  ])(
-    "refuses %s when the form requires the reporter's details",
-    async (
-      _label: string,
-      change: Record<string, string | undefined>,
-      message: string,
-    ) => {
-      const answers: JSONObject = { ...VALID_ANSWERS };
-
-      for (const [key, value] of Object.entries(change)) {
-        if (value === undefined) {
-          delete answers[key];
-        } else {
-          answers[key] = value;
-        }
-      }
-
-      const error: Exception | undefined = await refusal(submit({ answers }));
-
-      expect(error).toBeInstanceOf(BadDataException);
-      expect(error?.message).toBe(message);
-      expect(incidentCreate).not.toHaveBeenCalled();
-    },
-  );
-
-  test("reports every problem at once, as one message", async () => {
-    const error: Exception | undefined = await refusal(
-      submit({ answers: { title: "", reporterEmail: "nope" } }),
-    );
-
-    expect(error?.message).toBe(
-      formatIncidentFormSubmissionErrors([
-        "Title is required.",
-        "Your Name is required.",
-        "Your Email is not a valid email address.",
-      ]),
-    );
-  });
-
-  test("refuses a body without answers", async () => {
-    const error: Exception | undefined = await refusal(
-      submit({ answers: undefined }),
-    );
-
-    expect(error).toBeInstanceOf(BadDataException);
-    expect(error?.message).toBe(
-      "The submission must be an object holding the form's answers.",
-    );
-    expect(incidentCreate).not.toHaveBeenCalled();
-  });
-});
-
-/*
- * The template's owners go with the create, for IncidentService to add once
- * the incident's Slack and Teams channels exist - so their own hooks invite
- * them to those channels - and to notify. Added by the form after the
- * create returned, they raced the channel's creation and were never
- * invited (IncidentTemplateOwnersOnDeclare.test.ts pins the other half).
- */
-describe("IncidentFormService.submitPublicForm - the template's owners", () => {
-  function ids(value: unknown): Array<string> {
-    return (value as Array<ObjectID>).map((id: ObjectID): string => {
-      return id.toString();
-    });
-  }
-
-  test("are handed to the create, to be added once the incident's channels exist, and notified", async () => {
-    storedForm = withTemplate();
-
-    await submit();
-
-    const miscDataProps: JSONObject = createCall().miscDataProps!;
-
-    expect(Object.keys(miscDataProps).sort()).toEqual(
-      ["notifyOwners", "ownerTeams", "ownerUsers"].sort(),
-    );
-    expect(ids(miscDataProps["ownerUsers"])).toEqual(OWNER_USER_IDS);
-    expect(ids(miscDataProps["ownerTeams"])).toEqual([OWNER_TEAM_ID]);
-    expect(miscDataProps["notifyOwners"]).toBe(true);
-    expect(createCall().props).toEqual({ isRoot: true });
-  });
-
-  test("are never added by the form itself, after the create returned", async () => {
-    storedForm = withTemplate();
-
-    await submit();
-
-    expect(addOwners).not.toHaveBeenCalled();
-  });
-
-  test("are read for the form's template in the form's project, as root", async () => {
-    storedForm = withTemplate();
-
-    await submit();
-
-    for (const findBy of [
-      ownerUserFindBy.mock.calls[0]![0],
-      ownerTeamFindBy.mock.calls[0]![0],
-    ] as Array<{
-      query: Record<string, unknown>;
-      props: Record<string, unknown>;
-    }>) {
-      expect(String(findBy.query["incidentTemplateId"])).toBe(TEMPLATE_ID);
-      expect(String(findBy.query["projectId"])).toBe(PROJECT_ID.toString());
-      expect(findBy.props).toEqual({ isRoot: true });
-    }
-  });
-
-  test("with only owner users, hands them and no teams", async () => {
-    storedForm = withTemplate();
-    ownerTeamFindBy.mockResolvedValue([] as never);
-
-    await submit();
-
-    expect(createCall().miscDataProps).toEqual({
-      ownerUsers: expect.any(Array),
-      notifyOwners: true,
-    });
-    expect(ids(createCall().miscDataProps!["ownerUsers"])).toEqual(
-      OWNER_USER_IDS,
-    );
-  });
-
-  test("hands nothing when the template has no owners", async () => {
-    storedForm = withTemplate();
-    ownerUserFindBy.mockResolvedValue([] as never);
-    ownerTeamFindBy.mockResolvedValue([] as never);
-
-    await submit();
-
-    expect(createCall()).not.toHaveProperty("miscDataProps");
-  });
-
-  test("reads no owners, and hands none, for a form without a template", async () => {
-    await submit();
-
-    expect(ownerUserFindBy).not.toHaveBeenCalled();
-    expect(ownerTeamFindBy).not.toHaveBeenCalled();
-    expect(createCall()).not.toHaveProperty("miscDataProps");
-  });
-
-  test("a failure reading them is logged, and the incident is declared without them", async () => {
-    storedForm = withTemplate();
-    ownerTeamFindBy.mockRejectedValue(new Error("read failed"));
-
-    await expect(submit()).resolves.toEqual({
-      incidentNumber: "INC-42",
-      successMessage: "Thanks - **we are on it**.",
-    });
-    expect(createCall()).not.toHaveProperty("miscDataProps");
-    expect(logger.error).toHaveBeenCalledWith(
-      expect.stringContaining(
-        "could not read the owners of the template of incident form",
-      ),
-      expect.objectContaining({ incidentFormId: FORM_ID }),
-    );
-    expect(noteCreate).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe("IncidentFormService.submitPublicForm - the submission record", () => {
-  test("names the form, the incident and the reporter, with the email lowercased", async () => {
-    await submit();
-
-    expect(submissionCreate).toHaveBeenCalledTimes(1);
-
-    const createBy: {
-      data: IncidentFormSubmission;
-      props: Record<string, unknown>;
-    } = submissionCreate.mock.calls[0]![0] as never;
-
-    expect(createBy.props).toEqual({ isRoot: true });
-    expect(createBy.data).toBeInstanceOf(IncidentFormSubmission);
-    expect(createBy.data.projectId?.toString()).toBe(PROJECT_ID.toString());
-    expect(createBy.data.incidentFormId?.toString()).toBe(FORM_ID);
-    expect(createBy.data.incidentId?.toString()).toBe(INCIDENT_ID);
-    expect(createBy.data.reporterName).toBe("Jane Doe");
-    expect(createBy.data.reporterEmail).toBeInstanceOf(Email);
-    expect(createBy.data.reporterEmail?.toString()).toBe(
-      "jane.doe@example.com",
-    );
-  });
-
-  test("has no reporter for an anonymous report", async () => {
-    storedForm = buildForm({ isReporterDetailsRequired: false });
-
-    await submit({ answers: { title: "Checkout is down" } });
-
-    const createBy: { data: IncidentFormSubmission } = submissionCreate.mock
-      .calls[0]![0] as never;
-
-    expect(createBy.data.reporterName).toBeUndefined();
-    expect(createBy.data.reporterEmail).toBeUndefined();
-    expect(createBy.data.incidentId?.toString()).toBe(INCIDENT_ID);
-  });
-});
-
-describe("IncidentFormService.submitPublicForm - the private note", () => {
-  function noteCall(): {
-    data: IncidentInternalNote;
-    props: Record<string, unknown>;
-  } {
-    expect(noteCreate).toHaveBeenCalledTimes(1);
-
-    return noteCreate.mock.calls[0]![0] as never;
-  }
-
-  test("is a private note on the incident, written as root", async () => {
-    await submit();
-
-    expect(noteCall().props).toEqual({ isRoot: true });
-    expect(noteCall().data).toBeInstanceOf(IncidentInternalNote);
-    expect(noteCall().data.projectId?.toString()).toBe(PROJECT_ID.toString());
-    expect(noteCall().data.incidentId?.toString()).toBe(INCIDENT_ID);
-    expect(noteCall().data.createdByUserId).toBeUndefined();
-  });
-
-  test("names the form and the reporter", async () => {
-    await submit();
-
-    expect(noteCall().data.note).toBe(
-      "Reported through the incident form **Report a Problem** by Jane Doe (<jane.doe@example.com>).",
-    );
-  });
-
-  test("says anonymously when the reporter gave no details", async () => {
-    storedForm = buildForm({ isReporterDetailsRequired: false });
-
-    await submit({ answers: { title: "Checkout is down" } });
-
-    expect(noteCall().data.note).toBe(
-      "Reported anonymously through the incident form **Report a Problem**.",
-    );
-  });
-
-  /*
-   * The note is posted as it is - nobody reads it over first - so a
-   * reporter's name must arrive as the characters they typed: never a link
-   * to click, never an image fetched when a responder opens the incident,
-   * never restyling the sentence.
-   */
-  test("escapes a hostile name and email so they read as typed", async () => {
-    storedForm = buildForm({ isReporterDetailsRequired: false });
-
-    await submit({
-      answers: {
-        title: "Checkout is down",
-        reporterName:
-          "[x](javascript:alert(1)) **bold** ![p](https://t.example/p) <img>",
-        reporterEmail: "a_b+c@example.com",
-      },
-    });
-
-    const note: string = noteCall().data.note || "";
-
-    expect(note).toBe(
-      "Reported through the incident form **Report a Problem** by " +
-        "\\[x\\]\\(javascript:alert\\(1\\)\\) \\*\\*bold\\*\\* \\!\\[p\\]\\(https://t.example/p\\) \\<img\\> " +
-        "(<a_b+c@example.com>).",
-    );
-    expect(note).not.toContain("[x](");
-    expect(note).not.toContain("**bold**");
-    expect(note).not.toContain("![p](");
-  });
-});
-
-describe("getIncidentFormReporterNote", () => {
-  test.each([
-    [
-      "a name and an email",
-      { reporterName: "Jane", reporterEmail: "jane@example.com" },
-      "Reported through the incident form **Report a Problem** by Jane (<jane@example.com>).",
-    ],
-    [
-      "only a name",
-      { reporterName: "Jane" },
-      "Reported through the incident form **Report a Problem** by Jane.",
-    ],
-    [
-      "only an email",
-      { reporterEmail: "jane@example.com" },
-      "Reported through the incident form **Report a Problem** by <jane@example.com>.",
-    ],
-    [
-      "neither",
-      {},
-      "Reported anonymously through the incident form **Report a Problem**.",
-    ],
-    [
-      "blank details",
-      { reporterName: "  ", reporterEmail: null },
-      "Reported anonymously through the incident form **Report a Problem**.",
-    ],
-  ])(
-    "with %s",
-    (
-      _label: string,
-      reporter: { reporterName?: string | null; reporterEmail?: string | null },
-      note: string,
-    ) => {
-      expect(
-        getIncidentFormReporterNote({
-          formName: "Report a Problem",
-          ...reporter,
-        }),
-      ).toBe(note);
-    },
-  );
-
-  test("escapes the form's name too, which sits inside the note's own bold", () => {
-    expect(
-      getIncidentFormReporterNote({ formName: "IT ** Help_desk [EU]" }),
-    ).toBe(
-      "Reported anonymously through the incident form **IT \\*\\* Help\\_desk \\[EU\\]**.",
-    );
-  });
-
-  test("reads well without a form name", () => {
-    expect(getIncidentFormReporterNote({ reporterName: "Jane" })).toBe(
-      "Reported through an incident form by Jane.",
-    );
-  });
-
-  test("keeps a name on one line", () => {
-    expect(
-      getIncidentFormReporterNote({
-        formName: "Form",
-        reporterName: "Jane\n# Heading",
-      }),
-    ).toBe("Reported through the incident form **Form** by Jane \\# Heading.");
-  });
-
-  /*
-   * The note reaches the owners by email (SendNotePostedNotification renders
-   * it with marked) and the incident's Slack channels (slackify-markdown).
-   * Written backslash-escaped, the address made marked restart its link
-   * after each escape: mary\-jane.watson@... linked mailto:jane.watson@...,
-   * a colleague's mailbox. Every link must be the whole address the reporter
-   * gave - hyphen, underscore, plus, apostrophe or hyphenated domain.
-   */
-  describe("links the reporter's whole address", () => {
-    const ADDRESSES: Array<string> = [
-      "mary-jane.watson@corp.example",
-      "first_last@company.com",
-      "ops+alerts@company.com",
-      "jane@my-company.com",
-      "o'brien@company.com",
-      "a_b+c@example.com",
-    ];
-
-    const REPORTERS: Array<[string, string | undefined]> = [];
-
-    for (const address of ADDRESSES) {
-      REPORTERS.push([address, "Jane Doe"]);
-      REPORTERS.push([address, undefined]);
-    }
-
-    function hrefs(html: string): Array<string> {
-      return Array.from(html.matchAll(/href="([^"]*)"/g)).map(
-        (match: RegExpMatchArray): string => {
-          return match[1]!;
-        },
-      );
-    }
-
-    test.each(REPORTERS)(
-      "in the owners' email: %s (name %s)",
-      async (address: string, reporterName: string | undefined) => {
-        const note: string = getIncidentFormReporterNote({
-          formName: "Report a Problem",
-          reporterName: reporterName,
-          reporterEmail: address,
-        });
-
-        const html: string = await Markdown.convertToHTML(
-          note,
-          MarkdownContentType.Email,
-        );
-
-        expect(hrefs(html)).toEqual([
-          `mailto:${address.replace(/'/g, "&#39;")}`,
-        ]);
-        // The address reads as typed, too.
-        expect(html).toContain(`>${address.replace(/'/g, "&#39;")}</a>`);
-      },
-    );
-
-    test.each(REPORTERS)(
-      "in Slack: %s (name %s)",
-      (address: string, reporterName: string | undefined) => {
-        const note: string = getIncidentFormReporterNote({
-          formName: "Report a Problem",
-          reporterName: reporterName,
-          reporterEmail: address,
-        });
-
-        const sections: string = JSON.stringify(
-          SlackUtil.getMarkdownBlocks({
-            payloadMarkdownBlock: {
-              _type: "WorkspacePayloadMarkdown",
-              text: note,
-            },
-          }),
-        );
-
-        expect(sections).toContain(
-          JSON.stringify(`<mailto:${address}|${address}>`).slice(1, -1),
-        );
-      },
-    );
-
-    // Where a mail client sends a mailto: link: its path, nothing after it.
-    function mailtoAddress(href: string): string {
-      const link: URL = new URL(href);
-
-      expect(link.protocol).toBe("mailto:");
-      expect(link.search).toBe("");
-      expect(link.hash).toBe("");
-
-      return decodeURIComponent(link.pathname);
-    }
-
-    // A link as slackify writes it: <address|text>.
-    const SLACK_MAILTO_LINK: RegExp = /<mailto:([^|>]+)\|([^>]+)>/;
-
-    /*
-     * An autolink cannot carry every valid address whole: in a mailto: link
-     * a mail client reads "#" as a fragment, "?" as headers and "%41" as an
-     * escape, so <a%41@example.com> would write to aA@example.com - and one
-     * starting with "!" or "#" would open like a Slack control sequence.
-     * The renderers differ too: marked (the owners' email) drops "^" from
-     * its autolink rule, so <jane^doe@corp.example> linked doe@corp.example,
-     * and micromark (the dashboard, and slackify) takes no "!" in one, so
-     * <first.last!ops@corp.example> linked ops@corp.example. Such an address
-     * is linked explicitly, what a mailto: link may not carry as it is
-     * percent-encoded: it still writes to exactly the address given.
-     */
-    test.each([
-      ["!bang@example.com"],
-      ["#ops@corp.example"],
-      ["a#b@example.com"],
-      ["a?b@example.com"],
-      ["a%41@example.com"],
-      ["jane^doe@corp.example"],
-      ["^jane@corp.example"],
-      ["jane^@corp.example"],
-      ["first.last!ops@corp.example"],
-      ["a/b@example.com"],
-      ["a=b@example.com"],
-      ["a{b}@example.com"],
-      ["a|b@example.com"],
-      ["a`b@example.com"],
-    ])(
-      "links %s to itself, not to what a mail client would make of it",
-      async (address: string) => {
-        const note: string = getIncidentFormReporterNote({
-          formName: "Report a Problem",
-          reporterName: "Jane Doe",
-          reporterEmail: address,
-        });
-
-        expect(note).not.toContain(`<${address}>`);
-
-        const html: string = await Markdown.convertToHTML(
-          note,
-          MarkdownContentType.Email,
-        );
-
-        const links: Array<string> = hrefs(html);
-
-        expect(links).toHaveLength(1);
-        expect(mailtoAddress(links[0]!)).toBe(address);
-        expect(html).toContain(`>${address}</a>`);
-
-        const slack: string = JSON.stringify(
-          SlackUtil.getMarkdownBlocks({
-            payloadMarkdownBlock: {
-              _type: "WorkspacePayloadMarkdown",
-              text: note,
-            },
-          }),
-        );
-
-        const slackLink: RegExpExecArray | null = SLACK_MAILTO_LINK.exec(slack);
-
-        expect(slackLink).not.toBeNull();
-        expect(mailtoAddress(`mailto:${slackLink![1]!}`)).toBe(address);
-        expect(slackLink![2]).toBe(address);
-      },
-    );
-
-    // What a mailto: link may carry as it is (RFC 6068), the rest encoded.
-    const MAILTO_ADDRESS: RegExp =
-      /^(?:[A-Za-z0-9\-._~!$'()*+,;:@]|%[0-9A-F]{2})+$/;
-
-    // The address's link at the end of a note, written either way.
-    const NOTE_EXPLICIT_LINK: RegExp = /\]\((mailto:[^)]*)\)\)\.$/;
-    const NOTE_AUTOLINK: RegExp = /\(<([^>]+)>\)\.$/;
-
-    function withoutEntities(text: string): string {
-      return text
-        .replace(/&lt;/g, "<")
-        .replace(/&gt;/g, ">")
-        .replace(/&quot;/g, '"')
-        .replace(/&#39;/g, "'")
-        .replace(/&amp;/g, "&");
-    }
-
-    /*
-     * Every character an address may hold (WHOLE_EMAIL_ADDRESS), at the
-     * start, inside and at the end of its local part: the owners' email,
-     * Slack and the dashboard each link exactly the address given, and the
-     * note's own mailto: link carries nothing a mail client could read as
-     * anything but the address.
-     */
-    test("links an address holding any character an address may to exactly that address, in every renderer", async () => {
-      const addresses: Array<string> = [];
-
-      for (const character of "!#$%&'*+/=?^_`{|}~-") {
-        addresses.push(
-          `${character}jane@corp.example`,
-          `ja${character}ne@corp.example`,
-          `jane${character}@corp.example`,
-        );
-      }
-
-      const notes: Array<string> = addresses.map((address: string): string => {
-        return getIncidentFormReporterNote({
-          formName: "Report a Problem",
-          reporterName: "Jane Doe",
-          reporterEmail: address,
-        });
-      });
-
-      const dashboard: Array<string> = renderAsDashboard(notes);
-
-      for (const [index, address] of addresses.entries()) {
-        const note: string = notes[index]!;
-
-        const link: string =
-          NOTE_EXPLICIT_LINK.exec(note)?.[1] ||
-          `mailto:${NOTE_AUTOLINK.exec(note)![1]}`;
-
-        expect({ address: address, link: link }).toEqual({
-          address: address,
-          link: expect.stringMatching(/^mailto:/),
-        });
-        expect(link.slice("mailto:".length)).toMatch(MAILTO_ADDRESS);
-
-        const email: Array<string> = hrefsOf(
-          await Markdown.convertToHTML(note, MarkdownContentType.Email),
-        );
-
-        expect({ address: address, email: email.map(mailtoAddress) }).toEqual({
-          address: address,
-          email: [address],
-        });
-
-        expect({
-          address: address,
-          dashboard: hrefsOf(dashboard[index]!).map(mailtoAddress),
-        }).toEqual({ address: address, dashboard: [address] });
-
-        const slack: RegExpExecArray | null = SLACK_MAILTO_LINK.exec(
-          JSON.parse(
-            JSON.stringify(
-              SlackUtil.getMarkdownBlocks({
-                payloadMarkdownBlock: {
-                  _type: "WorkspacePayloadMarkdown",
-                  text: note,
-                },
-              }),
-            ),
-          )[0].text.text as string,
-        );
-
-        expect({
-          address: address,
-          slack: slack
-            ? [
-                mailtoAddress(`mailto:${withoutEntities(slack[1]!)}`),
-                withoutEntities(slack[2]!),
-              ]
-            : null,
-        }).toEqual({ address: address, slack: [address, address] });
-      }
-    });
-
-    test("escapes a value that is not one whole address, rather than linking it", () => {
-      expect(
-        getIncidentFormReporterNote({
-          formName: "Form",
-          reporterEmail: "Jane <jane@example.com>",
-        }),
-      ).toBe(
-        "Reported through the incident form **Form** by Jane \\<jane@example.com\\>.",
-      );
-    });
-  });
-});
-
-describe("IncidentFormService.submitPublicForm - after the incident exists", () => {
-  test("a failure recording the submission is logged, and the note still happens", async () => {
-    submissionCreate.mockRejectedValue(new Error("insert failed"));
-
-    await expect(submit()).resolves.toHaveProperty("incidentNumber", "INC-42");
-    expect(noteCreate).toHaveBeenCalledTimes(1);
-    expect(logger.error).toHaveBeenCalledWith(
-      expect.stringContaining("could not record the submission for incident"),
-      expect.anything(),
-    );
-  });
-
-  test("a failure writing the note is logged, not thrown", async () => {
-    noteCreate.mockRejectedValue(new Error("insert failed"));
-
-    await expect(submit()).resolves.toHaveProperty("incidentNumber", "INC-42");
-    expect(logger.error).toHaveBeenCalledWith(
-      expect.stringContaining("could not add the reporter's private note to"),
-      expect.anything(),
-    );
-  });
-
-  test("everything after the incident failing still answers with its number", async () => {
-    storedForm = withTemplate();
-    submissionCreate.mockRejectedValue(new Error("b"));
-    noteCreate.mockRejectedValue(new Error("c"));
-
-    await expect(submit()).resolves.toEqual({
-      incidentNumber: "INC-42",
-      successMessage: "Thanks - **we are on it**.",
-    });
-  });
-});
-
-describe("IncidentFormService.submitPublicForm - when the incident cannot be declared", () => {
-  test("answers with a message the reporter can act on, logs the reason, and does nothing else", async () => {
-    incidentCreate.mockRejectedValue(
-      new BadDataException(
-        "Created incident state not found for this project. Please add created incident state from settings.",
-      ),
-    );
-
-    const error: Exception | undefined = await refusal(submit());
-
-    expect(error).toBeInstanceOf(ServerException);
-    expect(error?.code).toBe(500);
-    expect(error?.message).toBe(INCIDENT_FORM_SUBMIT_FAILED_MESSAGE);
-    expect(logger.error).toHaveBeenCalled();
-    expect(addOwners).not.toHaveBeenCalled();
-    expect(submissionCreate).not.toHaveBeenCalled();
-    expect(noteCreate).not.toHaveBeenCalled();
-  });
-
-  test("never hands the reporter an internal message or id", async () => {
-    const internalId: string = ObjectID.generate().toString();
-    incidentCreate.mockRejectedValue(
-      new BadDataException(`Incident Severity ${internalId} is not in project`),
-    );
-
-    const error: Exception | undefined = await refusal(submit());
-
-    expect(error?.message).not.toContain(internalId);
-  });
-});
-
-describe("IncidentFormService.submitPublicForm - the answer", () => {
-  test("is the incident's number and the form's success message", async () => {
-    expect(await submit()).toEqual({
-      incidentNumber: "INC-42",
-      successMessage: "Thanks - **we are on it**.",
-    });
-  });
-
-  test("numbers an incident of a project without a prefix with a #", async () => {
-    setNull(createdIncident, "incidentNumberWithPrefix");
-
-    expect((await submit()).incidentNumber).toBe("#42");
-  });
-
-  test("leaves the number out when the incident came back without one", async () => {
-    setNull(createdIncident, "incidentNumberWithPrefix");
-    setNull(createdIncident, "incidentNumber");
-
-    expect(await submit()).not.toHaveProperty("incidentNumber");
-  });
-
-  test.each([
-    ["empty", ""],
-    ["blank", "  \n "],
-    ["unset", null],
-  ])(
-    "leaves out a success message that is %s",
-    async (_label: string, successMessage: string | null) => {
-      storedForm = buildForm();
-      (storedForm as unknown as Record<string, unknown>)["successMessage"] =
-        successMessage;
-
-      expect(await submit()).toEqual({ incidentNumber: "INC-42" });
-    },
-  );
-
-  test("never includes the incident's id, the form's id or its project", async () => {
-    const sent: string = JSON.stringify(await submit());
-
-    expect(sent).not.toContain(INCIDENT_ID);
-    expect(sent).not.toContain(FORM_ID);
-    expect(sent).not.toContain(PROJECT_ID.toString());
-  });
-});
-
-describe("IncidentFormService.submitPublicForm - the checks before anything is declared", () => {
-  test("verifies the captcha, when the instance has one on, with the token and the client address", async () => {
-    captchaEnabled.mockReturnValue(true);
-
-    await submit({ captchaToken: "token-from-hcaptcha" });
-
-    expect(verifyCaptcha).toHaveBeenCalledWith({
-      token: "token-from-hcaptcha",
-      remoteIp: CAPTCHA_IP,
-    });
-  });
-
-  test("does not verify a captcha when the instance has none, even if a token is sent", async () => {
-    await submit({ captchaToken: "token-from-hcaptcha" });
-
-    expect(verifyCaptcha).not.toHaveBeenCalled();
-    expect(incidentCreate).toHaveBeenCalledTimes(1);
-  });
-
-  test("refuses a failed captcha before reading or declaring anything", async () => {
-    captchaEnabled.mockReturnValue(true);
-    storedForm = buildForm({
-      customFieldSettings: FORM_QUESTIONS,
-      allowReporterToChooseSeverity: true,
-    });
-    verifyCaptcha.mockRejectedValue(
-      new BadDataException("Captcha verification failed. Please try again."),
-    );
-
-    const error: Exception | undefined = await refusal(submit());
-
-    expect(error).toBeInstanceOf(BadDataException);
-    expect(error?.message).toBe(
-      "Captcha verification failed. Please try again.",
-    );
-    expect(customFieldFindBy).not.toHaveBeenCalled();
-    expect(severityFindBy).not.toHaveBeenCalled();
-    expect(incidentCreate).not.toHaveBeenCalled();
-  });
-
-  test("checks the captcha before the answers", async () => {
-    captchaEnabled.mockReturnValue(true);
-    verifyCaptcha.mockRejectedValue(
-      new BadDataException(
-        "Captcha token is missing. Please complete the verification challenge.",
-      ),
-    );
-
-    const error: Exception | undefined = await refusal(
-      submit({ answers: { title: "" } }),
-    );
-
-    expect(error?.message).toBe(
-      "Captcha token is missing. Please complete the verification challenge.",
-    );
-  });
-
-  test.each([
-    ["a junk link", { shareKey: "junk" }],
-    ["an unknown link", { shareKey: OTHER_SHARE_KEY }],
-  ])(
-    "refuses %s as not available, without the captcha provider or a create",
-    async (_label: string, change: { shareKey: string }) => {
-      captchaEnabled.mockReturnValue(true);
-
-      const error: Exception | undefined = await refusal(submit(change));
-
-      expect(error).toBeInstanceOf(NotFoundException);
-      expect(error?.message).toBe(INCIDENT_FORM_NOT_AVAILABLE_MESSAGE);
-      expect(verifyCaptcha).not.toHaveBeenCalled();
-      expect(incidentCreate).not.toHaveBeenCalled();
-    },
-  );
-
-  test("refuses a form that is turned off as not available", async () => {
-    storedForm = buildForm({ isEnabled: false });
-
-    const error: Exception | undefined = await refusal(submit());
-
-    expect(error).toBeInstanceOf(NotFoundException);
-    expect(error?.message).toBe(INCIDENT_FORM_NOT_AVAILABLE_MESSAGE);
-    expect(incidentCreate).not.toHaveBeenCalled();
-  });
-
-  test("refuses a form of a project off plan with the same answer as an unknown link", async () => {
-    jest
-      .spyOn(IncidentFormService, "isProjectOnPlan")
-      .mockResolvedValue(false as never);
-
-    const offPlan: Exception | undefined = await refusal(submit());
-    const unknown: Exception | undefined = await refusal(
-      submit({ shareKey: OTHER_SHARE_KEY }),
-    );
-
-    expect(offPlan).toBeInstanceOf(NotFoundException);
-    expect([offPlan?.code, offPlan?.message]).toEqual([
-      unknown?.code,
-      unknown?.message,
-    ]);
-    expect(incidentCreate).not.toHaveBeenCalled();
-  });
-
-  test("refuses a network the form does not allow, before the captcha", async () => {
-    captchaEnabled.mockReturnValue(true);
-    storedForm = buildForm({ ipWhitelist: "198.51.100.0/24" });
-
-    const error: Exception | undefined = await refusal(submit());
-
-    expect(error).toBeInstanceOf(ForbiddenException);
-    expect(error?.message).toBe(INCIDENT_FORM_NETWORK_NOT_ALLOWED_MESSAGE);
-    expect(verifyCaptcha).not.toHaveBeenCalled();
-    expect(incidentCreate).not.toHaveBeenCalled();
-  });
-
-  test("lets an allowed network through to declare", async () => {
-    storedForm = buildForm({ ipWhitelist: `198.51.100.0/24\n${CLIENT_IP}` });
-
-    await submit();
-
-    expect(incidentCreate).toHaveBeenCalledTimes(1);
-  });
-
-  test("refuses a request without an address when the form has an allowlist", async () => {
-    storedForm = buildForm({ ipWhitelist: CLIENT_IP });
-
-    expect(await refusal(submit({ clientIp: undefined }))).toBeInstanceOf(
-      ForbiddenException,
-    );
-  });
-
-  test("looks the form up once, by its share key, as root", async () => {
-    await submit();
-
-    expect(formFindOneBy).toHaveBeenCalledTimes(1);
-
-    const findBy: {
-      query: Record<string, unknown>;
-      props: Record<string, unknown>;
-    } = formFindOneBy.mock.calls[0]![0] as never;
-
-    expect(Object.keys(findBy.query)).toEqual(["shareKey"]);
-    expect(String(findBy.query["shareKey"])).toBe(SHARE_KEY);
-    expect(findBy.props).toEqual({ isRoot: true });
-  });
-});
-
-/*
- * The form's hourly ceiling bounds the incidents - and pages - its link can
- * cause, so only a submission about to declare one may spend it. Were a
- * refused request to count, anyone holding the link - outside the IP
- * allowlist, or unable to solve the captcha - could use it up and lock the
- * form for everybody.
- */
-describe("IncidentFormService.submitPublicForm - the form's hourly ceiling", () => {
-  test("is spent once, for the form's link, after every check and right before the incident is declared", async () => {
-    await submit();
-
-    expect(reserveFormSubmission).toHaveBeenCalledTimes(1);
-    expect(reserveFormSubmission).toHaveBeenCalledWith({ shareKey: SHARE_KEY });
-    expect(reserveFormSubmission.mock.invocationCallOrder[0]!).toBeLessThan(
-      incidentCreate.mock.invocationCallOrder[0]!,
-    );
-  });
-
-  test.each([
-    [
-      "a link no form holds",
-      (): void => {
-        storedForm = null;
-      },
-      VALID_ANSWERS,
-    ],
-    [
-      "a form that is turned off",
-      (): void => {
-        storedForm = buildForm({ isEnabled: false });
-      },
-      VALID_ANSWERS,
-    ],
-    [
-      "a project off plan",
-      (): void => {
-        jest
-          .spyOn(IncidentFormService, "isProjectOnPlan")
-          .mockResolvedValue(false as never);
-      },
-      VALID_ANSWERS,
-    ],
-    [
-      "a network the form does not allow",
-      (): void => {
-        storedForm = buildForm({ ipWhitelist: "198.51.100.0/24" });
-      },
-      VALID_ANSWERS,
-    ],
-    [
-      "a failed captcha",
-      (): void => {
-        captchaEnabled.mockReturnValue(true);
-        verifyCaptcha.mockRejectedValue(
-          new BadDataException(
-            "Captcha verification failed. Please try again.",
-          ),
-        );
-      },
-      VALID_ANSWERS,
-    ],
-    [
-      "answers that do not pass",
-      (): void => {
-        // The answers below have no title.
-      },
-      { ...VALID_ANSWERS, title: "" },
-    ],
-    [
-      "no severity left",
-      (): void => {
-        storedForm = buildForm();
-        setNull(storedForm, "incidentSeverityId");
-      },
-      VALID_ANSWERS,
-    ],
-  ])(
-    "is never spent by a submission refused for %s",
-    async (_label: string, arrange: () => void, answers: JSONObject) => {
-      arrange();
-
-      const error: Exception | undefined = await refusal(submit({ answers }));
-
-      expect(error).toBeDefined();
-      expect(reserveFormSubmission).not.toHaveBeenCalled();
-      expect(incidentCreate).not.toHaveBeenCalled();
-    },
-  );
-
-  test("once the hour's allowance is used, nothing is declared and the refusal says when to come back", async () => {
-    storedForm = withTemplate();
-    reserveFormSubmission.mockRejectedValue(
-      new IncidentFormCeilingException(1800),
-    );
-
-    const error: Exception | undefined = await refusal(submit());
-
-    expect(error).toBeInstanceOf(IncidentFormCeilingException);
-    expect(error?.code).toBe(429);
-    expect(error?.message).toBe(INCIDENT_FORM_TOTAL_RATE_LIMIT_MESSAGE);
-    expect((error as IncidentFormCeilingException).retryAfterSeconds).toBe(
-      1800,
-    );
-    expect(incidentCreate).not.toHaveBeenCalled();
-    expect(ownerUserFindBy).not.toHaveBeenCalled();
-    expect(submissionCreate).not.toHaveBeenCalled();
-    expect(noteCreate).not.toHaveBeenCalled();
-  });
-
-  test("when the ceiling cannot be counted, nothing is declared (503)", async () => {
-    reserveFormSubmission.mockRejectedValue(
-      new ServiceUnavailableException(
-        INCIDENT_FORM_RATE_LIMIT_UNAVAILABLE_MESSAGE,
-      ),
-    );
-
-    const error: Exception | undefined = await refusal(submit());
-
-    expect(error?.code).toBe(503);
-    expect(error?.message).toBe(INCIDENT_FORM_RATE_LIMIT_UNAVAILABLE_MESSAGE);
-    expect(incidentCreate).not.toHaveBeenCalled();
-  });
-});
-
-/*
- * Making the description and the Rich text answers safe to show is the one
- * step whose cost grows with the Markdown in them, and it cannot refuse a
- * submission. So it is the last step before the incident is declared: a
- * submission refused on the way - for its title, its severity or the
- * form's ceiling - never pays for it, and every one that does is bounded by
- * that ceiling.
- */
-describe("IncidentFormService.submitPublicForm - reading the reporter's Markdown", () => {
-  const WITH_AN_IMAGE: JSONObject = {
-    ...VALID_ANSWERS,
-    description: "Broken: ![x](https://tracker.example/p.png)",
-  };
-
-  test("happens once the form's ceiling is spent, before the incident is declared", async () => {
-    const lex: ReturnType<typeof jest.spyOn> = jest.spyOn(
-      Lexer.prototype,
-      "lex",
-    );
-
-    await submit({ answers: WITH_AN_IMAGE });
-
-    expect(lex).toHaveBeenCalled();
-    expect(reserveFormSubmission.mock.invocationCallOrder[0]!).toBeLessThan(
-      lex.mock.invocationCallOrder[0]!,
-    );
-    expect(lex.mock.invocationCallOrder[0]!).toBeLessThan(
-      incidentCreate.mock.invocationCallOrder[0]!,
-    );
-    expect(createCall().data.description).toBe(
-      "Broken: \\![x](https://tracker.example/p.png)",
-    );
-  });
-
-  test.each([
-    [
-      "a title that no longer fits",
-      (): void => {
-        // The answers below have the title.
-      },
-      { ...WITH_AN_IMAGE, title: "<!".repeat(250) },
-    ],
-    [
-      "no severity left",
-      (): void => {
-        storedForm = buildForm();
-        setNull(storedForm, "incidentSeverityId");
-      },
-      WITH_AN_IMAGE,
-    ],
-    [
-      "the form's ceiling",
-      (): void => {
-        reserveFormSubmission.mockRejectedValue(
-          new IncidentFormCeilingException(1800),
-        );
-      },
-      WITH_AN_IMAGE,
-    ],
-  ])(
-    "never happens for a submission refused for %s",
-    async (_label: string, arrange: () => void, answers: JSONObject) => {
-      arrange();
-
-      const lex: ReturnType<typeof jest.spyOn> = jest.spyOn(
-        Lexer.prototype,
-        "lex",
-      );
-
-      const error: Exception | undefined = await refusal(submit({ answers }));
-
-      expect(error).toBeDefined();
-      expect(lex).not.toHaveBeenCalled();
-      expect(incidentCreate).not.toHaveBeenCalled();
-    },
-  );
-});