@oneuptime/common 14.0.7 → 14.0.9

package/Tests/Types/CustomField/CustomFieldSavedViews.test.ts

@@ -0,0 +1,247 @@
+import {
+  CUSTOM_FIELD_COLUMN_ID_PREFIX,
+  CUSTOM_FIELD_FACET_KEY_PREFIX,
+  INCIDENT_CUSTOM_FIELD_TABLE_VIEW_IDS,
+  RenamedCustomFieldSavedViewState,
+  renameCustomFieldInSavedView,
+} from "../../../Types/CustomField/CustomFieldSavedViews";
+import { getCustomFieldColumns } from "../../../UI/Components/ModelTable/CustomFieldColumns";
+import Columns from "../../../UI/Components/ModelTable/Columns";
+import Incident from "../../../Models/DatabaseModels/Incident";
+import CustomFieldType from "../../../Types/CustomField/CustomFieldType";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * A saved table view remembers custom fields by name: a column id
+ * "customFields.<name>" in its layout, a chip "customField:<name>" in its
+ * facets, and (should a table ever filter on one) query.customFields.<name>.
+ * Renaming a field has to rewrite exactly those, and nothing else, or the
+ * view silently loses the column and the chip.
+ */
+
+const FACETS: JSONObject = {
+  selectedOwnerKeys: ["user:abc"],
+  selectedLabelIds: ["label-1"],
+  ownerOperator: "is",
+  labelOperator: "is",
+  facetSelections: {
+    "customField:Impact": ["High"],
+    "customField:Region": ["East"],
+    currentIncidentState: ["state-1"],
+  },
+  facetOperators: {
+    "customField:Impact": "isNot",
+    currentIncidentState: "is",
+  },
+};
+
+const COLUMNS: JSONObject = {
+  order: ["title", "customFields.Impact", "customFields.Region"],
+  hidden: ["customFields.Impact", "labels"],
+};
+
+describe("renameCustomFieldInSavedView", () => {
+  test("renames the field's column, chip and operator, and keeps the rest", () => {
+    const renamed: RenamedCustomFieldSavedViewState =
+      renameCustomFieldInSavedView({
+        view: { facets: FACETS, columns: COLUMNS, query: { title: "x" } },
+        oldName: "Impact",
+        newName: "Business Impact",
+      });
+
+    expect(renamed.hasChanged).toBe(true);
+    expect(renamed.changes.columns).toEqual({
+      order: ["title", "customFields.Business Impact", "customFields.Region"],
+      hidden: ["customFields.Business Impact", "labels"],
+    });
+    expect(renamed.changes.facets).toEqual({
+      ...FACETS,
+      facetSelections: {
+        "customField:Business Impact": ["High"],
+        "customField:Region": ["East"],
+        currentIncidentState: ["state-1"],
+      },
+      facetOperators: {
+        "customField:Business Impact": "isNot",
+        currentIncidentState: "is",
+      },
+    });
+    // The query does not name the field, so it is not rewritten.
+    expect(renamed.changes.query).toBeUndefined();
+  });
+
+  test("keeps the chip where it was among the others", () => {
+    const renamed: RenamedCustomFieldSavedViewState =
+      renameCustomFieldInSavedView({
+        view: { facets: FACETS },
+        oldName: "Impact",
+        newName: "Severity",
+      });
+
+    expect(
+      Object.keys(
+        (renamed.changes.facets!["facetSelections"] as JSONObject) || {},
+      ),
+    ).toEqual([
+      "customField:Severity",
+      "customField:Region",
+      "currentIncidentState",
+    ]);
+  });
+
+  test("does not change the objects it was given", () => {
+    const facets: JSONObject = JSON.parse(JSON.stringify(FACETS));
+    const columns: JSONObject = JSON.parse(JSON.stringify(COLUMNS));
+
+    renameCustomFieldInSavedView({
+      view: { facets, columns },
+      oldName: "Impact",
+      newName: "Severity",
+    });
+
+    expect(facets).toEqual(FACETS);
+    expect(columns).toEqual(COLUMNS);
+  });
+
+  test("renames a filter on the field in the table's own query", () => {
+    const renamed: RenamedCustomFieldSavedViewState =
+      renameCustomFieldInSavedView({
+        view: {
+          query: {
+            title: "outage",
+            customFields: { Impact: "High", Region: "East" },
+          },
+        },
+        oldName: "Impact",
+        newName: "Severity",
+      });
+
+    expect(renamed.changes.query).toEqual({
+      title: "outage",
+      customFields: { Severity: "High", Region: "East" },
+    });
+  });
+
+  test("the renamed field wins over a stale entry under the new name", () => {
+    const renamed: RenamedCustomFieldSavedViewState =
+      renameCustomFieldInSavedView({
+        view: {
+          facets: {
+            facetSelections: {
+              "customField:Severity": ["stale"],
+              "customField:Impact": ["High"],
+            },
+          },
+          columns: {
+            order: ["customFields.Severity", "customFields.Impact"],
+            hidden: [],
+          },
+        },
+        oldName: "Impact",
+        newName: "Severity",
+      });
+
+    expect(renamed.changes.facets!["facetSelections"]).toEqual({
+      "customField:Severity": ["High"],
+    });
+    expect(renamed.changes.columns!["order"]).toEqual([
+      "customFields.Severity",
+    ]);
+  });
+
+  test("a view that does not mention the field is left alone", () => {
+    const renamed: RenamedCustomFieldSavedViewState =
+      renameCustomFieldInSavedView({
+        view: { facets: FACETS, columns: COLUMNS, query: {} },
+        oldName: "Customer",
+        newName: "Client",
+      });
+
+    expect(renamed).toEqual({ changes: {}, hasChanged: false });
+  });
+
+  test("another field whose name merely contains the old one is not touched", () => {
+    const renamed: RenamedCustomFieldSavedViewState =
+      renameCustomFieldInSavedView({
+        view: {
+          facets: {
+            facetSelections: { "customField:Impact Area": ["a"] },
+          },
+          columns: { order: ["customFields.Impact Area"], hidden: [] },
+        },
+        oldName: "Impact",
+        newName: "Severity",
+      });
+
+    expect(renamed.hasChanged).toBe(false);
+  });
+
+  test("a name that is not a custom field's (no prefix) is not touched", () => {
+    const renamed: RenamedCustomFieldSavedViewState =
+      renameCustomFieldInSavedView({
+        view: {
+          facets: { facetSelections: { Impact: ["x"] } },
+          columns: { order: ["Impact"], hidden: ["Impact"] },
+        },
+        oldName: "Impact",
+        newName: "Severity",
+      });
+
+    expect(renamed.hasChanged).toBe(false);
+  });
+
+  test.each([
+    [{ facets: null, columns: null, query: null }],
+    [{ facets: { facetSelections: "broken" }, columns: { order: "broken" } }],
+    [{}],
+  ])(
+    "tolerates a view with nothing, or junk, where it looks (%j)",
+    (view: unknown) => {
+      expect(
+        renameCustomFieldInSavedView({
+          view: view as never,
+          oldName: "Impact",
+          newName: "Severity",
+        }).hasChanged,
+      ).toBe(false);
+    },
+  );
+
+  test.each([
+    ["Impact", "Impact"],
+    ["", "Severity"],
+    ["Impact", ""],
+  ])("does nothing for %j -> %j", (oldName: string, newName: string) => {
+    expect(
+      renameCustomFieldInSavedView({
+        view: { facets: FACETS, columns: COLUMNS },
+        oldName,
+        newName,
+      }).hasChanged,
+    ).toBe(false);
+  });
+});
+
+describe("the saved-view spellings match the table and the facet bar", () => {
+  test("a custom field column's id is the prefix and the name", () => {
+    const columns: Columns<Incident> = getCustomFieldColumns<Incident>({
+      definitions: [
+        { name: "Impact", customFieldType: CustomFieldType.Dropdown },
+      ],
+    });
+
+    expect(CUSTOM_FIELD_COLUMN_ID_PREFIX).toBe("customFields.");
+    expect(columns[0]!.id).toBe(`${CUSTOM_FIELD_COLUMN_ID_PREFIX}Impact`);
+  });
+
+  test("the facet chip prefix is the one the dashboard uses", () => {
+    expect(CUSTOM_FIELD_FACET_KEY_PREFIX).toBe("customField:");
+  });
+
+  test("the incidents list is a table whose saved views are rewritten", () => {
+    expect(INCIDENT_CUSTOM_FIELD_TABLE_VIEW_IDS).toContain(
+      "all-incidents-table",
+    );
+  });
+});

