@capillarytech/creatives-library 8.0.316-alpha.2 → 8.0.316-alpha.4

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

@@ -40,7 +40,7 @@ describe('DeliverySettings', () => {
   const defaultProps = {
     channel: CHANNELS.SMS,
     deliverySettings: {},
-    senderDetailsOptions: [],
+    senderDetailsByChannel: {},
     wecrmAccounts: [],
     onSaveDeliverySettings: jest.fn(),
     isLoadingSenderDetails: false,
@@ -85,14 +85,14 @@ describe('DeliverySettings', () => {
     });
 
     it('should show summary values for SMS when deliverySettings and senderDetailsOptions match', () => {
-      const senderDetailsOptions = [{ domainId: 1, domainName: 'SMS Domain' }];
+      const senderDetailsByChannel = { [CHANNELS.SMS]: [{ domainId: 1, domainName: 'SMS Domain' }] };
       const deliverySettings = { domainId: 1, gsmSenderId: 'SENDER1' };
       render(
         <DeliverySettings
           {...defaultProps}
           channel={CHANNELS.SMS}
           deliverySettings={deliverySettings}
-          senderDetailsOptions={senderDetailsOptions}
+          senderDetailsByChannel={senderDetailsByChannel}
         />
       );
       expect(screen.getAllByText(/SMS Domain/).length).toBeGreaterThan(0);
@@ -105,7 +105,7 @@ describe('DeliverySettings', () => {
     });
 
     it('should show summary for EMAIL when has domain and sender', () => {
-      const senderDetailsOptions = [{ domainId: 2, domainName: 'Email Domain' }];
+      const senderDetailsByChannel = { [CHANNELS.EMAIL]: [{ domainId: 2, domainName: 'Email Domain' }] };
       const deliverySettings = {
         domainId: 2,
         senderEmail: 'noreply@test.com',
@@ -117,7 +117,7 @@ describe('DeliverySettings', () => {
           {...defaultProps}
           channel={CHANNELS.EMAIL}
           deliverySettings={deliverySettings}
-          senderDetailsOptions={senderDetailsOptions}
+          senderDetailsByChannel={senderDetailsByChannel}
         />
       );
       expect(screen.getAllByText(/Email Domain/).length).toBeGreaterThan(0);
@@ -141,6 +141,76 @@ describe('DeliverySettings', () => {
       expect(screen.getAllByText(/WABA One/).length).toBeGreaterThan(0);
       expect(screen.getAllByText(/\+1234567890/).length).toBeGreaterThan(0);
     });
+
+    it('RCS: when isChannelSmsFallbackPreviewEnabled is false, summary omits fallback SMS sender even if cdma is set', () => {
+      const rcsDomain = {
+        domainId: 10,
+        domainName: 'RCS D',
+        gsmSenders: [{ value: 'R1', default: true }],
+      };
+      const smsDomain = {
+        domainId: 20,
+        domainName: 'SMS D',
+        gsmSenders: [{ value: 'F1', default: true }],
+      };
+      const senderDetailsByChannel = {
+        [CHANNELS.RCS]: [rcsDomain],
+        [CHANNELS.SMS]: [smsDomain],
+      };
+      const deliverySettings = {
+        gsmSenderId: '10|R1',
+        cdmaSenderId: '20|F1',
+      };
+      render(
+        <IntlProvider locale="en" messages={{}}>
+          <DeliverySettings
+            {...defaultProps}
+            channel={CHANNELS.RCS}
+            deliverySettings={deliverySettings}
+            senderDetailsByChannel={senderDetailsByChannel}
+            isChannelSmsFallbackPreviewEnabled={false}
+            formatMessage={(m) => m?.defaultMessage || m?.id || ''}
+          />
+        </IntlProvider>,
+      );
+      expect(screen.getAllByText(/R1/).length).toBeGreaterThan(0);
+      expect(screen.queryByText(/F1/)).toBeNull();
+    });
+
+    it('RCS: when isChannelSmsFallbackPreviewEnabled is true, summary includes fallback SMS sender', () => {
+      const rcsDomain = {
+        domainId: 10,
+        domainName: 'RCS D',
+        gsmSenders: [{ value: 'R1', default: true }],
+      };
+      const smsDomain = {
+        domainId: 20,
+        domainName: 'SMS D',
+        gsmSenders: [{ value: 'F1', default: true }],
+      };
+      const senderDetailsByChannel = {
+        [CHANNELS.RCS]: [rcsDomain],
+        [CHANNELS.SMS]: [smsDomain],
+      };
+      const deliverySettings = {
+        gsmSenderId: '10|R1',
+        cdmaSenderId: '20|F1',
+      };
+      render(
+        <IntlProvider locale="en" messages={{}}>
+          <DeliverySettings
+            {...defaultProps}
+            channel={CHANNELS.RCS}
+            deliverySettings={deliverySettings}
+            senderDetailsByChannel={senderDetailsByChannel}
+            isChannelSmsFallbackPreviewEnabled
+            formatMessage={(m) => m?.defaultMessage || m?.id || ''}
+          />
+        </IntlProvider>,
+      );
+      expect(screen.getAllByText(/R1/).length).toBeGreaterThan(0);
+      expect(screen.getAllByText(/F1/).length).toBeGreaterThan(0);
+    });
   });
 
   describe('edit and slidebox', () => {
@@ -169,6 +239,49 @@ describe('DeliverySettings', () => {
       );
     });
 
+    it('RCS: should not pass smsFallbackSenderDetailsOptions when isChannelSmsFallbackPreviewEnabled is false', () => {
+      render(
+        <DeliverySettings
+          {...defaultProps}
+          channel={CHANNELS.RCS}
+          senderDetailsByChannel={{
+            [CHANNELS.RCS]: [{ domainId: 1, domainName: 'R', gsmSenders: [] }],
+            [CHANNELS.SMS]: [{ domainId: 2, domainName: 'S', gsmSenders: [] }],
+          }}
+          isChannelSmsFallbackPreviewEnabled={false}
+        />,
+      );
+      fireEvent.click(screen.getByTestId('delivery-settings-edit'));
+      expect(mockModifyDeliverySettings).toHaveBeenCalledWith(
+        expect.objectContaining({
+          channel: CHANNELS.RCS,
+          smsFallbackSenderDetailsOptions: undefined,
+        }),
+      );
+    });
+
+    it('RCS: should pass smsFallbackSenderDetailsOptions when isChannelSmsFallbackPreviewEnabled is true', () => {
+      const smsDomains = [{ domainId: 2, domainName: 'S', gsmSenders: [] }];
+      render(
+        <DeliverySettings
+          {...defaultProps}
+          channel={CHANNELS.RCS}
+          senderDetailsByChannel={{
+            [CHANNELS.RCS]: [{ domainId: 1, domainName: 'R', gsmSenders: [] }],
+            [CHANNELS.SMS]: smsDomains,
+          }}
+          isChannelSmsFallbackPreviewEnabled
+        />,
+      );
+      fireEvent.click(screen.getByTestId('delivery-settings-edit'));
+      expect(mockModifyDeliverySettings).toHaveBeenCalledWith(
+        expect.objectContaining({
+          channel: CHANNELS.RCS,
+          smsFallbackSenderDetailsOptions: smsDomains,
+        }),
+      );
+    });
+
     it('should call onSaveDeliverySettings and close slidebox when Done is clicked', () => {
       const onSave = jest.fn();
       render(

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,223 @@ 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: [] });
+    });
   });
 });

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,96 @@ 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/);
+      });
+    });
   });
 
   describe('Channel Routing - INAPP', () => {

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

@@ -238,6 +238,24 @@ describe('CommonTestAndPreview', () => {
       });
     });
 
