@capillarytech/creatives-library 8.0.353-alpha.5 → 8.0.353-alpha.6

package/v2Components/SmsFallback/tests/smsFallbackUtils.test.js

@@ -0,0 +1,309 @@
+import {
+  buildFallbackDataFromTemplate,
+  mapFallbackValueToEditTemplateData,
+  getBaseFromSmsTraiFormData,
+  getSmsFallbackCardDisplayContent,
+  resolveContentFromTraiBase,
+  filterSmsTemplatesByCategory,
+  buildFallbackDataFromCreativesPayload,
+} from '../smsFallbackUtils';
+import { SMS_CATEGORY_FILTERS } from '../constants';
+
+describe('smsFallbackUtils', () => {
+  describe('buildFallbackDataFromTemplate', () => {
+    it('returns safe defaults when template is nullish', () => {
+      expect(buildFallbackDataFromTemplate(null)).toEqual({
+        smsTemplateId: '',
+        templateName: '',
+        content: '',
+        templateContent: '',
+        senderId: '',
+        registeredSenderIds: [],
+        unicodeValidity: true,
+      });
+    });
+
+    it('maps template versions.base and header sender list', () => {
+      const template = {
+        name: 'My SMS',
+        versions: {
+          base: {
+            'sms-editor': 'Hello {{1}}',
+            header: ['S1', 'S2'],
+            'unicode-validity': false,
+            template_id: 'tid',
+          },
+        },
+      };
+      expect(buildFallbackDataFromTemplate(template)).toEqual({
+        smsTemplateId: 'tid',
+        templateName: 'My SMS',
+        content: 'Hello {{1}}',
+        templateContent: 'Hello {{1}}',
+        senderId: 'S1',
+        registeredSenderIds: ['S1', 'S2'],
+        unicodeValidity: false,
+      });
+    });
+
+    it('falls back to senderId when header is missing', () => {
+      const template = {
+        _id: '',
+        name: '',
+        versions: { base: { 'sms-editor': 'x', senderId: 'SID' } },
+      };
+      expect(buildFallbackDataFromTemplate(template).senderId).toBe('SID');
+      expect(buildFallbackDataFromTemplate(template).registeredSenderIds).toEqual([]);
+    });
+
+    it('defaults unicodeValidity to true when not a boolean', () => {
+      const template = {
+        versions: { base: { 'sms-editor': '' } },
+      };
+      expect(buildFallbackDataFromTemplate(template).unicodeValidity).toBe(true);
+    });
+
+    it('uses versions.base.template_name when root name is empty (DLT detail shape)', () => {
+      const template = {
+        _id: 'dlt1',
+        name: '',
+        versions: {
+          base: {
+            template_name: 'DLT Registered Name',
+            'sms-editor': 'Hi',
+            header: ['H1'],
+          },
+        },
+      };
+      expect(buildFallbackDataFromTemplate(template).templateName).toBe('DLT Registered Name');
+    });
+  });
+
+  describe('getSmsFallbackCardDisplayContent', () => {
+    it('returns raw template when rcsSmsFallbackVarMapped is empty', () => {
+      expect(
+        getSmsFallbackCardDisplayContent({
+          templateContent: 'A {#var#} B',
+          rcsSmsFallbackVarMapped: {},
+        }),
+      ).toBe('A {#var#} B');
+    });
+
+    it('substitutes slot values like preview when var map is set', () => {
+      expect(
+        getSmsFallbackCardDisplayContent({
+          templateContent: 'Hi {{name}}',
+          rcsSmsFallbackVarMapped: { '{{name}}_1': 'Pat' },
+        }),
+      ).toBe('Hi Pat');
+    });
+
+    it('shows raw {#var#} in card when slots saved empty (DLT, no labels)', () => {
+      expect(
+        getSmsFallbackCardDisplayContent({
+          templateContent: 'Balance {#var#}',
+          rcsSmsFallbackVarMapped: { '{#var#}_1': '' },
+        }),
+      ).toBe('Balance {#var#}');
+    });
+  });
+
+  describe('mapFallbackValueToEditTemplateData', () => {
+    it('returns null when source is missing', () => {
+      expect(mapFallbackValueToEditTemplateData(null)).toBeNull();
+      expect(mapFallbackValueToEditTemplateData(undefined)).toBeNull();
+    });
+
+    it('maps content, optional header and unicode flag', () => {
+      const source = {
+        smsTemplateId: 'id1',
+        templateName: 'N',
+        templateContent: 'body',
+        registeredSenderIds: ['h1'],
+        unicodeValidity: false,
+      };
+      expect(mapFallbackValueToEditTemplateData(source)).toEqual({
+        _id: 'id1',
+        name: 'N',
+        versions: {
+          base: {
+            'sms-editor': 'body',
+            template_name: 'N',
+            header: ['h1'],
+            'unicode-validity': false,
+          },
+        },
+      });
+    });
+
+    it('uses content when templateContent is empty', () => {
+      const source = {
+        smsTemplateId: 'x',
+        templateName: 'y',
+        content: 'from-content',
+      };
+      expect(mapFallbackValueToEditTemplateData(source).versions.base['sms-editor']).toBe('from-content');
+    });
+
+    it('omits header when registeredSenderIds is empty', () => {
+      const source = {
+        smsTemplateId: 'x',
+        templateName: 'y',
+        templateContent: 't',
+        registeredSenderIds: [],
+      };
+      expect(mapFallbackValueToEditTemplateData(source).versions.base.header).toBeUndefined();
+    });
+
+    it('omits unicode-validity when value is not a boolean', () => {
+      const source = {
+        smsTemplateId: 'x',
+        templateName: 'y',
+        templateContent: 't',
+        unicodeValidity: 'yes',
+      };
+      expect(mapFallbackValueToEditTemplateData(source).versions.base['unicode-validity']).toBeUndefined();
+    });
+  });
+
+  describe('getBaseFromSmsTraiFormData', () => {
+    it('reads versions.base', () => {
+      const fd = { versions: { base: { 'sms-editor': 'a' } } };
+      expect(getBaseFromSmsTraiFormData(fd)).toEqual({ base: { 'sms-editor': 'a' } });
+    });
+
+    it('falls back to value.base', () => {
+      const fd = { value: { base: { 'sms-editor': 'b' } } };
+      expect(getBaseFromSmsTraiFormData(fd)).toEqual({ base: { 'sms-editor': 'b' } });
+    });
+
+    it('uses empty base when neither path exists', () => {
+      expect(getBaseFromSmsTraiFormData({})).toEqual({ base: {} });
+    });
+
+    it('normalizes null versions.base to empty object', () => {
+      expect(getBaseFromSmsTraiFormData({ versions: { base: null } })).toEqual({ base: {} });
+    });
+  });
+
+  describe('resolveContentFromTraiBase', () => {
+    it('returns sms-editor string', () => {
+      expect(resolveContentFromTraiBase({ 'sms-editor': 'z' })).toBe('z');
+    });
+
+    it('returns empty string when missing', () => {
+      expect(resolveContentFromTraiBase({})).toBe('');
+    });
+
+    it('returns empty string for nullish base', () => {
+      expect(resolveContentFromTraiBase(null)).toBe('');
+      expect(resolveContentFromTraiBase(undefined)).toBe('');
+    });
+  });
+
+  describe('filterSmsTemplatesByCategory', () => {
+    const templates = [
+      { versions: { base: { type: 'Promo' } } },
+      { versions: { base: { type: 'Explicit' } } },
+    ];
+
+    it('returns empty array for non-array input', () => {
+      expect(filterSmsTemplatesByCategory(null, SMS_CATEGORY_FILTERS.PROMOTIONAL)).toEqual([]);
+    });
+
+    it('returns all templates for ALL or missing filter', () => {
+      expect(filterSmsTemplatesByCategory(templates, SMS_CATEGORY_FILTERS.ALL)).toEqual(templates);
+      expect(filterSmsTemplatesByCategory(templates, null)).toEqual(templates);
+    });
+
+    it('filters by lowercase type substring', () => {
+      const filtered = filterSmsTemplatesByCategory(templates, SMS_CATEGORY_FILTERS.PROMOTIONAL);
+      expect(filtered).toHaveLength(1);
+      expect(filtered[0].versions.base.type).toBe('Promo');
+    });
+
+    it('treats missing type as empty string for filtering', () => {
+      const mixed = [{}, { versions: { base: {} } }];
+      expect(filterSmsTemplatesByCategory(mixed, SMS_CATEGORY_FILTERS.PROMOTIONAL)).toEqual([]);
+    });
+  });
+
+  describe('buildFallbackDataFromCreativesPayload', () => {
+    it('returns null for missing or non-SMS channel', () => {
+      expect(buildFallbackDataFromCreativesPayload(null)).toBeNull();
+      expect(buildFallbackDataFromCreativesPayload({ channel: 'RCS' })).toBeNull();
+    });
+
+    it('maps SMS payload with messageBody and templateConfigs', () => {
+      const creativesData = {
+        channel: 'SMS',
+        messageBody: 'Hello',
+        templateConfigs: {
+          templateId: 99,
+          templateName: 'T',
+          template: 'Template str',
+          registeredSenderIds: ['R1'],
+        },
+      };
+      expect(buildFallbackDataFromCreativesPayload(creativesData)).toEqual({
+        smsTemplateId: '99',
+        templateName: 'T',
+        content: 'Hello',
+        templateContent: 'Template str',
+        senderId: 'R1',
+        registeredSenderIds: ['R1'],
+        unicodeValidity: true,
+      });
+    });
+
+    it('uses template string as body when messageBody is not a string', () => {
+      const creativesData = {
+        channel: 'SMS',
+        messageBody: null,
+        templateConfigs: {
+          template: 'only-template',
+        },
+      };
+      const out = buildFallbackDataFromCreativesPayload(creativesData);
+      expect(out.content).toBe('only-template');
+      expect(out.templateContent).toBe('only-template');
+    });
+
+    it('stringifies templateId and templateName when present', () => {
+      const creativesData = {
+        channel: 'SMS',
+        messageBody: 'm',
+        templateConfigs: { templateId: 0, templateName: null },
+      };
+      const out = buildFallbackDataFromCreativesPayload(creativesData);
+      expect(out.smsTemplateId).toBe('0');
+      expect(out.templateName).toBe('');
+    });
+
+    it('uses empty templateConfigs when null', () => {
+      const creativesData = {
+        channel: 'SMS',
+        messageBody: 'only-body',
+        templateConfigs: null,
+      };
+      const out = buildFallbackDataFromCreativesPayload(creativesData);
+      expect(out.templateContent).toBe('only-body');
+      expect(out.content).toBe('only-body');
+    });
+
+    it('falls back to templateConfigs.senderId when registeredSenderIds is empty', () => {
+      const creativesData = {
+        channel: 'SMS',
+        messageBody: 'hello',
+        templateConfigs: {
+          template: 'hello',
+          senderId: 'SID_123',
+          registeredSenderIds: [],
+        },
+      };
+      const out = buildFallbackDataFromCreativesPayload(creativesData);
+      expect(out.senderId).toBe('SID_123');
+      expect(out.registeredSenderIds).toEqual([]);
+    });
+  });
+});