package/Tests/Types/CustomField/CustomFieldTemplateValues.test.ts

@@ -0,0 +1,186 @@
+import { CustomFieldDefinition } from "../../../Types/CustomField/CustomFieldDefinition";
+import mergeTemplateCustomFieldsDefault, {
+  mergeTemplateCustomFields,
+} from "../../../Types/CustomField/CustomFieldTemplateMerge";
+import CustomFieldType from "../../../Types/CustomField/CustomFieldType";
+import { keepValidCustomFieldValues } from "../../../Types/CustomField/CustomFieldValueValidator";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * An incident template's custom field values reach a new incident in two
+ * places: the server copies them when an incident is created with
+ * `createdIncidentTemplateId` (mergeTemplateCustomFields), and the dashboard
+ * starts the Create page from them (keepValidCustomFieldValues drops the
+ * stale ones first). Both merge into what the incident is given; neither
+ * ever replaces it.
+ */
+
+describe("mergeTemplateCustomFields", () => {
+  test("the template fills in the fields the incident does not set", () => {
+    expect(
+      mergeTemplateCustomFields({
+        templateCustomFields: { Impact: "High", Category: "Network" },
+        customFields: { Ticket: "OPS-7" },
+      }),
+    ).toEqual({ Impact: "High", Category: "Network", Ticket: "OPS-7" });
+  });
+
+  test("a value the incident sets always wins", () => {
+    expect(
+      mergeTemplateCustomFields({
+        templateCustomFields: { Impact: "High", Category: "Network" },
+        customFields: { Impact: "Low" },
+      }),
+    ).toEqual({ Impact: "Low", Category: "Network" });
+  });
+
+  test("0, false, null and empty from the incident are answers, not gaps", () => {
+    expect(
+      mergeTemplateCustomFields({
+        templateCustomFields: {
+          Count: 5,
+          Acknowledged: true,
+          Impact: "High",
+          Notes: "From the template",
+        },
+        customFields: {
+          Count: 0,
+          Acknowledged: false,
+          Impact: null,
+          Notes: "",
+        },
+      }),
+    ).toEqual({ Count: 0, Acknowledged: false, Impact: null, Notes: "" });
+  });
+
+  test("an incident with no custom fields gets the template's", () => {
+    for (const customFields of [undefined, null]) {
+      expect(
+        mergeTemplateCustomFields({
+          templateCustomFields: { Impact: "High" },
+          customFields: customFields,
+        }),
+      ).toEqual({ Impact: "High" });
+    }
+  });
+
+  test("a template with no values changes nothing", () => {
+    for (const templateCustomFields of [undefined, null, {}, "x", [1]]) {
+      expect(
+        mergeTemplateCustomFields({
+          templateCustomFields: templateCustomFields,
+          customFields: { Ticket: "OPS-7" },
+        }),
+      ).toBeUndefined();
+    }
+  });
+
+  test("custom fields that are not a bag are left exactly as sent", () => {
+    for (const customFields of ["High", 7, ["a"]]) {
+      expect(
+        mergeTemplateCustomFields({
+          templateCustomFields: { Impact: "High" },
+          customFields: customFields,
+        }),
+      ).toBeUndefined();
+    }
+  });
+
+  test("returns a new bag, leaving both inputs untouched", () => {
+    const template: JSONObject = { Impact: "High" };
+    const incident: JSONObject = { Ticket: "OPS-7" };
+
+    const merged: JSONObject | undefined = mergeTemplateCustomFields({
+      templateCustomFields: template,
+      customFields: incident,
+    });
+
+    expect(merged).not.toBe(template);
+    expect(merged).not.toBe(incident);
+    expect(template).toEqual({ Impact: "High" });
+    expect(incident).toEqual({ Ticket: "OPS-7" });
+  });
+
+  test("is the module's default export", () => {
+    expect(mergeTemplateCustomFieldsDefault).toBe(mergeTemplateCustomFields);
+  });
+});
+
+describe("keepValidCustomFieldValues", () => {
+  const DEFINITIONS: Array<CustomFieldDefinition> = [
+    {
+      name: "Impact",
+      customFieldType: CustomFieldType.Dropdown,
+      dropdownOptions: "Low\nMedium\nHigh",
+    },
+    { name: "Estimated Duration", customFieldType: CustomFieldType.Number },
+    { name: "Acknowledgement", customFieldType: CustomFieldType.Boolean },
+    {
+      name: "Regions",
+      customFieldType: CustomFieldType.MultiSelectDropdown,
+      dropdownOptions: "East\nWest",
+    },
+  ];
+
+  test("keeps every value that still fits its field", () => {
+    expect(
+      keepValidCustomFieldValues({
+        definitions: DEFINITIONS,
+        customFields: {
+          Impact: "High",
+          "Estimated Duration": "0",
+          Acknowledgement: false,
+          Regions: ["East"],
+        },
+      }),
+    ).toEqual({
+      Impact: "High",
+      "Estimated Duration": "0",
+      Acknowledgement: false,
+      Regions: ["East"],
+    });
+  });
+
+  test("drops an option removed from a dropdown since the template was saved", () => {
+    expect(
+      keepValidCustomFieldValues({
+        definitions: DEFINITIONS,
+        customFields: { Impact: "Critical", Regions: ["East", "North"] },
+      }),
+    ).toEqual({});
+  });
+
+  test("drops a value of the wrong kind", () => {
+    expect(
+      keepValidCustomFieldValues({
+        definitions: DEFINITIONS,
+        customFields: {
+          "Estimated Duration": "about an hour",
+          Acknowledgement: "maybe",
+          Impact: "Low",
+        },
+      }),
+    ).toEqual({ Impact: "Low" });
+  });
+
+  test("keeps keys with no definition, and empty values", () => {
+    expect(
+      keepValidCustomFieldValues({
+        definitions: DEFINITIONS,
+        customFields: { "Deleted Field": "x", Impact: "" },
+      }),
+    ).toEqual({ "Deleted Field": "x", Impact: "" });
+  });
+
+  test("anything but a bag gives an empty bag", () => {
+    for (const customFields of [undefined, null, "x", [1]]) {
+      expect(
+        keepValidCustomFieldValues({
+          definitions: DEFINITIONS,
+          customFields: customFields,
+        }),
+      ).toEqual({});
+    }
+  });
+});

