cap-creatives-ui 8.0.280 → 8.0.321

package/app/v2Containers/Rcs/tests/utils.test.js

@@ -1,7 +1,21 @@
 import React from 'react';
 import renderer from 'react-test-renderer';
 import { render, screen } from '../../../utils/test-utils';
-import { getRCSContent, getRcsStatusType, getTemplateStatusType } from '../utils';
+import {
+  getRCSContent,
+  getRcsStatusType,
+  getTemplateStatusType,
+  normalizeCardVarMapped,
+  coalesceCardVarMappedToTemplate,
+  resolveCardVarMappedSlotValue,
+  isRcsTextOnlyCardMediaType,
+  mapRcsCardContentForConsumerWithResolvedTags,
+  resolveRcsCardPreviewStrings,
+  sanitizeCardVarMappedValue,
+  areAllRcsSmsFallbackVarSlotsFilled,
+  buildRcsNumericMustachePlaceholderRegex,
+} from '../utils';
+import { rcsVarRegex } from '../constants';
 import { RCS, RCS_BUTTON_TYPES, STATUS_OPTIONS, RCS_STATUSES } from '../constants';
 import { mockData } from './mockData';
 
@@ -59,6 +73,25 @@ describe('RCS utils - renderRcsSuggestionsPreview', () => {
     expect(labels.length).toBe(1);
     expect(labels[0].textContent).toContain('Call');
   });
+
+  it('renders only divider for unknown suggestion type', () => {
+    const template = JSON.parse(JSON.stringify(templateBase));
+    template.versions.base.content[RCS].rcsContent.cardContent[0].suggestions = [
+      { type: RCS_BUTTON_TYPES.NONE, text: 'Ignored' },
+    ];
+    render(getRCSContent(template));
+    expect(document.querySelectorAll('.rcs-cta-preview').length).toBe(0);
+    expect(document.querySelectorAll('.whatsapp-divider').length).toBeGreaterThan(0);
+  });
+
+  it('prefers thumbnailUrl over mediaUrl for preview image', () => {
+    const template = JSON.parse(JSON.stringify(templateBase));
+    const card = template.versions.base.content[RCS].rcsContent.cardContent[0];
+    card.media = { thumbnailUrl: 'thumb.jpg', mediaUrl: 'full.jpg' };
+    render(getRCSContent(template));
+    const img = document.querySelector('.rcs-listing-image');
+    expect(img?.getAttribute('src')).toBe('thumb.jpg');
+  });
 });
 
 describe('RCS utils', () => {
@@ -136,4 +169,349 @@ describe('RCS utils', () => {
       expect(getTemplateStatusType('some_unknown_status')).toBe('warning');
     });
   });
