cap-creatives-ui 8.0.280 → 8.0.321

package/app/utils/tests/tagValidations.test.js

@@ -1,7 +1,7 @@
 import '@testing-library/jest-dom';
 import {
-  checkSupport,
-  extractNames,
+  hasUnsubscribeTag,
+  validateTagsCore,
   getTagMapValue,
   getLoyaltyTagsMapValue,
   getForwardedMapValues,
@@ -9,10 +9,160 @@ import {
   validateIfTagClosed,
   validateTags,
   skipTags,
-  isInsideLiquidBlock,
+  checkIfSupportedTag,
+  transformInjectedTags,
 } from '../tagValidations';
 import { containsBase64Images } from '../content';
-import { eventContextTags } from '../../v2Containers/TagList/tests/mockdata';
+
+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' });
+  });
+});
 
 describe("check if curly brackets are balanced", () => {
     it("test for balanced curly brackets", () => {
@@ -22,6 +172,9 @@ 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);
@@ -64,53 +217,42 @@ 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 invalid response when a mandatory tag is missing", () => {
+  it("should return valid response when content has balanced braces and all tags present", () => {
     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,
-      updatedTagsParam,
-      injectedTagsParams,
+      tagsParam,
       location,
       tagModule,
+      waitEventContextTags: {},
     });
 
     expect(result.valid).toEqual(true);
-    expect(result.unsupportedTags).toEqual([]);
+    expect(result.missingTags).toEqual([]);
     expect(result.isBraceError).toEqual(false);
   });
 
-  it("should return invalid response when an unsupported tag is present", () => {
+  it("should return valid response when content has balanced braces with missingEventContextTags and partial tagsParam", () => {
     const content = "Hello {{tag1}}, {{tag2}}, {{tag3}} {{missingEventContextTags}}";
-    const tagsParam = [
+    const tagsParamLocal = [
       {
         definition: {
           supportedModules: [{ context: "DEFAULT", mandatory: true }],
@@ -124,27 +266,25 @@ describe("validateTags", () => {
         },
       },
     ];
-    const injectedTagsParams = [];
     const location = { query: { module: "DEFAULT" } };
     const tagModule = null;
 
     const result = validateTags({
       content,
-      tagsParam,
-      injectedTagsParams,
+      tagsParam: tagsParamLocal,
       location,
       tagModule,
+      waitEventContextTags: {},
     });
 
     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 tagsParam = [
+    const tagsParamLocal = [
       {
         definition: {
           supportedModules: [{ context: "DEFAULT", mandatory: true }],
@@ -164,26 +304,24 @@ describe("validateTags", () => {
         },
       },
     ];
-    const injectedTagsParams = [];
     const location = { query: { module: "DEFAULT" } };
     const tagModule = null;
 
     const result = validateTags({
       content,
-      tagsParam,
-      injectedTagsParams,
+      tagsParam: tagsParamLocal,
       location,
       tagModule,
+      waitEventContextTags: {},
     });
 
     expect(result.valid).toEqual(false);
-    expect(result.missingTags).toEqual(["tag1"]);
-    expect(result.unsupportedTags).toEqual([]);
+    expect(result.missingTags).toEqual([]);
     expect(result.isBraceError).toEqual(true);
   });
 
-  it("should remove 'unsubscribe' from missingTags if skipTags logic is triggered", () => {
-    const tagsParam = [
+  it("should require unsubscribe when mandatory and missing, and accept skipped unsubscribe variant", () => {
+    const tagsParamUnsubscribe = [
       {
         definition: {
           supportedModules: [{ context: "DEFAULT", mandatory: true }],
@@ -191,288 +329,341 @@ 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;
 
-    // First, verify unsubscribe is missing if not present
+    const contentMissing = "Hello world";
     const resultMissing = validateTags({
       content: contentMissing,
-      tagsParam,
-      injectedTagsParams,
+      tagsParam: tagsParamUnsubscribe,
       location,
       tagModule,
+      waitEventContextTags: {},
     });
     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,
-      injectedTagsParams,
+      tagsParam: tagsParamUnsubscribe,
       location,
       tagModule,
+      waitEventContextTags: {},
     });
     expect(resultSkipped.missingTags).not.toContain("unsubscribe");
     expect(resultSkipped.valid).toBe(true);
-  });
-});
 
-describe("extractNames", () => {
-  it("should return an empty array when data is empty", () => {
-    const data = [];
-    const result = extractNames(data);
-    expect(result).toEqual([]);
+    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([]);
   });
 
-  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: [],
-          },
-        ],
+  it('should treat tags from waitEventContextTags as supported', () => {
+    const content = 'Hello {{waitEvent.orderId}}';
+    const tagsParam = [];
+    const injectedTagsParams = [];
+    const location = { query: { module: 'DEFAULT' } };
+    const tagModule = null;
+    const waitEventContextTags = {
+      block1: {
+        eventName: 'Order Placed',
+        blockName: 'Wait Block',
+        tags: [{ tagName: 'waitEvent.orderId', label: 'Order ID' }],
       },
-      {
-        name: "Node 2",
-        children: [
-          {
-            name: "Node 2.1",
-            children: [],
-          },
-        ],
+    };
+
+    const result = validateTags({
+      content,
+      tagsParam,
+      injectedTagsParams,
+      location,
+      tagModule,
+      eventContextTags: [],
+      waitEventContextTags,
+    });
+
+    expect(result.valid).toEqual(true);
+    expect(result.missingTags).toEqual([]);
+    expect(result.isBraceError).toEqual(false);
+  });
+});
+
+describe('validateTags wrapper (v2 consumers)', () => {
+  const tagsWithUnsubscribe = [
+    {
+      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: [],
-          },
-        ],
+    },
+  ];
+  const tagsOutboundUnsubscribe = [
+    {
+      definition: {
+        supportedModules: [{ context: 'outbound', mandatory: true }],
+        value: 'unsubscribe',
       },
-      {
-        name: "Node 2",
-        children: [
-          {
-            name: "Node 2.1",
-            children: [],
-          },
-          {
-            name: "Node 2.2",
-          },
-        ],
+    },
+  ];
+  const tagsDefaultLowercase = [
+    {
+      definition: {
+        supportedModules: [{ context: 'default', mandatory: true }],
+        value: 'unsubscribe',
       },
-    ];
-    const result = extractNames(data);
-    expect(result).toEqual([
-      "Node 1",
-      "Node 1.1",
-      "Node 2",
-      "Node 2.1",
-      "Node 2.2",
-    ]);
-  });
-});
+    },
+  ];
 
+  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);
+    });
 
-describe("checkSupport", () => {
-  it("should return an empty array when args are empty", () => {
-    const result = checkSupport();
-    expect(result).toEqual([]);
-  });
-  it("should return an empty array when response data is empty", () => {
-    const response = { data: [] };
-    const tagObject = {};
-    const result = checkSupport(response, tagObject);
-    expect(result).toEqual([]);
-  });
+    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("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([]);
-  });
+    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("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('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);
+    });
   });
 
-  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"]);
+  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);
+    });
   });
 
-  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"]);
+  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 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([]);
+  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 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' ]);
+
+  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('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('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('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([]);
+    });
   });
 });
 
@@ -1048,6 +1239,10 @@ 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: {
@@ -1309,84 +1504,6 @@ 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;