@capillarytech/creatives-library 8.0.314 → 8.0.316-alpha.0

package/utils/tests/smsCharCount.test.js

@@ -0,0 +1,304 @@
+/**
+ * Test suite for legacy smsCharCount utility (app/utils/smsCharCount.js)
+ * Note: The actual smsCharCount.js file is referenced from this module path
+ */
+import { updateCharCount, checkUnicode } from '../smsCharCount';
+
+describe('SMS Character Count - Utility Functions', () => {
+  describe('updateCharCount function', () => {
+    it('should return object with totalLength, msgCount, charLeft properties', () => {
+      const result = updateCharCount('Hello');
+      expect(result).toHaveProperty('totalLength');
+      expect(result).toHaveProperty('msgCount');
+      expect(result).toHaveProperty('charLeft');
+    });
+
+    it('should handle simple ASCII message', () => {
+      const result = updateCharCount('Hello World');
+      expect(typeof result.msgCount).toBe('number');
+      expect(result.msgCount).toBe(1);
+    });
+
+    it('should count exactly 160 7-bit characters as single SMS', () => {
+      const msg160 = 'A'.repeat(160);
+      const result = updateCharCount(msg160);
+      expect(result.msgCount).toBe(1);
+      expect(result.charLeft).toBe(0);
+    });
+
+    it('should split 161 7-bit characters into 2 SMS', () => {
+      const msg161 = 'A'.repeat(161);
+      const result = updateCharCount(msg161);
+      expect(result.msgCount).toBe(2);
+    });
+
+    it('should count 153 7-bit characters per SMS after first', () => {
+      const msg = 'A'.repeat(313); // 160 + 153
+      const result = updateCharCount(msg);
+      // Math.ceil(313 / 153) calculates multipart for total length
+      expect(result.msgCount).toBe(Math.ceil(313 / 153));
+    });
+
+    it('should split 154 7-bit characters into 2 SMS (160 + 153 boundary)', () => {
+      const msg = 'A'.repeat(314); // 160 + 154
+      const result = updateCharCount(msg);
+      expect(result.msgCount).toBe(3);
+    });
+
+    it('should handle Unicode characters correctly', () => {
+      const msg = '你好';
+      const result = updateCharCount(msg);
+      expect(result.msgCount).toBe(1);
+    });
+
+    it('should count exactly 70 Unicode characters as single SMS', () => {
+      const msg70Unicode = '你'.repeat(70);
+      const result = updateCharCount(msg70Unicode);
+      expect(result.msgCount).toBe(1);
+    });
+
+    it('should split 71 Unicode characters into 2 SMS', () => {
+      const msg71Unicode = '你'.repeat(71);
+      const result = updateCharCount(msg71Unicode);
+      expect(result.msgCount).toBe(2);
+    });
+
+    it('should count 67 Unicode characters per SMS after first', () => {
+      const msg = '你'.repeat(137); // 70 + 67
+      const result = updateCharCount(msg);
+      // Math.ceil(137 / 67) calculates multipart for total length
+      expect(result.msgCount).toBe(Math.ceil(137 / 67));
+    });
+
+    it('should handle 2-byte GSM-7 extended characters', () => {
+      // Characters like \f, ^, {, }, \, [, ~, ], |, € count as 2 bytes
+      const msg = 'A\fB'; // \f is 2-byte
+      const result = updateCharCount(msg);
+      expect(result).toHaveProperty('msgCount');
+    });
+
+    it('should handle mixed 7-bit and extended GSM-7 characters', () => {
+      const msg = 'Hello^World{Test}';
+      const result = updateCharCount(msg);
+      expect(result.msgCount).toBe(1);
+    });
+
+    it('should handle form feed characters', () => {
+      const msg = 'Hello\fWorld';
+      const result = updateCharCount(msg);
+      expect(result).toHaveProperty('msgCount');
+    });
+
+    it('should handle newline characters', () => {
+      const msg = 'Hello\nWorld';
+      const result = updateCharCount(msg);
+      expect(result).toHaveProperty('msgCount');
+    });
+
+    it('should handle HTML entities like &', () => {
+      const msg = 'Hello & World';
+      const result = updateCharCount(msg);
+      expect(result).toHaveProperty('msgCount');
+    });
+
+    it('should handle non-breaking space character', () => {
+      const msg = 'Hello\u00a0World';
+      const result = updateCharCount(msg);
+      expect(result).toHaveProperty('msgCount');
+    });
+
+    it('should handle carriage return characters', () => {
+      const msg = 'Hello\r\nWorld';
+      const result = updateCharCount(msg);
+      expect(result).toHaveProperty('msgCount');
+    });
+
+    it('should handle empty or minimal content', () => {
+      const result = updateCharCount('A');
+      expect(result.msgCount).toBe(1);
+    });
+
+    it('should handle very long messages', () => {
+      const msg = 'A'.repeat(1000);
+      const result = updateCharCount(msg);
+      expect(result.msgCount).toBe(Math.ceil(1000 / 153));
+    });
+
+    it('should handle messages with special GSM-7 characters', () => {
+      const specialChars = '@£$¥èéùìòÇØø';
+      const result = updateCharCount(specialChars);
+      expect(result).toHaveProperty('msgCount');
+      expect(result.msgCount).toBe(1);
+    });
+
+    it('should handle euro symbol', () => {
+      const msg = '€'.repeat(10);
+      const result = updateCharCount(msg);
+      expect(result).toHaveProperty('msgCount');
+    });
+
+    it('should return props array with totalLength, msgcount, charLeft', () => {
+      const result = updateCharCount('Test');
+      // Result should contain labels and counts
+      expect(Array.isArray(result)).toBe(false);
+      expect(result).toBeInstanceOf(Object);
+    });
+
+    it('should correctly calculate characters left in current SMS', () => {
+      const msg = 'A'.repeat(100);
+      const result = updateCharCount(msg);
+      expect(result.charLeft).toBe(160 - 100);
+    });
+
+    it('should handle mixed ASCII and special characters', () => {
+      const msg = 'Hello[{World}]€Test';
+      const result = updateCharCount(msg);
+      expect(result.msgCount).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe('checkUnicode function', () => {
+    it('should return false for ASCII-only text', () => {
+      expect(checkUnicode('Hello World 123')).toBe(false);
+    });
+
+    it('should return true for Unicode characters', () => {
+      expect(checkUnicode('你好')).toBe(true);
+    });
+
+    it('should return true for mixed ASCII and Unicode', () => {
+      expect(checkUnicode('Hello你好')).toBe(true);
+    });
+
+    it('should return false for supported GSM-7 extended characters', () => {
+      expect(checkUnicode('@£$¥èéù')).toBe(false);
+    });
+
+    it('should return false for empty string', () => {
+      expect(checkUnicode('')).toBe(false);
+    });
+
+    it('should return false for GSM-7 extended escape characters', () => {
+      expect(checkUnicode('\f^{}[]~|€')).toBe(false);
+    });
+
+    it('should return true for Japanese characters', () => {
+      expect(checkUnicode('こんにちは')).toBe(true);
+    });
+
+    it('should return true for Korean characters', () => {
+      expect(checkUnicode('안녕하세요')).toBe(true);
+    });
+
+    it('should return true for Cyrillic characters', () => {
+      expect(checkUnicode('Привет')).toBe(true);
+    });
+
+    it('should return false for all supported extended ASCII', () => {
+      const supported = 'èéùìòÇØøÅåΔΦΓΛΩΠΨΣΘΞÆæßÉÄÖÑÜäöñüࣥ¤§¿€';
+      expect(checkUnicode(supported)).toBe(false);
+    });
+
+    it('should return true for emoji', () => {
+      expect(checkUnicode('Hello 🌍')).toBe(true);
+    });
+
+    it('should return false for numeric characters', () => {
+      expect(checkUnicode('0123456789')).toBe(false);
+    });
+
+    it('should return false for special ASCII characters', () => {
+      expect(checkUnicode('!@#$%^&*()_+-=[]{}|;:,.<>?')).toBe(false);
+    });
+
+    it('should handle newline in check', () => {
+      expect(checkUnicode('Hello\nWorld')).toBe(false);
+    });
+
+    it('should handle carriage return in check', () => {
+      expect(checkUnicode('Hello\r\nWorld')).toBe(false);
+    });
+
+    it('should handle form feed in check', () => {
+      expect(checkUnicode('Hello\fWorld')).toBe(false);
+    });
+
+    it('should handle non-breaking space in check', () => {
+      expect(checkUnicode('Hello\u00a0World')).toBe(false);
+    });
+
+    it('should return true when any non-GSM7 character is present', () => {
+      expect(checkUnicode('ABCDEFGHIJKLMNOPQRSTUVWXYZ你')).toBe(true);
+    });
+
+    it('should handle mixed supported and unsupported Unicode', () => {
+      expect(checkUnicode('è 你好 €')).toBe(true);
+    });
+
+    it('should return false for message with only spaces', () => {
+      expect(checkUnicode('     ')).toBe(false);
+    });
+
+    it('should return true for message with tabs (tabs are not in GSM-7 charset)', () => {
+      // Tab character (\t) is not in the GSM-7 character set, so it returns true
+      expect(checkUnicode('Hello\t\tWorld')).toBe(true);
+    });
+  });
+
+  describe('Integration Tests', () => {
+    it('should correctly identify and count Unicode message', () => {
+      const msg = 'Hello你好World';
+      const isUnicode = checkUnicode(msg);
+      const counts = updateCharCount(msg);
+
+      expect(isUnicode).toBe(true);
+      if (msg.length > 70) {
+        expect(counts.msgCount).toBeGreaterThan(1);
+      }
+    });
+
+    it('should correctly identify and count ASCII message', () => {
+      const msg = 'Hello World This is a test message';
+      const isUnicode = checkUnicode(msg);
+      const counts = updateCharCount(msg);
+
+      expect(isUnicode).toBe(false);
+      if (msg.length > 160) {
+        expect(counts.msgCount).toBeGreaterThan(1);
+      }
+    });
+
+    it('should handle long Unicode messages correctly', () => {
+      const msg = '你好'.repeat(50); // 100 characters
+      const isUnicode = checkUnicode(msg);
+      const counts = updateCharCount(msg);
+
+      expect(isUnicode).toBe(true);
+      expect(counts.msgCount).toBeGreaterThan(1);
+    });
+
+    it('should handle long ASCII messages correctly', () => {
+      const msg = 'A'.repeat(300);
+      const isUnicode = checkUnicode(msg);
+      const counts = updateCharCount(msg);
+
+      expect(isUnicode).toBe(false);
+      expect(counts.msgCount).toBeGreaterThan(1);
+    });
+
+    it('should handle boundary case: exactly 160 ASCII characters', () => {
+      const msg = 'A'.repeat(160);
+      const counts = updateCharCount(msg);
+
+      expect(counts.msgCount).toBe(1);
+      expect(counts.charLeft).toBe(0);
+    });
+
+    it('should handle boundary case: exactly 70 Unicode characters', () => {
+      const msg = '你'.repeat(70);
+      const counts = updateCharCount(msg);
+
+      expect(counts.msgCount).toBe(1);
+    });
+  });
+});

package/utils/tests/smsCharCountV2.test.js

@@ -1,12 +1,215 @@
 import React from 'react';
-import { updateCharCount } from '../smsCharCountV2';
-describe('test updateCharCount',() => {
-    it('test for optOut tag length', ()=>{
-        let res = updateCharCount("hello{{optout}}")
-        expect(res.optoutUrlPresent).toEqual(true);
-        expect(res.parts).toEqual(1);
-        let res_1 = updateCharCount("hi")
-        expect(res_1.optoutUrlPresent).toEqual(false);
-        expect(res_1.parts).toEqual(1);
-    })
+import { updateCharCount, checkUnicode } from '../smsCharCountV2';
+import * as Api from '../../services/api';
+
+jest.mock('../../services/api');
+
+describe('smsCharCountV2', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Setup default mock to return resolved promise
+    Api.getUnsubscribeUrl.mockResolvedValue({
+      response: { response: '' },
+    });
+  });
+
+  describe('checkUnicode', () => {
+    it('should return false for 7-bit ASCII characters', () => {
+      const result = checkUnicode('Hello');
+      expect(result).toBe(false);
+    });
+
+    it('should return true for Unicode characters', () => {
+      const result = checkUnicode('你好');
+      expect(result).toBe(true);
+    });
+
+    it('should return false for empty string', () => {
+      const result = checkUnicode('');
+      expect(result).toBe(false);
+    });
+
+    it('should return false for 7-bit extended characters', () => {
+      const result = checkUnicode('\f^{}');
+      expect(result).toBe(false);
+    });
+
+    it('should return true when mixed with Unicode', () => {
+      const result = checkUnicode('Hello世界');
+      expect(result).toBe(true);
+    });
+
+    it('should return false for special 7-bit GSM characters', () => {
+      const result = checkUnicode('@£$¥');
+      expect(result).toBe(false);
+    });
+
+    it('should return false for escape sequences', () => {
+      const result = checkUnicode('\\[~]|€');
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('updateCharCount', () => {
+    it('should return basic SMS details for simple 7-bit message', () => {
+      const result = updateCharCount('Hello');
+      expect(result).toHaveProperty('unicode', false);
+      expect(result).toHaveProperty('parts', 1);
+      expect(result).toHaveProperty('chars_sms', 160);
+      expect(result).toHaveProperty('optoutUrlPresent', false);
+    });
+
+    it('should return SMS details for simple Unicode message', () => {
+      const result = updateCharCount('你好');
+      expect(result.unicode).toBe(true);
+      expect(result.parts).toBe(1);
+      expect(result.chars_sms).toBe(70);
+    });
+
+    it('should detect 7-bit messages up to 160 characters', () => {
+      const msg = 'A'.repeat(160);
+      const result = updateCharCount(msg);
+      expect(result.unicode).toBe(false);
+      expect(result.parts).toBe(1);
+      expect(result.chars_sms).toBe(160);
+    });
+
+    it('should calculate multipart for 7-bit messages over 160 chars', () => {
+      const msg = 'A'.repeat(161);
+      const result = updateCharCount(msg);
+      expect(result.unicode).toBe(false);
+      expect(result.parts).toBe(2);
+      expect(result.chars_sms).toBe(153);
+    });
+
+    it('should calculate correct parts for large 7-bit messages', () => {
+      const msg = 'A'.repeat(500);
+      const result = updateCharCount(msg);
+      expect(result.unicode).toBe(false);
+      expect(result.parts).toBe(Math.ceil(500 / 153));
+    });
+
+    it('should detect Unicode messages up to 70 characters', () => {
+      const msg = '你'.repeat(70);
+      const result = updateCharCount(msg);
+      expect(result.unicode).toBe(true);
+      expect(result.parts).toBe(1);
+      expect(result.chars_sms).toBe(70);
+    });
+
+    it('should calculate multipart for Unicode messages over 70 chars', () => {
+      const msg = '你'.repeat(71);
+      const result = updateCharCount(msg);
+      expect(result.unicode).toBe(true);
+      expect(result.parts).toBe(2);
+      expect(result.chars_sms).toBe(67);
+    });
+
+    it('should handle message with optout tag', () => {
+      const result = updateCharCount('Hello{{optout}}');
+      expect(result.optoutUrlPresent).toBe(true);
+      expect(result.parts).toBe(1);
+    });
+
+    it('should handle message without optout tag', () => {
+      const res = updateCharCount('Hello');
+      expect(res.optoutUrlPresent).toBe(false);
+      expect(res.parts).toBe(1);
+    });
+
+    it('should handle multiple optout tags', () => {
+      const result = updateCharCount('Hello{{optout}}World{{optout}}');
+      expect(result.optoutUrlPresent).toBe(true);
+    });
+
+    it('should handle default empty string parameter', () => {
+      const result = updateCharCount();
+      expect(result.chars_used).toBe(0);
+      expect(result.parts).toBe(1);
+    });
+
+    it('should count 7-bit extended characters as 2 bytes', () => {
+      const result = updateCharCount('A\fB'); // \f is 2-byte GSM-7 character
+      expect(result.unicode).toBe(false);
+      expect(result.char_list).toBeDefined();
+    });
+
+    it('should handle isUnicodeEnabled parameter', () => {
+      const result = updateCharCount('Hello', true);
+      expect(result).toBeDefined();
+    });
+
+    it('should handle isUnicodeEnabled as false', () => {
+      const result = updateCharCount('Hello', false);
+      expect(result).toBeDefined();
+    });
+
+    it('should return char_list with React elements', () => {
+      const result = updateCharCount('Hi');
+      expect(Array.isArray(result.char_list)).toBe(true);
+      expect(result.char_list.length).toBe(2);
+    });
+
+    it('should include responseState in return object', () => {
+      const result = updateCharCount('Test');
+      expect(result).toHaveProperty('responseState');
+    });
+
+    it('should handle optout URL when available from API', () => {
+      Api.getUnsubscribeUrl.mockResolvedValueOnce({
+        response: { response: 'https://example.com/unsub' },
+      });
+
+      const result = updateCharCount('Hello{{optout}}');
+      expect(result.optoutUrlPresent).toBe(true);
+    });
+
+    it('should handle API error gracefully', () => {
+      Api.getUnsubscribeUrl.mockRejectedValueOnce(new Error('API failed'));
+
+      const result = updateCharCount('Hello{{optout}}');
+      expect(result).toBeDefined();
+    });
+
+    it('should calculate correct char count with 7-bit extended chars', () => {
+      const result = updateCharCount('Test[Message]');
+      expect(result.unicode).toBe(false);
+    });
+
+    it('should handle all GSM-7 alphabet characters', () => {
+      const gsm7Chars = '@£$¥èéùìòÇ';
+      const result = checkUnicode(gsm7Chars);
+      expect(result).toBe(false);
+    });
+
+    it('should handle whitespace and newlines', () => {
+      const result = updateCharCount('Line1\nLine2');
+      expect(result.unicode).toBe(false);
+    });
+
+    it('should maintain char_list integrity for multipart messages', () => {
+      const msg = 'A'.repeat(200);
+      const result = updateCharCount(msg);
+      expect(result.char_list.length).toBe(200);
+    });
+
+    it('should handle message with only special characters', () => {
+      const result = updateCharCount('!@#$%^&*()');
+      expect(result.unicode).toBe(false);
+    });
+
+    it('should calculate correct part boundaries for 7-bit', () => {
+      const msg = 'A'.repeat(153);
+      const result = updateCharCount(msg);
+      expect(result.parts).toBe(1);
+      expect(result.chars_sms).toBe(160);
+    });
+
+    it('should calculate correct part boundaries for Unicode', () => {
+      const msg = '你'.repeat(67);
+      const result = updateCharCount(msg);
+      expect(result.parts).toBe(1);
+      expect(result.chars_sms).toBe(70);
+    });
+  });
 });

package/v2Containers/InApp/index.js

@@ -68,6 +68,7 @@ import { HTML_EDITOR_VARIANTS } from "../../v2Components/HtmlEditor/constants";
 import { INAPP_EDITOR_TYPES } from "../InAppWrapper/constants";
 import InappAdvanced from "../InappAdvance/index";
 import CapDeviceContent from "../../v2Components/CapDeviceContent";
+import capDeviceContentMessages from "../../v2Components/CapDeviceContent/messages";
 import { ErrorInfoNote } from "../../v2Components/ErrorInfoNote";
 
 let editContent = {};
@@ -1277,16 +1278,29 @@ export const InApp = (props) => {
     return '';
   };
 
+  /** Same rules as CapDeviceContent onTitleChange / onTemplateMessageChange */
+  const computeInAppTemplateFieldError = (value) => {
+    let error = templateDescErrorHandler(value);
+    if (value === '') {
+      error = formatMessage(capDeviceContentMessages.emptyTemplateMessageErrorMessage);
+    }
+    return error;
+  };
+
   const onCopyTitleAndContent = () => {
     if (panes === ANDROID) {
       clearDeviceErrors(ANDROID);
       setTitleAndroid(titleIos);
       setTemplateMessageAndroid(templateMessageIos);
+      setTemplateTitleErrorAndroid(computeInAppTemplateFieldError(titleIos));
+      setTemplateMessageErrorAndroid(computeInAppTemplateFieldError(templateMessageIos));
       setInAppImageSrcAndroid(inAppImageSrcIos);
     } else {
       clearDeviceErrors(IOS);
       setTitleIos(titleAndroid);
       setTemplateMessageIos(templateMessageAndroid);
+      setTemplateTitleErrorIos(computeInAppTemplateFieldError(titleAndroid));
+      setTemplateMessageErrorIos(computeInAppTemplateFieldError(templateMessageAndroid));
       setInAppImageSrcIos(inAppImageSrcAndroid);
     }
   };
@@ -1295,12 +1309,20 @@ export const InApp = (props) => {
     const tag = `{{${value}}}`;
     if (panes === ANDROID) {
       clearDeviceErrors(ANDROID);
-      if (index === 0) setTitleAndroid((prev) => prev + tag);
-      else setTemplateMessageAndroid((prev) => prev + tag);
+      const nextTitle = index === 0 ? titleAndroid + tag : titleAndroid;
+      const nextMessage = index === 0 ? templateMessageAndroid : templateMessageAndroid + tag;
+      if (index === 0) setTitleAndroid(nextTitle);
+      else setTemplateMessageAndroid(nextMessage);
+      setTemplateTitleErrorAndroid(computeInAppTemplateFieldError(nextTitle));
+      setTemplateMessageErrorAndroid(computeInAppTemplateFieldError(nextMessage));
     } else {
       clearDeviceErrors(IOS);
-      if (index === 0) setTitleIos((prev) => prev + tag);
-      else setTemplateMessageIos((prev) => prev + tag);
+      const nextTitle = index === 0 ? titleIos + tag : titleIos;
+      const nextMessage = index === 0 ? templateMessageIos : templateMessageIos + tag;
+      if (index === 0) setTitleIos(nextTitle);
+      else setTemplateMessageIos(nextMessage);
+      setTemplateTitleErrorIos(computeInAppTemplateFieldError(nextTitle));
+      setTemplateMessageErrorIos(computeInAppTemplateFieldError(nextMessage));
     }
   };