+    it('should call getSenderDetailsRequested for RCS and SMS when channel is RCS', async () => {
+      render(
+        <TestWrapper>
+          <CommonTestAndPreview {...defaultProps} channel={CHANNELS.RCS} />
+        </TestWrapper>
+      );
+      await waitFor(() => {
+        expect(mockActions.getSenderDetailsRequested).toHaveBeenCalledWith({
+          channel: CHANNELS.RCS,
+          orgUnitId: -1,
+        });
+        expect(mockActions.getSenderDetailsRequested).toHaveBeenCalledWith({
+          channel: CHANNELS.SMS,
+          orgUnitId: -1,
+        });
+      });
+    });
+
     it('should not call getSenderDetailsRequested when channel is INAPP', async () => {
       render(
         <TestWrapper>
@@ -296,7 +314,7 @@ describe('CommonTestAndPreview', () => {
       });
       expect(lastSendTestMessageProps).toBeDefined();
       expect(lastSendTestMessageProps.deliverySettings).toBeDefined();
-      expect(lastSendTestMessageProps.senderDetailsOptions).toEqual(senderDetailsByChannel[CHANNELS.SMS]);
+      expect(lastSendTestMessageProps.senderDetailsByChannel).toEqual(senderDetailsByChannel);
       expect(lastSendTestMessageProps.wecrmAccounts).toEqual([]);
       expect(typeof lastSendTestMessageProps.onSaveDeliverySettings).toBe('function');
       expect(lastSendTestMessageProps.isLoadingSenderDetails).toBe(false);