@capillarytech/creatives-library 8.0.345-alpha.15 → 8.0.345-alpha.16

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

@@ -1,22 +1,7 @@
 import React from 'react';
 import renderer from 'react-test-renderer';
 import { render, screen } from '../../../utils/test-utils';
-import {
-  getRCSContent,
-  getRcsStatusType,
-  getTemplateStatusType,
-  normalizeCardVarMapped,
-  coalesceCardVarMappedToTemplate,
-  getRcsSemanticVarNamesSpanningTitleAndDesc,
-  resolveCardVarMappedSlotValue,
-  isRcsTextOnlyCardMediaType,
-  mapRcsCardContentForConsumerWithResolvedTags,
-  resolveRcsCardPreviewStrings,
-  sanitizeCardVarMappedValue,
-  areAllRcsSmsFallbackVarSlotsFilled,
-  buildRcsNumericMustachePlaceholderRegex,
-} from '../utils';
-import { rcsVarRegex } from '../constants';
+import { getRCSContent, getRcsStatusType, getTemplateStatusType } from '../utils';
 import { RCS, RCS_BUTTON_TYPES, STATUS_OPTIONS, RCS_STATUSES } from '../constants';
 import { mockData } from './mockData';
 
@@ -41,61 +26,53 @@ describe('RCS utils - renderRcsSuggestionsPreview', () => {
     },
   };
 
