@oneuptime/common 14.0.7 → 14.0.8

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

@@ -0,0 +1,343 @@
+import { CustomFieldDefinition } from "../../../Types/CustomField/CustomFieldDefinition";
+import CustomFieldType from "../../../Types/CustomField/CustomFieldType";
+import {
+  CustomFieldValueValidationError,
+  formatCustomFieldValueValidationErrors,
+  validateCustomFieldValues,
+} from "../../../Types/CustomField/CustomFieldValueValidator";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The server now checks custom field values against their definitions, in
+ * front of writes that have worked for years. What must hold:
+ *
+ *   - a value this write CHANGES must fit its field;
+ *   - a value it does not change passes, however it looks - the Custom
+ *     Fields card sends the whole bag back, so a legacy value (an option an
+ *     admin has since removed, text stored before the field became a
+ *     Number) must not block saving the other fields;
+ *   - unknown keys, empty values and untyped fields pass.
+ */
+
+const DEFINITIONS: Array<CustomFieldDefinition> = [
+  { name: "Summary", customFieldType: CustomFieldType.Text },
+  { name: "Details", customFieldType: CustomFieldType.LongText },
+  { name: "Notes", customFieldType: CustomFieldType.Markdown },
+  { name: "Estimated Duration", customFieldType: CustomFieldType.Number },
+  { name: "Acknowledgement", customFieldType: CustomFieldType.Boolean },
+  { name: "Started On", customFieldType: CustomFieldType.Date },
+  { name: "Expected Resolution", customFieldType: CustomFieldType.DateTime },
+  {
+    name: "Impact",
+    customFieldType: CustomFieldType.Dropdown,
+    dropdownOptions: "Low\nMedium\nHigh",
+  },
+  {
+    name: "Regions",
+    customFieldType: CustomFieldType.MultiSelectDropdown,
+    dropdownOptions: JSON.stringify([
+      { value: "East", color: "#ff0000" },
+      { value: "West", color: "#00ff00" },
+      { value: "North" },
+    ]),
+  },
+  {
+    name: "Unfinished Dropdown",
+    customFieldType: CustomFieldType.Dropdown,
+  },
+  { name: "Untyped" },
+];
+
+type ValidateFunction = (
+  customFields: unknown,
+  storedCustomFields?: unknown,
+) => Array<CustomFieldValueValidationError>;
+
+const validate: ValidateFunction = (
+  customFields: unknown,
+  storedCustomFields?: unknown,
+): Array<CustomFieldValueValidationError> => {
+  return validateCustomFieldValues({
+    definitions: DEFINITIONS,
+    customFields,
+    storedCustomFields,
+  });
+};
+
+type FieldNamesFunction = (
+  errors: Array<CustomFieldValueValidationError>,
+) => Array<string>;
+
+const fieldNames: FieldNamesFunction = (
+  errors: Array<CustomFieldValueValidationError>,
+): Array<string> => {
+  return errors.map((error: CustomFieldValueValidationError) => {
+    return error.fieldName;
+  });
+};
+
+describe("validateCustomFieldValues - values that fit", () => {
+  test.each([
+    ["Summary", "Payments are slow"],
+    ["Summary", 42],
+    ["Summary", true],
+    ["Details", "Line one\nLine two"],
+    ["Notes", "**Bold** and a [link](https://example.com)"],
+    ["Estimated Duration", 90],
+    ["Estimated Duration", 0],
+    ["Estimated Duration", -1.5],
+    ["Estimated Duration", "0"],
+    ["Estimated Duration", " 42 "],
+    ["Estimated Duration", "3.5"],
+    ["Acknowledgement", true],
+    ["Acknowledgement", false],
+    ["Acknowledgement", "true"],
+    ["Acknowledgement", "false"],
+    ["Started On", "2026-09-27"],
+    ["Started On", "2026-09-27T00:00:00.000Z"],
+    ["Expected Resolution", "2026-09-27T14:30:00.000Z"],
+    ["Expected Resolution", new Date("2026-09-27T14:30:00.000Z")],
+    ["Impact", "High"],
+    ["Regions", ["East", "West"]],
+    ["Regions", "North"],
+    ["Unfinished Dropdown", "Anything"],
+    ["Untyped", { any: "thing" }],
+  ])("%s accepts %j", (name: string, value: unknown) => {
+    expect(validate({ [name]: value })).toEqual([]);
+  });
+});
+
+describe("validateCustomFieldValues - values that do not fit", () => {
+  test.each([
+    ["Summary", { nested: true }],
+    ["Summary", ["a", "b"]],
+    ["Details", { nested: true }],
+    ["Notes", ["**a**"]],
+    ["Estimated Duration", "banana"],
+    ["Estimated Duration", "   "],
+    ["Estimated Duration", true],
+    ["Estimated Duration", ["1"]],
+    ["Acknowledgement", "yes"],
+    ["Acknowledgement", 1],
+    ["Started On", "not a date"],
+    ["Started On", 20260927],
+    ["Expected Resolution", "tomorrow-ish"],
+    ["Expected Resolution", new Date("invalid")],
+    ["Impact", "Critical"],
+    ["Impact", ["High"]],
+    ["Impact", { value: "High" }],
+    ["Regions", ["East", "South"]],
+    ["Regions", "South"],
+    ["Regions", [{ value: "East" }]],
+  ])("%s refuses %j", (name: string, value: unknown) => {
+    const errors: Array<CustomFieldValueValidationError> = validate({
+      [name]: value,
+    });
+
+    expect(fieldNames(errors)).toEqual([name]);
+    expect(errors[0]!.message).toContain(`"${name}"`);
+  });
+
+  test("names the options a dropdown value has to be one of", () => {
+    const errors: Array<CustomFieldValueValidationError> = validate({
+      Impact: "Critical",
+    });
+
+    expect(errors[0]!.message).toBe(
+      '"Critical" is not one of the options for "Impact". Choose one of: "Low", "Medium", "High".',
+    );
+  });
+
+  test("names every new multi-select entry that is not an option", () => {
+    const errors: Array<CustomFieldValueValidationError> = validate({
+      Regions: ["East", "South", "Central"],
+    });
+
+    expect(errors[0]!.message).toBe(
+      '"South", "Central" are not among the options for "Regions". Choose from: "East", "West", "North".',
+    );
+  });
+
+  test("reports every field that does not fit, in the order sent", () => {
+    const errors: Array<CustomFieldValueValidationError> = validate({
+      Impact: "Critical",
+      Summary: "fine",
+      "Estimated Duration": "soon",
+    });
+
+    expect(fieldNames(errors)).toEqual(["Impact", "Estimated Duration"]);
+    expect(formatCustomFieldValueValidationErrors(errors)).toBe(
+      `${errors[0]!.message} ${errors[1]!.message}`,
+    );
+  });
+
+  test("keeps a long value and a long option list to one line", () => {
+    const options: Array<string> = Array.from(
+      { length: 25 },
+      (_value: unknown, index: number) => {
+        return `Option ${index + 1}`;
+      },
+    );
+
+    const errors: Array<CustomFieldValueValidationError> =
+      validateCustomFieldValues({
+        definitions: [
+          {
+            name: "Big",
+            customFieldType: CustomFieldType.Dropdown,
+            dropdownOptions: options.join("\n"),
+          },
+        ],
+        customFields: { Big: "x".repeat(500) },
+      });
+
+    expect(errors[0]!.message).toContain("...");
+    expect(errors[0]!.message).toContain("and 15 more");
+    expect(errors[0]!.message.length).toBeLessThan(400);
+  });
+});
+
+describe("validateCustomFieldValues - only what this write changes", () => {
+  test("an unchanged legacy dropdown value passes", () => {
+    // "Severe" was an option once; the admin has since removed it.
+    expect(
+      validate(
+        { Impact: "Severe", Summary: "edited" },
+        { Impact: "Severe", Summary: "before" },
+      ),
+    ).toEqual([]);
+  });
+
+  test("an unchanged value of the wrong type passes", () => {
+    // Stored as free text before the field became a Number.
+    expect(
+      validate(
+        { "Estimated Duration": "about an hour", Impact: "High" },
+        { "Estimated Duration": "about an hour" },
+      ),
+    ).toEqual([]);
+  });
+
+  test("changing a legacy value to another invalid one fails", () => {
+    expect(
+      fieldNames(validate({ Impact: "Critical" }, { Impact: "Severe" })),
+    ).toEqual(["Impact"]);
+  });
+
+  test("changing a legacy value to a valid one passes", () => {
+    expect(validate({ Impact: "High" }, { Impact: "Severe" })).toEqual([]);
+  });
+
+  test("a multi-select keeps its removed options, and only new ones are checked", () => {
+    expect(
+      validate({ Regions: ["Old", "East"] }, { Regions: ["Old"] }),
+    ).toEqual([]);
+
+    expect(
+      fieldNames(validate({ Regions: ["Old", "South"] }, { Regions: ["Old"] })),
+    ).toEqual(["Regions"]);
+  });
+
+  test("a multi-select in a different order is unchanged", () => {
+    expect(
+      validate({ Regions: ["Gone", "Old"] }, { Regions: ["Old", "Gone"] }),
+    ).toEqual([]);
+  });
+
+  test("a multi-select that was a single value keeps it", () => {
+    expect(validate({ Regions: ["Old", "West"] }, { Regions: "Old" })).toEqual(
+      [],
+    );
+  });
+
+  test("a date sent as a Date matches the same stored string", () => {
+    expect(
+      validate(
+        { "Expected Resolution": new Date("2026-09-27T14:30:00.000Z") },
+        { "Expected Resolution": "2026-09-27T14:30:00.000Z" },
+      ),
+    ).toEqual([]);
+  });
+
+  test("every value counts as changed on create", () => {
+    expect(fieldNames(validate({ Impact: "Severe" }, {}))).toEqual(["Impact"]);
+    expect(fieldNames(validate({ Impact: "Severe" }))).toEqual(["Impact"]);
+    expect(fieldNames(validate({ Impact: "Severe" }, null))).toEqual([
+      "Impact",
+    ]);
+  });
+});
+
+describe("validateCustomFieldValues - what always passes", () => {
+  test("keys with no definition pass", () => {
+    expect(
+      validate({ "Deleted Field": { anything: [1, 2] }, Renamed: "banana" }),
+    ).toEqual([]);
+  });
+
+  test("keys match definitions by exact name", () => {
+    // A differently cased key is some other (unknown) key, not "Impact".
+    expect(validate({ impact: "Critical" })).toEqual([]);
+  });
+
+  test.each([[null], [undefined], [""], [[]]])(
+    "clearing a field with %j passes",
+    (value: unknown) => {
+      expect(
+        validate(
+          {
+            Impact: value,
+            Regions: value,
+            "Estimated Duration": value,
+            Acknowledgement: value,
+          },
+          { Impact: "High", Regions: ["East"] },
+        ),
+      ).toEqual([]);
+    },
+  );
+
+  test("false and 0 are values, and are checked as such", () => {
+    expect(
+      validate({ Acknowledgement: false, "Estimated Duration": 0 }),
+    ).toEqual([]);
+    expect(fieldNames(validate({ Impact: 0 }))).toEqual(["Impact"]);
+  });
+
+  test.each([[null], [undefined], ["a string"], [["an", "array"]], [42]])(
+    "a bag that is not an object (%j) is left to the rest of the write",
+    (customFields: unknown) => {
+      expect(validate(customFields)).toEqual([]);
+    },
+  );
+
+  test("a stored bag that is not an object counts as empty", () => {
+    expect(fieldNames(validate({ Impact: "Nope" }, "garbage"))).toEqual([
+      "Impact",
+    ]);
+    expect(validate({ Impact: "High" }, ["garbage"])).toEqual([]);
+  });
+
+  test("no definitions means nothing to check", () => {
+    expect(
+      validateCustomFieldValues({
+        definitions: [],
+        customFields: { Impact: "anything" },
+      }),
+    ).toEqual([]);
+  });
+
+  test("a field type this version does not know passes", () => {
+    expect(
+      validateCustomFieldValues({
+        definitions: [
+          {
+            name: "Future",
+            customFieldType: "Geolocation" as CustomFieldType,
+          },
+        ],
+        customFields: { Future: { lat: 1, lng: 2 } },
+      }),
+    ).toEqual([]);
+  });
+});

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

