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

package/v2Containers/WebPush/Create/utils/validation.test.js

@@ -127,6 +127,40 @@ describe('validation', () => {
       expect(result).toBe('Personalization tags are not supported for anonymous customers');
       expect(mockFormatMessage).toHaveBeenCalledWith(mockMessages.personalizationTokensErrorMessage);
     });
+
+    it('should return brace error when validationConfig is provided and validateTags returns isBraceError', () => {
+      const validationConfig = { tagsParam: [], location: {}, tagModule: '' };
+      validateTags.mockReturnValue({ isBraceError: true });
+      const result = validateTitle(
+        'Valid Title',
+        mockFormatMessage,
+        mockMessages,
+        false,
+        validationConfig,
+        false
+      );
+      expect(result).toBe('Unbalanced curly braces');
+      expect(mockFormatMessage).toHaveBeenCalledWith(globalMessages.unbalanacedCurlyBraces);
+      expect(validateTags).toHaveBeenCalledWith({
+        content: 'Valid Title',
+        ...validationConfig,
+        isFullMode: false,
+      });
+    });
+
+    it('should not run tag validation when validationConfig is null', () => {
+      validateTags.mockClear();
+      const result = validateTitle('Valid Title', mockFormatMessage, mockMessages, false, null);
+      expect(result).toBe('');
+      expect(validateTags).not.toHaveBeenCalled();
+    });
+
+    it('should not run tag validation when validationConfig is undefined', () => {
+      validateTags.mockClear();
+      const result = validateTitle('Valid Title', mockFormatMessage, mockMessages, false, undefined);
+      expect(result).toBe('');
+      expect(validateTags).not.toHaveBeenCalled();
+    });
   });
 
   describe('validateUrl', () => {
@@ -183,10 +217,8 @@ describe('validation', () => {
   describe('validateMessageContent', () => {
     const mockValidationConfig = {
       tagsParam: [],
-      injectedTagsParams: [],
       location: {},
       tagModule: '',
-      eventContextTags: [],
     };
 
     beforeEach(() => {
@@ -225,17 +257,6 @@ describe('validation', () => {
       });
     });
 
-    it('should return error message for unsupported tags', () => {
-      validateTags.mockReturnValue({
-        unsupportedTags: ['tag1', 'tag2'],
-      });
-      const result = validateMessageContent('Message with {tag1} and {tag2}', mockFormatMessage, mockMessages, mockValidationConfig);
-      expect(result).toBe('Unsupported tags: tag1, tag2');
-      expect(mockFormatMessage).toHaveBeenCalledWith(globalMessages.unsupportedTagsValidationError, {
-        unsupportedTags: 'tag1, tag2',
-      });
-    });
-
     it('should return error message for unbalanced curly braces', () => {
       validateTags.mockReturnValue({
         isBraceError: true,
@@ -245,22 +266,11 @@ describe('validation', () => {
       expect(mockFormatMessage).toHaveBeenCalledWith(globalMessages.unbalanacedCurlyBraces);
     });
 
-    it('should return error message for both unsupported tags and brace error (unsupported tags takes precedence)', () => {
-      validateTags.mockReturnValue({
-        unsupportedTags: ['tag1'],
-        isBraceError: true,
-      });
-      const result = validateMessageContent('Message with {tag1}', mockFormatMessage, mockMessages, mockValidationConfig);
-      expect(result).toBe('Unsupported tags: tag1');
-    });
-
     it('should pass validation config to validateTags', () => {
       const customConfig = {
         tagsParam: [{ id: 1, name: 'Tag1' }],
-        injectedTagsParams: [{ id: 2, name: 'Tag2' }],
         location: { query: { type: 'test' } },
         tagModule: 'custom',
-        eventContextTags: [{ id: 3, name: 'Tag3' }],
       };
       validateTags.mockReturnValue({});
       validateMessageContent('Valid message', mockFormatMessage, mockMessages, customConfig);
@@ -306,6 +316,31 @@ describe('validation', () => {
       expect(result).toBe('Personalization tags are not supported for anonymous customers');
       expect(mockFormatMessage).toHaveBeenCalledWith(mockMessages.personalizationTokensErrorMessage);
     });
+
+    it('should return unsupported tags error when validateTags returns unsupportedTags', () => {
+      validateTags.mockReturnValue({ unsupportedTags: ['invalidTag', 'otherTag'] });
+      const result = validateMessageContent(
+        'Hello {{invalidTag}}',
+        mockFormatMessage,
+        mockMessages,
+        mockValidationConfig
+      );
+      expect(result).toBe('Unsupported tags: invalidTag, otherTag');
+      expect(mockFormatMessage).toHaveBeenCalledWith(
+        globalMessages.unsupportedTagsValidationError,
+        { unsupportedTags: 'invalidTag, otherTag' }
+      );
+    });
+
+    it('should pass isFullMode to validateTags when provided', () => {
+      validateTags.mockReturnValue({});
+      validateMessageContent('Valid message', mockFormatMessage, mockMessages, mockValidationConfig, true);
+      expect(validateTags).toHaveBeenCalledWith({
+        content: 'Valid message',
+        ...mockValidationConfig,
+        isFullMode: true,
+      });
+    });
   });
 });
 

package/v2Containers/Whatsapp/index.js

@@ -637,22 +637,21 @@ export const Whatsapp = (props) => {
         validateTags({
           content: contentData.join(""),
           tagsParam: tags,
-          injectedTagsParams: injectedTags,
           location,
           tagModule: getDefaultTags,
-          eventContextTags,
           isFullMode,
         }) || {};
-      const unsupportedTagsLengthCheck =
-        validationResponse?.unsupportedTags?.length > 0;
       if (type === HEADER_TEXT) {
         headerTagValidationResponse = validationResponse;
-        updateIsHeaderTagValidationError(unsupportedTagsLengthCheck);
+        updateIsHeaderTagValidationError(validationResponse.isBraceError);
       } else if (type === CAROUSEL_TEXT) {
-        return [{fieldName: "carouselTagValidationErrMessage", value: validationResponse}, {fieldName: "carouselTagValidationErr", value: unsupportedTagsLengthCheck}];
+        return [
+          { fieldName: "carouselTagValidationErrMessage", value: validationResponse.isBraceError ? validationResponse : {} },
+          { fieldName: "carouselTagValidationErr", value: validationResponse.isBraceError },
+        ];
       } else {
         tagValidationResponse = validationResponse;
-        updateIsTagValidationError(unsupportedTagsLengthCheck);
+        updateIsTagValidationError(validationResponse.isBraceError);
       }
     }
   };
@@ -2682,18 +2681,11 @@ const isAuthenticationTemplate = isEqual(templateCategory, WHATSAPP_CATEGORIES.a
     } else {
       validationResponse = tagValidationResponse;
     }
-    const { unsupportedTags = [], isBraceError } = validationResponse;
-
-    let tagError = "";
-    if (unsupportedTags.length > 0) {
-      tagError = formatMessage(globalMessages.unsupportedTagsValidationError, {
-        unsupportedTags,
-      });
-    }
+    const { isBraceError } = validationResponse || {};
     if (isBraceError) {
-      tagError = formatMessage(globalMessages.unbalanacedCurlyBraces);
+      return <CapError>{formatMessage(globalMessages.unbalanacedCurlyBraces)}</CapError>;
     }
-    return <CapError>{tagError}</CapError>;
+    return null;
   };
 
   const editModeContent = () => (
@@ -3212,7 +3204,7 @@ const isAuthenticationTemplate = isEqual(templateCategory, WHATSAPP_CATEGORIES.a
       <TestAndPreviewSlidebox
         show={propsShowTestAndPreviewSlidebox || showTestAndPreviewSlidebox}
         onClose={handleCloseTestAndPreview}
-        formData={getTemplateContent()}
+        formData={null} // WhatsApp doesn't use formData structure like SMS
         content={getTemplateContent()}
         currentChannel={WHATSAPP}
       />