@capillarytech/creatives-library 8.0.288 → 8.0.290-alpha.0

package/utils/tests/commonUtil.test.js

@@ -6,6 +6,8 @@ import {
   extractContent,
   addBaseToTemplate,
   validateCarouselCards,
+  hasPersonalizationTags,
+  checkForPersonalizationTokens,
 } from "../commonUtils";
 import { skipTags } from "../tagValidations";
 import { SMS_TRAI_VAR } from '../../v2Containers/SmsTrai/Edit/constants';
@@ -20,13 +22,17 @@ describe("validateLiquidTemplateContent", () => {
     somethingWentWrong: { id: "wrong" },
     unsupportedTagsValidationError: { id: "unsupported" }
   };
-  const tagLookupMap = { foo: true };
   const eventContextTags = [{ tagName: "bar" }];
   const onError = jest.fn();
   const onSuccess = jest.fn();
 
   beforeEach(() => {
     jest.clearAllMocks();
+    formatMessage.mockImplementation((msg, vars) =>
+      vars && vars.unsupportedTags != null
+        ? `${msg?.id}:${vars.unsupportedTags}`
+        : (msg?.id ?? "unsupported")
+    );
   });
 
   it("calls onError for empty content", async () => {
@@ -39,11 +45,10 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags
     });
     expect(onError).toHaveBeenCalledWith({
-      standardErrors: [undefined],
+      standardErrors: ["empty"],
       liquidErrors: [],
       tabType: undefined
     });
@@ -58,7 +63,6 @@ describe("validateLiquidTemplateContent", () => {
       getLiquidTags,
       formatMessage,
       messages,
-      tagLookupMap,
       eventContextTags
     });
     expect(onError).not.toHaveBeenCalled();
@@ -75,7 +79,6 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags
     });
     expect(onError).toHaveBeenCalledWith({
@@ -86,9 +89,149 @@ describe("validateLiquidTemplateContent", () => {
     expect(onSuccess).not.toHaveBeenCalled();
   });
 
-  it("calls onError for unsupported tags", async () => {
+  it("categorizes errors as liquidErrors when isError=true with no result.errors (line 194-197)", async () => {
+    // isError=true + empty errors array → else-if (isError) branch → liquidErrors = [somethingWrongMsg]
+    // Use a plain function (not jest.fn) to avoid resetMocks:true wiping the implementation
+    const localFormatMessage = (msg) => msg?.id;
     const getLiquidTags = jest.fn((content, cb) =>
-      cb({ askAiraResponse: { errors: [], data: [{ name: "baz" }] }, isError: false })
+      cb({ askAiraResponse: { errors: [], data: [] }, isError: true })
+    );
+    await validateLiquidTemplateContent("foo", {
+      getLiquidTags,
+      formatMessage: localFormatMessage,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags
+    });
+    expect(onError).toHaveBeenCalledWith({
+      standardErrors: [],
+      liquidErrors: ["wrong"],
+      tabType: undefined
+    });
+    expect(onSuccess).not.toHaveBeenCalled();
+  });
+
+  it("falls back to somethingWentWrong when error.message is not a string (line 189-191)", async () => {
+    // error.message is an object, not a string → typeof check fails → returns somethingWrongMsg
+    const localFormatMessage = (msg) => msg?.id;
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ askAiraResponse: { errors: [{ message: { code: 123 } }], data: [] }, isError: false })
+    );
+    await validateLiquidTemplateContent("foo", {
+      getLiquidTags,
+      formatMessage: localFormatMessage,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags
+    });
+    expect(onError).toHaveBeenCalledWith({
+      standardErrors: [],
+      liquidErrors: ["wrong"],
+      tabType: undefined
+    });
+  });
+
+  it("falls back to somethingWentWrong when error.message is null (line 189-191)", async () => {
+    const localFormatMessage = (msg) => msg?.id;
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ askAiraResponse: { errors: [{ message: null }], data: [] }, isError: false })
+    );
+    await validateLiquidTemplateContent("foo", {
+      getLiquidTags,
+      formatMessage: localFormatMessage,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags
+    });
+    expect(onError).toHaveBeenCalledWith({
+      standardErrors: [],
+      liquidErrors: ["wrong"],
+      tabType: undefined
+    });
+  });
+
+  it("falls back to somethingWentWrong when error.message is undefined (line 189-191)", async () => {
+    const localFormatMessage = (msg) => msg?.id;
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ askAiraResponse: { errors: [{}], data: [] }, isError: false })
+    );
+    await validateLiquidTemplateContent("foo", {
+      getLiquidTags,
+      formatMessage: localFormatMessage,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags
+    });
+    expect(onError).toHaveBeenCalledWith({
+      standardErrors: [],
+      liquidErrors: ["wrong"],
+      tabType: undefined
+    });
+  });
+
+  it("maps multiple errors with mixed string/non-string messages (line 188-193)", async () => {
+    const localFormatMessage = (msg) => msg?.id;
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({
+        askAiraResponse: {
+          errors: [
+            { message: "First error" },
+            { message: null },
+            { message: "Third error" },
+          ],
+          data: [],
+        },
+        isError: false,
+      })
+    );
+    await validateLiquidTemplateContent("foo", {
+      getLiquidTags,
+      formatMessage: localFormatMessage,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags
+    });
+    expect(onError).toHaveBeenCalledWith({
+      standardErrors: [],
+      liquidErrors: ["First error", "wrong", "Third error"],
+      tabType: undefined
+    });
+  });
+
+  it("prefers result.errors over isError when both are present (result.errors takes the if-branch)", async () => {
+    // Both errors array AND isError=true → the if-branch (line 186) wins over else-if (line 194)
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ askAiraResponse: { errors: [{ message: "from errors array" }], data: [] }, isError: true })
+    );
+    await validateLiquidTemplateContent("foo", {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags
+    });
+    expect(onError).toHaveBeenCalledWith({
+      standardErrors: [],
+      liquidErrors: ["from errors array"],
+      tabType: undefined
+    });
+  });
+
+  it("calls onError when API returns success but response.errors has validation errors (e.g. unsupported tag)", async () => {
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({
+        askAiraResponse: {
+          errors: [{ message: "Unsupported tag: custom_tag" }],
+          data: []
+        },
+        isError: false
+      })
     );
     await validateLiquidTemplateContent("foo", {
       getLiquidTags,
@@ -96,18 +239,33 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags
     });
     expect(onError).toHaveBeenCalledWith({
       standardErrors: [],
-      liquidErrors: [undefined],
+      liquidErrors: ["Unsupported tag: custom_tag"],
       tabType: undefined
     });
     expect(onSuccess).not.toHaveBeenCalled();
   });
 