-  const renderWithSuggestion = (buttonType, text) => {
+  it('renders divider and QUICK_REPLY suggestion with small-link icon', () => {
     const template = JSON.parse(JSON.stringify(templateBase));
     template.versions.base.content[RCS].rcsContent.cardContent[0].suggestions = [
-      { type: buttonType, text },
+      { type: RCS_BUTTON_TYPES.QUICK_REPLY, text: 'Reply' },
     ];
     render(getRCSContent(template));
-  };
-
-  it.each([
-    [RCS_BUTTON_TYPES.QUICK_REPLY, 'Reply', true],
-    [RCS_BUTTON_TYPES.CTA, 'Visit', false],
-    [RCS_BUTTON_TYPES.PHONE_NUMBER, 'Call', false],
-  ])('renders %s suggestion with expected label', (buttonType, text, expectDivider) => {
-    renderWithSuggestion(buttonType, text);
-    if (expectDivider) {
-      expect(document.querySelectorAll('.whatsapp-divider').length).toBeGreaterThan(0);
-    }
+    expect(document.querySelectorAll('.whatsapp-divider').length).toBeGreaterThan(0);
     const labels = document.querySelectorAll('.rcs-cta-preview');
     expect(labels.length).toBe(1);
-    expect(labels[0].textContent).toContain(text);
+    expect(labels[0].textContent).toContain('Reply');
   });
 
-  it('renders only divider for unknown suggestion type', () => {
+  it('renders CTA suggestion with launch icon', () => {
     const template = JSON.parse(JSON.stringify(templateBase));
     template.versions.base.content[RCS].rcsContent.cardContent[0].suggestions = [
-      { type: RCS_BUTTON_TYPES.NONE, text: 'Ignored' },
+      { type: RCS_BUTTON_TYPES.CTA, text: 'Visit' },
     ];
     render(getRCSContent(template));
-    expect(document.querySelectorAll('.rcs-cta-preview').length).toBe(0);
-    expect(document.querySelectorAll('.whatsapp-divider').length).toBeGreaterThan(0);
+    const labels = document.querySelectorAll('.rcs-cta-preview');
+    expect(labels.length).toBe(1);
+    expect(labels[0].textContent).toContain('Visit');
   });
 
-  it('prefers thumbnailUrl over mediaUrl for preview image', () => {
+  it('renders PHONE_NUMBER suggestion with call icon', () => {
     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' };
+    template.versions.base.content[RCS].rcsContent.cardContent[0].suggestions = [
+      { type: RCS_BUTTON_TYPES.PHONE_NUMBER, text: 'Call' },
+    ];
     render(getRCSContent(template));
-    const img = document.querySelector('.rcs-listing-image');
-    expect(img?.getAttribute('src')).toBe('thumb.jpg');
+    const labels = document.querySelectorAll('.rcs-cta-preview');
+    expect(labels.length).toBe(1);
+    expect(labels[0].textContent).toContain('Call');
   });
 });
 
 describe('RCS utils', () => {
   describe('getRCSContent', () => {
-    /** Single place for snapshot serialization — keeps test bodies focused on template setup. */
-    const expectGetRCSContentSnapshot = (template) => {
-      expect(renderer.create(getRCSContent(template)).toJSON()).toMatchSnapshot();
-    };
-
     it('renders RCS content with image and CTA suggestion', () => {
-      expectGetRCSContentSnapshot(mockData.editData1.templateDetails);
+      const template = mockData.editData1.templateDetails;
+      const tree = renderer.create(getRCSContent(template)).toJSON();
+      expect(tree).toMatchSnapshot();
     });
 
     it('renders RCS content with no media', () => {
-      expectGetRCSContentSnapshot(mockData.editData3.templateDetails);
+      const template = mockData.editData3.templateDetails;
+      const tree = renderer.create(getRCSContent(template)).toJSON();
+      expect(tree).toMatchSnapshot();
     });
 
     it('renders RCS content with multiple suggestion types', () => {
@@ -105,212 +82,19 @@ describe('RCS utils', () => {
         { type: RCS_BUTTON_TYPES.CTA, text: 'URL Action' },
         { type: RCS_BUTTON_TYPES.PHONE_NUMBER, text: 'Call Now' },
       ];
-      expectGetRCSContentSnapshot(template);
+      const tree = renderer.create(getRCSContent(template)).toJSON();
+      expect(tree).toMatchSnapshot();
     });
 
     it('renders RCS content with missing cardContent', () => {
-      expectGetRCSContentSnapshot({ versions: { base: { content: { RCS: { rcsContent: {} } } } } });
+      const template = { versions: { base: { content: { RCS: { rcsContent: {} } } } } };
+      const tree = renderer.create(getRCSContent(template)).toJSON();
+      expect(tree).toMatchSnapshot();
     });
 
     it('renders RCS content with empty template', () => {
-      expectGetRCSContentSnapshot({});
-    });
-
-    it('renders RCS carousel listing preview when cardType is carousel', () => {
-      const template = JSON.parse(JSON.stringify(mockData.editData1.templateDetails));
-      const rcsContent = template.versions.base.content.RCS.rcsContent;
-      rcsContent.cardType = 'CAROUSEL';
-      rcsContent.cardContent = [
-        {
-          title: 'Card1',
-          description: 'Desc1',
-          media: { mediaUrl: 'https://example.com/1.png' },
-          suggestions: [],
-        },
-        {
-          title: 'Card2',
-          description: 'Desc2',
-          media: { mediaUrl: 'https://example.com/2.png' },
-          suggestions: [],
-        },
-        {
-          title: 'Card3',
-          description: 'Desc3',
-          media: { mediaUrl: 'https://example.com/3.png' },
-          suggestions: [],
-        },
-        {
-          title: 'Card4',
-          description: 'Desc4',
-          media: { mediaUrl: 'https://example.com/4.png' },
-          suggestions: [],
-        },
-      ];
-
-      render(getRCSContent(template));
-      // "Peek" shows max 3
-      expect(document.querySelectorAll('.whatsapp-carousel-container').length).toBe(3);
-      expect(document.querySelectorAll('.scroll-container').length).toBeGreaterThan(0);
-    });
-
-    const carouselTemplate = (cardContent) => ({
-      versions: {
-        base: {
-          content: {
-            [RCS]: {
-              rcsContent: {
-                cardType: 'carousel',
-                cardContent,
-              },
-            },
-          },
-        },
-      },
-    });
-
-    const carouselSecondCardFiller = {
-      title: 'B',
-      description: 'D',
-      media: { mediaUrl: 'https://example.com/b.png' },
-      suggestions: [],
-    };
-
-    it('carousel: video card with thumbnailUrl uses thumbnail (not placeholder)', () => {
-      const template = carouselTemplate([
-        {
-          title: 'Vid',
-          description: 'With thumb',
-          media: {
-            mediaType: 'VIDEO',
-            mediaUrl: 'https://example.com/video.mp4',
-            thumbnailUrl: 'https://example.com/poster.jpg',
-          },
-          suggestions: [],
-        },
-        carouselSecondCardFiller,
-      ]);
-      render(getRCSContent(template));
-      expect(document.querySelector('.rcs-video-preview-placeholder')).toBeFalsy();
-      const firstImg = document.querySelector('.whatsapp-carousel-card .whatsapp-image');
-      expect(firstImg).toBeTruthy();
-      expect(firstImg.getAttribute('src')).toBe('https://example.com/poster.jpg');
-    });
-
-    it('carousel: shows video preview placeholder when VIDEO has mediaUrl but no thumbnail (no img src to mp4)', () => {
-      const template = carouselTemplate([
-        {
-          title: 'Clip',
-          description: 'No thumb',
-          media: {
-            mediaType: 'VIDEO',
-            mediaUrl: 'https://example.com/video.mp4',
-          },
-          suggestions: [],
-        },
-        carouselSecondCardFiller,
-      ]);
-      render(getRCSContent(template));
-      expect(document.querySelector('.rcs-video-preview-placeholder')).toBeTruthy();
-      expect(document.querySelector('.rcs-video-preview-label')?.textContent).toContain('Video preview');
-    });
-
-    it('carousel: uses whatsapp-message-without-media when card has no image/video URL', () => {
-      const template = carouselTemplate([
-        {
-          title: 'Text only',
-          description: 'No media',
-          media: {},
-          suggestions: [],
-        },
-        {
-          title: 'Second',
-          description: '',
-          suggestions: [],
-        },
-      ]);
-      render(getRCSContent(template));
-      const withoutMedia = document.querySelectorAll('.whatsapp-message-without-media');
-      expect(withoutMedia.length).toBeGreaterThan(0);
-    });
-
-    it('carousel: body includes description with newline when description is set', () => {
-      const template = carouselTemplate([
-        {
-          title: 'Head',
-          description: 'Tail line',
-          media: { mediaUrl: 'https://example.com/x.png' },
-          suggestions: [],
-        },
-        {
-          title: 'Y',
-          description: 'Z',
-          media: { mediaUrl: 'https://example.com/y.png' },
-          suggestions: [],
-        },
-      ]);
-      render(getRCSContent(template));
-      const bodies = document.querySelectorAll('.whatsapp-carousel-body');
-      expect(bodies[0].textContent).toContain('Head');
-      expect(bodies[0].textContent).toContain('Tail line');
-    });
-
-    it('carousel: body handles missing title and empty description', () => {
-      const template = carouselTemplate([
-        {
-          description: '',
-          media: { mediaUrl: 'https://example.com/x.png' },
-          suggestions: [],
-        },
-        {
-          title: 'Only title',
-          media: { mediaUrl: 'https://example.com/y.png' },
-          suggestions: [],
-        },
-      ]);
-      render(getRCSContent(template));
-      const bodies = document.querySelectorAll('.whatsapp-carousel-body');
-      expect(bodies[0].textContent.trim()).toBe('');
-      expect(bodies[1].textContent).toContain('Only title');
-    });
-
-    it('carousel: renders per-card suggestions via renderRcsSuggestionsPreview', () => {
-      const template = carouselTemplate([
-        {
-          title: 'C1',
-          description: 'D1',
-          media: { mediaUrl: 'https://example.com/1.png' },
-          suggestions: [{ type: RCS_BUTTON_TYPES.CTA, text: 'Go' }],
-        },
-        {
-          title: 'C2',
-          description: 'D2',
-          media: { mediaUrl: 'https://example.com/2.png' },
-          suggestions: [],
-        },
-      ]);
-      render(getRCSContent(template));
-      expect(document.querySelectorAll('.rcs-cta-preview').length).toBeGreaterThanOrEqual(1);
-      expect(Array.from(document.querySelectorAll('.rcs-cta-preview')).some((el) => el.textContent.includes('Go'))).toBe(true);
-    });
-
-    it('carousel: does not render suggestion block when suggestions missing or not an array', () => {
-      const template = carouselTemplate([
-        {
-          title: 'A',
-          description: 'B',
-          media: { mediaUrl: 'https://example.com/a.png' },
-        },
-        {
-          title: 'C',
-          description: 'D',
-          media: { mediaUrl: 'https://example.com/c.png' },
-          suggestions: null,
-        },
-      ]);
-      render(getRCSContent(template));
-      const firstCard = document.querySelectorAll('.whatsapp-carousel-card')[0];
-      const dividersInFirst = firstCard.querySelectorAll('.whatsapp-divider');
-      expect(dividersInFirst.length).toBe(0);
+      const tree = renderer.create(getRCSContent({})).toJSON();
+      expect(tree).toMatchSnapshot();
     });
   });
 
@@ -352,404 +136,4 @@ 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('getRcsSemanticVarNamesSpanningTitleAndDesc', () => {
-    it('returns names that appear in both title and description', () => {
-      const set = getRcsSemanticVarNamesSpanningTitleAndDesc(
-        'Hello {{adv}}',
-        'Body {{adv}} x {{other}}',
-        rcsVarRegex,
-      );
-      expect(Array.from(set).sort()).toEqual(['adv']);
-    });
-
-    it('is empty when the same name is only repeated in the title', () => {
-      const set = getRcsSemanticVarNamesSpanningTitleAndDesc(
-        '{{user_name}} and {{user_name}}',
-        'Hi',
-        rcsVarRegex,
-      );
-      expect(set.size).toBe(0);
-    });
-  });
-
-  describe('coalesceCardVarMappedToTemplate', () => {
-    it('does not copy a shared semantic value into the second slot when the tag spans title and description', () => {
-      const out = coalesceCardVarMappedToTemplate(
-        { adv: 'shared' },
-        'T {{adv}}',
-        'D {{adv}}',
-        rcsVarRegex,
-      );
-      expect(out[1]).toBe('shared');
-      expect(out[2]).toBe('');
-      expect(out.adv).toBe('shared');
-    });
-
-    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}}');
-    });
-
-    it('omitSemanticFallback: duplicate title+desc tag does not read shared semantic for either slot', () => {
-      expect(
-        resolveCardVarMappedSlotValue({ adv: '{{adv}}', 1: '', 2: '' }, 'adv', 0, false, true),
-      ).toBe('');
-      expect(
-        resolveCardVarMappedSlotValue({ adv: '{{adv}}', 1: 'A', 2: 'B' }, 'adv', 0, false, true),
-      ).toBe('A');
-      expect(
-        resolveCardVarMappedSlotValue({ adv: '{{adv}}', 1: 'A', 2: 'B' }, 'adv', 1, false, true),
-      ).toBe('B');
-    });
-
-    it('omitSemanticFallback: cleared semantic does not force empty when numeric slot has a value', () => {
-      expect(
-        resolveCardVarMappedSlotValue({ adv: '', 1: 'first', 2: 'second' }, 'adv', 1, false, true),
-      ).toBe('second');
-    });
-  });
-
-  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}}');
-    });
-
-    it('passes through null or non-object items in the card array unchanged', () => {
-      const out = mapRcsCardContentForConsumerWithResolvedTags([null, 'string', 42], {}, false);
-      expect(out).toEqual([null, 'string', 42]);
-    });
-  });
-
-  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);
-    });
-  });
 });