@capillarytech/creatives-library 9.0.29 → 9.0.30

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

@@ -0,0 +1,912 @@
+import {
+  getUnmappedDesc,
+  hasRcsVarTokens,
+  normalizeLibraryLoadedTitleDesc,
+  mergeRcsSmsFallBackContentFromDetails,
+  mergeRcsSmsFallbackVarMapLayers,
+  pickFirstSmsFallbackTemplateString,
+  syncCardVarMappedSemanticsFromSlots,
+  hasMeaningfulSmsFallbackShape,
+  getLibrarySmsFallbackApiBaselineFromTemplateData,
+  extractRegisteredSenderIdsFromSmsFallbackRecord,
+  pickRcsCardVarMappedEntries,
+  mergeSmsFallbackForLibrary,
+  buildSmsFallBackContentForPayload,
+  resolveSmsFallbackHydrationFromDetails,
+  applySmsFallbackHydration,
+} from '../rcsLibraryHydrationUtils';
+import { rcsVarRegex } from '../constants';
+
+const enableTraiDlt = () => {
+  window.capAuth = { accessibleFeatures: ['TRAI_DLT'] };
+};
+const disableTraiDlt = () => {
+  delete window.capAuth;
+};
+
+describe('rcsLibraryHydrationUtils', () => {
+  describe('mergeRcsSmsFallBackContentFromDetails', () => {
+    it('returns empty object for missing details', () => {
+      expect(mergeRcsSmsFallBackContentFromDetails(null)).toEqual({});
+      expect(mergeRcsSmsFallBackContentFromDetails(undefined)).toEqual({});
+    });
+
+    it('merges nested RCS smsFallBackContent with root mirror; nested wins on overlap', () => {
+      const details = {
+        versions: {
+          base: {
+            content: {
+              RCS: {
+                smsFallBackContent: {
+                  smsTemplateName: 'OldName',
+                  message: 'from nested',
+                  smsContent: 'nested body',
+                },
+              },
+            },
+          },
+        },
+        smsFallBackContent: {
+          message: 'from root',
+        },
+      };
+      const out = mergeRcsSmsFallBackContentFromDetails(details);
+      expect(out.message).toBe('from nested');
+      expect(out.smsContent).toBe('nested body');
+      expect(out.smsTemplateName).toBe('OldName');
+    });
+
+    it('uses root when nested path is absent', () => {
+      const details = {
+        smsFallBackContent: { message: 'only root' },
+      };
+      expect(mergeRcsSmsFallBackContentFromDetails(details)).toEqual({ message: 'only root' });
+    });
+  });
+
+  describe('mergeRcsSmsFallbackVarMapLayers', () => {
+    it('merges API map with local so empty local object does not wipe API slots', () => {
+      const api = { rcsSmsFallbackVarMapped: { '{#a#}_0': 'x' } };
+      const local = { rcsSmsFallbackVarMapped: {} };
+      expect(mergeRcsSmsFallbackVarMapLayers(api, local)).toEqual({ '{#a#}_0': 'x' });
+    });
+
+    it('local slot values win on same key', () => {
+      const api = { rcsSmsFallbackVarMapped: { '{#a#}_0': 'old' } };
+      const local = { rcsSmsFallbackVarMapped: { '{#a#}_0': 'new' } };
+      expect(mergeRcsSmsFallbackVarMapLayers(api, local)).toEqual({ '{#a#}_0': 'new' });
+    });
+
+    it('reads kebab-case var map from a layer when camel is absent', () => {
+      const api = { 'rcs-sms-fallback-var-mapped': { '{#b#}_1': 'y' } };
+      expect(mergeRcsSmsFallbackVarMapLayers(api, {})).toEqual({ '{#b#}_1': 'y' });
+    });
+
+    it('defaults both layers to {} when called without arguments', () => {
+      expect(mergeRcsSmsFallbackVarMapLayers()).toEqual({});
+    });
+
+    it('treats a null layer as empty rather than throwing', () => {
+      expect(mergeRcsSmsFallbackVarMapLayers(null, null)).toEqual({});
+    });
+  });
+
+  describe('hasMeaningfulSmsFallbackShape', () => {
+    it('is false for empty / missing', () => {
+      expect(hasMeaningfulSmsFallbackShape(null)).toBe(false);
+      expect(hasMeaningfulSmsFallbackShape({})).toBe(false);
+    });
+
+    it('is true when template body or name or var map exists', () => {
+      expect(hasMeaningfulSmsFallbackShape({ message: 'hi' })).toBe(true);
+      expect(hasMeaningfulSmsFallbackShape({ smsTemplateName: 'T' })).toBe(true);
+      expect(hasMeaningfulSmsFallbackShape({ rcsSmsFallbackVarMapped: { '{#a#}_0': 'x' } })).toBe(true);
+    });
+  });
+
+  describe('getLibrarySmsFallbackApiBaselineFromTemplateData', () => {
+    it('merges root and nested; nested wins on overlap', () => {
+      const templateData = {
+        smsFallBackContent: { message: 'root' },
+        versions: {
+          base: {
+            content: {
+              RCS: {
+                smsFallBackContent: { message: 'nested', smsTemplateName: 'N' },
+              },
+            },
+          },
+        },
+      };
+      const out = getLibrarySmsFallbackApiBaselineFromTemplateData(templateData);
+      expect(out.message).toBe('nested');
+      expect(out.smsTemplateName).toBe('N');
+    });
+  });
+
+  describe('extractRegisteredSenderIdsFromSmsFallbackRecord', () => {
+    it('returns null for missing / empty', () => {
+      expect(extractRegisteredSenderIdsFromSmsFallbackRecord(null)).toBe(null);
+      expect(extractRegisteredSenderIdsFromSmsFallbackRecord({})).toBe(null);
+      expect(
+        extractRegisteredSenderIdsFromSmsFallbackRecord({ registeredSenderIds: [] }),
+      ).toBe(null);
+    });
+
+    it('prefers top-level registeredSenderIds', () => {
+      expect(
+        extractRegisteredSenderIdsFromSmsFallbackRecord({
+          registeredSenderIds: ['A'],
+          templateConfigs: { registeredSenderIds: ['B'] },
+        }),
+      ).toEqual(['A']);
+    });
+
+    it('reads templateConfigs.registeredSenderIds when top-level absent', () => {
+      expect(
+        extractRegisteredSenderIdsFromSmsFallbackRecord({
+          templateConfigs: { registeredSenderIds: ['DLT1', 'DLT2'] },
+        }),
+      ).toEqual(['DLT1', 'DLT2']);
+    });
+
+    it('falls back to templateConfigs.header array', () => {
+      expect(
+        extractRegisteredSenderIdsFromSmsFallbackRecord({
+          templateConfigs: { header: ['H1'] },
+        }),
+      ).toEqual(['H1']);
+    });
+  });
+
+  describe('pickFirstSmsFallbackTemplateString', () => {
+    it('prefers smsTemplateContent over resolved message so DLT tokens stay in the string', () => {
+      const sms = {
+        message: 'Hello user',
+        smsTemplateContent: 'Hello {#name#}',
+      };
+      expect(pickFirstSmsFallbackTemplateString(sms)).toBe('Hello {#name#}');
+    });
+
+    it('skips whitespace-only templateContent and uses next field', () => {
+      expect(
+        pickFirstSmsFallbackTemplateString({
+          templateContent: '   ',
+          message: 'x',
+        }),
+      ).toBe('x');
+    });
+
+    it('defaults to {} and returns "" when called without arguments', () => {
+      expect(pickFirstSmsFallbackTemplateString()).toBe('');
+    });
+
+    it('returns "" for a non-object input', () => {
+      expect(pickFirstSmsFallbackTemplateString(null)).toBe('');
+      expect(pickFirstSmsFallbackTemplateString('not-an-object')).toBe('');
+    });
+  });
+
+  describe('getUnmappedDesc', () => {
+    it('returns empty string for falsy str', () => {
+      expect(getUnmappedDesc('', { a: '1' })).toBe('');
+      expect(getUnmappedDesc(null, { a: '1' })).toBe('');
+    });
+
+    it('returns str when mapping is empty or missing', () => {
+      expect(getUnmappedDesc('hello', null)).toBe('hello');
+      expect(getUnmappedDesc('hello', {})).toBe('hello');
+    });
+
+    it('replaces literal values with {{key}} placeholders', () => {
+      expect(getUnmappedDesc('Hi Alice', { user_name: 'Alice' })).toBe('Hi {{user_name}}');
+    });
+
+    it('skips mapping entries with empty or whitespace-only values', () => {
+      expect(getUnmappedDesc('x', { a: '', b: '   ' })).toBe('x');
+    });
+
+    it('treats already-braced raw values without duplicating braced needle', () => {
+      expect(getUnmappedDesc('v {{user_id}}', { user_id: '{{user_id}}' })).toContain('{{user_id}}');
+    });
+
+    it('adds braced needle when resolved value is not already in {{…}} form', () => {
+      const out = getUnmappedDesc('Hello Bob', { nick: 'Bob' });
+      expect(out).toBe('Hello {{nick}}');
+    });
+
+    it('ignores undefined mapping values', () => {
+      expect(getUnmappedDesc('x', { a: undefined })).toBe('x');
+    });
+
+    it('matches longer needles first to avoid partial replaces', () => {
+      const out = getUnmappedDesc('ab', { x: 'a', y: 'ab' });
+      expect(out).toBe('{{y}}');
+    });
+
+    it('escapes regex metacharacters in resolved values', () => {
+      expect(getUnmappedDesc('price 9.99', { p: '9.99' })).toBe('price {{p}}');
+    });
+  });
+
+  describe('hasRcsVarTokens', () => {
+    it('is false for empty or non-matching strings', () => {
+      expect(hasRcsVarTokens('', rcsVarRegex)).toBe(false);
+      expect(hasRcsVarTokens('plain', rcsVarRegex)).toBe(false);
+    });
+
+    it('is true when string contains {{word}} tokens', () => {
+      expect(hasRcsVarTokens('{{1}} hi', rcsVarRegex)).toBe(true);
+      expect(hasRcsVarTokens('{{user_id}}', rcsVarRegex)).toBe(true);
+      expect(hasRcsVarTokens('{{dynamic_expiry_date_after_3_days.FORMAT_1}}', rcsVarRegex)).toBe(true);
+    });
+  });
+
+  describe('normalizeLibraryLoadedTitleDesc', () => {
+    const cardVarMappedAfterHydration = { user_id: '123' };
+
+    it('returns originals in full mode', () => {
+      const out = normalizeLibraryLoadedTitleDesc({
+        loadedTitle: 'Hello 123',
+        loadedDesc: 'Desc',
+        isFullMode: true,
+        cardVarMappedAfterHydration,
+        rcsVarRegex,
+      });
+      expect(out).toEqual({ normalizedTitle: 'Hello 123', normalizedDesc: 'Desc' });
+    });
+
+    it('unmaps when library mode, map present, and no mustache tokens', () => {
+      const out = normalizeLibraryLoadedTitleDesc({
+        loadedTitle: 'Hello 123',
+        loadedDesc: 'World 123',
+        isFullMode: false,
+        cardVarMappedAfterHydration,
+        rcsVarRegex,
+      });
+      expect(out.normalizedTitle).toBe('Hello {{user_id}}');
+      expect(out.normalizedDesc).toBe('World {{user_id}}');
+    });
+
+    it('keeps {{numeric}} slots when tokens already exist', () => {
+      const out = normalizeLibraryLoadedTitleDesc({
+        loadedTitle: 'Hi {{1}}',
+        loadedDesc: 'Body 123',
+        isFullMode: false,
+        cardVarMappedAfterHydration,
+        rcsVarRegex,
+      });
+      expect(out.normalizedTitle).toBe('Hi {{1}}');
+      expect(out.normalizedDesc).toBe('Body {{user_id}}');
+    });
+
+    it('does not unmap when cardVarMappedAfterHydration is empty', () => {
+      const out = normalizeLibraryLoadedTitleDesc({
+        loadedTitle: 'Hello',
+        loadedDesc: 'D',
+        isFullMode: false,
+        cardVarMappedAfterHydration: {},
+        rcsVarRegex,
+      });
+      expect(out).toEqual({ normalizedTitle: 'Hello', normalizedDesc: 'D' });
+    });
+  });
+
+  describe('syncCardVarMappedSemanticsFromSlots', () => {
+    it('copies numeric slot values onto empty semantic keys (campaign round-trip)', () => {
+      const out = syncCardVarMappedSemanticsFromSlots(
+        { 1: '[FirstName]', user_name: '', 2: 'x', other: '' },
+        'Hi {{user_name}}',
+        'More {{other}}',
+        rcsVarRegex,
+      );
+      expect(out.user_name).toBe('[FirstName]');
+      expect(out.other).toBe('x');
+    });
+
+    it('does not overwrite non-empty semantic keys', () => {
+      const out = syncCardVarMappedSemanticsFromSlots(
+        { 1: 'from-slot', user_name: 'kept' },
+        'Hello {{user_name}}',
+        '',
+        rcsVarRegex,
+      );
+      expect(out.user_name).toBe('kept');
+    });
+
+    it('treats a non-object cardVarMappedInput as an empty starting map', () => {
+      const out = syncCardVarMappedSemanticsFromSlots(null, 'Hi {{a}}', '', rcsVarRegex);
+      expect(out).toEqual({});
+    });
+
+    it('falls back to an empty token list when the title has no matches', () => {
+      const out = syncCardVarMappedSemanticsFromSlots(
+        {},
+        'plain title with no tokens',
+        'More {{other}}',
+        rcsVarRegex,
+      );
+      expect(out.other).toBeUndefined();
+    });
+
+    it('skips a token whose semantic name is blank after trimming', () => {
+      const out = syncCardVarMappedSemanticsFromSlots({}, 'Hi {{ }}', '', rcsVarRegex);
+      expect(out).toEqual({});
+    });
+
+    it('treats missing semantic and numeric slot values as empty rather than throwing', () => {
+      const out = syncCardVarMappedSemanticsFromSlots({}, 'Hi {{user_name}}', '', rcsVarRegex);
+      expect(out.user_name).toBeUndefined();
+    });
+  });
+
+  describe('pickRcsCardVarMappedEntries', () => {
+    it('returns {} for null, undefined, and array inputs', () => {
+      expect(pickRcsCardVarMappedEntries(null)).toEqual({});
+      expect(pickRcsCardVarMappedEntries(undefined)).toEqual({});
+      expect(pickRcsCardVarMappedEntries(['{#v#}_0', 'x'])).toEqual({});
+    });
+
+    it('keeps numeric slot keys', () => {
+      expect(pickRcsCardVarMappedEntries({ 1: 'a', 2: 'b' })).toEqual({ 1: 'a', 2: 'b' });
+    });
+
+    it('keeps semantic word keys', () => {
+      expect(pickRcsCardVarMappedEntries({ user_name: 'Alice', gt: '{{tag}}' })).toEqual({
+        user_name: 'Alice',
+        gt: '{{tag}}',
+      });
+    });
+
+    it('strips SMS fallback slot keys like {#var#}_0', () => {
+      const input = { 1: 'x', user_name: 'y', '{#promo#}_0': 'z', '{{name}}_1': 'w' };
+      const out = pickRcsCardVarMappedEntries(input);
+      expect(out).toEqual({ 1: 'x', user_name: 'y' });
+    });
+
+    it('returns {} for an empty object', () => {
+      expect(pickRcsCardVarMappedEntries({})).toEqual({});
+    });
+  });
+
+  describe('mergeSmsFallbackForLibrary', () => {
+    afterEach(() => disableTraiDlt());
+
+    it('full mode returns smsFallbackData as-is', () => {
+      const smsFallbackData = { message: 'hi' };
+      expect(mergeSmsFallbackForLibrary({}, smsFallbackData, true)).toBe(smsFallbackData);
+    });
+
+    it('full mode returns {} when smsFallbackData is missing', () => {
+      expect(mergeSmsFallbackForLibrary({}, null, true)).toEqual({});
+      expect(mergeSmsFallbackForLibrary({}, undefined, true)).toEqual({});
+    });
+
+    it('non-full mode: local wins over API baseline except var map merges', () => {
+      const templateData = {
+        smsFallBackContent: { message: 'api', rcsSmsFallbackVarMapped: { '{#a#}_0': 'x' } },
+      };
+      const local = { message: 'local', rcsSmsFallbackVarMapped: {} };
+      const out = mergeSmsFallbackForLibrary(templateData, local, false);
+      expect(out.message).toBe('local');
+      expect(out.rcsSmsFallbackVarMapped).toEqual({ '{#a#}_0': 'x' });
+    });
+
+    it('non-full mode: treats a non-object smsFallbackData as empty local layer', () => {
+      const templateData = { smsFallBackContent: { message: 'api-only' } };
+      const out = mergeSmsFallbackForLibrary(templateData, undefined, false);
+      expect(out.message).toBe('api-only');
+      expect(out.rcsSmsFallbackVarMapped).toEqual({});
+    });
+  });
+
+  describe('buildSmsFallBackContentForPayload', () => {
+    afterEach(() => disableTraiDlt());
+
+    it('full mode: returns undefined when smsFallbackData has no meaningful shape', () => {
+      const out = buildSmsFallBackContentForPayload({
+        smsFallbackData: {},
+        templateData: {},
+        isFullMode: true,
+        smsRegister: undefined,
+      });
+      expect(out).toBeUndefined();
+    });
+
+    it('full mode: builds full shape with unicodeValidity, var map, and templateConfigs from top-level fields', () => {
+      const out = buildSmsFallBackContentForPayload({
+        smsFallbackData: {
+          message: 'Hello',
+          templateName: 'T1',
+          unicodeValidity: true,
+          rcsSmsFallbackVarMapped: { '{#a#}_0': 'x' },
+          smsTemplateId: '111',
+          registeredSenderIds: ['S1'],
+        },
+        templateData: {},
+        isFullMode: true,
+        smsRegister: undefined,
+      });
+      expect(out).toEqual({
+        smsFallBackContent: {
+          smsTemplateName: 'T1',
+          smsContent: 'Hello',
+          message: 'Hello',
+          unicodeValidity: true,
+          rcsSmsFallbackVarMapped: { '{#a#}_0': 'x' },
+          templateConfigs: {
+            templateId: '111',
+            template: 'Hello',
+            templateName: 'T1',
+            registeredSenderIds: ['S1'],
+          },
+        },
+      });
+    });
+
+    it('full mode: omits unicodeValidity / var map / templateConfigs when absent', () => {
+      const out = buildSmsFallBackContentForPayload({
+        smsFallbackData: { message: 'Body' },
+        templateData: {},
+        isFullMode: true,
+        smsRegister: undefined,
+      });
+      expect(out).toEqual({
+        smsFallBackContent: {
+          smsTemplateName: '',
+          smsContent: 'Body',
+          message: 'Body',
+        },
+      });
+    });
+
+    it('full mode: templateConfigs.templateId / .template fall back when smsTemplateId absent', () => {
+      const out = buildSmsFallBackContentForPayload({
+        smsFallbackData: {
+          templateName: 'TN',
+          templateConfigs: {
+            templateId: 'TC2',
+            template: 'fallback template str',
+            registeredSenderIds: ['R2'],
+          },
+        },
+        templateData: {},
+        isFullMode: true,
+        smsRegister: undefined,
+      });
+      expect(out.smsFallBackContent.templateConfigs).toEqual({
+        templateId: 'TC2',
+        template: 'fallback template str',
+        templateName: 'TN',
+        registeredSenderIds: ['R2'],
+      });
+    });
+
+    it('full mode: templateConfigs.name / .header are used when nothing else is present', () => {
+      const out = buildSmsFallBackContentForPayload({
+        smsFallbackData: {
+          smsTemplateName: '',
+          message: '',
+          rcsSmsFallbackVarMapped: { a: '1' },
+          templateConfigs: { header: ['H1'], name: 'ConfigName' },
+        },
+        templateData: {},
+        isFullMode: true,
+        smsRegister: undefined,
+      });
+      expect(out.smsFallBackContent.templateConfigs).toEqual({
+        templateName: 'ConfigName',
+        registeredSenderIds: ['H1'],
+      });
+      expect(out.smsFallBackContent.rcsSmsFallbackVarMapped).toEqual({ a: '1' });
+    });
+
+    it('non-full mode: returns undefined when merged shape has no message/name/var map', () => {
+      const out = buildSmsFallBackContentForPayload({
+        smsFallbackData: {},
+        templateData: {},
+        isFullMode: false,
+        smsRegister: undefined,
+      });
+      expect(out).toBeUndefined();
+    });
+
+    it('non-full mode: DLT campaign with templateConfigs derived includes templateConfigs', () => {
+      enableTraiDlt();
+      const out = buildSmsFallBackContentForPayload({
+        smsFallbackData: {
+          message: 'Body2',
+          smsTemplateId: 'ID9',
+          registeredSenderIds: ['S9'],
+        },
+        templateData: {},
+        isFullMode: false,
+        smsRegister: 'DLT',
+      });
+      expect(out).toEqual({
+        smsFallBackContent: {
+          message: 'Body2',
+          templateContent: 'Body2',
+          registeredSenderIds: ['S9'],
+          templateConfigs: {
+            templateId: 'ID9',
+            template: 'Body2',
+            registeredSenderIds: ['S9'],
+          },
+        },
+      });
+    });
+
+    it('non-full mode: DLT campaign but no derivable templateConfigs omits templateConfigs', () => {
+      enableTraiDlt();
+      const out = buildSmsFallBackContentForPayload({
+        smsFallbackData: {
+          message: 'Hi',
+          unicodeValidity: false,
+          rcsSmsFallbackVarMapped: { '{#a#}_0': 'v' },
+        },
+        templateData: {},
+        isFullMode: false,
+        smsRegister: 'DLT',
+      });
+      expect(out).toEqual({
+        smsFallBackContent: {
+          message: 'Hi',
+          templateContent: 'Hi',
+          unicodeValidity: false,
+          rcsSmsFallbackVarMapped: { '{#a#}_0': 'v' },
+        },
+      });
+    });
+
+    it('non-full mode: non-DLT campaign omits templateConfigs even when derivable, but includes smsTemplateName', () => {
+      const out = buildSmsFallBackContentForPayload({
+        smsFallbackData: {
+          message: 'Body3',
+          templateName: 'TN3',
+          smsTemplateId: 'ID3',
+        },
+        templateData: {},
+        isFullMode: false,
+        smsRegister: 'NON_DLT',
+      });
+      expect(out).toEqual({
+        smsFallBackContent: {
+          message: 'Body3',
+          smsTemplateName: 'TN3',
+          templateContent: 'Body3',
+        },
+      });
+    });
+
+    it('non-full mode: omits templateContent when it resolves empty', () => {
+      const out = buildSmsFallBackContentForPayload({
+        smsFallbackData: { templateName: 'OnlyName' },
+        templateData: {},
+        isFullMode: false,
+        smsRegister: undefined,
+      });
+      expect(out).toEqual({
+        smsFallBackContent: {
+          message: '',
+          smsTemplateName: 'OnlyName',
+        },
+      });
+    });
+
+    it('non-full mode: falls back to a raw whitespace-only templateContent string over templateConfigs.template', () => {
+      enableTraiDlt();
+      const out = buildSmsFallBackContentForPayload({
+        smsFallbackData: {
+          templateName: 'HasName',
+          templateContent: '   ',
+          smsTemplateId: 'IDX',
+          templateConfigs: { template: 'should not be used' },
+        },
+        templateData: {},
+        isFullMode: false,
+        smsRegister: 'DLT',
+      });
+      expect(out.smsFallBackContent.message).toBe('');
+      expect(out.smsFallBackContent.templateConfigs.template).toBe('   ');
+    });
+
+    it('non-full mode: merges API baseline templateData with local editor state', () => {
+      const templateData = {
+        smsFallBackContent: { message: 'from-api', smsTemplateName: 'ApiName' },
+      };
+      const out = buildSmsFallBackContentForPayload({
+        smsFallbackData: { message: 'from-local' },
+        templateData,
+        isFullMode: false,
+        smsRegister: undefined,
+      });
+      expect(out.smsFallBackContent.message).toBe('from-local');
+      expect(out.smsFallBackContent.smsTemplateName).toBe('ApiName');
+    });
+  });
+
+  describe('resolveSmsFallbackHydrationFromDetails', () => {
+    let warnSpy;
+
+    beforeEach(() => {
+      warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+      warnSpy.mockRestore();
+    });
+
+    it('returns hasFallbackPayload false with __EMPTY__ key when there is no fallback content', () => {
+      expect(resolveSmsFallbackHydrationFromDetails({})).toEqual({
+        hasFallbackPayload: false,
+        nextSmsState: null,
+        hydrationKey: '__EMPTY__',
+      });
+    });
+
+    it('is meaningful from smsTemplateName alone and warns when no message/var map found', () => {
+      const out = resolveSmsFallbackHydrationFromDetails({
+        _id: 'c1',
+        smsFallBackContent: { smsTemplateName: 'T1' },
+      });
+      expect(out.hasFallbackPayload).toBe(true);
+      expect(out.nextSmsState.templateName).toBe('T1');
+      expect(out.nextSmsState.content).toBe('');
+      expect(warnSpy).toHaveBeenCalled();
+    });
+
+    it('falls back to templateConfigs.templateName when root-level name fields are absent', () => {
+      const out = resolveSmsFallbackHydrationFromDetails({
+        smsFallBackContent: {
+          templateConfigs: { templateName: 'ConfigTemplateName' },
+        },
+      });
+      expect(out.nextSmsState.templateName).toBe('ConfigTemplateName');
+    });
+
+    it('falls back to templateConfigs.name when no other name field is present anywhere', () => {
+      const out = resolveSmsFallbackHydrationFromDetails({
+        smsFallBackContent: {
+          templateConfigs: { name: 'ConfigName' },
+        },
+      });
+      expect(out.nextSmsState.templateName).toBe('ConfigName');
+    });
+
+    it('falls back to the root-level templateName when templateConfigs has no name field', () => {
+      const out = resolveSmsFallbackHydrationFromDetails({
+        smsFallBackContent: {
+          templateName: 'RootName',
+          templateConfigs: { registeredSenderIds: ['123'] },
+        },
+      });
+      expect(out.nextSmsState.templateName).toBe('RootName');
+    });
+
+    it('prefers the root templateName over a conflicting nested templateConfigs.name', () => {
+      const out = resolveSmsFallbackHydrationFromDetails({
+        smsFallBackContent: {
+          templateName: 'RootName',
+          smsTemplateName: '',
+          templateConfigs: { name: 'NestedName', header: ['H1'] },
+        },
+      });
+      expect(out.nextSmsState.templateName).toBe('RootName');
+    });
+
+    it('is meaningful from var map alone, with no template name or message text', () => {
+      const out = resolveSmsFallbackHydrationFromDetails({
+        smsFallBackContent: { rcsSmsFallbackVarMapped: { '{#a#}_0': 'v' } },
+      });
+      expect(out.hasFallbackPayload).toBe(true);
+      expect(out.nextSmsState.templateName).toBe('');
+      expect(out.nextSmsState.content).toBe('');
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it('does not warn when a var map is present even without message text', () => {
+      const out = resolveSmsFallbackHydrationFromDetails({
+        smsFallBackContent: {
+          smsTemplateName: 'T2',
+          rcsSmsFallbackVarMapped: { '{#a#}_0': 'x' },
+        },
+      });
+      expect(out.hasFallbackPayload).toBe(true);
+      expect(out.nextSmsState.rcsSmsFallbackVarMapped).toEqual({ '{#a#}_0': 'x' });
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it('does not warn in production even without message text or var map', () => {
+      const prevEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'production';
+      try {
+        const out = resolveSmsFallbackHydrationFromDetails({
+          smsFallBackContent: { smsTemplateName: 'T3' },
+        });
+        expect(out.hasFallbackPayload).toBe(true);
+        expect(warnSpy).not.toHaveBeenCalled();
+      } finally {
+        process.env.NODE_ENV = prevEnv;
+      }
+    });
+
+    it('prefers smsContent, then smsTemplateContent, then message, over nested editor text', () => {
+      expect(
+        resolveSmsFallbackHydrationFromDetails({
+          smsFallBackContent: { smsTemplateName: 'X', smsContent: 'Direct SMS' },
+        }).nextSmsState.content,
+      ).toBe('Direct SMS');
+      expect(
+        resolveSmsFallbackHydrationFromDetails({
+          smsFallBackContent: { smsTemplateName: 'X', smsTemplateContent: 'Direct Template' },
+        }).nextSmsState.content,
+      ).toBe('Direct Template');
+    });
+
+    it('joins an updated-sms-editor array into the fallback message', () => {
+      const out = resolveSmsFallbackHydrationFromDetails({
+        smsFallBackContent: {
+          smsTemplateName: 'X',
+          versions: { base: { 'updated-sms-editor': ['a', 'b', 'c'] } },
+        },
+      });
+      expect(out.nextSmsState.content).toBe('abc');
+    });
+
+    it('uses updated-sms-editor string directly when present', () => {
+      const out = resolveSmsFallbackHydrationFromDetails({
+        smsFallBackContent: {
+          smsTemplateName: 'X',
+          versions: { base: { 'updated-sms-editor': 'strval' } },
+        },
+      });
+      expect(out.nextSmsState.content).toBe('strval');
+    });
+
+    it('falls back to sms-editor when updated-sms-editor is neither an array nor a string', () => {
+      const out = resolveSmsFallbackHydrationFromDetails({
+        smsFallBackContent: {
+          smsTemplateName: 'X',
+          versions: { base: { 'updated-sms-editor': 5, 'sms-editor': 'final' } },
+        },
+      });
+      expect(out.nextSmsState.content).toBe('final');
+    });
+
+    it('resolves unicodeValidity from the fallback record boolean first', () => {
+      const out = resolveSmsFallbackHydrationFromDetails({
+        smsFallBackContent: {
+          smsContent: 'x',
+          unicodeValidity: false,
+          versions: { base: { 'unicode-validity': true } },
+        },
+      });
+      expect(out.nextSmsState.unicodeValidity).toBe(false);
+    });
+
+    it('falls back to nested unicode-validity boolean when top-level is not boolean', () => {
+      const out = resolveSmsFallbackHydrationFromDetails({
+        smsFallBackContent: {
+          smsContent: 'x',
+          versions: { base: { 'unicode-validity': false } },
+        },
+      });
+      expect(out.nextSmsState.unicodeValidity).toBe(false);
+    });
+
+    it('defaults unicodeValidity to true when neither source is a boolean', () => {
+      const out = resolveSmsFallbackHydrationFromDetails({
+        smsFallBackContent: { smsContent: 'x' },
+      });
+      expect(out.nextSmsState.unicodeValidity).toBe(true);
+    });
+
+    it('includes registeredSenderIds only when a non-empty array is extracted', () => {
+      const withIds = resolveSmsFallbackHydrationFromDetails({
+        smsFallBackContent: { smsContent: 'x', registeredSenderIds: ['S1'] },
+      });
+      expect(withIds.nextSmsState.registeredSenderIds).toEqual(['S1']);
+
+      const withoutIds = resolveSmsFallbackHydrationFromDetails({
+        smsFallBackContent: { smsContent: 'x' },
+      });
+      expect(withoutIds.nextSmsState.registeredSenderIds).toBeUndefined();
+    });
+
+    it('builds hydrationKey using _id, then name, then creativeName as the creative fingerprint', () => {
+      const base = { smsFallBackContent: { smsContent: 'x' } };
+      const byId = resolveSmsFallbackHydrationFromDetails({ ...base, _id: 'id1', name: 'n1', creativeName: 'cn1' });
+      const byName = resolveSmsFallbackHydrationFromDetails({ ...base, name: 'n1', creativeName: 'cn1' });
+      const byCreativeName = resolveSmsFallbackHydrationFromDetails({ ...base, creativeName: 'cn1' });
+      expect(byId.hydrationKey).toContain('id1');
+      expect(byName.hydrationKey).toContain('n1');
+      expect(byCreativeName.hydrationKey).toContain('cn1');
+    });
+  });
+
+  describe('applySmsFallbackHydration', () => {
+    it('full mode always calls setSmsFallbackData when a fallback payload exists, even if key is unchanged', () => {
+      const details = { smsFallBackContent: { smsContent: 'hi' } };
+      const { hydrationKey } = resolveSmsFallbackHydrationFromDetails(details);
+      const ref = { current: hydrationKey };
+      const setSmsFallbackData = jest.fn();
+      applySmsFallbackHydration({
+        details,
+        isFullMode: true,
+        lastSmsFallbackHydrationKeyRef: ref,
+        setSmsFallbackData,
+      });
+      expect(setSmsFallbackData).toHaveBeenCalledTimes(1);
+      expect(setSmsFallbackData).toHaveBeenCalledWith(expect.objectContaining({ content: 'hi' }));
+    });
+
+    it('non-full mode calls setSmsFallbackData when the hydration key changed', () => {
+      const details = { smsFallBackContent: { smsContent: 'hi' } };
+      const ref = { current: 'some-other-key' };
+      const setSmsFallbackData = jest.fn();
+      applySmsFallbackHydration({
+        details,
+        isFullMode: false,
+        lastSmsFallbackHydrationKeyRef: ref,
+        setSmsFallbackData,
+      });
+      expect(setSmsFallbackData).toHaveBeenCalledTimes(1);
+      expect(ref.current).not.toBe('some-other-key');
+    });
+
+    it('non-full mode skips setSmsFallbackData when the hydration key is unchanged (dedup)', () => {
+      const details = { smsFallBackContent: { smsContent: 'hi' } };
+      const { hydrationKey } = resolveSmsFallbackHydrationFromDetails(details);
+      const ref = { current: hydrationKey };
+      const setSmsFallbackData = jest.fn();
+      applySmsFallbackHydration({
+        details,
+        isFullMode: false,
+        lastSmsFallbackHydrationKeyRef: ref,
+        setSmsFallbackData,
+      });
+      expect(setSmsFallbackData).not.toHaveBeenCalled();
+      expect(ref.current).toBe(hydrationKey);
+    });
+
+    it('full mode always calls setSmsFallbackData(null) when there is no fallback payload', () => {
+      const ref = { current: '__EMPTY__' };
+      const setSmsFallbackData = jest.fn();
+      applySmsFallbackHydration({
+        details: {},
+        isFullMode: true,
+        lastSmsFallbackHydrationKeyRef: ref,
+        setSmsFallbackData,
+      });
+      expect(setSmsFallbackData).toHaveBeenCalledTimes(1);
+      expect(setSmsFallbackData).toHaveBeenCalledWith(null);
+    });
+
+    it('non-full mode skips setSmsFallbackData(null) when ref is already __EMPTY__', () => {
+      const ref = { current: '__EMPTY__' };
+      const setSmsFallbackData = jest.fn();
+      applySmsFallbackHydration({
+        details: {},
+        isFullMode: false,
+        lastSmsFallbackHydrationKeyRef: ref,
+        setSmsFallbackData,
+      });
+      expect(setSmsFallbackData).not.toHaveBeenCalled();
+    });
+
+    it('non-full mode calls setSmsFallbackData(null) once and marks ref __EMPTY__ when not yet deduped', () => {
+      const ref = { current: 'some-previous-key' };
+      const setSmsFallbackData = jest.fn();
+      applySmsFallbackHydration({
+        details: {},
+        isFullMode: false,
+        lastSmsFallbackHydrationKeyRef: ref,
+        setSmsFallbackData,
+      });
+      expect(setSmsFallbackData).toHaveBeenCalledTimes(1);
+      expect(setSmsFallbackData).toHaveBeenCalledWith(null);
+      expect(ref.current).toBe('__EMPTY__');
+    });
+  });
+});