package/Tests/Types/CustomField/CustomFieldTypeCorrespondence.test.ts

@@ -92,6 +92,54 @@ describe("CustomFieldType member set", () => {
   });
 });
 
+describe("CustomFieldType long and rich text", () => {
+  test("includes LongText and Markdown, spelled as the Detail and form types", () => {
+    /*
+     * Incident fields such as "Additional Information" need several lines,
+     * and a note-like field needs the Markdown editor. Both reuse existing
+     * render and input types, so a definition saved with either must name
+     * FieldType.LongText / FieldType.Markdown and
+     * FormFieldSchemaType.LongText / FormFieldSchemaType.Markdown by value.
+     */
+    expect(CustomFieldType.LongText).toEqual("LongText");
+    expect(CustomFieldType.Markdown).toEqual("Markdown");
+    expect(FieldType.LongText as string).toEqual(CustomFieldType.LongText);
+    expect(FieldType.Markdown as string).toEqual(CustomFieldType.Markdown);
+    expect(FormFieldSchemaType.LongText as string).toEqual(
+      CustomFieldType.LongText,
+    );
+    expect(FormFieldSchemaType.Markdown as string).toEqual(
+      CustomFieldType.Markdown,
+    );
+  });
+
+  test("keeps every member that definitions may already store", () => {
+    /*
+     * A stored definition keeps its type string forever; removing or
+     * respelling a member would make it fall through every switch.
+     */
+    expect(Object.values(CustomFieldType).sort()).toEqual(
+      [
+        "Boolean",
+        "Date",
+        "DateTime",
+        "Dropdown",
+        "LongText",
+        "Markdown",
+        "MultiSelectDropdown",
+        "Number",
+        "Text",
+      ].sort(),
+    );
+  });
+
+  test("keys equal values, so pickers built from either agree", () => {
+    for (const [key, value] of customFieldTypeEntries) {
+      expect(key).toEqual(value);
+    }
+  });
+});
+
 describe("CustomFieldType correspondence is by value, not by key", () => {
   test("Boolean reaches the form as Toggle, which is only visible by value", () => {
     /*

package/Tests/Types/CustomField/CustomFieldValueFormat.test.ts

@@ -0,0 +1,215 @@
+import {
+  customFieldValueToDate,
+  customFieldValueToText,
+  formatCustomFieldBoolean,
+  formatCustomFieldCalendarDate,
+} from "../../../Types/CustomField/CustomFieldValueFormat";
+import { sortCustomFieldDefinitions } from "../../../Types/CustomField/CustomFieldOrder";
+import OneUptimeDate from "../../../Types/Date";
+import Timezone from "../../../Types/Timezone";
+import { sortCustomFieldDefinitions as sortFromForms } from "../../../UI/Components/CustomFields/CustomFieldFormFields";
+import { describe, expect, test } from "@jest/globals";
+import moment from "moment-timezone";
+
+/*
+ * How a stored custom field value reads as words, shared by an incident
+ * note's placeholders and the status page subscriber messages, and the order
+ * fields are shown in, shared by the dashboard and the server.
+ */
+
+describe("customFieldValueToText", () => {
+  test.each([
+    [undefined, ""],
+    [null, ""],
+    ["", ""],
+    ["Site 03", "Site 03"],
+    [0, "0"],
+    [12.5, "12.5"],
+    [false, "false"],
+    [["Site 03", "", null, "Site 07"], "Site 03, Site 07"],
+    [[], ""],
+    [new Date("2026-09-27T14:05:00.000Z"), "2026-09-27T14:05:00.000Z"],
+    [new Date("not a date"), ""],
+    [{ a: 1 }, '{"a":1}'],
+  ] as Array<[unknown, string]>)(
+    "%p reads as %p",
+    (value: unknown, text: string) => {
+      expect(customFieldValueToText(value)).toBe(text);
+    },
+  );
+});
+
+describe("customFieldValueToDate", () => {
+  test("reads an ISO string and a Date, and nothing else", () => {
+    expect(
+      customFieldValueToDate(" 2026-09-27T14:05:00.000Z ")?.toISOString(),
+    ).toBe("2026-09-27T14:05:00.000Z");
+    expect(
+      customFieldValueToDate(new Date("2026-09-27T14:05:00.000Z"))?.getTime(),
+    ).toBe(Date.parse("2026-09-27T14:05:00.000Z"));
+    expect(customFieldValueToDate("soon")).toBeNull();
+    expect(customFieldValueToDate("")).toBeNull();
+    expect(customFieldValueToDate(12)).toBeNull();
+    expect(customFieldValueToDate(new Date("x"))).toBeNull();
+  });
+});
+
+describe("formatCustomFieldBoolean", () => {
+  test.each([
+    [true, "Yes"],
+    [false, "No"],
+    ["true", "Yes"],
+    ["false", "No"],
+    ["maybe", "maybe"],
+    [1, "1"],
+  ] as Array<[unknown, string]>)(
+    "%p reads as %p",
+    (value: unknown, text: string) => {
+      expect(formatCustomFieldBoolean(value)).toBe(text);
+    },
+  );
+});
+
+describe("formatCustomFieldCalendarDate", () => {
+  /*
+   * What the dashboard's date input stores when 27 Sep 2026 is picked in
+   * `zone`: the day's midnight there, as a UTC instant (Input's onChange,
+   * OneUptimeDate.fromDateTimeLocalString then toString).
+   */
+  function storedByTheDateInput(zone: string, day: string): string {
+    OneUptimeDate.setUserTimezone(zone as Timezone);
+
+    try {
+      return OneUptimeDate.toString(OneUptimeDate.fromDateTimeLocalString(day));
+    } finally {
+      OneUptimeDate.setUserTimezone(null);
+    }
+  }
+
+  test.each([
+    // Stored as the day, or UTC midnight, by an API client.
+    ["2026-09-27", "2026-09-27"],
+    [" 2026-09-27 ", "2026-09-27"],
+    ["2026-09-27T00:00:00.000Z", "2026-09-27"],
+    // A time with no offset names its day wherever it is read.
+    ["2026-09-27T00:00:00", "2026-09-27"],
+    ["2026-09-27 23:30", "2026-09-27"],
+    // Local midnight with its offset written out.
+    ["2026-09-27T00:00:00+02:00", "2026-09-27"],
+    ["2026-09-27T00:00:00-04:00", "2026-09-27"],
+    // As the date input stores 27 Sep picked east and west of UTC.
+    ["2026-09-26T22:00:00.000Z", "2026-09-27"], // Berlin, UTC+2
+    ["2026-09-27T04:00:00.000Z", "2026-09-27"], // New York, UTC-4
+    ["2026-09-26T18:30:00.000Z", "2026-09-27"], // Kolkata, UTC+5:30
+    ["2026-09-26T11:00:00.000Z", "2026-09-27"], // Auckland in summer, UTC+13
+    ["2026-09-27T10:00:00.000Z", "2026-09-27"], // Honolulu, UTC-10
+    [new Date("2026-09-26T22:00:00.000Z"), "2026-09-27"],
+    ["next week", "next week"],
+    ["", ""],
+  ] as Array<[unknown, string]>)(
+    "%p reads as %p",
+    (value: unknown, text: string) => {
+      expect(formatCustomFieldCalendarDate(value)).toBe(text);
+    },
+  );
+
+  test("a day picked in Berlin reads as that day, not the UTC day before", () => {
+    const stored: string = storedByTheDateInput("Europe/Berlin", "2026-09-27");
+
+    // The regression: the old reader took the UTC day, 26 Sep.
+    expect(stored).toBe("2026-09-26T22:00:00.000Z");
+    expect(formatCustomFieldCalendarDate(stored)).toBe("2026-09-27");
+  });
+
+  test("a day picked in New York reads as that day", () => {
+    const stored: string = storedByTheDateInput(
+      "America/New_York",
+      "2026-09-27",
+    );
+
+    expect(stored).toBe("2026-09-27T04:00:00.000Z");
+    expect(formatCustomFieldCalendarDate(stored)).toBe("2026-09-27");
+  });
+
+  /*
+   * Every time zone from UTC-10:59 to UTC+13:00 reads the picked day, in
+   * summer and in winter, and at the turn of a month and a year.
+   */
+  test("reads the picked day for an author in every zone from UTC-10:59 to UTC+13:00", () => {
+    const days: Array<string> = ["2026-09-27", "2026-01-01", "2026-03-31"];
+    let zonesChecked: number = 0;
+
+    for (const zone of moment.tz.names()) {
+      for (const day of days) {
+        const offsetMinutes: number = moment.tz(day, zone).utcOffset();
+
+        if (offsetMinutes <= -11 * 60 || offsetMinutes > 13 * 60) {
+          continue;
+        }
+
+        const stored: string = moment.tz(day, zone).toDate().toISOString();
+
+        expect({
+          zone,
+          day,
+          read: formatCustomFieldCalendarDate(stored),
+        }).toEqual({ zone, day, read: day });
+        zonesChecked++;
+      }
+    }
+
+    // Hundreds of zones, not a filter that let nothing through.
+    expect(zonesChecked).toBeGreaterThan(1000);
+  });
+
+  test("an author in UTC-11 or past UTC+13 is off by a day, as documented", () => {
+    expect(
+      formatCustomFieldCalendarDate(
+        storedByTheDateInput("Pacific/Pago_Pago", "2026-09-27"),
+      ),
+    ).toBe("2026-09-28");
+    expect(
+      formatCustomFieldCalendarDate(
+        storedByTheDateInput("Pacific/Kiritimati", "2026-09-27"),
+      ),
+    ).toBe("2026-09-26");
+  });
+
+  test("does not depend on the reader's time zone", () => {
+    const stored: string = storedByTheDateInput("Asia/Tokyo", "2026-09-27");
+
+    for (const reader of ["America/Los_Angeles", "UTC", "Asia/Tokyo"]) {
+      OneUptimeDate.setUserTimezone(reader as Timezone);
+
+      try {
+        expect(formatCustomFieldCalendarDate(stored)).toBe("2026-09-27");
+      } finally {
+        OneUptimeDate.setUserTimezone(null);
+      }
+    }
+  });
+});
+
+describe("sortCustomFieldDefinitions", () => {
+  test("is the one the forms use", () => {
+    expect(sortFromForms).toBe(sortCustomFieldDefinitions);
+  });
+
+  test("orders by sortOrder, lowest first, then keeps the given order", () => {
+    const sorted: Array<{ name: string; sortOrder?: number | null }> =
+      sortCustomFieldDefinitions([
+        { name: "none-a" },
+        { name: "two", sortOrder: 2 },
+        { name: "one", sortOrder: 1 },
+        { name: "none-b", sortOrder: null },
+        { name: "two-b", sortOrder: 2 },
+        { name: "nan", sortOrder: Number.NaN },
+      ]);
+
+    expect(
+      sorted.map((definition: { name: string }) => {
+        return definition.name;
+      }),
+    ).toEqual(["one", "two", "two-b", "none-a", "none-b", "nan"]);
+  });
+});