+
+  describe('normalizeCardVarMapped', () => {
+    it('maps numeric key + placeholder value to tag name', () => {
+      expect(normalizeCardVarMapped({ 1: '{{user_id_b64}}' })).toEqual({ user_id_b64: '' });
+    });
+
+    it('maps numeric key + literal value when orderedTagNames is provided', () => {
+      expect(
+        normalizeCardVarMapped({ 1: 'hello' }, ['user_id_b64']),
+      ).toEqual({ user_id_b64: 'hello' });
+    });
+
+    it('keeps numeric key when no orderedTagNames for literal value', () => {
+      expect(normalizeCardVarMapped({ 1: 'hello' })).toEqual({ 1: 'hello' });
+    });
+
+    it('keeps semantic key + different tag token (TagList value)', () => {
+      expect(normalizeCardVarMapped({ myKey: '{{tag}}' })).toEqual({ myKey: '{{tag}}' });
+    });
+
+    it('maps numeric slot + chosen tag onto template token when ordered names provided', () => {
+      expect(
+        normalizeCardVarMapped({ 1: '{{FirstName}}' }, ['user_name']),
+      ).toEqual({ user_name: '{{FirstName}}' });
+    });
+
+    it('returns {} for null, undefined, or non-object raw', () => {
+      expect(normalizeCardVarMapped(null)).toEqual({});
+      expect(normalizeCardVarMapped(undefined)).toEqual({});
+      expect(normalizeCardVarMapped('not-object')).toEqual({});
+    });
+
+    it('maps numeric key to order slot only when index is within orderedTagNames', () => {
+      expect(normalizeCardVarMapped({ 3: 'z' }, ['a', 'b'])).toEqual({ 3: 'z' });
+    });
+
+    it('does not overwrite a literal slot value with a duplicate semantic placeholder entry', () => {
+      expect(
+        normalizeCardVarMapped(
+          { 1: 'hello', user_id_b64: '{{user_id_b64}}' },
+          ['user_id_b64'],
+        ),
+      ).toEqual({ user_id_b64: 'hello' });
+    });
+  });
+
+  describe('coalesceCardVarMappedToTemplate', () => {
+    it('maps slot 1 to first token name from title', () => {
+      expect(
+        coalesceCardVarMappedToTemplate(
+          { 1: 'abc' },
+          'Hi {{user_name}}',
+          '',
+          rcsVarRegex,
+        ),
+      ).toEqual({ 1: 'abc', user_name: 'abc' });
+    });
+
+    it('keeps {{1}} style token as key 1', () => {
+      expect(
+        coalesceCardVarMappedToTemplate(
+          { 1: '' },
+          'Hi {{1}}',
+          '',
+          rcsVarRegex,
+        ),
+      ).toEqual({ 1: '' });
+    });
+
+    it('returns clone when no tokens', () => {
+      const raw = { 1: 'x' };
+      const out = coalesceCardVarMappedToTemplate(raw, 'no vars', '', rcsVarRegex);
+      expect(out).toEqual({ 1: 'x' });
+      expect(out).not.toBe(raw);
+    });
+
+    it('merges tokens from title and description', () => {
+      const out = coalesceCardVarMappedToTemplate(
+        { a: '1', b: '2' },
+        'T {{a}}',
+        'D {{b}}',
+        rcsVarRegex,
+      );
+      expect(out).toEqual({ a: '1', b: '2', 1: '1', 2: '2' });
+    });
+
+    it('returns {} when there are no tokens and raw is null or not an object', () => {
+      expect(coalesceCardVarMappedToTemplate(null, 'plain', '', rcsVarRegex)).toEqual({});
+      expect(coalesceCardVarMappedToTemplate(undefined, 'plain', '', rcsVarRegex)).toEqual({});
+    });
+
+    it('fills token values from legacy numeric slots when named key is missing', () => {
+      expect(
+        coalesceCardVarMappedToTemplate(
+          { 1: 'legacy-val' },
+          'Hello {{name}}',
+          '',
+          rcsVarRegex,
+        ),
+      ).toEqual({ 1: 'legacy-val', name: 'legacy-val' });
+    });
+
+    it('maps values when raw is non-null but missing named keys', () => {
+      expect(
+        coalesceCardVarMappedToTemplate(
+          {},
+          'X {{a}}',
+          '',
+          rcsVarRegex,
+        ),
+      ).toEqual({ 1: '', a: '' });
+    });
+  });
+
+  describe('resolveCardVarMappedSlotValue', () => {
+    it('prefers per-slot numeric key when both semantic and numeric are present', () => {
+      expect(
+        resolveCardVarMappedSlotValue({ user_name: 'A', 1: 'B' }, 'user_name', 0),
+      ).toBe('B');
+    });
+
+    it('falls back to slot 1 when name missing', () => {
+      expect(resolveCardVarMappedSlotValue({ 1: 'legacy' }, 'user_name', 0)).toBe('legacy');
+    });
+
+    it('uses global slot index for second variable', () => {
+      expect(resolveCardVarMappedSlotValue({ 2: 'second' }, 'b', 1)).toBe('second');
+    });
+
+    it('reads slot from string slot key when varName has no direct mapping', () => {
+      expect(resolveCardVarMappedSlotValue({ 1: 'only-slot' }, 'missing', 0)).toBe('only-slot');
+    });
+
+    it('reads numeric object key for slot when string slot key is absent', () => {
+      expect(resolveCardVarMappedSlotValue({ 2: 'n2' }, 'x', 1)).toBe('n2');
+    });
+
+    it('returns empty when named key is cleared, not numeric slot fallback', () => {
+      expect(
+        resolveCardVarMappedSlotValue({ user_name: '', 1: 'old value' }, 'user_name', 0),
+      ).toBe('');
+    });
+
+    it('library mode: semantic empty does not hide non-empty numeric slot (campaign / journey payload)', () => {
+      expect(
+        resolveCardVarMappedSlotValue(
+          { user_id_b64: '', 1: 'selected-from-library' },
+          'user_id_b64',
+          0,
+          true,
+        ),
+      ).toBe('selected-from-library');
+    });
+
+    it('empty numeric slot falls back to semantic tag (preview after hydration leaves 1:"")', () => {
+      expect(
+        resolveCardVarMappedSlotValue(
+          { promotion_points: '{{loyalty_points}}', 1: '' },
+          'promotion_points',
+          0,
+        ),
+      ).toBe('{{loyalty_points}}');
+    });
+  });
+
+  describe('mapRcsCardContentForConsumerWithResolvedTags', () => {
+    it('sets title and description to resolved tag strings on each card', () => {
+      const out = mapRcsCardContentForConsumerWithResolvedTags(
+        [
+          {
+            title: '',
+            description: 'Visit {{gt}} discount',
+            mediaType: 'NONE',
+            cardVarMapped: { gt: '{{loyalty_points}}', 1: '{{loyalty_points}}' },
+          },
+        ],
+        {},
+        false,
+      );
+      expect(out[0].title).toBe('');
+      expect(out[0].description).toBe('Visit {{loyalty_points}} discount');
+    });
+
+    it('merges root rcsCardVarMapped with nested cardVarMapped', () => {
+      const out = mapRcsCardContentForConsumerWithResolvedTags(
+        [
+          {
+            title: 'Hi {{first_name}}',
+            description: 'Pts {{promotion_points}}',
+            mediaType: 'IMAGE',
+            cardVarMapped: {
+              promotion_points: '{{loyalty_points}}',
+              2: '{{loyalty_points}}',
+            },
+          },
+        ],
+        {
+          first_name: '{{customer_name}}',
+          1: '{{customer_name}}',
+        },
+        false,
+      );
+      expect(out[0].title).toBe('Hi {{customer_name}}');
+      expect(out[0].description).toBe('Pts {{loyalty_points}}');
+    });
+  });
+
+  describe('isRcsTextOnlyCardMediaType', () => {
+    it('returns true for NONE and TEXT (text message card)', () => {
+      expect(isRcsTextOnlyCardMediaType('NONE')).toBe(true);
+      expect(isRcsTextOnlyCardMediaType('TEXT')).toBe(true);
+      expect(isRcsTextOnlyCardMediaType('text')).toBe(true);
+    });
+    it('returns false for rich card media', () => {
+      expect(isRcsTextOnlyCardMediaType('IMAGE')).toBe(false);
+      expect(isRcsTextOnlyCardMediaType('VIDEO')).toBe(false);
+    });
+  });
+
+  describe('resolveRcsCardPreviewStrings', () => {
+    it('substitutes mapped tags for title and description (campaign preview parity)', () => {
+      const { rcsTitle, rcsDesc } = resolveRcsCardPreviewStrings(
+        'Hi {{first_name}}',
+        'Pts {{promotion_points}}',
+        {
+          first_name: '{{customer_name}}',
+          promotion_points: '{{loyalty_points}}',
+          1: '{{customer_name}}',
+          2: '{{loyalty_points}}',
+        },
+        true,
+      );
+      expect(rcsTitle).toBe('Hi {{customer_name}}');
+      expect(rcsDesc).toBe('Pts {{loyalty_points}}');
+    });
+
+    it('leaves placeholders when map has no value', () => {
+      const { rcsTitle, rcsDesc } = resolveRcsCardPreviewStrings(
+        '{{a}}',
+        '{{b}}',
+        {},
+        false,
+      );
+      expect(rcsTitle).toBe('{{a}}');
+      expect(rcsDesc).toBe('{{b}}');
+    });
+
+    it('text-only card: ignores stale title and resolves description from global slot 0', () => {
+      const { rcsTitle, rcsDesc } = resolveRcsCardPreviewStrings(
+        'Stale {{old_tag}} title',
+        'Visit Store for {{gt}} discount',
+        { gt: '{{loyalty_points}}', 1: '{{loyalty_points}}' },
+        true,
+        true,
+      );
+      expect(rcsTitle).toBe('');
+      expect(rcsDesc).toBe('Visit Store for {{loyalty_points}} discount');
+    });
+  });
+
+  describe('sanitizeCardVarMappedValue', () => {
+    it('returns empty for null', () => {
+      expect(sanitizeCardVarMappedValue(null)).toBe('');
+    });
+
+    it('strips numeric-only self-placeholder stored as value', () => {
+      expect(sanitizeCardVarMappedValue('{{1}}')).toBe('');
+      expect(sanitizeCardVarMappedValue('{{12}}')).toBe('');
+    });
+
+    it('keeps semantic mustache values from TagList', () => {
+      expect(sanitizeCardVarMappedValue('{{FirstName}}')).toBe('{{FirstName}}');
+      expect(sanitizeCardVarMappedValue('{{user_name}}')).toBe('{{user_name}}');
+    });
+
+    it('returns original string for non-placeholder values', () => {
+      expect(sanitizeCardVarMappedValue('  literal  ')).toBe('  literal  ');
+    });
+  });
+
+  describe('areAllRcsSmsFallbackVarSlotsFilled', () => {
+    it('returns true when template empty', () => {
+      expect(areAllRcsSmsFallbackVarSlotsFilled('', { '{{a}}_0': 'x' })).toBe(true);
+    });
+
+    it('returns false when a mustache slot is only whitespace (parity with RCS title/desc vars)', () => {
+      expect(
+        areAllRcsSmsFallbackVarSlotsFilled('Hello {{name}}', { '{{name}}_1': '   ' }),
+      ).toBe(false);
+    });
+
+    it('returns false when a mustache slot is missing or empty string', () => {
+      expect(areAllRcsSmsFallbackVarSlotsFilled('Hello {{name}}', {})).toBe(false);
+      expect(areAllRcsSmsFallbackVarSlotsFilled('Hello {{name}}', { '{{name}}_1': '' })).toBe(
+        false,
+      );
+    });
+
+    it('returns false when a DLT {#var#} slot is empty', () => {
+      expect(areAllRcsSmsFallbackVarSlotsFilled('Hi {#x#}', { '{#x#}_1': '   ' })).toBe(false);
+    });
+
+    it('requires mapping for {{optout}} token like any other variable', () => {
+      expect(areAllRcsSmsFallbackVarSlotsFilled('test {{optout}}', {})).toBe(false);
+      expect(areAllRcsSmsFallbackVarSlotsFilled('test {{ optout }}', {})).toBe(false);
+      expect(areAllRcsSmsFallbackVarSlotsFilled('test {{optout}}', { '{{optout}}_1': '{{optout}}' })).toBe(true);
+      expect(areAllRcsSmsFallbackVarSlotsFilled('test {{optout}}', { '{{optout}}_1': '' })).toBe(false);
+    });
+
+    it('returns true when template is missing or not a string', () => {
+      expect(areAllRcsSmsFallbackVarSlotsFilled(null, {})).toBe(true);
+      expect(areAllRcsSmsFallbackVarSlotsFilled(undefined, {})).toBe(true);
+      expect(areAllRcsSmsFallbackVarSlotsFilled(123, {})).toBe(true);
+    });
+
+    it('returns true when all variable slots have non-whitespace values', () => {
+      expect(
+        areAllRcsSmsFallbackVarSlotsFilled('Hello {{name}}', { '{{name}}_1': 'Ann' }),
+      ).toBe(true);
+    });
+
+    it('coerces non-string slot values with String() so DLT/hydration payloads still count as filled', () => {
+      expect(
+        areAllRcsSmsFallbackVarSlotsFilled('Hello {{name}}', { '{{name}}_1': 42 }),
+      ).toBe(true);
+    });
+
+    it('accepts legacy 1-based ordinal keys when the only token is at segment index 0 (DLT / API parity)', () => {
+      expect(areAllRcsSmsFallbackVarSlotsFilled('{#shop#}', { '{#shop#}_1': 'Mart' })).toBe(true);
+      expect(areAllRcsSmsFallbackVarSlotsFilled('{#shop#}', { '{#shop#}_1': '' })).toBe(false);
+    });
+  });
+
+  describe('buildRcsNumericMustachePlaceholderRegex', () => {
+    it('escapes regex metacharacters in numeric name', () => {
+      const re = buildRcsNumericMustachePlaceholderRegex('1.5');
+      expect(re.test('{{1.5}}')).toBe(true);
+    });
+
+    it('matches simple numeric placeholder', () => {
+      const re = buildRcsNumericMustachePlaceholderRegex('2');
+      expect(re.test('{{2}}')).toBe(true);
+      expect(re.test('{{3}}')).toBe(false);
+    });
+  });
 });