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

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

@@ -0,0 +1,318 @@
+import {
+  getUnmappedDesc,
+  hasRcsVarTokens,
+  normalizeLibraryLoadedTitleDesc,
+  mergeRcsSmsFallBackContentFromDetails,
+  mergeRcsSmsFallbackVarMapLayers,
+  pickFirstSmsFallbackTemplateString,
+  syncCardVarMappedSemanticsFromSlots,
+  hasMeaningfulSmsFallbackShape,
+  getLibrarySmsFallbackApiBaselineFromTemplateData,
+  extractRegisteredSenderIdsFromSmsFallbackRecord,
+  pickRcsCardVarMappedEntries,
+} from '../rcsLibraryHydrationUtils';
+import { rcsVarRegex } from '../constants';
+
+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' });
+    });
+  });
+
+  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');
+    });
+  });
+
+  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');
+    });
+  });
+
+  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({});
+    });
+  });
+});