@@ -0,0 +1,364 @@
+import {
+  CUSTOM_FIELD_TEMPLATE_VARIABLE_PREFIX,
+  CUSTOM_FIELD_VARIABLE_KEY_FALLBACK,
+  CUSTOM_FIELD_VARIABLE_KEY_MAX_LENGTH,
+  generateCustomFieldVariableKey,
+  getCustomFieldTemplateVariableName,
+  getCustomFieldVariableKeyBase,
+  isValidCustomFieldVariableKey,
+} 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.
+ */
+
+type FillFunction = (key: string, value: string) => string;
+
+// What a template using the key comes out as.
+const fill: FillFunction = (key: string, value: string): string => {
+  return SubscriberNotificationTemplateCompiler.compileTemplate(
+    `Impact: {{${getCustomFieldTemplateVariableName(key)}}}`,
+    {
+      [getCustomFieldTemplateVariableName(key)]: value,
+    },
+  );
+};
+
+describe("getCustomFieldVariableKeyBase", () => {
+  test.each([
+    ["Impact", "impact"],
+    ["Expected Resolution", "expected_resolution"],
+    ["Estimated Duration (minutes)", "estimated_duration_minutes"],
+    ["Affected Users/Systems", "affected_users_systems"],
+    ["  Leading and trailing  ", "leading_and_trailing"],
+    ["multiple---separators___here", "multiple_separators_here"],
+    ["ALL CAPS", "all_caps"],
+    ["2FA Status", "2fa_status"],
+    ["already_snake_case", "already_snake_case"],
+    ["tabs\tand\nnewlines", "tabs_and_newlines"],
+    ["customFields.dotted", "customfields_dotted"],
+  ])("%j becomes %j", (name: string, key: string) => {
+    expect(getCustomFieldVariableKeyBase(name)).toBe(key);
+  });
+
+  test.each([
+    ["Café", "cafe"],
+    ["Résumé des impacts", "resume_des_impacts"],
+    ["Größe", "grosse"],
+    ["Straße", "strasse"],
+    ["Ærø Ø", "aero_o"],
+    ["Łódź", "lodz"],
+    ["Þórður", "thordur"],
+    ["Ñandú", "nandu"],
+    ["Ｆｕｌｌ ｗｉｄｔｈ", "full_width"],
+    ["field", "field"],
+    ["İstanbul", "istanbul"],
+    ["São Tomé", "sao_tome"],
+  ])(
+    "transliterates the Latin letters of %j into %j",
+    (name: string, key: string) => {
+      expect(getCustomFieldVariableKeyBase(name)).toBe(key);
+    },
+  );
+
+  test.each([
+    ["影响"],
+    ["Влияние"],
+    ["التأثير"],
+    ["🔥🔥"],
+    ["!!!"],
+    [""],
+    ["   "],
+    ["___"],
+  ])(
+    "falls back to %j's fallback key when nothing Latin is left",
+    (name: string) => {
+      expect(getCustomFieldVariableKeyBase(name)).toBe(
+        CUSTOM_FIELD_VARIABLE_KEY_FALLBACK,
+      );
+    },
+  );
+
+  test("keeps the Latin part of a mixed name", () => {
+    expect(getCustomFieldVariableKeyBase("Impact 影响")).toBe("impact");
+    expect(getCustomFieldVariableKeyBase("SLA — 🔥 Tier")).toBe("sla_tier");
+  });
+
+  test("tolerates a missing name", () => {
+    expect(getCustomFieldVariableKeyBase(undefined as unknown as string)).toBe(
+      CUSTOM_FIELD_VARIABLE_KEY_FALLBACK,
+    );
+  });
+
+  test("cuts a long name to the maximum without a trailing underscore", () => {
+    const name: string = `${"word ".repeat(40)}end`;
+    const key: string = getCustomFieldVariableKeyBase(name);
+
+    expect(key.length).toBeLessThanOrEqual(
+      CUSTOM_FIELD_VARIABLE_KEY_MAX_LENGTH,
+    );
+    expect(key.endsWith("_")).toBe(false);
+    expect(isValidCustomFieldVariableKey(key)).toBe(true);
+  });
+});
+
+describe("generateCustomFieldVariableKey", () => {
+  test("uses the name's key when nothing else has it", () => {
+    expect(
+      generateCustomFieldVariableKey({
+        name: "Impact",
+        existingKeys: ["expected_resolution"],
+      }),
+    ).toBe("impact");
+  });
+
+  test("numbers a collision from _2", () => {
+    expect(
+      generateCustomFieldVariableKey({
+        name: "Impact",
+        existingKeys: ["impact"],
+      }),
+    ).toBe("impact_2");
+  });
+
+  test("takes the first free number", () => {
+    expect(
+      generateCustomFieldVariableKey({
+        name: "impact!",
+        existingKeys: ["impact", "impact_2", "impact_3", "impact_5"],
+      }),
+    ).toBe("impact_4");
+  });
+
+  test("names differing only in punctuation or case get different keys", () => {
+    const taken: Array<string> = [];
+
+    for (const name of [
+      "Expected Resolution",
+      "expected-resolution",
+      "EXPECTED RESOLUTION",
+      "Expected  Resolution!",
+    ]) {
+      taken.push(generateCustomFieldVariableKey({ name, existingKeys: taken }));
+    }
+
+    expect(taken).toEqual([
+      "expected_resolution",
+      "expected_resolution_2",
+      "expected_resolution_3",
+      "expected_resolution_4",
+    ]);
+  });
+
+  test("a field literally named like a numbered key is not given it twice", () => {
+    const first: string = generateCustomFieldVariableKey({
+      name: "Impact 2",
+      existingKeys: [],
+    });
+    const second: string = generateCustomFieldVariableKey({
+      name: "Impact",
+      existingKeys: [first],
+    });
+    const third: string = generateCustomFieldVariableKey({
+      name: "Impact",
+      existingKeys: [first, second],
+    });
+
+    expect(first).toBe("impact_2");
+    expect(second).toBe("impact");
+    expect(third).toBe("impact_3");
+  });
+
+  test("names with nothing Latin share the fallback, numbered", () => {
+    const taken: Array<string> = [];
+
+    for (const name of ["影响", "Влияние", "🔥"]) {
+      taken.push(generateCustomFieldVariableKey({ name, existingKeys: taken }));
+    }
+
+    expect(taken).toEqual(["field", "field_2", "field_3"]);
+  });
+
+  test("ignores empty and missing existing keys", () => {
+    expect(
+      generateCustomFieldVariableKey({
+        name: "Impact",
+        existingKeys: [null, undefined, ""],
+      }),
+    ).toBe("impact");
+  });
+
+  test("accepts any iterable of existing keys", () => {
+    expect(
+      generateCustomFieldVariableKey({
+        name: "Impact",
+        existingKeys: new Set<string>(["impact"]),
+      }),
+    ).toBe("impact_2");
+  });
+
+  test("a numbered key of a maximum-length name still fits", () => {
+    const name: string = "a".repeat(200);
+    const base: string = getCustomFieldVariableKeyBase(name);
+    const numbered: string = generateCustomFieldVariableKey({
+      name,
+      existingKeys: [base],
+    });
+
+    expect(base.length).toBe(CUSTOM_FIELD_VARIABLE_KEY_MAX_LENGTH);
+    expect(numbered.length).toBeLessThanOrEqual(
+      CUSTOM_FIELD_VARIABLE_KEY_MAX_LENGTH,
+    );
+    expect(numbered.endsWith("_2")).toBe(true);
+    expect(isValidCustomFieldVariableKey(numbered)).toBe(true);
+  });
+
+  test("never ends the cut before a suffix on an underscore", () => {
+    // 62 characters, where the cut for "_2" lands right after an underscore.
+    const name: string = `${"a".repeat(61)} b`;
+    const base: string = getCustomFieldVariableKeyBase(name);
+    const numbered: string = generateCustomFieldVariableKey({
+      name,
+      existingKeys: [base],
+    });
+
+    expect(numbered).not.toContain("__");
+    expect(isValidCustomFieldVariableKey(numbered)).toBe(true);
+  });
+
+  test("hundreds of colliding fields all get distinct, valid keys", () => {
+    const taken: Array<string> = [];
+
+    for (let i: number = 0; i < 300; i++) {
+      taken.push(
+        generateCustomFieldVariableKey({
+          name: i % 2 === 0 ? "Impact" : "impact?",
+          existingKeys: taken,
+        }),
+      );
+    }
+
+    expect(new Set<string>(taken).size).toBe(300);
+    for (const key of taken) {
+      expect(isValidCustomFieldVariableKey(key)).toBe(true);
+    }
+  });
+});
+
+describe("keys always fit the template placeholder pattern", () => {
+  const names: Array<string> = [
+    "Impact",
+    "Expected Resolution",
+    "Größe",
+    "影响",
+    "Влияние",
+    "🔥 hot",
+    "a.b.c",
+    "{{customFields.x}}",
+    "$&",
+    "<script>alert(1)</script>",
+    "x".repeat(500),
+    "   ",
+    "2FA",
+    "Ｆｕｌｌ ｗｉｄｔｈ",
+  ];
+
+  test.each(names)(
+    "the key for %j is filled in by the compiler",
+    (name: string) => {
+      const key: string = generateCustomFieldVariableKey({
+        name,
+        existingKeys: ["impact", "field"],
+      });
+
+      expect(key).toMatch(/^[a-z0-9]+(?:_[a-z0-9]+)*$/);
+      expect(isValidCustomFieldVariableKey(key)).toBe(true);
+      expect(
+        SubscriberNotificationTemplateCompiler.isPlaceholderName(
+          getCustomFieldTemplateVariableName(key),
+        ),
+      ).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.");
+    expect(getCustomFieldTemplateVariableName("impact")).toBe(
+      "customFields.impact",
+    );
+  });
+
+  test("a slug would not work, which is why keys are not slugs", () => {
+    // Slug.getSlug joins with hyphens, which the compiler leaves as written.
+    const slug: string = Slug.getSlug("Expected Resolution");
+
+    expect(isValidCustomFieldVariableKey(slug)).toBe(false);
+    expect(
+      SubscriberNotificationTemplateCompiler.compileTemplate(
+        `{{customFields.${slug}}}`,
+        { [`customFields.${slug}`]: "x" },
+      ),
+    ).toBe(`{{customFields.${slug}}}`);
+  });
+});
+
+describe("isValidCustomFieldVariableKey", () => {
+  test.each(["impact", "expected_resolution", "a1_b2", "2fa", "x"])(
+    "accepts %j",
+    (key: string) => {
+      expect(isValidCustomFieldVariableKey(key)).toBe(true);
+    },
+  );
+
+  test.each([
+    "",
+    "Impact",
+    "expected-resolution",
+    "expected resolution",
+    "_impact",
+    "impact_",
+    "im__pact",
+    "im.pact",
+    "größe",
+    "a".repeat(CUSTOM_FIELD_VARIABLE_KEY_MAX_LENGTH + 1),
+    null,
+    undefined,
+    42,
+  ])("rejects %j", (key: unknown) => {
+    expect(isValidCustomFieldVariableKey(key)).toBe(false);
+  });
+});
+
+describe("SubscriberNotificationTemplateCompiler.isPlaceholderName", () => {
+  test("agrees with what the compiler fills", () => {
+    for (const name of ["a", "a.b", "customFields.impact_2", "A_1.b"]) {
+      expect(
+        SubscriberNotificationTemplateCompiler.isPlaceholderName(name),
+      ).toBe(true);
+      expect(
+        SubscriberNotificationTemplateCompiler.compileTemplate(`{{${name}}}`, {
+          [name]: "filled",
+        }),
+      ).toBe("filled");
+    }
+
+    for (const name of ["a-b", "a b", "é", "", "a{b"]) {
+      expect(
+        SubscriberNotificationTemplateCompiler.isPlaceholderName(name),
+      ).toBe(false);
+      expect(
+        SubscriberNotificationTemplateCompiler.compileTemplate(`{{${name}}}`, {
+          [name]: "filled",
+        }),
+      ).toBe(`{{${name}}}`);
+    }
+  });
+});