@capillarytech/creatives-library 8.0.307 → 8.0.308

package/utils/tests/tagValidations.test.js

@@ -1,7 +1,7 @@
 import '@testing-library/jest-dom';
 import {
-  hasUnsubscribeTag,
-  validateTagsCore,
+  checkSupport,
+  extractNames,
   getTagMapValue,
   getLoyaltyTagsMapValue,
   getForwardedMapValues,
@@ -9,160 +9,10 @@ import {
   validateIfTagClosed,
   validateTags,
   skipTags,
-  checkIfSupportedTag,
-  transformInjectedTags,
+  isInsideLiquidBlock,
 } from '../tagValidations';
 import { containsBase64Images } from '../content';
-
-describe('hasUnsubscribeTag', () => {
-  it('should return false when content is not a string', () => {
-    expect(hasUnsubscribeTag(null)).toBe(false);
-    expect(hasUnsubscribeTag(undefined)).toBe(false);
-    expect(hasUnsubscribeTag(123)).toBe(false);
-    expect(hasUnsubscribeTag({})).toBe(false);
-  });
-
-  it('should return false when content has no unsubscribe tag', () => {
-    expect(hasUnsubscribeTag('Hello world')).toBe(false);
-    expect(hasUnsubscribeTag('{{ name }}')).toBe(false);
-  });
-
-  it('should return true when content has {{ unsubscribe }}', () => {
-    expect(hasUnsubscribeTag('Click {{ unsubscribe }} here')).toBe(true);
-    expect(hasUnsubscribeTag('{{ unsubscribe }}')).toBe(true);
-  });
-});
-
-describe('validateTagsCore', () => {
-  it('should include isContentEmpty: false when includeIsContentEmpty is true', () => {
-    const result = validateTagsCore({
-      contentForBraceCheck: '{{a}}',
-      contentForUnsubscribeScan: '{{a}}',
-      tags: null,
-      currentModule: 'default',
-      isFullMode: true,
-      includeIsContentEmpty: true,
-    });
-    expect(result.isContentEmpty).toBe(false);
-    expect(result.valid).toBe(true);
-  });
-
-  it('should use initialMissingTags when provided', () => {
-    const result = validateTagsCore({
-      contentForBraceCheck: '{{a}}',
-      contentForUnsubscribeScan: '{{a}}',
-      tags: [{ definition: { supportedModules: [], value: 'x' } }],
-      currentModule: 'default',
-      isFullMode: false,
-      initialMissingTags: ['requiredTag'],
-    });
-    expect(result.missingTags).toEqual(['requiredTag']);
-    expect(result.valid).toBe(false);
-  });
-
-  it('should use custom skipTagsFn when provided', () => {
-    const customSkip = jest.fn(() => true);
-    const result = validateTagsCore({
-      contentForBraceCheck: '{{ unsubscribe }}',
-      contentForUnsubscribeScan: '{{ unsubscribe }}',
-      tags: [
-        {
-          definition: {
-            supportedModules: [{ context: 'DEFAULT', mandatory: true }],
-            value: 'unsubscribe',
-          },
-        },
-      ],
-      currentModule: 'DEFAULT',
-      isFullMode: false,
-      skipTagsFn: customSkip,
-    });
-    expect(customSkip).toHaveBeenCalled();
-    expect(result.valid).toBe(true);
-  });
-});
-
-describe('checkIfSupportedTag', () => {
-  it('should return false for empty or no injected tags', () => {
-    expect(checkIfSupportedTag('someTag', {})).toBe(false);
-    expect(checkIfSupportedTag('someTag', undefined)).toBe(false);
-  });
-
-  it('should return true when tag matches a top-level key', () => {
-    const injectedTags = { name: { name: 'Name' }, unsubscribe: { name: 'Unsubscribe' } };
-    expect(checkIfSupportedTag('name', injectedTags)).toBe(true);
-    expect(checkIfSupportedTag('unsubscribe', injectedTags)).toBe(true);
-  });
-
-  it('should return false when tag does not match any key', () => {
-    const injectedTags = { name: { name: 'Name' } };
-    expect(checkIfSupportedTag('other', injectedTags)).toBe(false);
-  });
-
-  it('should return true when tag matches a nested subtag', () => {
-    const injectedTags = {
-      customer: {
-        name: 'Customer',
-        subtags: {
-          first_name: { name: 'First Name' },
-          last_name: { name: 'Last Name' },
-        },
-      },
-    };
-    expect(checkIfSupportedTag('first_name', injectedTags)).toBe(true);
-    expect(checkIfSupportedTag('last_name', injectedTags)).toBe(true);
-  });
-
-  it('should return false when tag is in neither top-level nor subtags', () => {
-    const injectedTags = {
-      customer: {
-        name: 'Customer',
-        subtags: { first_name: { name: 'First Name' } },
-      },
-    };
-    expect(checkIfSupportedTag('unknown', injectedTags)).toBe(false);
-  });
-});
-
-describe('transformInjectedTags', () => {
-  it('should add tag-header and normalize subtags when key contains "subtags"', () => {
-    const tags = [
-      {
-        name: 'Customer',
-        subtags: {
-          first_name: { name: 'First Name' },
-        },
-      },
-    ];
-    const result = transformInjectedTags(tags);
-    expect(result).toBe(tags);
-    expect(tags[0]['tag-header']).toBe(true);
-    expect(tags[0].subtags).toEqual({ first_name: { name: 'First Name' } });
-  });
-
-  it('should recursively transform nested subtags', () => {
-    const tags = [
-      {
-        name: 'Parent',
-        subtags: {
-          child: {
-            name: 'Child',
-            subtags: { grandchild: { name: 'Grandchild' } },
-          },
-        },
-      },
-    ];
-    transformInjectedTags(tags);
-    expect(tags[0].subtags.child.subtags).toEqual({ grandchild: { name: 'Grandchild' } });
-  });
-
-  it('should return tags unchanged when no subtag keys exist', () => {
-    const tags = [{ name: 'Simple', desc: 'No subtags' }];
-    const result = transformInjectedTags(tags);
-    expect(result).toBe(tags);
-    expect(tags[0]).toEqual({ name: 'Simple', desc: 'No subtags' });
-  });
-});
+import { eventContextTags } from '../../v2Containers/TagList/tests/mockdata';
 
 describe("check if curly brackets are balanced", () => {
     it("test for balanced curly brackets", () => {
@@ -172,9 +22,6 @@ describe("check if curly brackets are balanced", () => {
         value += "}}"
         let result = validateIfTagClosed(value);
         expect(result).toEqual(true);
-        // no braces or empty string: match returns null, l1/l2/l3 undefined -> true
-        expect(validateIfTagClosed("")).toEqual(true);
-        expect(validateIfTagClosed("plain text no braces")).toEqual(true);
         //valid cases
         expect(validateIfTagClosed("{{{Hello}}}")).toEqual(true);
         expect(validateIfTagClosed("{{{Hello}}")).toEqual(true);
@@ -217,41 +64,53 @@ describe("validateTags", () => {
   it("should return valid response when all tags are present", () => {
     const content = "Hello {{tag1}}, {{tag2}}, {{tag3}} {{entryTrigger.lifetimePurchases}}";
 
+    const injectedTagsParams = [];
     const location = { query: { module: "DEFAULT" } };
     const tagModule = null;
 
     const result = validateTags({
       content,
       tagsParam,
+      injectedTagsParams,
       location,
       tagModule,
+      eventContextTags,
     });
 
     expect(result.valid).toEqual(true);
     expect(result.missingTags).toEqual([]);
+    expect(result.unsupportedTags).toEqual([]);
     expect(result.isBraceError).toEqual(false);
   });
 
-  it("should return valid response when content has balanced braces and all tags present", () => {
+  it("should return invalid response when a mandatory tag is missing", () => {
     const content = "Hello {{tag1}}, {{tag2}}, {{tag3}}";
+    const updatedTagsParam = [...tagsParam,       {
+      definition: {
+        supportedModules: [{ context: "DEFAULT", mandatory: true }],
+        value: "tag4",
+      },
+    },];
+    const injectedTagsParams = [];
     const location = { query: { module: "DEFAULT" } };
     const tagModule = null;
 
     const result = validateTags({
       content,
-      tagsParam,
+      updatedTagsParam,
+      injectedTagsParams,
       location,
       tagModule,
     });
 
     expect(result.valid).toEqual(true);
-    expect(result.missingTags).toEqual([]);
+    expect(result.unsupportedTags).toEqual(["tag1", "tag2", "tag3"]);
     expect(result.isBraceError).toEqual(false);
   });
 
-  it("should return valid response when content has balanced braces with missingEventContextTags and partial tagsParam", () => {
+  it("should return invalid response when an unsupported tag is present", () => {
     const content = "Hello {{tag1}}, {{tag2}}, {{tag3}} {{missingEventContextTags}}";
-    const tagsParamLocal = [
+    const tagsParam = [
       {
         definition: {
           supportedModules: [{ context: "DEFAULT", mandatory: true }],
@@ -265,24 +124,27 @@ describe("validateTags", () => {
         },
       },
     ];
+    const injectedTagsParams = [];
     const location = { query: { module: "DEFAULT" } };
     const tagModule = null;
 
     const result = validateTags({
       content,
-      tagsParam: tagsParamLocal,
+      tagsParam,
+      injectedTagsParams,
       location,
       tagModule,
     });
 
     expect(result.valid).toEqual(true);
     expect(result.missingTags).toEqual([]);
+    expect(result.unsupportedTags).toEqual(["tag3", "missingEventContextTags"]);
     expect(result.isBraceError).toEqual(false);
   });
 
   it("should return invalid response when there is an unbalanced bracket error", () => {
     const content = "Hello {{tag1}, {{tag2}}, {{tag3}}";
-    const tagsParamLocal = [
+    const tagsParam = [
       {
         definition: {
           supportedModules: [{ context: "DEFAULT", mandatory: true }],
@@ -302,23 +164,26 @@ describe("validateTags", () => {
         },
       },
     ];
+    const injectedTagsParams = [];
     const location = { query: { module: "DEFAULT" } };
     const tagModule = null;
 
     const result = validateTags({
       content,
-      tagsParam: tagsParamLocal,
+      tagsParam,
+      injectedTagsParams,
       location,
       tagModule,
     });
 
     expect(result.valid).toEqual(false);
-    expect(result.missingTags).toEqual([]);
+    expect(result.missingTags).toEqual(["tag1"]);
+    expect(result.unsupportedTags).toEqual([]);
     expect(result.isBraceError).toEqual(true);
   });
 
-  it("should require unsubscribe when mandatory and missing, and accept skipped unsubscribe variant", () => {
-    const tagsParamUnsubscribe = [
+  it("should remove 'unsubscribe' from missingTags if skipTags logic is triggered", () => {
+    const tagsParam = [
       {
         definition: {
           supportedModules: [{ context: "DEFAULT", mandatory: true }],
@@ -326,310 +191,288 @@ describe("validateTags", () => {
         },
       },
     ];
+    // Content does not include {{unsubscribe}}, so it would be missing
+    const contentMissing = "Hello {{tag1}}";
+    const injectedTagsParams = [];
     const location = { query: { module: "DEFAULT" } };
     const tagModule = null;
 
-    const contentMissing = "Hello world";
+    // First, verify unsubscribe is missing if not present
     const resultMissing = validateTags({
       content: contentMissing,
-      tagsParam: tagsParamUnsubscribe,
+      tagsParam,
+      injectedTagsParams,
       location,
       tagModule,
     });
     expect(resultMissing.missingTags).toContain("unsubscribe");
-    expect(resultMissing.valid).toBe(false);
 
+    // Now, content includes a tag that triggers skipTags logic for unsubscribe
+    // e.g., {{unsubscribe(#123456)}} matches the skipTags regex
     const contentWithSkippedUnsubscribe = "Hello {{unsubscribe(#123456)}}";
     const resultSkipped = validateTags({
       content: contentWithSkippedUnsubscribe,
-      tagsParam: tagsParamUnsubscribe,
+      tagsParam,
+      injectedTagsParams,
       location,
       tagModule,
     });
     expect(resultSkipped.missingTags).not.toContain("unsubscribe");
     expect(resultSkipped.valid).toBe(true);
-
-    const contentWithWhitespaceUnsubscribe = "Hello {{ unsubscribe }}";
-    const resultWhitespace = validateTags({
-      content: contentWithWhitespaceUnsubscribe,
-      tagsParam: tagsParamUnsubscribe,
-      location,
-      tagModule,
-    });
-    expect(resultWhitespace.missingTags).not.toContain("unsubscribe");
-    expect(resultWhitespace.valid).toBe(true);
-    expect(resultWhitespace.unsupportedTags ?? []).toEqual([]);
   });
 });
 
-describe('validateTags wrapper (v2 consumers)', () => {
-  const tagsWithUnsubscribe = [
-    {
-      definition: {
-        supportedModules: [{ context: 'DEFAULT', mandatory: true }],
-        value: 'unsubscribe',
+describe("extractNames", () => {
+  it("should return an empty array when data is empty", () => {
+    const data = [];
+    const result = extractNames(data);
+    expect(result).toEqual([]);
+  });
+
+  it("should return an array of names when data contains nodes with names", () => {
+    const data = [
+      {
+        name: "Node 1",
+        children: [
+          {
+            name: "Node 1.1",
+            children: [],
+          },
+          {
+            name: "Node 1.2",
+            children: [],
+          },
+        ],
       },
-    },
-  ];
-  const tagsOutboundUnsubscribe = [
-    {
-      definition: {
-        supportedModules: [{ context: 'outbound', mandatory: true }],
-        value: 'unsubscribe',
+      {
+        name: "Node 2",
+        children: [
+          {
+            name: "Node 2.1",
+            children: [],
+          },
+        ],
       },
-    },
-  ];
-  const tagsDefaultLowercase = [
-    {
-      definition: {
-        supportedModules: [{ context: 'default', mandatory: true }],
-        value: 'unsubscribe',
+    ];
+    const result = extractNames(data);
+    expect(result).toEqual([
+      "Node 1",
+      "Node 1.1",
+      "Node 1.2",
+      "Node 2",
+      "Node 2.1",
+    ]);
+  });
+
+  it("should ignore nodes without names", () => {
+    const data = [
+      {
+        name: "Node 1",
+        children: [
+          {
+            name: "Node 1.1",
+            children: [],
+          },
+          {
+            children: [],
+          },
+        ],
       },
-    },
-  ];
-
-  describe('module selection (location.query.module vs tagModule vs DEFAULT)', () => {
-    it('uses location.query.module when set and tagModule not provided', () => {
-      const content = 'Hello world';
-      const result = validateTags({
-        content,
-        tagsParam: tagsWithUnsubscribe,
-        location: { query: { module: 'DEFAULT' } },
-        tagModule: null,
-      });
-      expect(result.missingTags).toContain('unsubscribe');
-      expect(result.valid).toBe(false);
-    });
-
-    it('uses tagModule override when provided (overrides location.query.module)', () => {
-      const content = 'Hello world';
-      const resultWithOutbound = validateTags({
-        content,
-        tagsParam: tagsOutboundUnsubscribe,
-        location: { query: { module: 'DEFAULT' } },
-        tagModule: 'outbound',
-      });
-      expect(resultWithOutbound.missingTags).toContain('unsubscribe');
-      expect(resultWithOutbound.valid).toBe(false);
-
-      const resultWithDefault = validateTags({
-        content,
-        tagsParam: tagsWithUnsubscribe,
-        location: { query: { module: 'outbound' } },
-        tagModule: 'DEFAULT',
-      });
-      expect(resultWithDefault.missingTags).toContain('unsubscribe');
-      expect(resultWithDefault.valid).toBe(false);
-    });
-
-    it('uses DEFAULT (lowercase) when location is undefined', () => {
-      const content = 'Hello world';
-      const result = validateTags({
-        content,
-        tagsParam: tagsDefaultLowercase,
-        location: undefined,
-        tagModule: null,
-      });
-      expect(result.missingTags).toContain('unsubscribe');
-      expect(result.valid).toBe(false);
-    });
-
-    it('uses DEFAULT when location.query is undefined', () => {
-      const content = 'Hello world';
-      const result = validateTags({
-        content,
-        tagsParam: tagsDefaultLowercase,
-        location: {},
-        tagModule: null,
-      });
-      expect(result.missingTags).toContain('unsubscribe');
-      expect(result.valid).toBe(false);
-    });
-
-    it('uses DEFAULT when location.query.module is falsy', () => {
-      const content = 'Hello world';
-      const result = validateTags({
-        content,
-        tagsParam: tagsDefaultLowercase,
-        location: { query: { module: '' } },
-        tagModule: null,
-      });
-      expect(result.missingTags).toContain('unsubscribe');
-      expect(result.valid).toBe(false);
-    });
+      {
+        name: "Node 2",
+        children: [
+          {
+            name: "Node 2.1",
+            children: [],
+          },
+          {
+            name: "Node 2.2",
+          },
+        ],
+      },
+    ];
+    const result = extractNames(data);
+    expect(result).toEqual([
+      "Node 1",
+      "Node 1.1",
+      "Node 2",
+      "Node 2.1",
+      "Node 2.2",
+    ]);
   });
+});
 
-  describe('content passed to contentForBraceCheck and contentForUnsubscribeScan', () => {
-    it('uses same content for brace check (isBraceError when unbalanced)', () => {
-      const content = 'Hello {{tag1}, {{tag2}}';
-      const result = validateTags({
-        content,
-        tagsParam: [],
-        location: { query: { module: 'DEFAULT' } },
-      });
-      expect(result.isBraceError).toBe(true);
-      expect(result.valid).toBe(false);
-    });
-
-    it('uses same content for unsubscribe scan (missing unsubscribe when required)', () => {
-      const content = 'Hello {{other}}';
-      const result = validateTags({
-        content,
-        tagsParam: tagsWithUnsubscribe,
-        location: { query: { module: 'DEFAULT' } },
-      });
-      expect(result.missingTags).toContain('unsubscribe');
-      expect(result.valid).toBe(false);
-    });
 
-    it('content with {{ unsubscribe }} satisfies unsubscribe requirement', () => {
-      const content = 'Hello {{ unsubscribe }}';
-      const result = validateTags({
-        content,
-        tagsParam: tagsWithUnsubscribe,
-        location: { query: { module: 'DEFAULT' } },
-      });
-      expect(result.missingTags).not.toContain('unsubscribe');
-      expect(result.valid).toBe(true);
-    });
+describe("checkSupport", () => {
+  it("should return an empty array when args are empty", () => {
+    const result = checkSupport();
+    expect(result).toEqual([]);
   });
-
-  describe('isFullMode', () => {
-    it('when true skips unsubscribe check (no missingTags for mandatory unsubscribe)', () => {
-      const content = 'Hello world';
-      const result = validateTags({
-        content,
-        tagsParam: tagsWithUnsubscribe,
-        location: { query: { module: 'DEFAULT' } },
-        isFullMode: true,
-      });
-      expect(result.missingTags).toEqual([]);
-      expect(result.valid).toBe(true);
-    });
-
-    it('when true still runs brace check', () => {
-      const content = 'Hello {{tag1}';
-      const result = validateTags({
-        content,
-        tagsParam: tagsWithUnsubscribe,
-        location: { query: { module: 'DEFAULT' } },
-        isFullMode: true,
-      });
-      expect(result.isBraceError).toBe(true);
-      expect(result.valid).toBe(false);
-    });
+  it("should return an empty array when response data is empty", () => {
+    const response = { data: [] };
+    const tagObject = {};
+    const result = checkSupport(response, tagObject);
+    expect(result).toEqual([]);
   });
 
-  describe('tagsParam null or empty', () => {
-    it('when null: only brace check runs, no missing-tag logic', () => {
-      const content = 'Hello {{a}}';
-      const result = validateTags({
-        content,
-        tagsParam: null,
-        location: { query: { module: 'DEFAULT' } },
-      });
-      expect(result.missingTags).toEqual([]);
-      expect(result.isBraceError).toBe(false);
-      expect(result.valid).toBe(true);
-    });
-
-    it('when empty array: only brace check runs', () => {
-      const content = 'Hello {{a}}';
-      const result = validateTags({
-        content,
-        tagsParam: [],
-        location: { query: { module: 'DEFAULT' } },
-      });
-      expect(result.missingTags).toEqual([]);
-      expect(result.valid).toBe(true);
-    });
-
-    it('when null with unbalanced braces: returns isBraceError', () => {
-      const content = 'Hello {{a}';
-      const result = validateTags({
-        content,
-        tagsParam: null,
-        location: { query: { module: 'DEFAULT' } },
-      });
-      expect(result.isBraceError).toBe(true);
-      expect(result.valid).toBe(false);
-      expect(result.missingTags).toEqual([]);
-    });
+  it("should return an empty array when tagObject is empty", () => {
+    const response = {
+      data: [{ name: "tag1" }, { name: "tag2" }, { name: "tag3" }],
+    };
+    const tagObject = {};
+    const result = checkSupport(response, tagObject);
+    expect(result).toEqual([]);
   });
 
-  describe('v2 consumer call patterns', () => {
-    it('Whatsapp-style: content, tagsParam, location, tagModule (getDefaultTags), isFullMode', () => {
-      const content = 'Hello {{ unsubscribe }}';
-      const result = validateTags({
-        content: content,
-        tagsParam: tagsWithUnsubscribe,
-        location: { query: { module: 'DEFAULT' } },
-        tagModule: 'DEFAULT',
-        isFullMode: false,
-      });
-      expect(result.valid).toBe(true);
-      expect(result.isBraceError).toBe(false);
-    });
-
-    it('Zalo / Rcs / MobilePushNew / EmailWrapper: same pattern as Whatsapp', () => {
-      const result = validateTags({
-        content: 'Hi {{ unsubscribe }}',
-        tagsParam: tagsWithUnsubscribe,
-        location: { query: { module: 'DEFAULT' } },
-        tagModule: 'DEFAULT',
-        isFullMode: false,
-      });
-      expect(result.valid).toBe(true);
-    });
+  it("should return event context tags even if tagObject is empty", () => {
+    const response = {
+      data: [{ name: "tag1" }, { name: "entryTrigger.lifetimePurchases" }],
+    };
+    const tagObject = {};
+    const result = checkSupport(response, tagObject, eventContextTags);
+    expect(result).toEqual(['entryTrigger.lifetimePurchases']);
+  });
 
-    it('Line / Viber: tagModule "outbound"', () => {
-      const contentMissing = 'Hello';
-      const resultMissing = validateTags({
-        content: contentMissing,
-        tagsParam: tagsOutboundUnsubscribe,
-        location: { query: { module: 'inbound' } },
-        tagModule: 'outbound',
-        isFullMode: false,
-      });
-      expect(resultMissing.missingTags).toContain('unsubscribe');
-      expect(resultMissing.valid).toBe(false);
-
-      const resultOk = validateTags({
-        content: 'Hello {{ unsubscribe }}',
-        tagsParam: tagsOutboundUnsubscribe,
-        location: {},
-        tagModule: 'outbound',
-        isFullMode: false,
-      });
-      expect(resultOk.valid).toBe(true);
-    });
+  it("should return an array of supported tags", () => {
+    const response = {
+      data: [{ name: "tag1" }, { name: "tag2" }, { name: "tag3" }],
+    };
+    const tagObject = {
+      tag1: { definition: { subtags: ["tag1.1", "tag1.2"] } },
+      tag2: { definition: { subtags: ["tag2.1", "tag2.2"] } },
+      tag3: { definition: { subtags: ["tag3.1", "tag3.2"] } },
+    };
+    const result = checkSupport(response, tagObject);
+    expect(result).toEqual(["tag1", "tag2", "tag3"]);
+  });
 
-    it('WebPush: validationConfig spread (content + tagsParam, location, tagModule, isFullMode)', () => {
-      const validationConfig = {
-        tagsParam: tagsWithUnsubscribe,
-        location: { query: { module: 'DEFAULT' } },
-        tagModule: 'DEFAULT',
-      };
-      const result = validateTags({
-        content: 'Hello {{ unsubscribe }}',
-        ...validationConfig,
-        isFullMode: false,
-      });
-      expect(result.valid).toBe(true);
-      expect(result.isBraceError).toBe(false);
-    });
+  it("should return an array of supported tags with subtags", () => {
+    const response = {
+      data: [{ name: "tag1" }, { name: "tag2" }, { name: "tag3" }],
+    };
+    const tagObject = {
+      tag1: { definition: { subtags: ["tag1.1", "tag1.2"] } },
+      tag2: { definition: { subtags: ["tag2.1", "tag2.2"] } },
+      tag3: { definition: { subtags: ["tag3.1", "tag3.2"] } },
+      "tag1.1": {},
+      "tag2.1": {},
+      "tag3.1": {},
+    };
+    const result = checkSupport(response, tagObject);
+    expect(result).toEqual(["tag1", "tag2", "tag3"]);
+  });
 
-    it('WebPush with isFullMode: only brace check', () => {
-      const result = validateTags({
-        content: 'Hello world',
-        tagsParam: tagsWithUnsubscribe,
-        location: { query: { module: 'DEFAULT' } },
-        tagModule: 'DEFAULT',
-        isFullMode: true,
-      });
-      expect(result.valid).toBe(true);
-      expect(result.missingTags).toEqual([]);
-    });
+  it("should return an empty array when no tags are supported", () => {
+    const response = {
+      data: [{ name: "tag1" }, { name: "tag2" }, { name: "tag3" }],
+    };
+    const tagObject = {
+      tag4: {},
+      tag5: {},
+      tag6: {},
+    };
+    const result = checkSupport(response, tagObject);
+    expect(result).toEqual([]);
+  });
+  it("should return an array of supported tags with subtags", () => {
+    const response = {
+      data: [
+        {
+          name: "tag1",
+          children: [{ name: "tag1.1", children: [{ name: "tag1.2" }] }],
+        },
+        { name: "tag2", children: [] },
+        { name: "tag3" },
+      ],
+    };
+    const tagObject = {
+      tag1: { definition: { subtags: [".1", "tag1.2"] } },
+      tag2: { definition: { subtags: ["tag2.1", "tag2.2"] } },
+      tag3: { definition: { subtags: ["tag3.1", "tag3.2"] } },
+      "tag1.1": {},
+      "tag2.1": {},
+      "tag3.1": {},
+    };
+    const result = checkSupport(response, tagObject);
+    expect(result).toEqual(["tag1", "tag1.1", "tag2", "tag3"]);
+  });
+  it("should return an array of supported tags children as an object", () => {
+    const response = {
+      data: [
+        { name: "tag1", children: [{ name: "tag" }] },
+        { name: "tag2", children: [] },
+        { name: "tag3" },
+      ],
+    };
+    const tagObject = {
+      tag1: { definition: { subtags: [".1", "tag1.2"] } },
+      tag2: { definition: { subtags: ["tag2.1", "tag2.2"] } },
+      tag3: { definition: { subtags: ["tag3.1", "tag3.2"] } },
+      "tag1.1": {},
+      "tag2.1": {},
+      "tag3.1": {},
+    };
+    const result = checkSupport(response, tagObject);
+    expect(result).toEqual(["tag1", "tag2", "tag3"]);
+  });
+  it("should return an empty array if tagObject is empty", () => {
+    const response = {
+      data: [
+        { name: "tag1", children: [{ name: "tag" }] },
+        { name: "tag2", children: [] },
+        { name: "tag3" },
+      ],
+    };
+    const result = checkSupport(response, {});
+    expect(result).toEqual([]);
+  });
+
+  it("should add childName to supportedList if it is a subtag of parentTag in eventContextTags", () => {
+    const response = { data: [{ name: "leaderboard", children: [{name: "person.userId"}]}]};
+    const tagObject = {};
+    const eventContextTags = [{ tagName: "leaderboard", subTags: ["userId"]}];
+    const isLiquidFlow = true;
+    const result = checkSupport(response, tagObject, eventContextTags, isLiquidFlow);
+    expect(result).toEqual( [ 'leaderboard', 'person.userId' ]);
+  });
+
+  it("should not add childName to supportedList which does not have dot in eventContextTags", () => {
+    // This case is unlikely to happen as we are not supporting tags without dot in eventContextTags
+    const response = { data: [{ name: "entryTrigger.lifetimePoints", children: [{name: "userId"}] }]};
+    const tagObject = {};
+    const eventContextTags = [{ tagName: "entryTrigger.lifetimePoints", children: [{name: "userId"}] }];
+    const isLiquidFlow = true;
+    const result = checkSupport(response, tagObject, eventContextTags, isLiquidFlow);
+    expect(result).toEqual( [ "entryTrigger.lifetimePoints" ]);
+  });
+
+  it("should add only parent tag to supportedList if isLiquidFlow false", () => {
+    const response = { data: [{ name: "leaderboard", children: [{name: "person.userId"}]}]};
+    const tagObject = {};
+    const eventContextTags = [{ tagName: "leaderboard", subTags: ["userId"]}];
+    const isLiquidFlow = false;
+    const result = checkSupport(response, tagObject, eventContextTags, isLiquidFlow);
+    expect(result).toEqual( [ 'leaderboard' ]);
+  });
+
+  it("test for checking loyalty tags in that are coming in forwardedTags", () => {
+    const response = { data: [{ name: "leaderboard", children: [{name: "person.userId"}]}]};
+    const tagObject = {};
+    const isLiquidFlow = true;
+    // forwardedTags contains tag hierarchy with parent tags and their subtags
+    // needed for loyalty email liquid tag resolution
+    const forwardedTags = {
+      leaderboard: {
+        name: "Leaderboard",
+        subtags: {
+          "person.userId": {
+            name: "User ID",
+          },
+        },
+      },
+    };
+    const result = checkSupport(response, tagObject, [], isLiquidFlow, forwardedTags);
+    expect(result).toEqual( [ 'leaderboard', 'person.userId' ]);
   });
 });
 
@@ -1205,10 +1048,6 @@ describe('getForwardedMapValues', () => {
     expect(getForwardedMapValues(input)).toEqual(expected);
   });
 
-  test('should return empty object when called with no argument (default param)', () => {
-    expect(getForwardedMapValues()).toEqual({});
-  });
-
   test('should correctly process objects with subtags', () => {
     const input = {
       customer: {
@@ -1470,6 +1309,84 @@ describe('getForwardedMapValues', () => {
   });
 });
 
+describe('isInsideLiquidBlock', () => {
+  it('returns true for index inside a single block', () => {
+    const content = 'Hello {% assign foo = 1 %} World';
+    // Index of 'a' in 'assign' inside the block
+    const tagIndex = content.indexOf('assign');
+    expect(isInsideLiquidBlock(content, tagIndex)).toBe(true);
+  });
+
+  it('returns false for index outside any block', () => {
+    const content = 'Hello {% assign foo = 1 %} World';
+    // Index of 'H' in 'Hello'
+    expect(isInsideLiquidBlock(content, 0)).toBe(false);
+    // Index of 'W' in 'World'
+    expect(isInsideLiquidBlock(content, content.indexOf('World'))).toBe(false);
+  });
+
+  it('returns true for index at the start of a block', () => {
+    const content = 'Hello {% assign foo = 1 %} World';
+    // Index of '{' in '{%'
+    const tagIndex = content.indexOf('{%');
+    expect(isInsideLiquidBlock(content, tagIndex)).toBe(true);
+  });
+
+  it('returns false for index at the end of a block (exclusive)', () => {
+    const content = 'Hello {% assign foo = 1 %} World';
+    // Index just after the closing '%}'
+    const blockEnd = content.indexOf('%}') + 2;
+    expect(isInsideLiquidBlock(content, blockEnd)).toBe(false);
+  });
+
+  it('returns true for index inside the second of multiple blocks', () => {
+    const content = 'A {% first %} B {% second %} C';
+    const tagIndex = content.indexOf('second');
+    expect(isInsideLiquidBlock(content, tagIndex)).toBe(true);
+  });
+
+  it('returns false for index between blocks', () => {
+    const content = 'A {% first %} B {% second %} C';
+    // Index of 'B' (between blocks)
+    const tagIndex = content.indexOf('B');
+    expect(isInsideLiquidBlock(content, tagIndex)).toBe(false);
+  });
+
+  it('returns false for empty string', () => {
+    expect(isInsideLiquidBlock('', 0)).toBe(false);
+  });
+
+  it('returns false if there are no blocks', () => {
+    const content = 'Just some text with no blocks';
+    expect(isInsideLiquidBlock(content, 5)).toBe(false);
+  });
+
+  it('returns false for negative index', () => {
+    const content = 'Hello {% assign foo = 1 %} World';
+    expect(isInsideLiquidBlock(content, -1)).toBe(false);
+  });
+
+  it('returns false for index beyond string length', () => {
+    const content = 'Hello {% assign foo = 1 %} World';
+    expect(isInsideLiquidBlock(content, 100)).toBe(false);
+  });
+
+  it('works for nested-like blocks (not truly nested)', () => {
+    const content = 'A {% outer {% inner %} outer %} B';
+    // Index of 'inner' (should be inside the first block)
+    const tagIndex = content.indexOf('inner');
+    expect(isInsideLiquidBlock(content, tagIndex)).toBe(true);
+  });
+
+  it('returns true for index at last char inside block', () => {
+    const content = 'A {% foo %} B';
+    // Index of last char inside block (just before %})
+    const blockStart = content.indexOf('{%');
+    const blockEnd = content.indexOf('%}');
+    expect(isInsideLiquidBlock(content, blockEnd - 1)).toBe(true);
+  });
+});
+
 describe('containsBase64Images', () => {
   let mockCapNotification;
   let mockCallback;