@capillarytech/creatives-library 9.0.29 → 9.0.31

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

@@ -0,0 +1,916 @@
+import {
+  getCarouselImageAssetIndex,
+  getCarouselVideoAssetIndex,
+  getCarouselThumbnailAssetIndex,
+  isThumbnailAssetIndex,
+  getCarouselDimensionKey,
+  ensureFirstCardDefaultPhoneSuggestions,
+  carouselButtonTextHasForbiddenChars,
+  isCompleteSavedCarouselSuggestion,
+  isCarouselCardValid,
+  checkDisableAddCarouselButton,
+  getNextCarouselVarToken,
+  getCarouselTitleCharacterCount,
+  getCarouselDescriptionCharacterCount,
+  buildCarouselCardsForPreview,
+  buildCarouselCardContentForPayload,
+} from '../carouselUtils';
+import { RCS_CTA_URL_TYPE } from '../../../v2Components/CapActionButton/constants';
+import {
+  RCS_MEDIA_TYPES,
+  RCS_BUTTON_TYPES,
+  RCS_CAROUSEL_ASSET_INDEX_BASE,
+  RCS_CAROUSEL_FIRST_CARD_DEFAULT_SUGGESTIONS,
+  TEMPLATE_TITLE_MAX_LENGTH,
+  RCS_RICH_CARD_MAX_LENGTH,
+  rcsVarRegex,
+  MEDIUM,
+} from '../constants';
+
+describe('getCarouselImageAssetIndex', () => {
+  it('returns base index for card 0', () => {
+    expect(getCarouselImageAssetIndex(0)).toBe(RCS_CAROUSEL_ASSET_INDEX_BASE);
+  });
+
+  it('returns base + 3*cardIndex for later cards', () => {
+    expect(getCarouselImageAssetIndex(1)).toBe(RCS_CAROUSEL_ASSET_INDEX_BASE + 3);
+    expect(getCarouselImageAssetIndex(3)).toBe(RCS_CAROUSEL_ASSET_INDEX_BASE + 9);
+  });
+});
+
+describe('getCarouselVideoAssetIndex', () => {
+  it('returns base + 3*cardIndex + 1', () => {
+    expect(getCarouselVideoAssetIndex(0)).toBe(RCS_CAROUSEL_ASSET_INDEX_BASE + 1);
+    expect(getCarouselVideoAssetIndex(2)).toBe(RCS_CAROUSEL_ASSET_INDEX_BASE + 7);
+  });
+});
+
+describe('getCarouselThumbnailAssetIndex', () => {
+  it('returns base + 3*cardIndex + 2', () => {
+    expect(getCarouselThumbnailAssetIndex(0)).toBe(RCS_CAROUSEL_ASSET_INDEX_BASE + 2);
+    expect(getCarouselThumbnailAssetIndex(2)).toBe(RCS_CAROUSEL_ASSET_INDEX_BASE + 8);
+  });
+});
+
+describe('isThumbnailAssetIndex', () => {
+  it('returns true for the standalone thumbnail index 1', () => {
+    expect(isThumbnailAssetIndex(1)).toBe(true);
+  });
+
+  it('returns true for carousel thumbnail slots (base + 2, base + 5, ...)', () => {
+    expect(isThumbnailAssetIndex(RCS_CAROUSEL_ASSET_INDEX_BASE + 2)).toBe(true);
+    expect(isThumbnailAssetIndex(RCS_CAROUSEL_ASSET_INDEX_BASE + 5)).toBe(true);
+  });
+
+  it('returns false for carousel image/video slots', () => {
+    expect(isThumbnailAssetIndex(RCS_CAROUSEL_ASSET_INDEX_BASE)).toBe(false);
+    expect(isThumbnailAssetIndex(RCS_CAROUSEL_ASSET_INDEX_BASE + 1)).toBe(false);
+    expect(isThumbnailAssetIndex(RCS_CAROUSEL_ASSET_INDEX_BASE + 3)).toBe(false);
+  });
+
+  it('returns false for standalone indices below the carousel base other than 1', () => {
+    expect(isThumbnailAssetIndex(0)).toBe(false);
+    expect(isThumbnailAssetIndex(2)).toBe(false);
+    expect(isThumbnailAssetIndex(9)).toBe(false);
+  });
+});
+
+describe('getCarouselDimensionKey', () => {
+  it('joins height and width with underscore', () => {
+    expect(getCarouselDimensionKey('SHORT', 'SMALL')).toBe('SHORT_SMALL');
+    expect(getCarouselDimensionKey('MEDIUM', 'MEDIUM')).toBe('MEDIUM_MEDIUM');
+  });
+});
+
+describe('ensureFirstCardDefaultPhoneSuggestions', () => {
+  it('returns empty array when cards is null, undefined, or empty', () => {
+    expect(ensureFirstCardDefaultPhoneSuggestions(null)).toEqual([]);
+    expect(ensureFirstCardDefaultPhoneSuggestions(undefined)).toEqual([]);
+    expect(ensureFirstCardDefaultPhoneSuggestions([])).toEqual([]);
+  });
+
+  it('adds default suggestions to first card when suggestions is missing', () => {
+    const out = ensureFirstCardDefaultPhoneSuggestions([{ title: 'A' }]);
+    expect(out[0].suggestions).toEqual(RCS_CAROUSEL_FIRST_CARD_DEFAULT_SUGGESTIONS);
+  });
+
+  it('adds default suggestions to first card when suggestions is an empty array', () => {
+    const out = ensureFirstCardDefaultPhoneSuggestions([{ title: 'A', suggestions: [] }]);
+    expect(out[0].suggestions).toEqual(RCS_CAROUSEL_FIRST_CARD_DEFAULT_SUGGESTIONS);
+  });
+
+  it('adds default suggestions to first card when suggestions is not an array', () => {
+    const out = ensureFirstCardDefaultPhoneSuggestions([{ title: 'A', suggestions: 'nope' }]);
+    expect(out[0].suggestions).toEqual(RCS_CAROUSEL_FIRST_CARD_DEFAULT_SUGGESTIONS);
+  });
+
+  it('keeps existing first-card suggestions when already present', () => {
+    const existing = [{ type: RCS_BUTTON_TYPES.QUICK_REPLY, text: 'Hi' }];
+    const out = ensureFirstCardDefaultPhoneSuggestions([{ title: 'A', suggestions: existing }]);
+    expect(out[0].suggestions).toEqual(existing);
+  });
+
+  it('does not touch cards after the first', () => {
+    const out = ensureFirstCardDefaultPhoneSuggestions([
+      { title: 'A' },
+      { title: 'B' },
+    ]);
+    expect(out[1].suggestions).toBeUndefined();
+  });
+
+  it('does not mutate the original input array', () => {
+    const original = [{ title: 'A', suggestions: [{ type: RCS_BUTTON_TYPES.QUICK_REPLY }] }];
+    const out = ensureFirstCardDefaultPhoneSuggestions(original);
+    out[0].suggestions.push({ type: RCS_BUTTON_TYPES.CTA });
+    expect(original[0].suggestions.length).toBe(1);
+  });
+});
+
+describe('carouselButtonTextHasForbiddenChars', () => {
+  it('returns false for falsy values', () => {
+    expect(carouselButtonTextHasForbiddenChars('')).toBe(false);
+    expect(carouselButtonTextHasForbiddenChars(null)).toBe(false);
+    expect(carouselButtonTextHasForbiddenChars(undefined)).toBe(false);
+  });
+
+  it('returns true when value contains [ or ]', () => {
+    expect(carouselButtonTextHasForbiddenChars('Hello [there]')).toBe(true);
+    expect(carouselButtonTextHasForbiddenChars('Only [')).toBe(true);
+    expect(carouselButtonTextHasForbiddenChars('Only ]')).toBe(true);
+  });
+
+  it('returns false when the only braces are valid {{var}} tokens', () => {
+    expect(carouselButtonTextHasForbiddenChars('Hi {{1}}')).toBe(false);
+    expect(carouselButtonTextHasForbiddenChars('Plain text')).toBe(false);
+  });
+
+  it('returns true when a stray { or } remains after stripping valid variables', () => {
+    expect(carouselButtonTextHasForbiddenChars('Hi {{1}} extra {')).toBe(true);
+    expect(carouselButtonTextHasForbiddenChars('Hi {{1}} extra }')).toBe(true);
+    expect(carouselButtonTextHasForbiddenChars('just {')).toBe(true);
+    expect(carouselButtonTextHasForbiddenChars('just }')).toBe(true);
+  });
+});
+
+describe('isCompleteSavedCarouselSuggestion', () => {
+  it('returns false when suggestion is missing or not saved', () => {
+    expect(isCompleteSavedCarouselSuggestion(null)).toBe(false);
+    expect(isCompleteSavedCarouselSuggestion(undefined)).toBe(false);
+    expect(isCompleteSavedCarouselSuggestion({ isSaved: false })).toBe(false);
+    expect(isCompleteSavedCarouselSuggestion({})).toBe(false);
+  });
+
+  it('returns false when text is empty, whitespace-only, or invalid', () => {
+    expect(isCompleteSavedCarouselSuggestion({ isSaved: true, text: '' })).toBe(false);
+    expect(isCompleteSavedCarouselSuggestion({ isSaved: true, text: '   ' })).toBe(false);
+    expect(isCompleteSavedCarouselSuggestion({ isSaved: true, text: 'Bad!' })).toBe(false);
+  });
+
+  describe('PHONE_NUMBER suggestions', () => {
+    it('returns true when phoneNumber length is at least 5', () => {
+      expect(
+        isCompleteSavedCarouselSuggestion({
+          isSaved: true,
+          text: 'Call',
+          type: RCS_BUTTON_TYPES.PHONE_NUMBER,
+          phoneNumber: '12345',
+        }),
+      ).toBe(true);
+    });
+
+    it('returns false when phoneNumber is too short or missing', () => {
+      expect(
+        isCompleteSavedCarouselSuggestion({
+          isSaved: true,
+          text: 'Call',
+          type: RCS_BUTTON_TYPES.PHONE_NUMBER,
+          phoneNumber: '123',
+        }),
+      ).toBe(false);
+      expect(
+        isCompleteSavedCarouselSuggestion({
+          isSaved: true,
+          text: 'Call',
+          type: RCS_BUTTON_TYPES.PHONE_NUMBER,
+        }),
+      ).toBe(false);
+    });
+  });
+
+  describe('CTA suggestions', () => {
+    it('returns false when url is empty or whitespace-only', () => {
+      expect(
+        isCompleteSavedCarouselSuggestion({
+          isSaved: true,
+          text: 'Go',
+          type: RCS_BUTTON_TYPES.CTA,
+          url: '   ',
+        }),
+      ).toBe(false);
+      expect(
+        isCompleteSavedCarouselSuggestion({
+          isSaved: true,
+          text: 'Go',
+          type: RCS_BUTTON_TYPES.CTA,
+        }),
+      ).toBe(false);
+    });
+
+    it('returns false when url exceeds max length', () => {
+      const longUrl = `https://example.com/${'a'.repeat(2000)}`;
+      expect(
+        isCompleteSavedCarouselSuggestion({
+          isSaved: true,
+          text: 'Go',
+          type: RCS_BUTTON_TYPES.CTA,
+          url: longUrl,
+        }),
+      ).toBe(false);
+    });
+
+    it('returns true for DYNAMIC urlType regardless of url shape', () => {
+      expect(
+        isCompleteSavedCarouselSuggestion({
+          isSaved: true,
+          text: 'Go',
+          type: RCS_BUTTON_TYPES.CTA,
+          url: 'not-a-real-url',
+          urlType: RCS_CTA_URL_TYPE.DYNAMIC,
+        }),
+      ).toBe(true);
+    });
+
+    it('returns false for STATIC (default) urlType when url is not a valid url', () => {
+      expect(
+        isCompleteSavedCarouselSuggestion({
+          isSaved: true,
+          text: 'Go',
+          type: RCS_BUTTON_TYPES.CTA,
+          url: 'not-a-real-url',
+        }),
+      ).toBe(false);
+    });
+
+    it('returns false for STATIC urlType when the url contains a var token', () => {
+      expect(
+        isCompleteSavedCarouselSuggestion({
+          isSaved: true,
+          text: 'Go',
+          type: RCS_BUTTON_TYPES.CTA,
+          url: 'https://example.com/{{promo}}',
+          urlType: RCS_CTA_URL_TYPE.STATIC,
+        }),
+      ).toBe(false);
+    });
+
+    it('returns true for STATIC urlType with a clean valid url', () => {
+      expect(
+        isCompleteSavedCarouselSuggestion({
+          isSaved: true,
+          text: 'Go',
+          type: RCS_BUTTON_TYPES.CTA,
+          url: 'https://example.com/page',
+          urlType: RCS_CTA_URL_TYPE.STATIC,
+        }),
+      ).toBe(true);
+    });
+  });
+
+  it('returns true for QUICK_REPLY suggestions with valid text', () => {
+    expect(
+      isCompleteSavedCarouselSuggestion({
+        isSaved: true,
+        text: 'Yes please',
+        type: RCS_BUTTON_TYPES.QUICK_REPLY,
+      }),
+    ).toBe(true);
+  });
+
+  it('returns false for unrecognized or NONE suggestion types', () => {
+    expect(
+      isCompleteSavedCarouselSuggestion({
+        isSaved: true,
+        text: 'Hi',
+        type: RCS_BUTTON_TYPES.NONE,
+      }),
+    ).toBe(false);
+    expect(
+      isCompleteSavedCarouselSuggestion({
+        isSaved: true,
+        text: 'Hi',
+        type: 'SOMETHING_ELSE',
+      }),
+    ).toBe(false);
+  });
+});
+
+describe('isCarouselCardValid', () => {
+  const validImageCard = {
+    title: 'Title',
+    description: 'Description',
+    mediaType: RCS_MEDIA_TYPES.IMAGE,
+    imageSrc: 'https://example.com/img.png',
+  };
+
+  it('returns false when card is missing', () => {
+    expect(isCarouselCardValid(null, 0)).toBe(false);
+    expect(isCarouselCardValid(undefined, 0)).toBe(false);
+  });
+
+  it('returns false when title is missing, empty, or whitespace-only', () => {
+    expect(isCarouselCardValid({ ...validImageCard, title: undefined }, 1)).toBe(false);
+    expect(isCarouselCardValid({ ...validImageCard, title: '' }, 1)).toBe(false);
+    expect(isCarouselCardValid({ ...validImageCard, title: '   ' }, 1)).toBe(false);
+  });
+
+  it('returns false when title exceeds TEMPLATE_TITLE_MAX_LENGTH', () => {
+    const longTitle = 'a'.repeat(TEMPLATE_TITLE_MAX_LENGTH + 1);
+    expect(isCarouselCardValid({ ...validImageCard, title: longTitle }, 1)).toBe(false);
+  });
+
+  it('accepts a title exactly at TEMPLATE_TITLE_MAX_LENGTH', () => {
+    const maxTitle = 'a'.repeat(TEMPLATE_TITLE_MAX_LENGTH);
+    expect(isCarouselCardValid({ ...validImageCard, title: maxTitle }, 1)).toBe(true);
+  });
+
+  it('returns false when description is missing, empty, or whitespace-only', () => {
+    expect(isCarouselCardValid({ ...validImageCard, description: undefined }, 1)).toBe(false);
+    expect(isCarouselCardValid({ ...validImageCard, description: '' }, 1)).toBe(false);
+    expect(isCarouselCardValid({ ...validImageCard, description: '   ' }, 1)).toBe(false);
+  });
+
+  it('returns false when description exceeds RCS_RICH_CARD_MAX_LENGTH', () => {
+    const longDesc = 'a'.repeat(RCS_RICH_CARD_MAX_LENGTH + 1);
+    expect(isCarouselCardValid({ ...validImageCard, description: longDesc }, 1)).toBe(false);
+  });
+
+  it('accepts a description exactly at RCS_RICH_CARD_MAX_LENGTH', () => {
+    const maxDesc = 'a'.repeat(RCS_RICH_CARD_MAX_LENGTH);
+    expect(isCarouselCardValid({ ...validImageCard, description: maxDesc }, 1)).toBe(true);
+  });
+
+  it('returns false for an unrecognized/NONE media type', () => {
+    expect(isCarouselCardValid({ ...validImageCard, mediaType: RCS_MEDIA_TYPES.NONE }, 1)).toBe(false);
+    expect(isCarouselCardValid({ ...validImageCard, mediaType: undefined }, 1)).toBe(false);
+  });
+
+  describe('IMAGE media', () => {
+    it('returns false when imageSrc is missing or blank', () => {
+      expect(isCarouselCardValid({ ...validImageCard, imageSrc: '' }, 1)).toBe(false);
+      expect(isCarouselCardValid({ ...validImageCard, imageSrc: '   ' }, 1)).toBe(false);
+      expect(isCarouselCardValid({ ...validImageCard, imageSrc: undefined }, 1)).toBe(false);
+    });
+
+    it('returns true when imageSrc is present', () => {
+      expect(isCarouselCardValid(validImageCard, 1)).toBe(true);
+    });
+  });
+
+  describe('VIDEO media', () => {
+    const baseVideoCard = {
+      title: 'Title',
+      description: 'Description',
+      mediaType: RCS_MEDIA_TYPES.VIDEO,
+      videoAsset: { videoSrc: 'https://example.com/v.mp4' },
+      thumbnailSrc: 'https://example.com/thumb.png',
+    };
+
+    it('returns true when both videoSrc and thumbnailSrc are present', () => {
+      expect(isCarouselCardValid(baseVideoCard, 1)).toBe(true);
+    });
+
+    it('returns false when videoAsset.videoSrc is missing', () => {
+      expect(isCarouselCardValid({ ...baseVideoCard, videoAsset: {} }, 1)).toBe(false);
+      expect(isCarouselCardValid({ ...baseVideoCard, videoAsset: undefined }, 1)).toBe(false);
+    });
+
+    it('returns false when thumbnailSrc is missing or blank', () => {
+      expect(isCarouselCardValid({ ...baseVideoCard, thumbnailSrc: '' }, 1)).toBe(false);
+      expect(isCarouselCardValid({ ...baseVideoCard, thumbnailSrc: '   ' }, 1)).toBe(false);
+    });
+  });
+
+  describe('first card suggestion requirement (cardIndex === 0)', () => {
+    it('returns false when there are no complete saved suggestions', () => {
+      expect(isCarouselCardValid({ ...validImageCard, suggestions: [] }, 0)).toBe(false);
+      expect(isCarouselCardValid({ ...validImageCard, suggestions: undefined }, 0)).toBe(false);
+      expect(
+        isCarouselCardValid(
+          { ...validImageCard, suggestions: [{ isSaved: false }] },
+          0,
+        ),
+      ).toBe(false);
+    });
+
+    it('returns true when at least one suggestion is complete and saved', () => {
+      expect(
+        isCarouselCardValid(
+          {
+            ...validImageCard,
+            suggestions: [
+              {
+                isSaved: true,
+                text: 'Yes',
+                type: RCS_BUTTON_TYPES.QUICK_REPLY,
+              },
+            ],
+          },
+          0,
+        ),
+      ).toBe(true);
+    });
+
+    it('treats a non-array suggestions field as empty', () => {
+      expect(isCarouselCardValid({ ...validImageCard, suggestions: 'nope' }, 0)).toBe(false);
+    });
+  });
+
+  it('does not require suggestions for cards after the first', () => {
+    expect(isCarouselCardValid({ ...validImageCard, suggestions: [] }, 1)).toBe(true);
+    expect(isCarouselCardValid({ ...validImageCard, suggestions: undefined }, 2)).toBe(true);
+  });
+});
+
+describe('checkDisableAddCarouselButton', () => {
+  const validCard = {
+    title: 'Title',
+    description: 'Description',
+    mediaType: RCS_MEDIA_TYPES.IMAGE,
+    imageSrc: 'https://example.com/img.png',
+    suggestions: [{ isSaved: true, text: 'Yes', type: RCS_BUTTON_TYPES.QUICK_REPLY }],
+  };
+
+  it('returns false when the active card is valid', () => {
+    expect(checkDisableAddCarouselButton([validCard], 0)).toBe(false);
+  });
+
+  it('returns true when the active card is invalid', () => {
+    expect(checkDisableAddCarouselButton([{ title: '' }], 0)).toBe(true);
+  });
+
+  it('returns true when the active card is out of bounds', () => {
+    expect(checkDisableAddCarouselButton([validCard], 5)).toBe(true);
+  });
+
+  it('returns true when carouselData is null or undefined', () => {
+    expect(checkDisableAddCarouselButton(null, 0)).toBe(true);
+    expect(checkDisableAddCarouselButton(undefined, 0)).toBe(true);
+  });
+
+  it('parses a string activeCarouselIndex', () => {
+    expect(checkDisableAddCarouselButton([{}, validCard], '1')).toBe(false);
+  });
+
+  it('handles a non-numeric activeCarouselIndex as out of bounds', () => {
+    expect(checkDisableAddCarouselButton([validCard], 'abc')).toBe(true);
+  });
+});
+
+describe('getNextCarouselVarToken', () => {
+  it('returns {{1}} when carouselData is null, undefined, or empty', () => {
+    expect(getNextCarouselVarToken(null)).toBe('{{1}}');
+    expect(getNextCarouselVarToken(undefined)).toBe('{{1}}');
+    expect(getNextCarouselVarToken([])).toBe('{{1}}');
+  });
+
+  it('returns {{1}} when no cards contain numeric var tokens', () => {
+    expect(
+      getNextCarouselVarToken([{ title: 'Hello', description: 'World' }]),
+    ).toBe('{{1}}');
+  });
+
+  it('handles cards with missing title/description gracefully', () => {
+    expect(getNextCarouselVarToken([{}, undefined])).toBe('{{1}}');
+  });
+
+  it('returns the next number after the highest used token', () => {
+    expect(
+      getNextCarouselVarToken([{ title: 'Hi {{1}}', description: '' }]),
+    ).toBe('{{2}}');
+  });
+
+  it('fills a gap in used numbers', () => {
+    expect(
+      getNextCarouselVarToken([
+        { title: 'Hi {{1}}', description: 'Bye {{3}}' },
+      ]),
+    ).toBe('{{2}}');
+  });
+
+  it('collects numeric tokens from title and description across multiple cards', () => {
+    expect(
+      getNextCarouselVarToken([
+        { title: '{{1}}', description: '{{2}}' },
+        { title: '{{4}}', description: '' },
+      ]),
+    ).toBe('{{3}}');
+  });
+
+  it('returns an empty string once all slots 1-19 are used', () => {
+    const allTokens = Array.from({ length: 19 }, (_, i) => `{{${i + 1}}}`).join(' ');
+    expect(
+      getNextCarouselVarToken([{ title: allTokens, description: '' }]),
+    ).toBe('');
+  });
+});
+
+describe('getCarouselTitleCharacterCount', () => {
+  it('returns 0 when carouselData, card, or title is missing', () => {
+    expect(getCarouselTitleCharacterCount(undefined, 0)).toBe(0);
+    expect(getCarouselTitleCharacterCount([], 0)).toBe(0);
+    expect(getCarouselTitleCharacterCount([{}], 0)).toBe(0);
+    expect(getCarouselTitleCharacterCount([{ title: '' }], 0)).toBe(0);
+  });
+
+  it('returns the title length for the given card index', () => {
+    expect(getCarouselTitleCharacterCount([{ title: 'Hello' }], 0)).toBe(5);
+    expect(
+      getCarouselTitleCharacterCount([{ title: 'A' }, { title: 'Longer title' }], 1),
+    ).toBe(12);
+  });
+});
+
+describe('getCarouselDescriptionCharacterCount', () => {
+  it('returns 0 when carouselData, card, or description is missing', () => {
+    expect(getCarouselDescriptionCharacterCount(undefined, 0)).toBe(0);
+    expect(getCarouselDescriptionCharacterCount([], 0)).toBe(0);
+    expect(getCarouselDescriptionCharacterCount([{}], 0)).toBe(0);
+    expect(getCarouselDescriptionCharacterCount([{ description: '' }], 0)).toBe(0);
+  });
+
+  it('returns the description length for the given card index', () => {
+    expect(getCarouselDescriptionCharacterCount([{ description: 'Hello' }], 0)).toBe(5);
+    expect(
+      getCarouselDescriptionCharacterCount(
+        [{ description: 'A' }, { description: 'Longer desc' }],
+        1,
+      ),
+    ).toBe(11);
+  });
+});
+
+describe('buildCarouselCardsForPreview', () => {
+  it('returns an empty array when cards is missing', () => {
+    expect(
+      buildCarouselCardsForPreview(undefined, {
+        isFullMode: false,
+        rcsVarRegex,
+        resolveTemplateWithMap: jest.fn(),
+      }),
+    ).toEqual([]);
+    expect(
+      buildCarouselCardsForPreview([], {
+        isFullMode: false,
+        rcsVarRegex,
+        resolveTemplateWithMap: jest.fn(),
+      }),
+    ).toEqual([]);
+  });
+
+  it('returns an empty array when cards is explicitly null', () => {
+    expect(
+      buildCarouselCardsForPreview(null, {
+        isFullMode: false,
+        rcsVarRegex,
+        resolveTemplateWithMap: jest.fn(),
+      }),
+    ).toEqual([]);
+  });
+
+  it('passes title/description through unresolved in full mode without calling resolveTemplateWithMap', () => {
+    const resolveTemplateWithMap = jest.fn();
+    const out = buildCarouselCardsForPreview(
+      [{ title: 'Hi {{a}}', description: 'Bye {{b}}' }],
+      { isFullMode: true, rcsVarRegex, resolveTemplateWithMap },
+    );
+    expect(resolveTemplateWithMap).not.toHaveBeenCalled();
+    expect(out[0].title).toBe('Hi {{a}}');
+    expect(out[0].bodyText).toBe('Bye {{b}}');
+  });
+
+  it('resolves title/description through resolveTemplateWithMap and accumulates slot offset across cards', () => {
+    const resolveTemplateWithMap = jest.fn((str, offset) => `R(${str}|${offset})`);
+    const out = buildCarouselCardsForPreview(
+      [
+        { title: 'Hi {{a}}', description: 'Bye {{b}} {{c}}' },
+        { title: 'Solo {{d}}', description: 'none' },
+      ],
+      { isFullMode: false, rcsVarRegex, resolveTemplateWithMap },
+    );
+    expect(resolveTemplateWithMap).toHaveBeenNthCalledWith(1, 'Hi {{a}}', 0);
+    expect(resolveTemplateWithMap).toHaveBeenNthCalledWith(2, 'Bye {{b}} {{c}}', 1);
+    expect(resolveTemplateWithMap).toHaveBeenNthCalledWith(3, 'Solo {{d}}', 3);
+    expect(resolveTemplateWithMap).toHaveBeenNthCalledWith(4, 'none', 4);
+    expect(out[0].title).toBe('R(Hi {{a}}|0)');
+    expect(out[0].bodyText).toBe('R(Bye {{b}} {{c}}|1)');
+    expect(out[1].title).toBe('R(Solo {{d}}|3)');
+    expect(out[1].bodyText).toBe('R(none|4)');
+  });
+
+  it('defaults missing card fields, including a default {} for a missing array item', () => {
+    const out = buildCarouselCardsForPreview([undefined], {
+      isFullMode: true,
+      rcsVarRegex,
+      resolveTemplateWithMap: jest.fn(),
+    });
+    expect(out[0]).toEqual({
+      mediaType: '',
+      imageSrc: '',
+      videoSrc: '',
+      videoPreviewImg: '',
+      title: '',
+      bodyText: '',
+      suggestions: [],
+    });
+  });
+
+  it('lowercases mediaType and passes through imageSrc/suggestions', () => {
+    const out = buildCarouselCardsForPreview(
+      [
+        {
+          mediaType: RCS_MEDIA_TYPES.IMAGE,
+          imageSrc: 'img.png',
+          suggestions: [{ text: 'Hi' }],
+          title: '',
+          description: '',
+        },
+      ],
+      { isFullMode: true, rcsVarRegex, resolveTemplateWithMap: jest.fn() },
+    );
+    expect(out[0].mediaType).toBe('image');
+    expect(out[0].imageSrc).toBe('img.png');
+    expect(out[0].suggestions).toEqual([{ text: 'Hi' }]);
+  });
+
+  it('prefers thumbnailSrc over videoAsset.videoThumbnail for videoPreviewImg', () => {
+    const out = buildCarouselCardsForPreview(
+      [
+        {
+          mediaType: RCS_MEDIA_TYPES.VIDEO,
+          thumbnailSrc: 'thumb.png',
+          videoAsset: { videoSrc: 'v.mp4', videoThumbnail: 'other-thumb.png' },
+        },
+      ],
+      { isFullMode: true, rcsVarRegex, resolveTemplateWithMap: jest.fn() },
+    );
+    expect(out[0].videoPreviewImg).toBe('thumb.png');
+    expect(out[0].videoSrc).toBe('v.mp4');
+  });
+
+  it('falls back to videoAsset.videoThumbnail when thumbnailSrc is missing', () => {
+    const out = buildCarouselCardsForPreview(
+      [
+        {
+          mediaType: RCS_MEDIA_TYPES.VIDEO,
+          videoAsset: { videoSrc: 'v.mp4', videoThumbnail: 'other-thumb.png' },
+        },
+      ],
+      { isFullMode: true, rcsVarRegex, resolveTemplateWithMap: jest.fn() },
+    );
+    expect(out[0].videoPreviewImg).toBe('other-thumb.png');
+  });
+
+  it('defaults videoPreviewImg and videoSrc to empty string when nothing is set', () => {
+    const out = buildCarouselCardsForPreview(
+      [{ mediaType: RCS_MEDIA_TYPES.IMAGE }],
+      { isFullMode: true, rcsVarRegex, resolveTemplateWithMap: jest.fn() },
+    );
+    expect(out[0].videoPreviewImg).toBe('');
+    expect(out[0].videoSrc).toBe('');
+  });
+});
+
+describe('buildCarouselCardContentForPayload', () => {
+  it('returns an empty array when carouselData is missing', () => {
+    expect(
+      buildCarouselCardContentForPayload(undefined, {
+        isSlotMappingMode: false,
+        cardVarMapped: {},
+        selectedCarouselHeight: 'SHORT',
+        rcsVarRegex,
+      }),
+    ).toEqual([]);
+  });
+
+  it('returns an empty array when carouselData is explicitly null', () => {
+    expect(
+      buildCarouselCardContentForPayload(null, {
+        isSlotMappingMode: false,
+        cardVarMapped: {},
+        selectedCarouselHeight: 'SHORT',
+        rcsVarRegex,
+      }),
+    ).toEqual([]);
+  });
+
+  it('defaults a missing array item to {}', () => {
+    const out = buildCarouselCardContentForPayload([undefined], {
+      isSlotMappingMode: false,
+      cardVarMapped: {},
+      selectedCarouselHeight: 'SHORT',
+      rcsVarRegex,
+    });
+    expect(out[0]).toEqual({ title: '', description: '' });
+  });
+
+  it('builds title/description/mediaType and omits media for non image/video cards', () => {
+    const out = buildCarouselCardContentForPayload(
+      [{ title: 'T', description: 'D', mediaType: RCS_MEDIA_TYPES.NONE }],
+      { isSlotMappingMode: false, cardVarMapped: {}, selectedCarouselHeight: 'SHORT', rcsVarRegex },
+    );
+    expect(out[0]).toEqual({ title: 'T', description: 'D', mediaType: RCS_MEDIA_TYPES.NONE });
+  });
+
+  describe('IMAGE media', () => {
+    it('uses imageSrc as mediaUrl and an empty thumbnailUrl', () => {
+      const out = buildCarouselCardContentForPayload(
+        [{ title: 'T', description: 'D', mediaType: RCS_MEDIA_TYPES.IMAGE, imageSrc: 'img.png' }],
+        { isSlotMappingMode: false, cardVarMapped: {}, selectedCarouselHeight: 'SHORT', rcsVarRegex },
+      );
+      expect(out[0].media).toEqual({ mediaUrl: 'img.png', thumbnailUrl: '', height: 'SHORT' });
+    });
+
+    it('defaults height to MEDIUM when selectedCarouselHeight is missing', () => {
+      const out = buildCarouselCardContentForPayload(
+        [{ title: 'T', description: 'D', mediaType: RCS_MEDIA_TYPES.IMAGE, imageSrc: 'img.png' }],
+        { isSlotMappingMode: false, cardVarMapped: {}, selectedCarouselHeight: undefined, rcsVarRegex },
+      );
+      expect(out[0].media.height).toBe(MEDIUM);
+    });
+  });
+
+  describe('VIDEO media', () => {
+    it('uses videoAsset.videoSrc as mediaUrl and thumbnailSrc as thumbnailUrl', () => {
+      const out = buildCarouselCardContentForPayload(
+        [
+          {
+            title: 'T',
+            description: 'D',
+            mediaType: RCS_MEDIA_TYPES.VIDEO,
+            videoAsset: { videoSrc: 'v.mp4' },
+            thumbnailSrc: 'thumb.png',
+          },
+        ],
+        { isSlotMappingMode: false, cardVarMapped: {}, selectedCarouselHeight: 'SHORT', rcsVarRegex },
+      );
+      expect(out[0].media.mediaUrl).toBe('v.mp4');
+      expect(out[0].media.thumbnailUrl).toBe('thumb.png');
+    });
+
+    it('falls back to videoAsset.videoThumbnail when thumbnailSrc missing', () => {
+      const out = buildCarouselCardContentForPayload(
+        [
+          {
+            title: 'T',
+            description: 'D',
+            mediaType: RCS_MEDIA_TYPES.VIDEO,
+            videoAsset: { videoSrc: 'v.mp4', videoThumbnail: 'fallback-thumb.png' },
+          },
+        ],
+        { isSlotMappingMode: false, cardVarMapped: {}, selectedCarouselHeight: 'SHORT', rcsVarRegex },
+      );
+      expect(out[0].media.thumbnailUrl).toBe('fallback-thumb.png');
+    });
+
+    it('includes videoName only when videoAsset.videoName is present', () => {
+      const withName = buildCarouselCardContentForPayload(
+        [
+          {
+            title: 'T',
+            description: 'D',
+            mediaType: RCS_MEDIA_TYPES.VIDEO,
+            videoAsset: { videoSrc: 'v.mp4', videoName: 'clip.mp4' },
+          },
+        ],
+        { isSlotMappingMode: false, cardVarMapped: {}, selectedCarouselHeight: 'SHORT', rcsVarRegex },
+      );
+      expect(withName[0].media.videoName).toBe('clip.mp4');
+
+      const withoutName = buildCarouselCardContentForPayload(
+        [
+          {
+            title: 'T',
+            description: 'D',
+            mediaType: RCS_MEDIA_TYPES.VIDEO,
+            videoAsset: { videoSrc: 'v.mp4' },
+          },
+        ],
+        { isSlotMappingMode: false, cardVarMapped: {}, selectedCarouselHeight: 'SHORT', rcsVarRegex },
+      );
+      expect(withoutName[0].media.videoName).toBeUndefined();
+    });
+
+    it('defaults mediaUrl to empty string when videoAsset.videoSrc is missing', () => {
+      const out = buildCarouselCardContentForPayload(
+        [{ title: 'T', description: 'D', mediaType: RCS_MEDIA_TYPES.VIDEO, videoAsset: {} }],
+        { isSlotMappingMode: false, cardVarMapped: {}, selectedCarouselHeight: 'SHORT', rcsVarRegex },
+      );
+      expect(out[0].media.mediaUrl).toBe('');
+    });
+  });
+
+  describe('suggestions', () => {
+    it('includes suggestions when the array is non-empty', () => {
+      const suggestions = [{ type: RCS_BUTTON_TYPES.QUICK_REPLY, text: 'Hi' }];
+      const out = buildCarouselCardContentForPayload(
+        [{ title: 'T', description: 'D', mediaType: RCS_MEDIA_TYPES.NONE, suggestions }],
+        { isSlotMappingMode: false, cardVarMapped: {}, selectedCarouselHeight: 'SHORT', rcsVarRegex },
+      );
+      expect(out[0].suggestions).toEqual(suggestions);
+    });
+
+    it('omits suggestions when array is empty, missing, or not an array', () => {
+      const outEmpty = buildCarouselCardContentForPayload(
+        [{ title: 'T', description: 'D', mediaType: RCS_MEDIA_TYPES.NONE, suggestions: [] }],
+        { isSlotMappingMode: false, cardVarMapped: {}, selectedCarouselHeight: 'SHORT', rcsVarRegex },
+      );
+      expect(outEmpty[0].suggestions).toBeUndefined();
+
+      const outMissing = buildCarouselCardContentForPayload(
+        [{ title: 'T', description: 'D', mediaType: RCS_MEDIA_TYPES.NONE }],
+        { isSlotMappingMode: false, cardVarMapped: {}, selectedCarouselHeight: 'SHORT', rcsVarRegex },
+      );
+      expect(outMissing[0].suggestions).toBeUndefined();
+
+      const outNotArray = buildCarouselCardContentForPayload(
+        [{ title: 'T', description: 'D', mediaType: RCS_MEDIA_TYPES.NONE, suggestions: 'nope' }],
+        { isSlotMappingMode: false, cardVarMapped: {}, selectedCarouselHeight: 'SHORT', rcsVarRegex },
+      );
+      expect(outNotArray[0].suggestions).toBeUndefined();
+    });
+  });
+
+  describe('cardVarMapped', () => {
+    it('omits cardVarMapped when isSlotMappingMode is false, even if there are var tokens', () => {
+      const out = buildCarouselCardContentForPayload(
+        [{ title: 'Hi {{name}}', description: 'D', mediaType: RCS_MEDIA_TYPES.NONE }],
+        { isSlotMappingMode: false, cardVarMapped: { name: 'Bob' }, selectedCarouselHeight: 'SHORT', rcsVarRegex },
+      );
+      expect(out[0].cardVarMapped).toBeUndefined();
+    });
+
+    it('omits cardVarMapped when isSlotMappingMode is true but there are no var tokens', () => {
+      const out = buildCarouselCardContentForPayload(
+        [{ title: 'Hi', description: 'D', mediaType: RCS_MEDIA_TYPES.NONE }],
+        { isSlotMappingMode: true, cardVarMapped: {}, selectedCarouselHeight: 'SHORT', rcsVarRegex },
+      );
+      expect(out[0].cardVarMapped).toBeUndefined();
+    });
+
+    it('builds cardVarMapped from title and description tokens, sanitizing values', () => {
+      const out = buildCarouselCardContentForPayload(
+        [{ title: 'Hi {{name}}', description: 'Pts {{points}}', mediaType: RCS_MEDIA_TYPES.NONE }],
+        {
+          isSlotMappingMode: true,
+          cardVarMapped: { name: 'Bob', points: '{{2}}' },
+          selectedCarouselHeight: 'SHORT',
+          rcsVarRegex,
+        },
+      );
+      expect(out[0].cardVarMapped).toEqual({ name: 'Bob', points: '' });
+    });
+
+    it('defaults an unmapped token value to empty string via sanitizeCardVarMappedValue', () => {
+      const out = buildCarouselCardContentForPayload(
+        [{ title: 'Hi {{missing}}', description: 'D', mediaType: RCS_MEDIA_TYPES.NONE }],
+        { isSlotMappingMode: true, cardVarMapped: {}, selectedCarouselHeight: 'SHORT', rcsVarRegex },
+      );
+      expect(out[0].cardVarMapped).toEqual({ missing: '' });
+    });
+
+    it('handles a missing cardVarMapped object entirely', () => {
+      const out = buildCarouselCardContentForPayload(
+        [{ title: 'Hi {{name}}', description: 'D', mediaType: RCS_MEDIA_TYPES.NONE }],
+        { isSlotMappingMode: true, cardVarMapped: undefined, selectedCarouselHeight: 'SHORT', rcsVarRegex },
+      );
+      expect(out[0].cardVarMapped).toEqual({ name: '' });
+    });
+
+    it('skips a matched token that strips down to an empty variable name', () => {
+      const emptyTokenRegex = /\{\{\}\}/g;
+      const out = buildCarouselCardContentForPayload(
+        [{ title: 'Hi {{}}', description: 'D', mediaType: RCS_MEDIA_TYPES.NONE }],
+        {
+          isSlotMappingMode: true,
+          cardVarMapped: {},
+          selectedCarouselHeight: 'SHORT',
+          rcsVarRegex: emptyTokenRegex,
+        },
+      );
+      expect(out[0].cardVarMapped).toBeUndefined();
+    });
+  });
+
+  it('builds independent content for multiple cards in one call', () => {
+    const out = buildCarouselCardContentForPayload(
+      [
+        { title: 'A', description: 'B', mediaType: RCS_MEDIA_TYPES.IMAGE, imageSrc: 'a.png' },
+        { title: 'C', description: 'D', mediaType: RCS_MEDIA_TYPES.NONE },
+      ],
+      { isSlotMappingMode: false, cardVarMapped: {}, selectedCarouselHeight: 'SHORT', rcsVarRegex },
+    );
+    expect(out).toHaveLength(2);
+    expect(out[0].media).toBeDefined();
+    expect(out[1].media).toBeUndefined();
+  });
+});