-  it("calls onSuccess for valid content", async () => {
+  it("calls onSuccess when API returns no errors and a single extracted tag (extracted tags are not validated)", async () => {
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ askAiraResponse: { errors: [], data: [{ name: "foo" }] }, isError: false })
+    );
+    await validateLiquidTemplateContent("foo", {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags
+    });
+    expect(onSuccess).toHaveBeenCalledWith("foo", undefined);
+    expect(onError).not.toHaveBeenCalled();
+  });
+
+  it("calls onSuccess for valid content when API returns multiple extracted tags but no errors", async () => {
     const getLiquidTags = jest.fn((content, cb) =>
       cb({ askAiraResponse: { errors: [], data: [{ name: "foo" }, { name: "bar" }] }, isError: false })
     );
@@ -117,7 +275,6 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags
     });
     expect(onSuccess).toHaveBeenCalledWith("foo", undefined);
@@ -133,7 +290,6 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags,
       skipTags
     });
@@ -151,7 +307,6 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags,
       skipTags
     });
@@ -169,7 +324,6 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags,
       skipTags
     });
@@ -187,7 +341,6 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags,
       skipTags
     });
@@ -205,7 +358,6 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags,
       skipTags
     });
@@ -223,7 +375,6 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags,
       skipTags
     });
