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

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

@@ -1,309 +0,0 @@
-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([]);
-    });
-  });
-});