@oneuptime/common 14.0.10 → 14.0.11

package/Tests/Types/Incident/IncidentFormPublic.test.ts

@@ -0,0 +1,1916 @@
+import Incident from "../../../Models/DatabaseModels/Incident";
+import IncidentCustomField from "../../../Models/DatabaseModels/IncidentCustomField";
+import { getIncidentFormAskedDefinitions } from "../../../Types/CustomField/CustomFieldCreateSettings";
+import CustomFieldType from "../../../Types/CustomField/CustomFieldType";
+import {
+  DEFAULT_INCIDENT_FORM_DESCRIPTION_SETTING,
+  INCIDENT_FORM_CUSTOM_FIELD_TEXT_MAX_LENGTH,
+  INCIDENT_FORM_DESCRIPTION_MAX_LENGTH,
+  INCIDENT_FORM_FIELD_SETTINGS,
+  INCIDENT_FORM_MULTI_SELECT_MAX_CHOICES,
+  INCIDENT_FORM_QUESTION_LABELS,
+  INCIDENT_FORM_REPORTER_EMAIL_MAX_LENGTH,
+  INCIDENT_FORM_REPORTER_NAME_MAX_LENGTH,
+  INCIDENT_FORM_TITLE_MAX_LENGTH,
+  IncidentFormAskedDefinition,
+  IncidentFormFieldSetting,
+  IncidentFormSubmissionRules,
+  IncidentFormSubmissionValidationResult,
+  PublicIncidentForm,
+  PublicIncidentFormField,
+  PublicIncidentFormSeverity,
+  PublicIncidentFormSource,
+  ValidatedIncidentFormSubmission,
+  formatIncidentFormSubmissionErrors,
+  getPublicIncidentForm,
+  getPublicIncidentFormFields,
+  isIncidentFormFieldSetting,
+  validateIncidentFormSubmission,
+} from "../../../Types/Incident/IncidentFormPublic";
+import { JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import { CUSTOM_FIELD_MUST_BE_CHECKED_MESSAGE } from "../../../UI/Components/CustomFields/CustomFieldFormFields";
+import { describe, expect, test } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+import { getMetadataArgsStorage } from "typeorm";
+import type { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
+
+/*
+ * The public half of incident forms: what a stranger's browser is told about
+ * a form, and the rules a stranger's submission is held to before an
+ * incident is declared from it.
+ *
+ * Everything here is a boundary the server relies on. The incident is built
+ * only from validateIncidentFormSubmission's value, so what matters most is
+ * what can NOT get through it: answers to fields the form does not ask,
+ * anything that is not an answer (a projectId, a state, isPrivate), text
+ * longer than its column, and a severity the form does not offer.
+ */
+
+const SEVERITY_HIGH: string = "0a0a0a0a-0000-4000-8000-000000000001";
+const SEVERITY_LOW: string = "0a0a0a0a-0000-4000-8000-000000000002";
+
+const SEVERITIES: Array<PublicIncidentFormSeverity> = [
+  { _id: SEVERITY_HIGH, name: "High", color: "#ff0000" },
+  { _id: SEVERITY_LOW, name: "Low" },
+];
+
+// The rules of a form that asks for nothing optional beyond the defaults.
+const DEFAULT_RULES: IncidentFormSubmissionRules = {
+  descriptionSetting: IncidentFormFieldSetting.Optional,
+  isReporterDetailsRequired: true,
+  allowReporterToChooseSeverity: false,
+};
+
+// The fields a form might ask for, as getIncidentFormAskedDefinitions hands them.
+const ASKED: Array<IncidentFormAskedDefinition> = [
+  {
+    name: "Impact",
+    customFieldType: CustomFieldType.Text,
+    isRequiredOnCreate: true,
+  },
+  {
+    name: "Steps to Reproduce",
+    customFieldType: CustomFieldType.LongText,
+    isRequiredOnCreate: false,
+  },
+  {
+    name: "Notes",
+    customFieldType: CustomFieldType.Markdown,
+    isRequiredOnCreate: false,
+  },
+  {
+    name: "Users Affected",
+    customFieldType: CustomFieldType.Number,
+    isRequiredOnCreate: false,
+  },
+  {
+    name: "I Have Checked The Status Page",
+    customFieldType: CustomFieldType.Boolean,
+    isRequiredOnCreate: true,
+  },
+  {
+    name: "Customer Facing",
+    customFieldType: CustomFieldType.Boolean,
+    isRequiredOnCreate: false,
+  },
+  {
+    name: "Region",
+    customFieldType: CustomFieldType.Dropdown,
+    dropdownOptions: "EU\nUS",
+    isRequiredOnCreate: false,
+  },
+  {
+    name: "Systems",
+    customFieldType: CustomFieldType.MultiSelectDropdown,
+    dropdownOptions: '[{"value":"API","color":"#112233"},{"value":"Web"}]',
+    isRequiredOnCreate: false,
+  },
+  {
+    name: "Noticed On",
+    customFieldType: CustomFieldType.Date,
+    isRequiredOnCreate: false,
+  },
+  {
+    name: "Noticed At",
+    customFieldType: CustomFieldType.DateTime,
+    isRequiredOnCreate: false,
+  },
+  {
+    name: "Untyped",
+    customFieldType: undefined,
+    isRequiredOnCreate: false,
+  },
+];
+
+// The answers every required question needs.
+const REQUIRED_ANSWERS: JSONObject = {
+  Impact: "Checkout is down",
+  "I Have Checked The Status Page": true,
+};
+
+type SubmissionFunction = (overrides?: JSONObject) => JSONObject;
+
+const submission: SubmissionFunction = (
+  overrides: JSONObject = {},
+): JSONObject => {
+  return {
+    title: "Checkout fails",
+    reporterName: "Jane Doe",
+    reporterEmail: "jane@example.com",
+    customFields: { ...REQUIRED_ANSWERS },
+    ...overrides,
+  };
+};
+
+type ValidateFunction = (
+  data: unknown,
+  options?: {
+    form?: IncidentFormSubmissionRules;
+    askedDefinitions?: Array<IncidentFormAskedDefinition>;
+    severities?: Array<{ _id: string }>;
+  },
+) => IncidentFormSubmissionValidationResult;
+
+const validate: ValidateFunction = (
+  data: unknown,
+  options: {
+    form?: IncidentFormSubmissionRules;
+    askedDefinitions?: Array<IncidentFormAskedDefinition>;
+    severities?: Array<{ _id: string }>;
+  } = {},
+): IncidentFormSubmissionValidationResult => {
+  return validateIncidentFormSubmission({
+    form: options.form || DEFAULT_RULES,
+    askedDefinitions: options.askedDefinitions || ASKED,
+    severities: options.severities || SEVERITIES,
+    data: data,
+  });
+};
+
+type ErrorsOfFunction = (
+  result: IncidentFormSubmissionValidationResult,
+) => Array<string>;
+
+const errorsOf: ErrorsOfFunction = (
+  result: IncidentFormSubmissionValidationResult,
+): Array<string> => {
+  if (result.isValid) {
+    throw new Error(
+      `Expected the submission to be refused, but it passed: ${JSON.stringify(
+        result.value,
+      )}`,
+    );
+  }
+
+  return result.errors;
+};
+
+type ValueOfFunction = (
+  result: IncidentFormSubmissionValidationResult,
+) => ValidatedIncidentFormSubmission;
+
+const valueOf: ValueOfFunction = (
+  result: IncidentFormSubmissionValidationResult,
+): ValidatedIncidentFormSubmission => {
+  if (!result.isValid) {
+    throw new Error(
+      `Expected the submission to pass, but it was refused: ${result.errors.join(
+        " | ",
+      )}`,
+    );
+  }
+
+  return result.value;
+};
+
+type ColumnLengthFunction = (
+  target: unknown,
+  propertyName: string,
+) => number | undefined;
+
+// The length TypeORM creates a varchar column with.
+const columnLength: ColumnLengthFunction = (
+  target: unknown,
+  propertyName: string,
+): number | undefined => {
+  const column: ColumnMetadataArgs | undefined =
+    getMetadataArgsStorage().columns.find(
+      (candidate: ColumnMetadataArgs): boolean => {
+        return (
+          candidate.target === target && candidate.propertyName === propertyName
+        );
+      },
+    );
+
+  const length: string | number | undefined = column?.options.length;
+
+  return length === undefined ? undefined : Number(length);
+};
+
+type DeepFreezeFunction = <T>(value: T) => T;
+
+const deepFreeze: DeepFreezeFunction = <T>(value: T): T => {
+  if (value && typeof value === "object") {
+    for (const child of Object.values(
+      value as unknown as Record<string, unknown>,
+    )) {
+      deepFreeze(child);
+    }
+
+    Object.freeze(value);
+  }
+
+  return value;
+};
+
+describe("IncidentFormFieldSetting", () => {
+  test("stores the three settings under these exact strings", () => {
+    expect(IncidentFormFieldSetting.Required).toBe("Required");
+    expect(IncidentFormFieldSetting.Optional).toBe("Optional");
+    expect(IncidentFormFieldSetting.Hidden).toBe("Hidden");
+    expect(INCIDENT_FORM_FIELD_SETTINGS).toEqual([
+      IncidentFormFieldSetting.Required,
+      IncidentFormFieldSetting.Optional,
+      IncidentFormFieldSetting.Hidden,
+    ]);
+  });
+
+  /*
+   * IncidentFormModel.test.ts pins that the IncidentForm column defaults to
+   * the same value.
+   */
+  test("a form asks for an optional description unless told otherwise", () => {
+    expect(DEFAULT_INCIDENT_FORM_DESCRIPTION_SETTING).toBe(
+      IncidentFormFieldSetting.Optional,
+    );
+  });
+
+  test.each(["Required", "Optional", "Hidden"])(
+    "%s is a setting",
+    (value: string) => {
+      expect(isIncidentFormFieldSetting(value)).toBe(true);
+    },
+  );
+
+  test.each([
+    ["Default"],
+    ["required"],
+    ["OPTIONAL"],
+    [" Hidden"],
+    [""],
+    [null],
+    [undefined],
+    [1],
+    [{}],
+  ])("%j is not a setting", (value: unknown) => {
+    expect(isIncidentFormFieldSetting(value)).toBe(false);
+  });
+});
+
+describe("the size caps fit the columns the answers land in", () => {
+  test("a title is at most as long as Incident.title", () => {
+    expect(INCIDENT_FORM_TITLE_MAX_LENGTH).toBe(500);
+    expect(columnLength(Incident, "title")).toBe(
+      INCIDENT_FORM_TITLE_MAX_LENGTH,
+    );
+  });
+
+  /*
+   * IncidentFormModel.test.ts pins the IncidentFormSubmission columns to the
+   * same lengths.
+   */
+  test("the reporter's name and email are capped at 100", () => {
+    expect(INCIDENT_FORM_REPORTER_NAME_MAX_LENGTH).toBe(100);
+    expect(INCIDENT_FORM_REPORTER_EMAIL_MAX_LENGTH).toBe(100);
+  });
+
+  test("the description and custom field text caps", () => {
+    expect(INCIDENT_FORM_DESCRIPTION_MAX_LENGTH).toBe(20000);
+    expect(INCIDENT_FORM_CUSTOM_FIELD_TEXT_MAX_LENGTH).toBe(10000);
+  });
+});
+
+describe("the question labels", () => {
+  test("are the public page's field titles", () => {
+    expect(INCIDENT_FORM_QUESTION_LABELS).toEqual({
+      title: "Title",
+      description: "Description",
+      severity: "Severity",
+      reporterName: "Your Name",
+      reporterEmail: "Your Email",
+    });
+  });
+
+  test("errors are worded as the browser's own checks word them", () => {
+    const validationSource: string = fs.readFileSync(
+      path.join(__dirname, "../../../UI/Components/Forms/Validation.ts"),
+      "utf8",
+    );
+
+    // The templates the server fills in, straight from the form's checks.
+    expect(validationSource).toContain('"{{field}} is required."');
+    expect(validationSource).toContain(
+      '"{{field}} cannot be more than {{maxLength}} characters."',
+    );
+
+    expect(errorsOf(validate(submission({ title: "" })))).toEqual([
+      "Title is required.",
+    ]);
+    expect(
+      errorsOf(
+        validate(
+          submission({ title: "x".repeat(INCIDENT_FORM_TITLE_MAX_LENGTH + 1) }),
+        ),
+      ),
+    ).toEqual(["Title cannot be more than 500 characters."]);
+  });
+
+  test("a required yes/no answered no reads as the dashboard's must-be-checked message", () => {
+    const name: string = "I Have Checked The Status Page";
+
+    expect(
+      errorsOf(
+        validate(
+          submission({
+            customFields: { ...REQUIRED_ANSWERS, [name]: false },
+          }),
+        ),
+      ),
+    ).toEqual([
+      CUSTOM_FIELD_MUST_BE_CHECKED_MESSAGE.replace("{{field}}", name),
+    ]);
+  });
+});
+
+describe("getPublicIncidentFormFields: what the page is told about each question", () => {
+  test("names, types, help text and whether it is required - nothing else", () => {
+    expect(
+      getPublicIncidentFormFields([
+        {
+          name: "Impact",
+          description: "How bad is it?",
+          customFieldType: CustomFieldType.Text,
+          isRequiredOnCreate: true,
+        },
+        {
+          name: "Region",
+          customFieldType: CustomFieldType.Dropdown,
+          dropdownOptions: "EU\nUS",
+          isRequiredOnCreate: false,
+        },
+      ]),
+    ).toEqual([
+      {
+        name: "Impact",
+        description: "How bad is it?",
+        customFieldType: CustomFieldType.Text,
+        isRequired: true,
+      },
+      {
+        name: "Region",
+        customFieldType: CustomFieldType.Dropdown,
+        dropdownOptions: "EU\nUS",
+        isRequired: false,
+      },
+    ]);
+  });
+
+  test("an IncidentCustomField row can be passed as it is, and none of its other columns leak", () => {
+    const row: IncidentCustomField = new IncidentCustomField();
+    row._id = "0b0b0b0b-0000-4000-8000-000000000001";
+    row.projectId = ObjectID.generate();
+    row.name = "Region";
+    row.description = "Where it happened";
+    row.customFieldType = CustomFieldType.MultiSelectDropdown;
+    row.dropdownOptions = "EU\nUS";
+    row.variableKey = "region";
+    row.sortOrder = 2;
+    row.showOnCreate = false;
+    row.isRequiredOnCreate = true;
+    row.includeInSubscriberNotifications = true;
+
+    const [field] = getPublicIncidentFormFields(
+      getIncidentFormAskedDefinitions([row], { region: "Required" }),
+    );
+
+    expect(field).toEqual({
+      name: "Region",
+      description: "Where it happened",
+      customFieldType: CustomFieldType.MultiSelectDropdown,
+      dropdownOptions: "EU\nUS",
+      isRequired: true,
+    });
+    expect(Object.keys(field!).sort()).toEqual(
+      [
+        "customFieldType",
+        "description",
+        "dropdownOptions",
+        "isRequired",
+        "name",
+      ].sort(),
+    );
+  });
+
+  test("a dropdown's options are only sent for a dropdown", () => {
+    const [text] = getPublicIncidentFormFields([
+      {
+        name: "Once A Dropdown",
+        customFieldType: CustomFieldType.Text,
+        dropdownOptions: "Secret option\nAnother",
+      },
+    ]);
+
+    expect(text).not.toHaveProperty("dropdownOptions");
+  });
+
+  test.each([[undefined], [null], ["Colour"], [""]])(
+    "a field whose type is %j is asked as Text",
+    (customFieldType: string | null | undefined) => {
+      expect(
+        getPublicIncidentFormFields([{ name: "Odd", customFieldType }])[0]!
+          .customFieldType,
+      ).toBe(CustomFieldType.Text);
+    },
+  );
+
+  test("blank help text and blank options are left out", () => {
+    const [field] = getPublicIncidentFormFields([
+      {
+        name: "Region",
+        description: "   ",
+        customFieldType: CustomFieldType.Dropdown,
+        dropdownOptions: " \n ",
+      },
+    ]);
+
+    expect(field).toEqual({
+      name: "Region",
+      customFieldType: CustomFieldType.Dropdown,
+      isRequired: false,
+    });
+  });
+
+  test("a field without a name is left out, and so is a second field with the same name", () => {
+    expect(
+      getPublicIncidentFormFields([
+        { name: "", customFieldType: CustomFieldType.Text },
+        { name: null, customFieldType: CustomFieldType.Text },
+        { customFieldType: CustomFieldType.Text },
+        {
+          name: "Impact",
+          customFieldType: CustomFieldType.Text,
+          isRequiredOnCreate: true,
+        },
+        {
+          name: "Impact",
+          customFieldType: CustomFieldType.Number,
+          isRequiredOnCreate: false,
+        },
+      ]),
+    ).toEqual([
+      {
+        name: "Impact",
+        customFieldType: CustomFieldType.Text,
+        isRequired: true,
+      },
+    ]);
+  });
+
+  test("keeps the order it is given", () => {
+    expect(
+      getPublicIncidentFormFields([
+        { name: "B" },
+        { name: "A" },
+        { name: "C" },
+      ]).map((field: PublicIncidentFormField): string => {
+        return field.name;
+      }),
+    ).toEqual(["B", "A", "C"]);
+  });
+
+  test("nothing asked, nothing shown", () => {
+    expect(getPublicIncidentFormFields([])).toEqual([]);
+  });
+});
+
+describe("getPublicIncidentForm: what the page is told about the form", () => {
+  type StoredForm = PublicIncidentFormSource & Record<string, unknown>;
+
+  type StoredFormFunction = () => StoredForm;
+
+  const SHARE_KEY: string = "0d0d0d0d-0000-4000-8000-000000000001";
+
+  /*
+   * A form with every column set, as the submit route would load it.
+   * IncidentFormModel.test.ts passes a real IncidentForm row the same way.
+   */
+  const storedForm: StoredFormFunction = (): StoredForm => {
+    return {
+      _id: "0c0c0c0c-0000-4000-8000-000000000001",
+      projectId: ObjectID.generate(),
+      name: "Report a Security Concern",
+      description: "Tell us what you saw.",
+      isEnabled: true,
+      shareKey: new ObjectID(SHARE_KEY),
+      incidentSeverityId: new ObjectID(SEVERITY_LOW.toUpperCase()),
+      allowReporterToChooseSeverity: true,
+      incidentTemplateId: ObjectID.generate(),
+      descriptionSetting: IncidentFormFieldSetting.Required,
+      customFieldSettings: { impact: "Required" },
+      isReporterDetailsRequired: false,
+      successMessage: "Thanks!",
+      ipWhitelist: "10.0.0.0/8",
+      createdByUserId: ObjectID.generate(),
+    };
+  };
+
+  test("a stored form can be passed as it is, and only the public subset comes out", () => {
+    const publicForm: PublicIncidentForm = getPublicIncidentForm({
+      form: storedForm(),
+      askedDefinitions: [
+        {
+          name: "Impact",
+          customFieldType: CustomFieldType.Text,
+          isRequiredOnCreate: true,
+        },
+      ],
+      severities: SEVERITIES,
+      isCaptchaRequired: true,
+    });
+
+    expect(publicForm).toEqual({
+      name: "Report a Security Concern",
+      description: "Tell us what you saw.",
+      descriptionSetting: IncidentFormFieldSetting.Required,
+      isReporterDetailsRequired: false,
+      severities: [
+        { _id: SEVERITY_HIGH, name: "High", color: "#ff0000" },
+        { _id: SEVERITY_LOW, name: "Low" },
+      ],
+      defaultIncidentSeverityId: SEVERITY_LOW,
+      customFields: [
+        {
+          name: "Impact",
+          customFieldType: CustomFieldType.Text,
+          isRequired: true,
+        },
+      ],
+      isCaptchaRequired: true,
+    });
+
+    // The link key, the project, the template and the allowlist stay home.
+    const serialized: string = JSON.stringify(publicForm);
+
+    for (const secret of [
+      SHARE_KEY,
+      "10.0.0.0/8",
+      "Thanks!",
+      "projectId",
+      "shareKey",
+      "incidentTemplateId",
+      "ipWhitelist",
+      "customFieldSettings",
+    ]) {
+      expect(serialized).not.toContain(secret);
+    }
+  });
+
+  test("the severities are only listed when the reporter may choose one", () => {
+    const form: StoredForm = storedForm();
+    form.allowReporterToChooseSeverity = false;
+
+    const publicForm: PublicIncidentForm = getPublicIncidentForm({
+      form: form,
+      askedDefinitions: [],
+      severities: SEVERITIES,
+      isCaptchaRequired: false,
+    });
+
+    expect(publicForm).not.toHaveProperty("severities");
+    expect(publicForm).not.toHaveProperty("defaultIncidentSeverityId");
+  });
+
+  test("the form's own severity is only preselected when it is one of those listed", () => {
+    const form: StoredForm = storedForm();
+    form.incidentSeverityId = ObjectID.generate();
+
+    const publicForm: PublicIncidentForm = getPublicIncidentForm({
+      form: form,
+      askedDefinitions: [],
+      severities: SEVERITIES,
+      isCaptchaRequired: false,
+    });
+
+    expect(publicForm.severities).toHaveLength(2);
+    expect(publicForm).not.toHaveProperty("defaultIncidentSeverityId");
+
+    delete form.incidentSeverityId;
+
+    expect(
+      getPublicIncidentForm({
+        form: form,
+        askedDefinitions: [],
+        severities: SEVERITIES,
+        isCaptchaRequired: false,
+      }),
+    ).not.toHaveProperty("defaultIncidentSeverityId");
+  });
+
+  test("only the three properties of each severity are listed, and a severity with no id is not", () => {
+    const publicForm: PublicIncidentForm = getPublicIncidentForm({
+      form: { allowReporterToChooseSeverity: true },
+      askedDefinitions: [],
+      severities: [
+        {
+          _id: SEVERITY_HIGH,
+          name: "High",
+          projectId: "somewhere",
+          order: 1,
+        } as unknown as PublicIncidentFormSeverity,
+        { _id: "", name: "No Id" },
+      ],
+      isCaptchaRequired: false,
+    });
+
+    expect(publicForm.severities).toEqual([
+      { _id: SEVERITY_HIGH, name: "High" },
+    ]);
+  });
+
+  test("defaults for a form read without its settings", () => {
+    expect(
+      getPublicIncidentForm({
+        form: {},
+        askedDefinitions: [],
+        severities: SEVERITIES,
+        isCaptchaRequired: false,
+      }),
+    ).toEqual({
+      name: "",
+      descriptionSetting: IncidentFormFieldSetting.Optional,
+      isReporterDetailsRequired: true,
+      customFields: [],
+      isCaptchaRequired: false,
+    });
+  });
+
+  test("a description of only whitespace is not sent, and an unknown description setting reads as Optional", () => {
+    expect(
+      getPublicIncidentForm({
+        form: { description: "  \n ", descriptionSetting: "Mandatory" },
+        askedDefinitions: [],
+        severities: [],
+        isCaptchaRequired: false,
+      }),
+    ).toEqual({
+      name: "",
+      descriptionSetting: IncidentFormFieldSetting.Optional,
+      isReporterDetailsRequired: true,
+      customFields: [],
+      isCaptchaRequired: false,
+    });
+  });
+});
+
+describe("validateIncidentFormSubmission: the shape of the request", () => {
+  test.each([
+    ["null", null],
+    ["undefined", undefined],
+    ["a string", "title=Down"],
+    ["an array", [{ title: "Down" }]],
+    ["a number", 5],
+  ])("refuses %s", (_label: string, data: unknown) => {
+    expect(errorsOf(validate(data))).toEqual([
+      "The submission must be an object holding the form's answers.",
+    ]);
+  });
+
+  test("a complete submission passes, cleaned", () => {
+    expect(valueOf(validate(submission()))).toEqual({
+      title: "Checkout fails",
+      reporterName: "Jane Doe",
+      reporterEmail: "jane@example.com",
+      customFields: {
+        Impact: "Checkout is down",
+        "I Have Checked The Status Page": true,
+      },
+    });
+  });
+
+  test("nothing but the answers gets through: a projectId, a state or a privacy flag is dropped", () => {
+    const value: ValidatedIncidentFormSubmission = valueOf(
+      validate(
+        submission({
+          projectId: ObjectID.generate().toString(),
+          currentIncidentStateId: ObjectID.generate().toString(),
+          createdIncidentTemplateId: ObjectID.generate().toString(),
+          isPrivate: true,
+          isVisibleOnStatusPage: true,
+          createdByUserId: ObjectID.generate().toString(),
+          _id: ObjectID.generate().toString(),
+          monitors: [ObjectID.generate().toString()],
+        }),
+      ),
+    );
+
+    expect(Object.keys(value).sort()).toEqual(
+      ["customFields", "reporterEmail", "reporterName", "title"].sort(),
+    );
+  });
+
+  test("every problem is reported at once, in the order of the form", () => {
+    expect(
+      errorsOf(
+        validate({
+          title: "",
+          reporterName: "",
+          reporterEmail: "not an email",
+          customFields: {},
+        }),
+      ),
+    ).toEqual([
+      "Title is required.",
+      "Your Name is required.",
+      "Your Email is not a valid email address.",
+      "Impact is required.",
+      "I Have Checked The Status Page must be checked.",
+    ]);
+  });
+
+  test("never changes the request it is given", () => {
+    const data: JSONObject = deepFreeze(
+      submission({
+        title: "  Checkout fails  ",
+        customFields: {
+          ...REQUIRED_ANSWERS,
+          Systems: ["API", "API", " Web "],
+        },
+      }),
+    );
+
+    expect(valueOf(validate(data)).customFields["Systems"]).toEqual([
+      "API",
+      "Web",
+    ]);
+    expect(data["title"]).toBe("  Checkout fails  ");
+  });
+
+  test("missing settings and lists are read as their defaults", () => {
+    const result: IncidentFormSubmissionValidationResult =
+      validateIncidentFormSubmission({
+        form: undefined as unknown as IncidentFormSubmissionRules,
+        askedDefinitions:
+          undefined as unknown as Array<IncidentFormAskedDefinition>,
+        severities: undefined as unknown as Array<{ _id: string }>,
+        data: { title: "Down", incidentSeverityId: SEVERITY_HIGH },
+      });
+
+    // Reporter details are required by default; nothing else is asked.
+    expect(errorsOf(result)).toEqual([
+      "Your Name is required.",
+      "Your Email is required.",
+    ]);
+  });
+});
+
+describe("validateIncidentFormSubmission: the title", () => {
+  test.each([
+    ["missing", undefined],
+    ["null", null],
+    ["empty", ""],
+    ["only spaces", "    "],
+    ["only line breaks and tabs", "\n\t\r\n"],
+  ])("is required: %s is refused", (_label: string, title: unknown) => {
+    const data: JSONObject = submission();
+
+    if (title === undefined) {
+      delete data["title"];
+    } else {
+      data["title"] = title as JSONObject[string];
+    }
+
+    expect(errorsOf(validate(data))).toEqual(["Title is required."]);
+  });
+
+  test.each([[5], [true], [{ text: "Down" }], [["Down"]]])(
+    "must be text: %j is refused once, not also as missing",
+    (title: unknown) => {
+      expect(
+        errorsOf(validate(submission({ title: title as JSONObject[string] }))),
+      ).toEqual(["Title must be text."]);
+    },
+  );
+
+  test("is trimmed, and its line breaks, tabs and control characters become single spaces", () => {
+    expect(
+      valueOf(
+        validate(
+          submission({ title: "  Checkout\n\n down\tin\u0000EU\u007f " }),
+        ),
+      ).title,
+    ).toBe("Checkout down in EU");
+    expect(
+      valueOf(validate(submission({ title: "Checkout    down" }))).title,
+    ).toBe("Checkout down");
+  });
+
+  test("keeps characters that are not control characters, non-breaking spaces and emoji included", () => {
+    expect(
+      valueOf(validate(submission({ title: "Café down 🔥 (EU)" }))).title,
+    ).toBe("Café down 🔥 (EU)");
+  });
+
+  test("may be exactly 500 characters, measured after trimming", () => {
+    const longest: string = "x".repeat(INCIDENT_FORM_TITLE_MAX_LENGTH);
+
+    expect(
+      valueOf(validate(submission({ title: `  ${longest}  ` }))).title,
+    ).toBe(longest);
+  });
+
+  test("may not be 501", () => {
+    expect(
+      errorsOf(
+        validate(
+          submission({ title: "x".repeat(INCIDENT_FORM_TITLE_MAX_LENGTH + 1) }),
+        ),
+      ),
+    ).toEqual(["Title cannot be more than 500 characters."]);
+  });
+});
+
+describe("validateIncidentFormSubmission: the description", () => {
+  type RulesFunction = (
+    setting: IncidentFormFieldSetting | string | undefined,
+  ) => IncidentFormSubmissionRules;
+
+  const rules: RulesFunction = (
+    setting: IncidentFormFieldSetting | string | undefined,
+  ): IncidentFormSubmissionRules => {
+    return { ...DEFAULT_RULES, descriptionSetting: setting };
+  };
+
+  test("an optional description may be left out, or left empty", () => {
+    for (const description of [undefined, null, "", "   ", "\n\n  \n"]) {
+      const data: JSONObject = submission();
+
+      if (description !== undefined) {
+        data["description"] = description;
+      }
+
+      expect(
+        valueOf(
+          validate(data, { form: rules(IncidentFormFieldSetting.Optional) }),
+        ),
+      ).not.toHaveProperty("description");
+    }
+  });
+
+  test("a required description may not", () => {
+    for (const description of [undefined, "", "  \n  "]) {
+      const data: JSONObject = submission();
+
+      if (description !== undefined) {
+        data["description"] = description;
+      }
+
+      expect(
+        errorsOf(
+          validate(data, { form: rules(IncidentFormFieldSetting.Required) }),
+        ),
+      ).toEqual(["Description is required."]);
+    }
+  });
+
+  test("a hidden description is not even read: whatever is sent is dropped", () => {
+    for (const description of [
+      "Sneaked in",
+      5,
+      { nested: true },
+      "x".repeat(INCIDENT_FORM_DESCRIPTION_MAX_LENGTH + 100),
+    ]) {
+      expect(
+        valueOf(
+          validate(
+            submission({ description: description as JSONObject[string] }),
+            { form: rules(IncidentFormFieldSetting.Hidden) },
+          ),
+        ),
+      ).not.toHaveProperty("description");
+    }
+  });
+
+  test("keeps the reporter's Markdown: line breaks inside, and the first line's indentation", () => {
+    expect(
+      valueOf(
+        validate(
+          submission({
+            description:
+              "\n\n    npm run build\n    exit 1\n\n**Since 10:00**  \n\n",
+          }),
+        ),
+      ).description,
+    ).toBe("    npm run build\n    exit 1\n\n**Since 10:00**");
+  });
+
+  test("drops NUL characters, which Postgres cannot store", () => {
+    expect(
+      valueOf(validate(submission({ description: "a\u0000b" }))).description,
+    ).toBe("ab");
+  });
+
+  test("must be text when it is asked", () => {
+    expect(errorsOf(validate(submission({ description: 42 })))).toEqual([
+      "Description must be text.",
+    ]);
+  });
+
+  test("may be 20000 characters, not 20001", () => {
+    expect(
+      valueOf(
+        validate(
+          submission({
+            description: "x".repeat(INCIDENT_FORM_DESCRIPTION_MAX_LENGTH),
+          }),
+        ),
+      ).description,
+    ).toHaveLength(INCIDENT_FORM_DESCRIPTION_MAX_LENGTH);
+
+    expect(
+      errorsOf(
+        validate(
+          submission({
+            description: "x".repeat(INCIDENT_FORM_DESCRIPTION_MAX_LENGTH + 1),
+          }),
+        ),
+      ),
+    ).toEqual(["Description cannot be more than 20000 characters."]);
+  });
+
+  test.each([[undefined], ["Mandatory"], ["required"], [null]])(
+    "a description setting of %j is read as Optional",
+    (setting: unknown) => {
+      const form: IncidentFormSubmissionRules = {
+        ...DEFAULT_RULES,
+        descriptionSetting: setting as string,
+      };
+
+      expect(valueOf(validate(submission(), { form })).title).toBe(
+        "Checkout fails",
+      );
+      expect(
+        valueOf(validate(submission({ description: "Kept" }), { form }))
+          .description,
+      ).toBe("Kept");
+    },
+  );
+});
+
+describe("validateIncidentFormSubmission: the severity", () => {
+  const CHOOSING: IncidentFormSubmissionRules = {
+    ...DEFAULT_RULES,
+    allowReporterToChooseSeverity: true,
+  };
+
+  test("is not read when the form does not let the reporter choose", () => {
+    for (const incidentSeverityId of [
+      SEVERITY_HIGH,
+      "not an id",
+      5,
+      ObjectID.generate().toString(),
+    ]) {
+      const value: ValidatedIncidentFormSubmission = valueOf(
+        validate(
+          submission({
+            incidentSeverityId: incidentSeverityId as JSONObject[string],
+          }),
+        ),
+      );
+
+      expect(value).not.toHaveProperty("incidentSeverityId");
+    }
+  });
+
+  test("may be left out, which means the form's own severity", () => {
+    for (const incidentSeverityId of [undefined, null, "", "   "]) {
+      const data: JSONObject = submission();
+
+      if (incidentSeverityId !== undefined) {
+        data["incidentSeverityId"] = incidentSeverityId;
+      }
+
+      expect(valueOf(validate(data, { form: CHOOSING }))).not.toHaveProperty(
+        "incidentSeverityId",
+      );
+    }
+  });
+
+  test("one of the listed severities is taken, as listed", () => {
+    expect(
+      valueOf(
+        validate(submission({ incidentSeverityId: SEVERITY_LOW }), {
+          form: CHOOSING,
+        }),
+      ).incidentSeverityId,
+    ).toBe(SEVERITY_LOW);
+
+    expect(
+      valueOf(
+        validate(
+          submission({
+            incidentSeverityId: `  ${SEVERITY_HIGH.toUpperCase()} `,
+          }),
+          { form: CHOOSING },
+        ),
+      ).incidentSeverityId,
+    ).toBe(SEVERITY_HIGH);
+  });
+
+  test.each([
+    ["another project's severity", ObjectID.generate().toString()],
+    ["something that is not an id", "critical"],
+    ["a number", 1],
+    ["an object", { _id: SEVERITY_HIGH }],
+    ["a list", [SEVERITY_HIGH]],
+  ])("%s is refused", (_label: string, incidentSeverityId: unknown) => {
+    expect(
+      errorsOf(
+        validate(
+          submission({
+            incidentSeverityId: incidentSeverityId as JSONObject[string],
+          }),
+          { form: CHOOSING },
+        ),
+      ),
+    ).toEqual(["Severity must be one of the severities this form lists."]);
+  });
+
+  test("with no severities to list, any choice is refused", () => {
+    expect(
+      errorsOf(
+        validate(submission({ incidentSeverityId: SEVERITY_HIGH }), {
+          form: CHOOSING,
+          severities: [],
+        }),
+      ),
+    ).toEqual(["Severity must be one of the severities this form lists."]);
+  });
+});
+
+describe("validateIncidentFormSubmission: the reporter", () => {
+  const ANONYMOUS: IncidentFormSubmissionRules = {
+    ...DEFAULT_RULES,
+    isReporterDetailsRequired: false,
+  };
+
+  test("the name and email are required unless the form says otherwise", () => {
+    const data: JSONObject = submission();
+    delete data["reporterName"];
+    delete data["reporterEmail"];
+
+    expect(errorsOf(validate(data))).toEqual([
+      "Your Name is required.",
+      "Your Email is required.",
+    ]);
+
+    // Undefined is the column's default: details required.
+    expect(
+      errorsOf(
+        validate(data, {
+          form: { ...DEFAULT_RULES, isReporterDetailsRequired: undefined },
+        }),
+      ),
+    ).toEqual(["Your Name is required.", "Your Email is required."]);
+  });
+
+  test("an anonymous report leaves both out", () => {
+    const data: JSONObject = submission({
+      reporterName: "  ",
+      reporterEmail: "",
+    });
+
+    const value: ValidatedIncidentFormSubmission = valueOf(
+      validate(data, { form: ANONYMOUS }),
+    );
+
+    expect(value).not.toHaveProperty("reporterName");
+    expect(value).not.toHaveProperty("reporterEmail");
+  });
+
+  test("details given on an anonymous form are still kept, and still checked", () => {
+    expect(valueOf(validate(submission(), { form: ANONYMOUS }))).toMatchObject({
+      reporterName: "Jane Doe",
+      reporterEmail: "jane@example.com",
+    });
+
+    expect(
+      errorsOf(
+        validate(submission({ reporterEmail: "jane" }), { form: ANONYMOUS }),
+      ),
+    ).toEqual(["Your Email is not a valid email address."]);
+  });
+
+  test("the name is cleaned to one line", () => {
+    expect(
+      valueOf(validate(submission({ reporterName: "  Jane\n\tDoe " })))
+        .reporterName,
+    ).toBe("Jane Doe");
+  });
+
+  test("the name may be 100 characters, not 101", () => {
+    expect(
+      valueOf(
+        validate(
+          submission({
+            reporterName: "n".repeat(INCIDENT_FORM_REPORTER_NAME_MAX_LENGTH),
+          }),
+        ),
+      ).reporterName,
+    ).toHaveLength(INCIDENT_FORM_REPORTER_NAME_MAX_LENGTH);
+
+    expect(
+      errorsOf(
+        validate(
+          submission({
+            reporterName: "n".repeat(
+              INCIDENT_FORM_REPORTER_NAME_MAX_LENGTH + 1,
+            ),
+          }),
+        ),
+      ),
+    ).toEqual(["Your Name cannot be more than 100 characters."]);
+  });
+
+  test("the email is trimmed and lowercased, as Email stores it", () => {
+    expect(
+      valueOf(
+        validate(submission({ reporterEmail: "  Jane.Doe@Example.COM\n" })),
+      ).reporterEmail,
+    ).toBe("jane.doe@example.com");
+  });
+
+  test.each([
+    ["no at sign", "jane.example.com"],
+    ["no domain", "jane@"],
+    ["no mailbox", "@example.com"],
+    ["no dot in the domain", "jane@localhost"],
+    ["a space", "jane doe@example.com"],
+    ["two at signs", "jane@@example.com"],
+    ["a display name", "Jane <jane@example.com>"],
+    ["trailing words", "jane@example.com please reply"],
+    ["leading words", "mail jane@example.com"],
+    ["a line break inside", "jane@exam\nple.com"],
+    ["a trailing dot", "jane@example.com."],
+    ["a leading dot", ".jane@example.com"],
+  ])(
+    "an email with %s is refused, even though Email finds an address in it",
+    (_label: string, email: string) => {
+      expect(errorsOf(validate(submission({ reporterEmail: email })))).toEqual([
+        "Your Email is not a valid email address.",
+      ]);
+    },
+  );
+
+  test.each([
+    ["jane+incidents@example.com"],
+    ["j.o'hara@sub.example.co.uk"],
+    ["ops_team-1@example-mail.io"],
+  ])("an ordinary address like %s passes", (email: string) => {
+    expect(
+      valueOf(validate(submission({ reporterEmail: email }))).reporterEmail,
+    ).toBe(email);
+  });
+
+  test("the email may be 100 characters, not 101 - and a long one is only told it is too long", () => {
+    const domain: string = "@example.com";
+    const longest: string = `${"a".repeat(
+      INCIDENT_FORM_REPORTER_EMAIL_MAX_LENGTH - domain.length,
+    )}${domain}`;
+
+    expect(
+      valueOf(validate(submission({ reporterEmail: longest }))).reporterEmail,
+    ).toBe(longest);
+
+    expect(
+      errorsOf(validate(submission({ reporterEmail: `a${longest}` }))),
+    ).toEqual(["Your Email cannot be more than 100 characters."]);
+  });
+
+  test.each([
+    [5],
+    [true],
+    [{ email: "jane@example.com" }],
+    [["jane@example.com"]],
+  ])(
+    "the name and email must be text: %j is refused once each",
+    (value: unknown) => {
+      expect(
+        errorsOf(
+          validate(
+            submission({
+              reporterName: value as JSONObject[string],
+              reporterEmail: value as JSONObject[string],
+            }),
+          ),
+        ),
+      ).toEqual(["Your Name must be text.", "Your Email must be text."]);
+    },
+  );
+});
+
+describe("validateIncidentFormSubmission: custom field answers", () => {
+  type AnswerFunction = (
+    answers: JSONObject,
+  ) => IncidentFormSubmissionValidationResult;
+
+  const answer: AnswerFunction = (
+    answers: JSONObject,
+  ): IncidentFormSubmissionValidationResult => {
+    return validate(
+      submission({ customFields: { ...REQUIRED_ANSWERS, ...answers } }),
+    );
+  };
+
+  test("answers are an object keyed by field name", () => {
+    for (const customFields of ["Impact=down", ["Checkout is down"], 5, true]) {
+      expect(
+        errorsOf(
+          validate(
+            submission({ customFields: customFields as JSONObject[string] }),
+          ),
+        ),
+      ).toEqual([
+        "The custom field answers must be an object keyed by field name.",
+        "Impact is required.",
+        "I Have Checked The Status Page must be checked.",
+      ]);
+    }
+  });
+
+  test("no answers at all only fails the required questions", () => {
+    const data: JSONObject = submission();
+    delete data["customFields"];
+
+    expect(errorsOf(validate(data))).toEqual([
+      "Impact is required.",
+      "I Have Checked The Status Page must be checked.",
+    ]);
+  });
+
+  test("an answer to a field the form does not ask is dropped unread", () => {
+    const value: ValidatedIncidentFormSubmission = valueOf(
+      answer({
+        "Internal Cost Centre": "4411",
+        "Secret Escalation Note": { not: "even valid" },
+        impact: "lowercase name, not the field",
+      }),
+    );
+
+    expect(Object.keys(value.customFields).sort()).toEqual(
+      ["I Have Checked The Status Page", "Impact"].sort(),
+    );
+  });
+
+  test("a form that asks nothing stores nothing, whatever is sent", () => {
+    expect(
+      valueOf(
+        validate(submission({ customFields: { Impact: "Down", Other: 1 } }), {
+          askedDefinitions: [],
+        }),
+      ).customFields,
+    ).toEqual({});
+  });
+
+  test("an optional question left empty is left out, so a template's value still applies", () => {
+    const value: ValidatedIncidentFormSubmission = valueOf(
+      answer({
+        "Steps to Reproduce": "   ",
+        Notes: "",
+        "Users Affected": null,
+        Region: "",
+        Systems: [],
+        "Noticed On": "  ",
+      }),
+    );
+
+    expect(value.customFields).toEqual(REQUIRED_ANSWERS);
+  });
+
+  test("a required text question answered with whitespace is still unanswered", () => {
+    expect(errorsOf(answer({ Impact: " \n\t " }))).toEqual([
+      "Impact is required.",
+    ]);
+  });
+
+  test("text is cleaned as its field shows it", () => {
+    const value: ValidatedIncidentFormSubmission = valueOf(
+      answer({
+        Impact: "  Checkout\ndown  ",
+        "Steps to Reproduce": "\n1. Open checkout\n2. Pay\n\n",
+        Notes: "\n\n    stack trace\n",
+      }),
+    );
+
+    expect(value.customFields["Impact"]).toBe("Checkout down");
+    expect(value.customFields["Steps to Reproduce"]).toBe(
+      "1. Open checkout\n2. Pay",
+    );
+    expect(value.customFields["Notes"]).toBe("    stack trace");
+  });
+
+  test("NUL characters are dropped from every text answer", () => {
+    const value: ValidatedIncidentFormSubmission = valueOf(
+      answer({
+        Impact: "Check\u0000out",
+        Notes: "a\u0000b",
+        Region: "E\u0000U",
+        Systems: ["A\u0000PI"],
+      }),
+    );
+
+    expect(value.customFields).toMatchObject({
+      Impact: "Check out",
+      Notes: "ab",
+      Region: "EU",
+      Systems: ["API"],
+    });
+  });
+
+  test("each answer is checked as an API write would check it", () => {
+    expect(
+      errorsOf(
+        answer({
+          "Users Affected": "lots",
+          Region: "APAC",
+          Systems: ["API", "Mobile"],
+          "Noticed On": "yesterday-ish",
+          "Noticed At": "soon",
+          Untyped: { nested: true },
+        }),
+      ),
+    ).toEqual([
+      '"Users Affected" holds a number, but was sent "lots".',
+      '"APAC" is not one of the options for "Region". Choose one of: "EU", "US".',
+      '"Mobile" is not one of the options for "Systems". Choose from: "API", "Web".',
+      '"Noticed On" holds a date, but was sent "yesterday-ish".',
+      '"Noticed At" holds a date and time, but was sent "soon".',
+      "Untyped takes one answer, not an object.",
+    ]);
+  });
+
+  /*
+   * An answer is one value - text, a number, a yes/no - or, for a
+   * multi-select, a list of them; nothing the form's page sends is an
+   * object. One is refused before anything reads it: checked as an API
+   * write would check it, it would be turned into text twice first -
+   * seconds for one with a million keys, and far longer for one nested
+   * millions deep.
+   */
+  test.each([
+    ["a text question", "Impact", "Impact takes one answer, not an object."],
+    [
+      "a long text question",
+      "Steps to Reproduce",
+      "Steps to Reproduce takes one answer, not an object.",
+    ],
+    ["a Markdown question", "Notes", "Notes takes one answer, not an object."],
+    [
+      "a number question",
+      "Users Affected",
+      "Users Affected takes one answer, not an object.",
+    ],
+    [
+      "a yes/no question",
+      "Customer Facing",
+      "Customer Facing takes one answer, not an object.",
+    ],
+    ["a dropdown", "Region", "Region takes one answer, not an object."],
+    [
+      "a multi-select",
+      "Systems",
+      "Systems takes a list of its options, not an object.",
+    ],
+    [
+      "a date question",
+      "Noticed On",
+      "Noticed On takes one answer, not an object.",
+    ],
+    [
+      "a date and time question",
+      "Noticed At",
+      "Noticed At takes one answer, not an object.",
+    ],
+    [
+      "a question with no type",
+      "Untyped",
+      "Untyped takes one answer, not an object.",
+    ],
+  ])(
+    "refuses an object for %s",
+    (_label: string, name: string, message: string) => {
+      expect(errorsOf(answer({ [name]: { nested: true } }))).toEqual([message]);
+    },
+  );
+
+  test("refuses an empty object as well: it is no more an answer", () => {
+    expect(errorsOf(answer({ Region: {} }))).toEqual([
+      "Region takes one answer, not an object.",
+    ]);
+  });
+
+  test("refuses an object without reading any of it", () => {
+    const refuseToBeRead: () => never = (): never => {
+      throw new Error("The answer was read.");
+    };
+
+    const unreadable: JSONObject = new Proxy(
+      {},
+      {
+        get: refuseToBeRead,
+        has: refuseToBeRead,
+        ownKeys: refuseToBeRead,
+        getOwnPropertyDescriptor: refuseToBeRead,
+        getPrototypeOf: refuseToBeRead,
+      },
+    ) as JSONObject;
+
+    let result: IncidentFormSubmissionValidationResult | undefined;
+
+    expect(() => {
+      result = answer({ Region: unreadable });
+    }).not.toThrow();
+
+    expect(errorsOf(result!)).toEqual([
+      "Region takes one answer, not an object.",
+    ]);
+  });
+
+  test("refuses an object nested two hundred thousand deep at once, without throwing", () => {
+    const depth: number = 200_000;
+    const nested: JSONObject = JSON.parse(
+      `${'{"a":'.repeat(depth)}1${"}".repeat(depth)}`,
+    ) as JSONObject;
+
+    const started: number = Date.now();
+    let result: IncidentFormSubmissionValidationResult | undefined;
+
+    expect(() => {
+      result = answer({ Notes: nested });
+    }).not.toThrow();
+
+    expect(Date.now() - started).toBeLessThan(1000);
+    expect(errorsOf(result!)).toEqual([
+      "Notes takes one answer, not an object.",
+    ]);
+  });
+
+  test("a null answer is still no answer", () => {
+    expect(errorsOf(answer({ Impact: null }))).toEqual(["Impact is required."]);
+    expect(
+      valueOf(answer({ Region: null })).customFields["Region"],
+    ).toBeUndefined();
+  });
+
+  test("good answers of every type are kept", () => {
+    const value: ValidatedIncidentFormSubmission = valueOf(
+      answer({
+        "Users Affected": "1200",
+        Region: " EU ",
+        Systems: ["Web", "API"],
+        "Noticed On": "2026-09-29",
+        "Noticed At": "2026-09-29T08:15:00.000Z",
+        Untyped: "free text",
+        "Customer Facing": false,
+      }),
+    );
+
+    expect(value.customFields).toEqual({
+      ...REQUIRED_ANSWERS,
+      "Users Affected": "1200",
+      Region: "EU",
+      Systems: ["Web", "API"],
+      "Noticed On": "2026-09-29",
+      "Noticed At": "2026-09-29T08:15:00.000Z",
+      Untyped: "free text",
+      "Customer Facing": false,
+    });
+  });
+
+  test("a number may be sent as a number", () => {
+    expect(
+      valueOf(answer({ "Users Affected": 0 })).customFields["Users Affected"],
+    ).toBe(0);
+  });
+
+  test("a required yes/no must be ticked: no, missing, or anything else is refused", () => {
+    const name: string = "I Have Checked The Status Page";
+
+    for (const unticked of [false, "false", null, ""]) {
+      expect(
+        errorsOf(
+          validate(
+            submission({
+              customFields: {
+                Impact: "Down",
+                [name]: unticked as JSONObject[string],
+              },
+            }),
+          ),
+        ),
+      ).toEqual([`${name} must be checked.`]);
+    }
+
+    expect(
+      errorsOf(validate(submission({ customFields: { Impact: "Down" } }))),
+    ).toEqual([`${name} must be checked.`]);
+
+    expect(
+      errorsOf(
+        validate(
+          submission({ customFields: { Impact: "Down", [name]: "yes" } }),
+        ),
+      ),
+    ).toEqual([`"${name}" holds true or false, but was sent "yes".`]);
+  });
+
+  test('a yes/no answered "true" or "false" is stored as the boolean the dashboard stores', () => {
+    const value: ValidatedIncidentFormSubmission = valueOf(
+      validate(
+        submission({
+          customFields: {
+            Impact: "Down",
+            "I Have Checked The Status Page": " true ",
+            "Customer Facing": "false",
+          },
+        }),
+      ),
+    );
+
+    expect(value.customFields["I Have Checked The Status Page"]).toBe(true);
+    expect(value.customFields["Customer Facing"]).toBe(false);
+  });
+
+  test("a multi-select holds each option once, trimmed, and one bare option becomes a list", () => {
+    expect(
+      valueOf(answer({ Systems: ["API", " API ", "", "Web", "API"] }))
+        .customFields["Systems"],
+    ).toEqual(["API", "Web"]);
+
+    expect(
+      valueOf(answer({ Systems: " Web " })).customFields["Systems"],
+    ).toEqual(["Web"]);
+  });
+
+  test("a required multi-select with nothing chosen is unanswered", () => {
+    expect(
+      errorsOf(
+        validate(
+          submission({
+            customFields: { ...REQUIRED_ANSWERS, Systems: ["", " "] },
+          }),
+          {
+            askedDefinitions: [
+              ...ASKED.filter((field: IncidentFormAskedDefinition): boolean => {
+                return field.name !== "Systems";
+              }),
+              {
+                name: "Systems",
+                customFieldType: CustomFieldType.MultiSelectDropdown,
+                dropdownOptions: "API\nWeb",
+                isRequiredOnCreate: true,
+              },
+            ],
+          },
+        ),
+      ),
+    ).toEqual(["Systems is required."]);
+  });
+
+  test("text answers may be 10000 characters, not 10001 - a list entry included", () => {
+    const longest: string = "x".repeat(
+      INCIDENT_FORM_CUSTOM_FIELD_TEXT_MAX_LENGTH,
+    );
+
+    expect(valueOf(answer({ Notes: longest })).customFields["Notes"]).toBe(
+      longest,
+    );
+
+    expect(errorsOf(answer({ Notes: `${longest}x` }))).toEqual([
+      "Notes cannot be more than 10000 characters.",
+    ]);
+    expect(
+      errorsOf(answer({ "Users Affected": `1${"0".repeat(10000)}` })),
+    ).toEqual(["Users Affected cannot be more than 10000 characters."]);
+    expect(errorsOf(answer({ Systems: ["API", `${longest}x`] }))).toEqual([
+      "Systems cannot be more than 10000 characters.",
+    ]);
+  });
+
+  /*
+   * A multi-select answer is bounded before any of its entries is read:
+   * otherwise a single request of a million entries has each of them
+   * cleaned, sorted and quoted back in a refusal as large as the request,
+   * or - for a field nobody gave options to - stored on the incident.
+   */
+  describe("how many choices a multi-select answer may have", () => {
+    const systems: (options: string) => Array<IncidentFormAskedDefinition> = (
+      options: string,
+    ): Array<IncidentFormAskedDefinition> => {
+      return [
+        {
+          name: "Systems",
+          customFieldType: CustomFieldType.MultiSelectDropdown,
+          dropdownOptions: options,
+          isRequiredOnCreate: false,
+        },
+      ];
+    };
+
+    const entries: (count: number, prefix?: string) => Array<string> = (
+      count: number,
+      prefix: string = "x",
+    ): Array<string> => {
+      return Array.from({ length: count }, (_value: unknown, index: number) => {
+        return `${prefix}${index}`;
+      });
+    };
+
+    test("is at most 100, whatever is in the list, and the refusal quotes none of it", () => {
+      const errors: Array<string> = errorsOf(
+        validate(submission({ customFields: { Systems: entries(101) } }), {
+          askedDefinitions: systems("EU\nUS\nAPAC"),
+        }),
+      );
+
+      expect(errors).toEqual([
+        `Systems cannot have more than ${INCIDENT_FORM_MULTI_SELECT_MAX_CHOICES} choices.`,
+      ]);
+      expect(INCIDENT_FORM_MULTI_SELECT_MAX_CHOICES).toBe(100);
+      expect(errors.join(" ")).not.toContain("x0");
+    });
+
+    test("is counted before duplicates are dropped", () => {
+      expect(
+        errorsOf(
+          validate(
+            submission({
+              customFields: {
+                Systems: Array(101).fill("EU") as JSONObject[string],
+              },
+            }),
+            { askedDefinitions: systems("EU\nUS") },
+          ),
+        ),
+      ).toEqual(["Systems cannot have more than 100 choices."]);
+    });
+
+    test("refuses a million entries at once, quickly, with one short message", () => {
+      const started: number = Date.now();
+
+      const errors: Array<string> = errorsOf(
+        validate(
+          submission({ customFields: { Systems: entries(1_000_000) } }),
+          { askedDefinitions: systems("EU\nUS\nAPAC") },
+        ),
+      );
+
+      expect(Date.now() - started).toBeLessThan(1000);
+      expect(errors).toEqual(["Systems cannot have more than 100 choices."]);
+      expect(formatIncidentFormSubmissionErrors(errors).length).toBeLessThan(
+        200,
+      );
+    });
+
+    test("on a field nobody gave options to, 100 entries are stored and 101 refused", () => {
+      const hundred: Array<string> = entries(100);
+
+      expect(
+        valueOf(
+          validate(submission({ customFields: { Systems: hundred } }), {
+            askedDefinitions: systems(""),
+          }),
+        ).customFields["Systems"],
+      ).toEqual(hundred);
+
+      const refused: IncidentFormSubmissionValidationResult = validate(
+        submission({ customFields: { Systems: entries(101) } }),
+        { askedDefinitions: systems("") },
+      );
+
+      expect(errorsOf(refused)).toEqual([
+        "Systems cannot have more than 100 choices.",
+      ]);
+    });
+
+    test("is the field's number of options, when it has more than 100 - so every option can be chosen", () => {
+      const options: Array<string> = entries(150, "option ");
+
+      expect(
+        valueOf(
+          validate(submission({ customFields: { Systems: options } }), {
+            askedDefinitions: systems(options.join("\n")),
+          }),
+        ).customFields["Systems"],
+      ).toEqual(options);
+
+      expect(
+        errorsOf(
+          validate(
+            submission({
+              customFields: { Systems: [...options, "option 0"] },
+            }),
+            { askedDefinitions: systems(options.join("\n")) },
+          ),
+        ),
+      ).toEqual(["Systems cannot have more than 150 choices."]);
+    });
+
+    test.each([
+      ["a text question", "Impact"],
+      ["a long text question", "Steps to Reproduce"],
+      ["a Markdown question", "Notes"],
+      ["a number question", "Users Affected"],
+      ["a yes/no question", "Customer Facing"],
+      ["a dropdown", "Region"],
+      ["a date question", "Noticed On"],
+      ["a question with no type", "Untyped"],
+    ])(
+      "refuses a list for %s, without reading it",
+      (_label: string, name: string) => {
+        const errors: Array<string> = errorsOf(
+          answer({ [name]: entries(1_000_000) }),
+        );
+
+        expect(errors).toEqual([`${name} takes one answer, not a list.`]);
+      },
+    );
+
+    test("an empty list for a single-answer question is still no answer", () => {
+      expect(errorsOf(answer({ Impact: [] }))).toEqual(["Impact is required."]);
+      expect(
+        valueOf(answer({ Region: [] })).customFields["Region"],
+      ).toBeUndefined();
+    });
+
+    /*
+     * A choice is one option. A list nested inside the answer - thousands
+     * deep, which the app's JSON parser accepts - would overflow the stack
+     * the moment anything turned it into text, so a list or an object
+     * inside the list is refused unread, and validation still never throws.
+     */
+    test.each([
+      ["a list inside the list", [["EU"]]],
+      ["an object inside the list", [{ EU: true }]],
+      ["a choice beside a list", ["EU", ["US"]]],
+    ])("refuses %s", (_label: string, list: Array<unknown>) => {
+      expect(
+        errorsOf(
+          validate(
+            submission({
+              customFields: { Systems: list as JSONObject[string] },
+            }),
+            { askedDefinitions: systems("EU\nUS\nAPAC") },
+          ),
+        ),
+      ).toEqual([
+        "Systems takes a list of its options, not lists or objects within it.",
+      ]);
+    });
+
+    test("refuses a list nested a hundred thousand deep, without throwing", () => {
+      let nested: unknown = "EU";
+
+      for (let depth: number = 0; depth < 100000; depth++) {
+        nested = [nested];
+      }
+
+      let result: IncidentFormSubmissionValidationResult | undefined;
+
+      expect(() => {
+        result = validate(
+          submission({
+            customFields: { Systems: [nested] as JSONObject[string] },
+          }),
+          { askedDefinitions: systems("EU\nUS\nAPAC") },
+        );
+      }).not.toThrow();
+
+      expect(errorsOf(result!)).toEqual([
+        "Systems takes a list of its options, not lists or objects within it.",
+      ]);
+    });
+  });
+
+  test("a field name with $ patterns is quoted back as typed", () => {
+    expect(
+      errorsOf(
+        validate(submission({ customFields: {} }), {
+          askedDefinitions: [
+            {
+              name: "Cost $& ($1) $$",
+              customFieldType: CustomFieldType.Text,
+              isRequiredOnCreate: true,
+            },
+          ],
+        }),
+      ),
+    ).toEqual(["Cost $& ($1) $$ is required."]);
+  });
+
+  test("regression: a field named __proto__ is stored as an answer, not as the object's prototype", () => {
+    const asked: Array<IncidentFormAskedDefinition> = [
+      {
+        name: "__proto__",
+        customFieldType: CustomFieldType.MultiSelectDropdown,
+        dropdownOptions: "API\nWeb",
+        isRequiredOnCreate: true,
+      },
+    ];
+
+    const value: ValidatedIncidentFormSubmission = valueOf(
+      validate(
+        submission({
+          customFields: JSON.parse('{"__proto__": ["API"]}') as JSONObject,
+        }),
+        { askedDefinitions: asked },
+      ),
+    );
+
+    expect(Object.getPrototypeOf(value.customFields)).toBe(Object.prototype);
+    expect(Object.keys(value.customFields)).toEqual(["__proto__"]);
+    expect(JSON.stringify(value.customFields)).toBe('{"__proto__":["API"]}');
+  });
+
+  test("an inherited answer is not an answer", () => {
+    const answers: JSONObject = Object.create({
+      Impact: "Inherited",
+    }) as JSONObject;
+
+    expect(errorsOf(validate(submission({ customFields: answers })))).toEqual([
+      "Impact is required.",
+      "I Have Checked The Status Page must be checked.",
+    ]);
+  });
+});
+
+describe("formatIncidentFormSubmissionErrors", () => {
+  test("joins every problem into one message", () => {
+    expect(
+      formatIncidentFormSubmissionErrors([
+        "Title is required.",
+        "Your Email is not a valid email address.",
+      ]),
+    ).toBe("Title is required. Your Email is not a valid email address.");
+    expect(formatIncidentFormSubmissionErrors([])).toBe("");
+  });
+});
+
+// A relative import: another pure module of Common.
+const RELATIVE_IMPORT: RegExp = /^\.\.?\//;
+
+describe("the module stays pure", () => {
+  test("imports nothing from React, the database, the server or the UI", () => {
+    const source: string = fs.readFileSync(
+      path.join(__dirname, "../../../Types/Incident/IncidentFormPublic.ts"),
+      "utf8",
+    );
+
+    const imports: Array<string> = Array.from(
+      source.matchAll(/from\s+"([^"]+)"/g),
+    ).map((match: RegExpMatchArray): string => {
+      return match[1]!;
+    });
+
+    expect(imports.length).toBeGreaterThan(0);
+
+    for (const imported of imports) {
+      expect({ imported, relative: RELATIVE_IMPORT.test(imported) }).toEqual({
+        imported,
+        relative: true,
+      });
+      expect(imported).not.toMatch(/react|typeorm|Server|UI|Models/i);
+    }
+  });
+});