@capillarytech/creatives-library 8.0.316 → 8.0.317-alpha.0

package/v2Components/CommonTestAndPreview/tests/DeliverySettings/utils/parseSenderDetailsResponse.test.js

@@ -55,6 +55,33 @@ describe('parseSenderDetailsResponse', () => {
       expect(result.domains[0].cdmaSenders[0].value).toBe('CDMA1');
     });
 
+    it('should populate SMS senders when channel argument is lowercase (normalized for branches)', () => {
+      const response = {
+        entity: {
+          SMS: [
+            {
+              id: 10,
+              priority: 1,
+              domainProperties: {
+                domainName: 'SMS Domain 1',
+                id: 100,
+                contactInfo: [
+                  { type: 'gsm_sender_id', valid: true, value: 'GSM1', default: true },
+                  { type: 'cdma_sender_id', valid: true, value: 'CDMA1' },
+                ],
+                connectionProperties: {},
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('sms', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0].gsmSenders).toHaveLength(1);
+      expect(result.domains[0].gsmSenders[0].value).toBe('GSM1');
+      expect(result.domains[0].cdmaSenders).toHaveLength(1);
+    });
+
     it('should parse EMAIL channel entity array', () => {
       const response = {
         entity: {
@@ -231,5 +258,319 @@ describe('parseSenderDetailsResponse', () => {
       const result = parseSenderDetailsResponse('WHATSAPP', response);
       expect(result.domains[0].sourceAccountIdentifier).toBe('waba-456');
     });
+
+    it('should map hostName to domainName when domainName missing (RCS)', () => {
+      const response = {
+        entity: {
+          RCS: [
+            {
+              id: 1,
+              priority: 0,
+              domainProperties: {
+                hostName: 'rcs-host',
+                id: 42,
+                contactInfo: [
+                  { type: 'gsm_sender_id', valid: true, value: 'S1', default: true },
+                ],
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('RCS', response);
+      expect(result.domains[0].domainName).toBe('rcs-host');
+      expect(result.domains[0].domainId).toBe(42);
+      expect(result.domains[0].gsmSenders[0].value).toBe('S1');
+    });
+
+    it('should unwrap result.entity when top-level entity is absent', () => {
+      const response = {
+        result: {
+          entity: {
+            SMS: [
+              {
+                id: 1,
+                priority: 0,
+                domainProperties: {
+                  domainName: 'ViaResult',
+                  id: 9,
+                  contactInfo: [{ type: 'gsm_sender_id', valid: true, value: 'G' }],
+                },
+              },
+            ],
+          },
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains[0].domainName).toBe('ViaResult');
+    });
+
+    it('should merge rcs_sender_id into gsmSenders for RCS', () => {
+      const response = {
+        entity: {
+          RCS: [
+            {
+              id: 1,
+              priority: 0,
+              domainProperties: {
+                domainName: 'RCS Domain',
+                id: 1,
+                contactInfo: [
+                  { type: 'rcs_sender_id', valid: true, value: 'RCS123', default: true },
+                ],
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('RCS', response);
+      expect(result.domains[0].gsmSenders).toHaveLength(1);
+      expect(result.domains[0].gsmSenders[0].value).toBe('RCS123');
+    });
+
+    it('should unwrap data.entity when top-level entity is absent', () => {
+      const response = {
+        data: {
+          entity: {
+            SMS: [
+              {
+                id: 1,
+                priority: 0,
+                domainProperties: {
+                  domainName: 'ViaData',
+                  id: 9,
+                  contactInfo: [{ type: 'gsm_sender_id', valid: true, value: 'G' }],
+                },
+              },
+            ],
+          },
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains[0].domainName).toBe('ViaData');
+    });
+
+    it('should return empty domains when entity is explicitly null', () => {
+      expect(parseSenderDetailsResponse('SMS', { entity: null })).toEqual({ domains: [] });
+    });
+
+    it('should return empty when channel data is a non-domain object', () => {
+      expect(parseSenderDetailsResponse('SMS', { entity: { notAnArray: true } })).toEqual({ domains: [] });
+    });
+
+    it('should use userid when sourceAccountIdentifier and wabaId are missing (WHATSAPP)', () => {
+      const response = {
+        entity: {
+          WHATSAPP: [
+            {
+              id: 1,
+              priority: 0,
+              domainProperties: {
+                domainName: 'W',
+                id: 1,
+                connectionProperties: { userid: 'user-99' },
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('WHATSAPP', response);
+      expect(result.domains[0].sourceAccountIdentifier).toBe('user-99');
+    });
+
+    it('should dedupe duplicate GSM values for RCS (merged contact types)', () => {
+      const response = {
+        entity: {
+          RCS: [
+            {
+              id: 1,
+              priority: 0,
+              domainProperties: {
+                domainName: 'R',
+                id: 1,
+                contactInfo: [
+                  { type: 'gsm_sender_id', valid: true, value: 'SAME', default: true },
+                  { type: 'rcs_sender_id', valid: true, value: 'SAME' },
+                ],
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('RCS', response);
+      expect(result.domains[0].gsmSenders.filter((r) => r.value === 'SAME')).toHaveLength(1);
+    });
+
+    it('should return empty domains when response is not an object', () => {
+      expect(parseSenderDetailsResponse('SMS', 42)).toEqual({ domains: [] });
+      expect(parseSenderDetailsResponse('SMS', 'x')).toEqual({ domains: [] });
+    });
+
+    it('should return empty domains when entity is empty string', () => {
+      expect(parseSenderDetailsResponse('SMS', { entity: '' })).toEqual({ domains: [] });
+    });
+
+    it('should normalize hyphenated contactInfo.type to match gsm_sender_id', () => {
+      const response = {
+        entity: {
+          SMS: [
+            {
+              id: 1,
+              domainProperties: {
+                domainName: 'D',
+                id: 1,
+                contactInfo: [
+                  { type: 'gsm-sender-id', valid: true, value: 'HYPH' },
+                ],
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains[0].gsmSenders[0].value).toBe('HYPH');
+    });
+
+    it('should skip whitespace-only GSM values when merging RCS contact types', () => {
+      const response = {
+        entity: {
+          RCS: [
+            {
+              id: 1,
+              domainProperties: {
+                domainName: 'R',
+                id: 1,
+                contactInfo: [
+                  { type: 'gsm_sender_id', valid: true, value: '   ' },
+                  { type: 'gsm_sender_id', valid: true, value: 'OK' },
+                ],
+              },
+            },
+          ],
+        },
+      };
+      const values = parseSenderDetailsResponse('RCS', response).domains[0].gsmSenders.map((g) => g.value);
+      expect(values).toEqual(['OK']);
+    });
+
+    it('should use default priority 0 when priority is null', () => {
+      const response = {
+        entity: {
+          SMS: [
+            {
+              id: 1,
+              priority: null,
+              domainProperties: {
+                domainName: 'P',
+                id: 9,
+                contactInfo: [],
+              },
+            },
+          ],
+        },
+      };
+      expect(parseSenderDetailsResponse('SMS', response).domains[0].priority).toBe(0);
+    });
+
+    it('should unwrap entity from raw response object when entity key is absent', () => {
+      const response = { misc: 1 };
+      expect(parseSenderDetailsResponse('SMS', response)).toEqual({ domains: [] });
+    });
+  });
+
+  describe('unwrapEntity edge cases', () => {
+    it('should return empty domains when entity key is explicitly null', () => {
+      // unwrapEntity: response.entity === null → returns null → parseSenderDetailsResponse returns { domains: [] }
+      expect(parseSenderDetailsResponse('SMS', { entity: null })).toEqual({ domains: [] });
+    });
+  });
+
+  describe('null or empty channel', () => {
+    it('should return empty domains when channel is null', () => {
+      const response = { entity: { SMS: [{ id: 1, domainProperties: { domainName: 'D', id: 10, contactInfo: [] } }] } };
+      expect(parseSenderDetailsResponse(null, response)).toEqual({ domains: [] });
+    });
+
+    it('should return empty domains when channel is empty string', () => {
+      const response = { entity: { SMS: [{ id: 1, domainProperties: { domainName: 'D', id: 10, contactInfo: [] } }] } };
+      expect(parseSenderDetailsResponse('', response)).toEqual({ domains: [] });
+    });
+  });
+
+  describe('single non-array domain object', () => {
+    it('should wrap single domain with domainProperties in an array and return one domain', () => {
+      const response = {
+        entity: {
+          SMS: {
+            id: 5,
+            domainProperties: {
+              domainName: 'SingleDomain',
+              id: 99,
+              contactInfo: [{ type: 'gsm_sender_id', valid: true, value: 'GSMSINGLE' }],
+            },
+          },
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0].domainName).toBe('SingleDomain');
+      expect(result.domains[0].gsmSenders[0].value).toBe('GSMSINGLE');
+    });
+
+    it('should return empty domains for single non-array domain without domainProperties', () => {
+      const response = {
+        entity: { SMS: { id: 5, someProp: 'value' } },
+      };
+      expect(parseSenderDetailsResponse('SMS', response)).toEqual({ domains: [] });
+    });
+  });
+
+  describe('deduplication by domainId when domainName is null', () => {
+    it('should deduplicate two entries sharing the same domainId when domainName is null', () => {
+      const response = {
+        entity: {
+          SMS: [
+            {
+              id: 10,
+              priority: 1,
+              domainProperties: { domainName: null, id: 42, contactInfo: [] },
+            },
+            {
+              id: 11,
+              priority: 2,
+              domainProperties: { domainName: null, id: 42, contactInfo: [] },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0].domainId).toBe(42);
+    });
+  });
+
+  describe('typeMatches null-type filtering', () => {
+    it('should exclude contactInfo items with null type from gsmSenders', () => {
+      const response = {
+        entity: {
+          SMS: [
+            {
+              id: 1,
+              domainProperties: {
+                domainName: 'D',
+                id: 1,
+                contactInfo: [
+                  { type: null, valid: true, value: 'EXCLUDED' },
+                  { type: 'gsm_sender_id', valid: true, value: 'INCLUDED' },
+                ],
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains[0].gsmSenders).toHaveLength(1);
+      expect(result.domains[0].gsmSenders[0].value).toBe('INCLUDED');
+    });
   });
 });

package/v2Components/CommonTestAndPreview/tests/SendTestMessage.test.js

@@ -24,17 +24,19 @@ import SendTestMessage from '../SendTestMessage';
 
 // Mock DeliverySettings to assert props
 jest.mock('../DeliverySettings', () => function MockDeliverySettings(props) {
-  return (
+  const smsRows = props.senderDetailsByChannel?.SMS || [];
+    return (
     <div data-testid="delivery-settings" data-props={JSON.stringify({
       channel: props.channel,
       hasDeliverySettings: !!props.deliverySettings,
-      senderDetailsLength: (props.senderDetailsOptions || []).length,
+      senderDetailsLength: smsRows.length,
       wecrmAccountsLength: (props.wecrmAccounts || []).length,
       hasOnSave: typeof props.onSaveDeliverySettings === 'function',
       isLoadingSenderDetails: props.isLoadingSenderDetails,
       smsTraiDltEnabled: props.smsTraiDltEnabled,
       registeredSenderIds: props.registeredSenderIds,
       whatsappAccountFromForm: props.whatsappAccountFromForm,
+      isChannelSmsFallbackPreviewEnabled: props.isChannelSmsFallbackPreviewEnabled,
     })}
     />
   );
@@ -129,12 +131,13 @@ describe('SendTestMessage', () => {
     formatMessage: jest.fn((msg) => msg.defaultMessage || msg.id),
     channel: 'EMAIL',
     deliverySettings: {},
-    senderDetailsOptions: [],
+    senderDetailsByChannel: {},
     wecrmAccounts: [],
     onSaveDeliverySettings: jest.fn(),
     isLoadingSenderDetails: false,
     smsTraiDltEnabled: false,
     registeredSenderIds: [],
+    isChannelSmsFallbackPreviewEnabled: false,
   };
 
   beforeEach(() => {
@@ -229,6 +232,22 @@ describe('SendTestMessage', () => {
       expect(screen.getByTestId('delivery-settings')).toBeTruthy();
     });
 
+    it('should render DeliverySettings when channel is RCS and pass SMS fallback preview flag', () => {
+      render(
+        <TestWrapper>
+          <SendTestMessage
+            {...defaultProps}
+            channel="RCS"
+            isChannelSmsFallbackPreviewEnabled
+          />
+        </TestWrapper>
+      );
+      const el = screen.getByTestId('delivery-settings');
+      const data = JSON.parse(el.getAttribute('data-props'));
+      expect(data.channel).toBe('RCS');
+      expect(data.isChannelSmsFallbackPreviewEnabled).toBe(true);
+    });
+
     it('should not render DeliverySettings when channel is INAPP', () => {
       render(
         <TestWrapper>
@@ -276,7 +295,9 @@ describe('SendTestMessage', () => {
             {...defaultProps}
             channel="SMS"
             deliverySettings={{ domainId: 1 }}
-            senderDetailsOptions={[{ domainId: 1, domainName: 'SMS Dom' }]}
+            senderDetailsByChannel={{
+              SMS: [{ domainId: 1, domainName: 'SMS Dom' }],
+            }}
             wecrmAccounts={[]}
             onSaveDeliverySettings={onSave}
             isLoadingSenderDetails={true}

package/v2Components/CommonTestAndPreview/tests/UnifiedPreview/index.test.js

@@ -9,7 +9,16 @@ import { render, screen } from '@testing-library/react';
 import '@testing-library/jest-dom';
 import { injectIntl, IntlProvider } from 'react-intl';
 import UnifiedPreview from '../../UnifiedPreview';
-import { CHANNELS, DESKTOP, TABLET, MOBILE, ANDROID, IOS } from '../../constants';
+import {
+  CHANNELS,
+  DESKTOP,
+  TABLET,
+  MOBILE,
+  ANDROID,
+  IOS,
+  PREVIEW_TAB_RCS,
+  PREVIEW_TAB_SMS_FALLBACK,
+} from '../../constants';
 import messages from '../../messages';
 
 // Convert messages object to format expected by IntlProvider
@@ -547,6 +556,195 @@ describe('UnifiedPreview', () => {
 
       expect(screen.getByTestId('rcs-sender-id')).toHaveTextContent('RCS_SENDER');
     });
+
+    describe('RCS SMS fallback — Test & Preview tabs', () => {
+      it('without SMS fallback selected, shows only RCS preview (no RCS+SMS tab layout)', () => {
+        const props = {
+          ...defaultProps,
+          channel: CHANNELS.RCS,
+          content: { rcsTitle: 'Hello RCS' },
+          smsFallbackContent: undefined,
+        };
+
+        const { container } = render(
+          <TestWrapper>
+            <ComponentToRender {...props} />
+          </TestWrapper>
+        );
+
+        expect(container.querySelector('.unified-preview-rcs-tabs')).toBeNull();
+        expect(screen.getByTestId('rcs-preview')).toBeInTheDocument();
+        expect(screen.queryByTestId('sms-preview')).not.toBeInTheDocument();
+      });
+
+      it('with SMS fallback template body, shows RCS and Fallback SMS tabs', () => {
+        const props = {
+          ...defaultProps,
+          channel: CHANNELS.RCS,
+          content: { rcsTitle: 'Hello RCS' },
+          smsFallbackContent: {
+            content: 'SMS fallback body',
+            templateContent: 'SMS fallback body',
+          },
+        };
+
+        const { container } = render(
+          <TestWrapper>
+            <ComponentToRender {...props} />
+          </TestWrapper>
+        );
+
+        expect(container.querySelector('.unified-preview-rcs-tabs')).toBeInTheDocument();
+        expect(
+          screen.getByRole('tab', { name: messages.rcsTab.defaultMessage })
+        ).toBeInTheDocument();
+        expect(
+          screen.getByRole('tab', { name: messages.smsFallbackTab.defaultMessage })
+        ).toBeInTheDocument();
+      });
+
+      it('on SMS fallback tab, renders SMS preview with resolved fallback text when smsFallbackResolvedText is set', () => {
+        const props = {
+          ...defaultProps,
+          channel: CHANNELS.RCS,
+          content: { rcsTitle: 'Hello RCS' },
+          smsFallbackContent: {
+            content: '{{var}}',
+            templateContent: '{{var}}',
+          },
+          smsFallbackResolvedText: 'Resolved SMS for preview',
+          activePreviewTab: PREVIEW_TAB_SMS_FALLBACK,
+          onPreviewTabChange: jest.fn(),
+        };
+
+        render(
+          <TestWrapper>
+            <ComponentToRender {...props} />
+          </TestWrapper>
+        );
+
+        expect(screen.getByTestId('sms-content')).toHaveTextContent('Resolved SMS for preview');
+      });
+
+      it('on RCS tab (default), renders RCS preview when dual tabs are shown', () => {
+        const props = {
+          ...defaultProps,
+          channel: CHANNELS.RCS,
+          content: { rcsTitle: 'Only RCS pane' },
+          smsFallbackContent: { content: 'SMS', templateContent: 'SMS' },
+          activePreviewTab: PREVIEW_TAB_RCS,
+          onPreviewTabChange: jest.fn(),
+        };
+
+        render(
+          <TestWrapper>
+            <ComponentToRender {...props} />
+          </TestWrapper>
+        );
+
+        expect(screen.getByTestId('rcs-preview')).toBeInTheDocument();
+        expect(screen.getByTestId('rcs-content')).toHaveTextContent(/Only RCS pane/);
+      });
+
+      it('on SMS fallback tab, shows raw template when no varmap and no resolved text', () => {
+        const props = {
+          ...defaultProps,
+          channel: CHANNELS.RCS,
+          content: { rcsTitle: 'Hello RCS' },
+          smsFallbackContent: {
+            content: 'Hello {{name}}',
+            templateContent: 'Hello {{name}}',
+            // no rcsSmsFallbackVarMapped
+          },
+          smsFallbackResolvedText: undefined,
+          activePreviewTab: PREVIEW_TAB_SMS_FALLBACK,
+          onPreviewTabChange: jest.fn(),
+        };
+
+        render(
+          <TestWrapper>
+            <ComponentToRender {...props} />
+          </TestWrapper>
+        );
+
+        // rawFallbackTemplate is shown directly — {{tags}} remain visible
+        expect(screen.getByTestId('sms-content')).toHaveTextContent('Hello {{name}}');
+      });
+
+      it('on SMS fallback tab, treats empty resolved text as absent and shows raw template', () => {
+        const props = {
+          ...defaultProps,
+          channel: CHANNELS.RCS,
+          content: { rcsTitle: 'Hello RCS' },
+          smsFallbackContent: {
+            content: 'Raw {{var}} template',
+            templateContent: 'Raw {{var}} template',
+          },
+          smsFallbackResolvedText: '',
+          activePreviewTab: PREVIEW_TAB_SMS_FALLBACK,
+          onPreviewTabChange: jest.fn(),
+        };
+
+        render(
+          <TestWrapper>
+            <ComponentToRender {...props} />
+          </TestWrapper>
+        );
+
+        expect(screen.getByTestId('sms-content')).toHaveTextContent('Raw {{var}} template');
+      });
+
+      it('on SMS fallback tab, applies varmap slot substitution when varmap entries exist and no resolved text', () => {
+        // getFallbackResolvedContent key format: `${fullToken}_${segmentIndex}`
+        // 'Hello {{name}}' → segments ['Hello ', '{{name}}'], so {{name}} is at index 1 → key '{{name}}_1'
+        const props = {
+          ...defaultProps,
+          channel: CHANNELS.RCS,
+          content: { rcsTitle: 'Hello RCS' },
+          smsFallbackContent: {
+            content: 'Hello {{name}}',
+            templateContent: 'Hello {{name}}',
+            rcsSmsFallbackVarMapped: { '{{name}}_1': 'World' },
+          },
+          smsFallbackResolvedText: undefined,
+          activePreviewTab: PREVIEW_TAB_SMS_FALLBACK,
+          onPreviewTabChange: jest.fn(),
+        };
+
+        render(
+          <TestWrapper>
+            <ComponentToRender {...props} />
+          </TestWrapper>
+        );
+
+        expect(screen.getByTestId('sms-content')).toHaveTextContent('Hello World');
+      });
+
+      it('on SMS fallback tab, resolved text takes priority over varmap entries', () => {
+        const props = {
+          ...defaultProps,
+          channel: CHANNELS.RCS,
+          content: { rcsTitle: 'Hello RCS' },
+          smsFallbackContent: {
+            content: 'Hello {{name}}',
+            templateContent: 'Hello {{name}}',
+            rcsSmsFallbackVarMapped: { '{{name}}_1': 'World' },
+          },
+          smsFallbackResolvedText: 'Hello John',
+          activePreviewTab: PREVIEW_TAB_SMS_FALLBACK,
+          onPreviewTabChange: jest.fn(),
+        };
+
+        render(
+          <TestWrapper>
+            <ComponentToRender {...props} />
+          </TestWrapper>
+        );
+
+        // resolvedText wins over varmap substitution
+        expect(screen.getByTestId('sms-content')).toHaveTextContent('Hello John');
+      });
+    });
   });
 
   describe('Channel Routing - INAPP', () => {