@oneuptime/common 14.0.12 → 14.0.13

package/Tests/Server/Utils/StatusPage/SubscriberNotificationPreviewBuilder.test.ts

@@ -6,7 +6,7 @@ import {
   jest,
   test,
 } from "@jest/globals";
-import type { Mock } from "jest-mock";
+import type { Mock, SpyInstance } from "jest-mock";
 
 /*
  * SubscriberNotificationPreviewBuilder: what "Preview notification" and "Send
@@ -83,6 +83,8 @@ import SubscriberNotificationPreviewBuilder, {
 } from "../../../../Server/Utils/StatusPage/SubscriberNotificationPreviewBuilder";
 import Hostname from "../../../../Types/API/Hostname";
 import Protocol from "../../../../Types/API/Protocol";
+import Color from "../../../../Types/Color";
+import EmailColorUtil from "../../../../Utils/Email/EmailColorUtil";
 import DatabaseCommonInteractionProps from "../../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import CustomFieldType from "../../../../Types/CustomField/CustomFieldType";
 import Dictionary from "../../../../Types/Dictionary";
@@ -908,6 +910,79 @@ describe("the emails", () => {
 
     expect(build.statusPages).toEqual([]);
   });
+
+  /*
+   * A preview shows the email subscribers get, and the default email now
+   * paints the severity in its own colour - so the preview reads the colour
+   * with the name, for a draft's chosen severity and for an existing
+   * incident's alike.
+   */
+  test("a draft's default email paints its severity in the severity's own colour", async () => {
+    const severityRead: SpyInstance<typeof IncidentSeverityService.findOneBy> =
+      jest
+        .spyOn(IncidentSeverityService, "findOneBy")
+        .mockImplementation((async (): Promise<IncidentSeverity> => {
+          const severity: IncidentSeverity = new IncidentSeverity();
+          severity._id = SEVERITY_ID;
+          severity.name = "Major";
+          severity.color = new Color("#facc15");
+          return severity;
+        }) as never);
+
+    const build: SubscriberNotificationPreviewBuild = await preview(draft(), {
+      onlyStatusPageId: SITE_2,
+    });
+
+    expect(
+      (severityRead.mock.calls[0]![0] as { select: JSONObject }).select,
+    ).toEqual(expect.objectContaining({ name: true, color: true }));
+    expect(body(build.statusPages[0]!)).toEqual(
+      expect.objectContaining({
+        incidentSeverity: "Major",
+        ...EmailColorUtil.getTemplateVariables("incidentSeverity", "#facc15"),
+      }),
+    );
+  });
+
+  test("an existing incident's preview reads its severity's colour too", async () => {
+    await preview(publicNote());
+
+    // The access check reads the incident first; the content read follows.
+    const severitySelects: Array<JSONObject> = (
+      IncidentService.findOneBy as unknown as jest.Mock
+    ).mock.calls
+      .map((call: Array<unknown>): JSONObject | undefined => {
+        return (call[0] as { select?: JSONObject }).select?.[
+          "incidentSeverity"
+        ] as JSONObject | undefined;
+      })
+      .filter((select: JSONObject | undefined): select is JSONObject => {
+        return Boolean(select);
+      });
+
+    expect(severitySelects).toEqual([{ name: true, color: true }]);
+  });
+
+  test("a severity without a usable colour previews the plain severity", async () => {
+    jest
+      .spyOn(IncidentSeverityService, "findOneBy")
+      .mockImplementation((async (): Promise<IncidentSeverity> => {
+        const severity: IncidentSeverity = new IncidentSeverity();
+        severity._id = SEVERITY_ID;
+        severity.name = "Major";
+        severity.color = new Color("#fff; position: fixed");
+        return severity;
+      }) as never);
+
+    const build: SubscriberNotificationPreviewBuild = await preview(draft(), {
+      onlyStatusPageId: SITE_2,
+    });
+
+    expect(body(build.statusPages[0]!)["incidentSeverity"]).toBe("Major");
+    expect(body(build.statusPages[0]!)).not.toHaveProperty(
+      "incidentSeverityColor",
+    );
+  });
 });
 
 describe("no side effects, and no addresses", () => {

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

@@ -7,8 +7,6 @@ import {
   compactCustomFieldCreateSettings,
   getCustomFieldCreateSetting,
   getEffectiveCustomFieldCreateSetting,
-  getIncidentFormAskedDefinitions,
-  getIncidentFormCustomFieldSetting,
   isCustomFieldCreateSetting,
   readCustomFieldCreateSettings,
   validateCustomFieldCreateSettings,
@@ -22,7 +20,7 @@ import fs from "fs";
 import path from "path";
 
 /*
- * A template's (or a form's) say over which incident custom fields are asked
+ * A template's say over which incident custom fields are asked
  * when an incident is declared, and which must be filled in (issue #4114).
  *
  * What matters most here:
@@ -31,8 +29,6 @@ import path from "path";
  *     (Terraform compares the column with its configuration);
  *   - a TEMPLATE only overrides: Default and unlisted fields keep their own
  *     Show on Create / Required on Create;
- *   - a FORM only asks what it lists as Required or Optional - never a field
- *     because of its project-wide switches, since the form is public;
  *   - nothing here changes the definitions it is handed.
  */
 
@@ -285,8 +281,10 @@ describe("validateCustomFieldCreateSettings: what the API accepts", () => {
     ["_impact", "a leading underscore"],
     ["impact_", "a trailing underscore"],
     ["impact__level", "a doubled underscore"],
-    ["customFields.impact", "the template placeholder"],
-    ["{{customFields.impact}}", "a whole placeholder"],
+    ["incident.customFields.impact", "the template placeholder"],
+    ["{{incident.customFields.impact}}", "a whole placeholder"],
+    ["customFields.impact", "the older template placeholder"],
+    ["{{customFields.impact}}", "a whole older placeholder"],
     ["", "nothing"],
     ["__proto__", "the prototype key"],
     ["ímpact", "an accent"],
@@ -663,35 +661,6 @@ describe("getEffectiveCustomFieldCreateSetting: what the Details step does with
   });
 });
 
-describe("getIncidentFormCustomFieldSetting: a form asks only what it lists", () => {
-  test.each([
-    ["Required", CustomFieldCreateSetting.Required],
-    ["Optional", CustomFieldCreateSetting.Optional],
-    ["Hidden", CustomFieldCreateSetting.Hidden],
-    ["Default", CustomFieldCreateSetting.Hidden],
-    ["required", CustomFieldCreateSetting.Hidden],
-  ])(
-    "a field listed as %j is %s",
-    (stored: string, expected: CustomFieldCreateSetting) => {
-      expect(
-        getIncidentFormCustomFieldSetting({ impact: stored }, "impact"),
-      ).toBe(expected);
-    },
-  );
-
-  test("a field that is not listed is not asked", () => {
-    expect(getIncidentFormCustomFieldSetting({}, "impact")).toBe(
-      CustomFieldCreateSetting.Hidden,
-    );
-    expect(getIncidentFormCustomFieldSetting(null, "impact")).toBe(
-      CustomFieldCreateSetting.Hidden,
-    );
-    expect(getIncidentFormCustomFieldSetting({ impact: "Required" })).toBe(
-      CustomFieldCreateSetting.Hidden,
-    );
-  });
-});
-
 describe("applyTemplateCustomFieldCreateSettings: a template only overrides", () => {
   test("Required, Optional and Hidden set both switches; Default and unlisted fields keep theirs", () => {
     const applied: Array<Definition> = applyTemplateCustomFieldCreateSettings(
@@ -884,120 +853,6 @@ describe("applyTemplateCustomFieldCreateSettings: a template only overrides", ()
   });
 });
 
-describe("getIncidentFormAskedDefinitions: a public form asks only what it lists", () => {
-  test("asks the Required and Optional fields, with the form's own Required", () => {
-    const asked: Array<Definition> = getIncidentFormAskedDefinitions(
-      projectFields(),
-      {
-        additional_information: "Required",
-        customer: "Optional",
-      },
-    );
-
-    expect(switchesOf(asked)).toEqual([
-      {
-        name: "Additional Information",
-        showOnCreate: true,
-        isRequiredOnCreate: true,
-      },
-      { name: "Customer", showOnCreate: true, isRequiredOnCreate: false },
-    ]);
-  });
-
-  test("never asks a field because of its project-wide switches", () => {
-    /*
-     * Impact is shown and required on the dashboard's Declare Incident form,
-     * but this form does not list it, so its name and its options must not
-     * reach the public page.
-     */
-    expect(names(getIncidentFormAskedDefinitions(projectFields(), {}))).toEqual(
-      [],
-    );
-    expect(
-      names(
-        getIncidentFormAskedDefinitions(projectFields(), {
-          impact: "Default",
-          affected_location: "Hidden",
-        }),
-      ),
-    ).toEqual([]);
-  });
-
-  test("a form's Optional does not become required because the project requires the field", () => {
-    const [asked] = getIncidentFormAskedDefinitions(projectFields(), {
-      impact: "Optional",
-    });
-
-    expect(asked!.name).toBe("Impact");
-    expect(asked!.isRequiredOnCreate).toBe(false);
-  });
-
-  test("puts the fields in the order fields are shown everywhere else", () => {
-    const fields: Array<Definition> = [
-      definition("Unordered B", "unordered_b"),
-      definition("Third", "third", { sortOrder: 3 }),
-      definition("Unordered A", "unordered_a"),
-      definition("First", "first", { sortOrder: 1 }),
-    ];
-
-    expect(
-      names(
-        getIncidentFormAskedDefinitions(fields, {
-          unordered_b: "Optional",
-          third: "Required",
-          unordered_a: "Optional",
-          first: "Optional",
-        }),
-      ),
-    ).toEqual(["First", "Third", "Unordered B", "Unordered A"]);
-  });
-
-  test("never asks a field with no key, or anything with no valid settings", () => {
-    const fields: Array<Definition> = [
-      definition("Legacy", undefined, { showOnCreate: true }),
-      definition("Impact", "impact"),
-    ];
-
-    expect(
-      getIncidentFormAskedDefinitions(fields, { legacy: "Required" }),
-    ).toEqual([]);
-
-    for (const settings of [undefined, null, [], "Required", 5]) {
-      expect(getIncidentFormAskedDefinitions(fields, settings)).toEqual([]);
-    }
-  });
-
-  test("returns copies and never touches the definitions it is given", () => {
-    const fields: Array<Definition> = deepFreeze(projectFields());
-
-    const asked: Array<Definition> = getIncidentFormAskedDefinitions(fields, {
-      impact: "Optional",
-    });
-
-    expect(asked[0]).not.toBe(fields[0]);
-    expect(fields).toEqual(projectFields());
-  });
-
-  test("a model instance comes back as an instance of its own class", () => {
-    class FieldRow {
-      public name: string = "Impact";
-      public variableKey: string = "impact";
-      public sortOrder: number = 1;
-
-      public label(): string {
-        return this.name.toUpperCase();
-      }
-    }
-
-    const [asked] = getIncidentFormAskedDefinitions([new FieldRow()], {
-      impact: "Required",
-    });
-
-    expect(asked).toBeInstanceOf(FieldRow);
-    expect(asked!.label()).toBe("IMPACT");
-  });
-});
-
 describe("compactCustomFieldCreateSettings: the smallest value that means the same", () => {
   test("drops Default entries and invalid ones, keeps the rest", () => {
     expect(
@@ -1016,23 +871,6 @@ describe("compactCustomFieldCreateSettings: the smallest value that means the sa
     });
   });
 
-  test("for a form, drops Hidden too: it means not asked, as Default does", () => {
-    expect(
-      compactCustomFieldCreateSettings(
-        {
-          impact: "Required",
-          affected_location: "Optional",
-          additional_information: "Hidden",
-          customer: "Default",
-        },
-        { dropHidden: true },
-      ),
-    ).toEqual({
-      impact: "Required",
-      affected_location: "Optional",
-    });
-  });
-
   test.each([["null", null], ["undefined", undefined], ...NOT_SETTINGS])(
     "compacts %s to no settings",
     (_label: string, value: unknown) => {
@@ -1064,20 +902,14 @@ describe("compactCustomFieldCreateSettings: the smallest value that means the sa
 
     const compacted: CustomFieldCreateSettings =
       compactCustomFieldCreateSettings(settings);
-    const compactedForForm: CustomFieldCreateSettings =
-      compactCustomFieldCreateSettings(settings, { dropHidden: true });
 
     expect(validateCustomFieldCreateSettings(compacted)).toBeNull();
-    expect(validateCustomFieldCreateSettings(compactedForForm)).toBeNull();
 
     expect(
       applyTemplateCustomFieldCreateSettings(projectFields(), compacted),
     ).toEqual(
       applyTemplateCustomFieldCreateSettings(projectFields(), settings),
     );
-    expect(
-      getIncidentFormAskedDefinitions(projectFields(), compactedForForm),
-    ).toEqual(getIncidentFormAskedDefinitions(projectFields(), settings));
   });
 });
 

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

@@ -1,22 +1,29 @@
 import {
   CUSTOM_FIELD_TEMPLATE_VARIABLE_PREFIX,
+  CUSTOM_FIELD_TEMPLATE_VARIABLE_PREFIXES,
   CUSTOM_FIELD_VARIABLE_KEY_FALLBACK,
   CUSTOM_FIELD_VARIABLE_KEY_MAX_LENGTH,
   generateCustomFieldVariableKey,
   getCustomFieldTemplateVariableName,
+  getCustomFieldTemplateVariableNames,
   getCustomFieldVariableKeyBase,
+  getCustomFieldVariableKeyFromTemplateVariableName,
+  isCustomFieldTemplateVariableName,
   isValidCustomFieldVariableKey,
+  LEGACY_CUSTOM_FIELD_TEMPLATE_VARIABLE_PREFIX,
+  normalizeCustomFieldTemplateVariableName,
 } from "../../../Types/CustomField/CustomFieldVariableKey";
 import Slug from "../../../Utils/Slug";
 import SubscriberNotificationTemplateCompiler from "../../../Types/StatusPage/SubscriberNotificationTemplateCompiler";
 import { describe, expect, test } from "@jest/globals";
 
 /*
- * An incident custom field's template key is how a custom subscriber email
- * reaches its value: {{customFields.<key>}}. The template compiler fills only
- * placeholders of ASCII word characters and dots, so what matters most here
- * is that every key - whatever the name, whatever else the project holds -
- * is one the compiler will actually fill.
+ * An incident custom field's template key is how a note template or a custom
+ * subscriber email reaches its value: {{incident.customFields.<key>}}. The
+ * template compiler fills only placeholders of ASCII word characters and
+ * dots, so what matters most here is that every key - whatever the name,
+ * whatever else the project holds - is one the compiler will actually fill,
+ * under the documented name and the older {{customFields.<key>}} alike.
  */
 
 type FillFunction = (key: string, value: string) => string;
@@ -280,19 +287,25 @@ describe("keys always fit the template placeholder pattern", () => {
 
       expect(key).toMatch(/^[a-z0-9]+(?:_[a-z0-9]+)*$/);
       expect(isValidCustomFieldVariableKey(key)).toBe(true);
-      expect(
-        SubscriberNotificationTemplateCompiler.isPlaceholderName(
-          getCustomFieldTemplateVariableName(key),
-        ),
-      ).toBe(true);
+
+      for (const variableName of getCustomFieldTemplateVariableNames(key)) {
+        expect(
+          SubscriberNotificationTemplateCompiler.isPlaceholderName(
+            variableName,
+          ),
+        ).toBe(true);
+      }
+
       expect(fill(key, "High")).toBe("Impact: High");
     },
   );
 
-  test("the prefix is the one custom templates use", () => {
-    expect(CUSTOM_FIELD_TEMPLATE_VARIABLE_PREFIX).toBe("customFields.");
+  test("the prefix names the incident: {{incident.customFields.<key>}}", () => {
+    expect(CUSTOM_FIELD_TEMPLATE_VARIABLE_PREFIX).toBe(
+      "incident.customFields.",
+    );
     expect(getCustomFieldTemplateVariableName("impact")).toBe(
-      "customFields.impact",
+      "incident.customFields.impact",
     );
   });
 
@@ -301,12 +314,136 @@ describe("keys always fit the template placeholder pattern", () => {
     const slug: string = Slug.getSlug("Expected Resolution");
 
     expect(isValidCustomFieldVariableKey(slug)).toBe(false);
+
+    for (const variableName of getCustomFieldTemplateVariableNames(slug)) {
+      expect(
+        SubscriberNotificationTemplateCompiler.compileTemplate(
+          `{{${variableName}}}`,
+          { [variableName]: "x" },
+        ),
+      ).toBe(`{{${variableName}}}`);
+    }
+  });
+});
+
+/*
+ * "This custom fields.key template should be prefixed with incident." The
+ * documented name of a custom field variable is
+ * {{incident.customFields.<key>}}, beside {{incident.title}} and the other
+ * incident values; templates saved with the older {{customFields.<key>}}
+ * keep working, so the older name is still recognised everywhere a variable
+ * is filled or checked - but it is never the one handed out.
+ */
+describe("the template variable names a field is reached by", () => {
+  test("the documented prefix comes first, then the older one", () => {
+    expect(LEGACY_CUSTOM_FIELD_TEMPLATE_VARIABLE_PREFIX).toBe("customFields.");
+    expect(CUSTOM_FIELD_TEMPLATE_VARIABLE_PREFIXES).toEqual([
+      "incident.customFields.",
+      "customFields.",
+    ]);
+  });
+
+  test("a key is reached by both names, the documented one first", () => {
+    expect(getCustomFieldTemplateVariableNames("expected_resolution")).toEqual([
+      "incident.customFields.expected_resolution",
+      "customFields.expected_resolution",
+    ]);
+    expect(getCustomFieldTemplateVariableNames("impact")[0]).toBe(
+      getCustomFieldTemplateVariableName("impact"),
+    );
+  });
+
+  test("a template written either way is filled with the same value", () => {
+    const values: Record<string, string> = {};
+
+    for (const variableName of getCustomFieldTemplateVariableNames("impact")) {
+      values[variableName] = "High";
+    }
+
     expect(
       SubscriberNotificationTemplateCompiler.compileTemplate(
-        `{{customFields.${slug}}}`,
-        { [`customFields.${slug}`]: "x" },
+        "new={{incident.customFields.impact}} old={{customFields.impact}} spaced={{ incident.customFields.impact }}",
+        values,
+      ),
+    ).toBe("new=High old=High spaced=High");
+  });
+
+  test.each([
+    ["incident.customFields.impact", "impact"],
+    ["customFields.impact", "impact"],
+    ["incident.customFields.expected_resolution_2", "expected_resolution_2"],
+    // Not checked for shape: a mistyped key still names a custom field.
+    ["incident.customFields.Not-A-Key", "Not-A-Key"],
+    ["customFields.", ""],
+    ["incident.customFields.", ""],
+  ])("%j reaches the key %j", (name: string, key: string) => {
+    expect(getCustomFieldVariableKeyFromTemplateVariableName(name)).toBe(key);
+    expect(isCustomFieldTemplateVariableName(name)).toBe(true);
+  });
+
+  test.each([
+    "incidentTitle",
+    "incident.title",
+    "incident.labels",
+    "incidentLabels",
+    "affectedStatusPages",
+    "customfields.impact",
+    "incident.customfields.impact",
+    "Incident.customFields.impact",
+    "customFieldsimpact",
+    "incident.customFieldsimpact",
+    "alert.customFields.impact",
+    "monitor.customFields.impact",
+    "",
+  ])("%j is not a custom field variable", (name: string) => {
+    expect(getCustomFieldVariableKeyFromTemplateVariableName(name)).toBeNull();
+    expect(isCustomFieldTemplateVariableName(name)).toBe(false);
+    // Anything else is left exactly as it is.
+    expect(normalizeCustomFieldTemplateVariableName(name)).toBe(name);
+  });
+
+  test("tolerates a name that is not a string", () => {
+    expect(
+      getCustomFieldVariableKeyFromTemplateVariableName(
+        undefined as unknown as string,
       ),
-    ).toBe(`{{customFields.${slug}}}`);
+    ).toBeNull();
+  });
+
+  test("the older name of a field reads as its documented name", () => {
+    expect(
+      normalizeCustomFieldTemplateVariableName("customFields.impact"),
+    ).toBe("incident.customFields.impact");
+    expect(
+      normalizeCustomFieldTemplateVariableName("incident.customFields.impact"),
+    ).toBe("incident.customFields.impact");
+    expect(
+      normalizeCustomFieldTemplateVariableName("customFields.root_cause"),
+    ).toBe(
+      normalizeCustomFieldTemplateVariableName(
+        "incident.customFields.root_cause",
+      ),
+    );
+    expect(
+      normalizeCustomFieldTemplateVariableName("customFields.root_cause"),
+    ).not.toBe(normalizeCustomFieldTemplateVariableName("customFields.impact"));
+  });
+
+  test("every generated key is valid under both names", () => {
+    for (const name of ["Impact", "Expected Resolution", "影响", "2FA"]) {
+      const key: string = generateCustomFieldVariableKey({
+        name: name,
+        existingKeys: [],
+      });
+
+      expect(isValidCustomFieldVariableKey(key)).toBe(true);
+
+      for (const variableName of getCustomFieldTemplateVariableNames(key)) {
+        expect(
+          getCustomFieldVariableKeyFromTemplateVariableName(variableName),
+        ).toBe(key);
+      }
+    }
   });
 });
 
@@ -339,7 +476,13 @@ describe("isValidCustomFieldVariableKey", () => {
 
 describe("SubscriberNotificationTemplateCompiler.isPlaceholderName", () => {
   test("agrees with what the compiler fills", () => {
-    for (const name of ["a", "a.b", "customFields.impact_2", "A_1.b"]) {
+    for (const name of [
+      "a",
+      "a.b",
+      "incident.customFields.impact_2",
+      "customFields.impact_2",
+      "A_1.b",
+    ]) {
       expect(
         SubscriberNotificationTemplateCompiler.isPlaceholderName(name),
       ).toBe(true);