@@ -241,7 +392,6 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags,
       skipTags
     });
@@ -259,7 +409,6 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags,
       skipTags
     });
@@ -277,7 +426,6 @@ describe("validateLiquidTemplateContent", () => {
     };
     const onError = jest.fn();
     const onSuccess = jest.fn();
-    const tagLookupMap = {};
     const eventContextTags = [];
     await validateLiquidTemplateContent('', {
       getLiquidTags,
@@ -285,7 +433,6 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags,
     });
     expect(formatMessage).toHaveBeenCalledWith(messages.emailBodyEmptyError);
@@ -297,7 +444,7 @@ describe("validateLiquidTemplateContent", () => {
     expect(onSuccess).not.toHaveBeenCalled();
   });
 
-  it("should skip tags that appear in {% %} syntax (like order.items in for loop)", async () => {
+  it("calls onSuccess when API returns extracted tags from {% for %} template but no errors (extracted tags are not validated)", async () => {
     const content = '{% for item in order.items %} Hello {% endfor %}';
     const getLiquidTags = jest.fn((content, cb) =>
       cb({ askAiraResponse: { errors: [], data: [{ name: "order.items" }] }, isError: false })
@@ -308,15 +455,13 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags
     });
-    // order.items appears in {% %} syntax, so it should be skipped and validation should pass
     expect(onSuccess).toHaveBeenCalledWith(content, undefined);
     expect(onError).not.toHaveBeenCalled();
   });
 
-  it("should skip tags that appear only inside {% %} blocks (like item.name in for loop)", async () => {
+  it("calls onSuccess when API returns extracted tags in {% %} blocks but no errors", async () => {
     const content = '{% for item in order.items %} {{ item.name }} - {{ item.quantity }} {% endfor %}';
     const getLiquidTags = jest.fn((content, cb) =>
       cb({ askAiraResponse: { errors: [], data: [{ name: "item.name" }, { name: "item.quantity" }] }, isError: false })
@@ -327,15 +472,13 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags
     });
-    // item.name and item.quantity appear inside {% for %} block, so they should be skipped
     expect(onSuccess).toHaveBeenCalledWith(content, undefined);
     expect(onError).not.toHaveBeenCalled();
   });
 
-  it("should validate tags that don't appear in content but are extracted by API", async () => {
+  it("calls onSuccess when API returns extracted tags not in content but no errors", async () => {
     const content = 'Some content without the tag';
     const getLiquidTags = jest.fn((content, cb) =>
       cb({ askAiraResponse: { errors: [], data: [{ name: "extractedTag" }] }, isError: false })
@@ -346,19 +489,13 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags
     });
-    // extractedTag doesn't appear in content but was extracted by API, should be validated
-    expect(onError).toHaveBeenCalledWith({
-      standardErrors: [],
-      liquidErrors: [undefined],
-      tabType: undefined
-    });
-    expect(onSuccess).not.toHaveBeenCalled();
+    expect(onSuccess).toHaveBeenCalledWith(content, undefined);
+    expect(onError).not.toHaveBeenCalled();
   });
 
-  it("should validate tags that appear outside {% %} blocks", async () => {
+  it("calls onSuccess when API returns tags outside {% %} but no errors", async () => {
     const content = '{{ outsideTag }} {% for item in order.items %} {{ item.name }} {% endfor %}';
     const getLiquidTags = jest.fn((content, cb) =>
       cb({ askAiraResponse: { errors: [], data: [{ name: "outsideTag" }, { name: "item.name" }] }, isError: false })
@@ -369,20 +506,70 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags
     });
-    // outsideTag appears outside {% %} block, so it should be validated
-    // item.name appears inside block, so it should be skipped
-    expect(onError).toHaveBeenCalledWith({
-      standardErrors: [],
-      liquidErrors: [undefined],
-      tabType: undefined
+    expect(onSuccess).toHaveBeenCalledWith(content, undefined);
+    expect(onError).not.toHaveBeenCalled();
+  });
+
+  it("calls onSuccess when API returns tag in {{ }} and no errors", async () => {
+    const content = 'Hello {{ unsupportedTag }} world';
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ askAiraResponse: { errors: [], data: [{ name: "unsupportedTag" }] }, isError: false })
+    );
+    await validateLiquidTemplateContent(content, {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags
     });
-    expect(onSuccess).not.toHaveBeenCalled();
+    expect(onSuccess).toHaveBeenCalledWith(content, undefined);
+    expect(onError).not.toHaveBeenCalled();
+  });
+
+  it("calls onSuccess when API returns tag with spacing variants and no errors", async () => {
+    const content = '{{ tag}} and {{tag }} and {{ tag }}';
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({
+        askAiraResponse: {
+          errors: [],
+          data: [{ name: "tag" }]
+        },
+        isError: false
+      })
+    );
+    await validateLiquidTemplateContent(content, {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags
+    });
+    expect(onSuccess).toHaveBeenCalledWith(content, undefined);
+    expect(onError).not.toHaveBeenCalled();
+  });
+
+  it("calls onSuccess when API returns tag inside {% %} blocks but no errors", async () => {
+    const content = '{% for x in some.unsupported %} {{ x }} {% endfor %}';
+    const getLiquidTags = jest.fn((content, cb) =>
+      cb({ askAiraResponse: { errors: [], data: [{ name: "some.unsupported" }] }, isError: false })
+    );
+    await validateLiquidTemplateContent(content, {
+      getLiquidTags,
+      formatMessage,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags
+    });
+    expect(onSuccess).toHaveBeenCalledWith(content, undefined);
+    expect(onError).not.toHaveBeenCalled();
   });
 
-  it("should skip tags with dots that appear in {% %} syntax", async () => {
+  it("calls onSuccess when API returns tags with dots in {% %} syntax but no errors", async () => {
     const content = '{% assign myVar = order.items %} Some text';
     const getLiquidTags = jest.fn((content, cb) =>
       cb({ askAiraResponse: { errors: [], data: [{ name: "order.items" }] }, isError: false })
@@ -393,10 +580,8 @@ describe("validateLiquidTemplateContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags
     });
-    // order.items appears in {% %} syntax, so it should be skipped
     expect(onSuccess).toHaveBeenCalledWith(content, undefined);
     expect(onError).not.toHaveBeenCalled();
   });
@@ -451,7 +636,6 @@ describe("validateMobilePushContent", () => {
     somethingWentWrong: { id: "wrong" },
     unsupportedTagsValidationError: { id: "unsupported" }
   };
-  const tagLookupMap = { foo: true };
   const eventContextTags = [{ tagName: "foo" }];
   const onError = jest.fn();
   const onSuccess = jest.fn();
@@ -460,7 +644,7 @@ describe("validateMobilePushContent", () => {
     jest.clearAllMocks();
   });
 
-  it("calls onError for empty formData", async () => {
+  it("calls onError for empty formData (validateMobilePushContent)", async () => {
     const getLiquidTags = jest.fn((content, cb) =>
       cb({ askAiraResponse: { errors: [], data: [] }, isError: false })
     );
@@ -469,18 +653,17 @@ describe("validateMobilePushContent", () => {
       {
         getLiquidTags,
         formatMessage,
-        messages,
-        onError,
-        onSuccess,
-        tagLookupMap,
-        eventContextTags,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags,
         currentTab: 1
       }
     );
     expect(onError).toHaveBeenCalled();
   });
 
-  it("calls onSuccess for valid android and ios content", async () => {
+  it("calls onSuccess for valid android and ios content (validateMobilePushContent)", async () => {
     const getLiquidTags = jest.fn((content, cb) =>
       cb({ askAiraResponse: { errors: [], data: [] }, isError: false })
     );
@@ -491,7 +674,6 @@ describe("validateMobilePushContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags,
       currentTab: 1
     });
@@ -509,7 +691,6 @@ describe("validateMobilePushContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags,
       currentTab: 1
     });
@@ -527,7 +708,6 @@ describe("validateMobilePushContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags,
       currentTab: 2
     });
@@ -545,7 +725,6 @@ describe("validateMobilePushContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags
     });
     expect(onSuccess).toHaveBeenCalledWith(JSON.stringify(formData[0]), "android");
@@ -562,7 +741,6 @@ describe("validateMobilePushContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags
     });
     expect(onSuccess).toHaveBeenCalledWith("null", "android");
@@ -575,11 +753,10 @@ describe("validateMobilePushContent", () => {
       {
         getLiquidTags,
         formatMessage,
-        messages,
-        onError,
-        onSuccess,
-        tagLookupMap,
-        eventContextTags,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags,
         currentTab: 1,
       },
     );
@@ -593,11 +770,10 @@ describe("validateMobilePushContent", () => {
       {
         getLiquidTags,
         formatMessage,
-        messages,
-        onError,
-        onSuccess,
-        tagLookupMap,
-        eventContextTags,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags,
         currentTab: 1,
       },
     );
@@ -611,11 +787,10 @@ describe("validateMobilePushContent", () => {
       {
         getLiquidTags,
         formatMessage,
-        messages,
-        onError,
-        onSuccess,
-        tagLookupMap,
-        eventContextTags,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags,
         currentTab: 1,
       },
     );
@@ -629,11 +804,10 @@ describe("validateMobilePushContent", () => {
       {
         getLiquidTags,
         formatMessage,
-        messages,
-        onError,
-        onSuccess,
-        tagLookupMap,
-        eventContextTags,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags,
         currentTab: 1,
       },
     );
@@ -647,11 +821,10 @@ describe("validateMobilePushContent", () => {
       {
         getLiquidTags,
         formatMessage,
-        messages,
-        onError,
-        onSuccess,
-        tagLookupMap,
-        eventContextTags,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags,
       },
     );
     expect(onError).toHaveBeenCalled();
@@ -664,11 +837,10 @@ describe("validateMobilePushContent", () => {
       {
         getLiquidTags,
         formatMessage,
-        messages,
-        onError,
-        onSuccess,
-        tagLookupMap,
-        eventContextTags,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags,
       },
     );
     expect(onError).toHaveBeenCalled();
@@ -681,11 +853,10 @@ describe("validateMobilePushContent", () => {
       {
         getLiquidTags,
         formatMessage,
-        messages,
-        onError,
-        onSuccess,
-        tagLookupMap,
-        eventContextTags,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags,
       },
     );
     expect(onError).toHaveBeenCalled();
@@ -698,11 +869,10 @@ describe("validateMobilePushContent", () => {
       {
         getLiquidTags,
         formatMessage,
-        messages,
-        onError,
-        onSuccess,
-        tagLookupMap,
-        eventContextTags,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags,
       },
     );
     expect(onError).toHaveBeenCalled();
@@ -715,11 +885,10 @@ describe("validateMobilePushContent", () => {
       {
         getLiquidTags,
         formatMessage,
-        messages,
-        onError,
-        onSuccess,
-        tagLookupMap,
-        eventContextTags,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags,
       },
     );
     expect(onError).toHaveBeenCalled();
@@ -733,7 +902,6 @@ describe("validateInAppContent", () => {
     somethingWentWrong: { id: "wrong" },
     unsupportedTagsValidationError: { id: "unsupported" }
   };
-  const tagLookupMap = { foo: true };
   const eventContextTags = [{ tagName: "foo" }];
   const onError = jest.fn();
   const onSuccess = jest.fn();
@@ -742,7 +910,7 @@ describe("validateInAppContent", () => {
     jest.clearAllMocks();
   });
 
-  it("calls onError for empty formData", async () => {
+  it("calls onError for empty formData (validateInAppContent)", async () => {
     const getLiquidTags = jest.fn((content, cb) =>
       cb({ askAiraResponse: { errors: [], data: [] }, isError: false })
     );
@@ -751,17 +919,16 @@ describe("validateInAppContent", () => {
       {
         getLiquidTags,
         formatMessage,
-        messages,
-        onError,
-        onSuccess,
-        tagLookupMap,
-        eventContextTags,
+      messages,
+      onError,
+      onSuccess,
+      eventContextTags,
       }
     );
     expect(onError).toHaveBeenCalled();
   });
 
-  it("calls onSuccess for valid android and ios content", async () => {
+  it("calls onSuccess for valid android and ios content (validateInAppContent)", async () => {
     const getLiquidTags = jest.fn((content, cb) =>
       cb({ askAiraResponse: { errors: [], data: [] }, isError: false })
     );
@@ -781,7 +948,6 @@ describe("validateInAppContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags,
       singleTab: ANDROID,
     });
@@ -808,7 +974,6 @@ describe("validateInAppContent", () => {
       messages,
       onError,
       onSuccess,
-      tagLookupMap,
       eventContextTags,
       singleTab: IOS,
     });
@@ -835,11 +1000,11 @@ describe("getChannelData", () => {
     expect(getChannelData("SMS", formData)).toBe("Hi Test");
   });
 
-  it("returns string with undefineds for SMS channel with missing fields", () => {
+  it("returns string with undefineds for SMS when base and template-name are empty or undefined", () => {
     const formData = { base: {}, "template-name": undefined };
     expect(getChannelData("SMS", formData)).toBe("undefined undefined");
   });
-  it("returns string with undefineds for SMS channel with missing fields", () => {
+  it("returns string with undefineds for SMS when formData is empty string", () => {
     expect(getChannelData("SMS", "")).toBe("undefined undefined");
   });
 
@@ -1601,3 +1766,181 @@ describe("validateCarouselCards", () => {
   });
 });
 
+describe('hasPersonalizationTags', () => {
+  describe('liquid tags {{ }}', () => {
+    it('returns true when text contains a liquid tag', () => {
+      expect(hasPersonalizationTags('Hello {{user.name}}')).toBe(true);
+    });
+
+    it('returns true for text with only opening and closing braces', () => {
+      expect(hasPersonalizationTags('{{}}')).toBe(true);
+    });
+
+    it('returns false when only {{ is present without }}', () => {
+      expect(hasPersonalizationTags('Hello {{user.name')).toBeFalsy();
+    });
+
+    it('returns false when only }} is present without {{', () => {
+      expect(hasPersonalizationTags('Hello user.name}}')).toBeFalsy();
+    });
+  });
+
+  describe('event context tags [ ]', () => {
+    it('returns true when text contains square bracket tags', () => {
+      expect(hasPersonalizationTags('Hello [first_name]')).toBe(true);
+    });
+
+    it('returns true for text with only [ ]', () => {
+      expect(hasPersonalizationTags('[]')).toBe(true);
+    });
+
+    it('returns false when only [ is present without ]', () => {
+      expect(hasPersonalizationTags('Hello [first_name')).toBeFalsy();
+    });
+
+    it('returns false when only ] is present without [', () => {
+      expect(hasPersonalizationTags('Hello first_name]')).toBeFalsy();
+    });
+  });
+
+  describe('both tag types', () => {
+    it('returns true when text contains both liquid and square bracket tags', () => {
+      expect(hasPersonalizationTags('{{title}} and [body]')).toBe(true);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('returns falsy for empty string (default parameter)', () => {
+      expect(hasPersonalizationTags()).toBeFalsy();
+    });
+
+    it('returns falsy for empty string argument', () => {
+      expect(hasPersonalizationTags('')).toBeFalsy();
+    });
+
+    it('returns falsy for plain text with no tokens', () => {
+      expect(hasPersonalizationTags('Hello World')).toBeFalsy();
+    });
+
+    it('returns falsy for null', () => {
+      expect(hasPersonalizationTags(null)).toBeFalsy();
+    });
+
+    it('returns falsy for undefined', () => {
+      expect(hasPersonalizationTags(undefined)).toBeFalsy();
+    });
+  });
+});
+
+describe('checkForPersonalizationTokens', () => {
+  describe('liquid tags {{ }}', () => {
+    it('returns true when a field contains a liquid tag', () => {
+      const formData = {
+        tab1: { title: 'Hello {{user.name}}' },
+      };
+      expect(checkForPersonalizationTokens(formData)).toBe(true);
+    });
+
+    it('returns true for multiline liquid tag spanning field value', () => {
+      const formData = {
+        tab1: { body: '{{user\n.name}}' },
+      };
+      expect(checkForPersonalizationTokens(formData)).toBe(true);
+    });
+  });
+
+  describe('event context tags [ ]', () => {
+    it('returns true when a field contains a square bracket token', () => {
+      const formData = {
+        tab1: { message: 'Hi [first_name]' },
+      };
+      expect(checkForPersonalizationTokens(formData)).toBe(true);
+    });
+
+    it('returns true for multiline square bracket token', () => {
+      const formData = {
+        tab1: { body: '[first\nname]' },
+      };
+      expect(checkForPersonalizationTokens(formData)).toBe(true);
+    });
+  });
+
+  describe('multiple tabs / fields', () => {
+    it('returns true when token is in a nested tab other than the first', () => {
+      const formData = {
+        tab1: { title: 'plain text' },
+        tab2: { body: 'Hello {{name}}' },
+      };
+      expect(checkForPersonalizationTokens(formData)).toBe(true);
+    });
+
+    it('returns true when token is in a field other than the first in a tab', () => {
+      const formData = {
+        tab1: { title: 'plain text', body: '[event_tag]' },
+      };
+      expect(checkForPersonalizationTokens(formData)).toBe(true);
+    });
+
+    it('returns false when no field in any tab has a token', () => {
+      const formData = {
+        tab1: { title: 'Hello World', body: 'No tokens here' },
+        tab2: { title: 'Also plain', body: 'Still plain' },
+      };
+      expect(checkForPersonalizationTokens(formData)).toBe(false);
+    });
+  });
+
+  describe('non-string field values', () => {
+    it('ignores numeric field values', () => {
+      const formData = {
+        tab1: { count: 42 },
+      };
+      expect(checkForPersonalizationTokens(formData)).toBe(false);
+    });
+
+    it('ignores boolean field values', () => {
+      const formData = {
+        tab1: { enabled: true },
+      };
+      expect(checkForPersonalizationTokens(formData)).toBe(false);
+    });
+
+    it('ignores null field values', () => {
+      const formData = {
+        tab1: { title: null },
+      };
+      expect(checkForPersonalizationTokens(formData)).toBe(false);
+    });
+
+    it('ignores nested object field values (only one level deep)', () => {
+      const formData = {
+        tab1: { nested: { title: '{{token}}' } },
+      };
+      expect(checkForPersonalizationTokens(formData)).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('returns false for null input', () => {
+      expect(checkForPersonalizationTokens(null)).toBe(false);
+    });
+
+    it('returns false for undefined input', () => {
+      expect(checkForPersonalizationTokens(undefined)).toBe(false);
+    });
+
+    it('returns false for empty object', () => {
+      expect(checkForPersonalizationTokens({})).toBe(false);
+    });
+
+    it('returns false for non-object input (string)', () => {
+      expect(checkForPersonalizationTokens('{{token}}')).toBe(false);
+    });
+
+    it('returns false when tab value is not an object', () => {
+      const formData = { tab1: '{{token}}' };
+      expect(checkForPersonalizationTokens(formData)).toBe(false);
+    });
+  });
+});
+