@capillarytech/creatives-library 8.0.291 → 8.0.292

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

@@ -30,6 +30,12 @@ import {
   GET_PREFILLED_VALUES_REQUESTED,
   GET_PREFILLED_VALUES_SUCCESS,
   GET_PREFILLED_VALUES_FAILURE,
+  GET_SENDER_DETAILS_REQUESTED,
+  GET_SENDER_DETAILS_SUCCESS,
+  GET_SENDER_DETAILS_FAILURE,
+  GET_WECRM_ACCOUNTS_REQUESTED,
+  GET_WECRM_ACCOUNTS_SUCCESS,
+  GET_WECRM_ACCOUNTS_FAILURE,
   CLEAR_CUSTOMER_SEARCH_STATE,
   CLEAR_SEARCH_RESULTS,
   CLEAR_PREFILLED_VALUES,
@@ -137,6 +143,18 @@ describe('CommonTestAndPreview Constants', () => {
       expect(GET_PREFILLED_VALUES_FAILURE).toBe('app/CommonTestAndPreview/GET_PREFILLED_VALUES_FAILURE');
     });
 
+    it('should export all get sender details action types', () => {
+      expect(GET_SENDER_DETAILS_REQUESTED).toBe('app/CommonTestAndPreview/GET_SENDER_DETAILS_REQUESTED');
+      expect(GET_SENDER_DETAILS_SUCCESS).toBe('app/CommonTestAndPreview/GET_SENDER_DETAILS_SUCCESS');
+      expect(GET_SENDER_DETAILS_FAILURE).toBe('app/CommonTestAndPreview/GET_SENDER_DETAILS_FAILURE');
+    });
+
+    it('should export all get wecrm accounts action types', () => {
+      expect(GET_WECRM_ACCOUNTS_REQUESTED).toBe('app/CommonTestAndPreview/GET_WECRM_ACCOUNTS_REQUESTED');
+      expect(GET_WECRM_ACCOUNTS_SUCCESS).toBe('app/CommonTestAndPreview/GET_WECRM_ACCOUNTS_SUCCESS');
+      expect(GET_WECRM_ACCOUNTS_FAILURE).toBe('app/CommonTestAndPreview/GET_WECRM_ACCOUNTS_FAILURE');
+    });
+
     it('should export all clear action types', () => {
       expect(CLEAR_CUSTOMER_SEARCH_STATE).toBe('app/CommonTestAndPreview/CLEAR_CUSTOMER_SEARCH_STATE');
       expect(CLEAR_SEARCH_RESULTS).toBe('app/CommonTestAndPreview/CLEAR_SEARCH_RESULTS');

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

@@ -52,12 +52,14 @@ jest.mock('../CustomValuesEditor', () => {
   };
 });
 
+let lastSendTestMessageProps = null;
 jest.mock('../SendTestMessage', () => {
   // eslint-disable-next-line global-require, import/no-extraneous-dependencies
   const ReactLib = require('react');
   return {
     __esModule: true,
-    default: function MockSendTestMessage() {
+    default: function MockSendTestMessage(props) {
+      lastSendTestMessageProps = props;
       return ReactLib.createElement('div', { 'data-testid': 'send-test-message' }, 'Send Test Message');
     },
   };
@@ -122,6 +124,8 @@ describe('CommonTestAndPreview', () => {
     getPrefilledValuesRequested: jest.fn(),
     clearPrefilledValues: jest.fn(),
     clearPreviewErrors: jest.fn(),
+    getSenderDetailsRequested: jest.fn(),
+    getWeCrmAccountsRequested: jest.fn(),
   };
 
   const defaultProps = {
@@ -171,10 +175,15 @@ describe('CommonTestAndPreview', () => {
     fetchPrefilledValuesErrors: [],
     isSendingTestMessage: false,
     currentTab: 1,
+    senderDetailsByChannel: {},
+    wecrmAccounts: [],
+    isLoadingSenderDetails: false,
+    orgUnitId: -1,
   };
 
   beforeEach(() => {
     jest.clearAllMocks();
+    lastSendTestMessageProps = null;
     // Reset all mock function implementations
     Object.values(mockActions).forEach((mockFn) => {
       if (jest.isMockFunction(mockFn)) {
@@ -183,6 +192,338 @@ describe('CommonTestAndPreview', () => {
     });
   });
 
+  describe('Delivery settings / sender ID', () => {
+    it('should call getSenderDetailsRequested when show and channel is SMS', async () => {
+      render(
+        <TestWrapper>
+          <CommonTestAndPreview {...defaultProps} channel={CHANNELS.SMS} />
+        </TestWrapper>
+      );
+      await waitFor(() => {
+        expect(mockActions.getSenderDetailsRequested).toHaveBeenCalledWith({
+          channel: CHANNELS.SMS,
+          orgUnitId: -1,
+        });
+      });
+    });
+
+    it('should call getSenderDetailsRequested when show and channel is EMAIL', async () => {
+      render(
+        <TestWrapper>
+          <CommonTestAndPreview {...defaultProps} channel={CHANNELS.EMAIL} />
+        </TestWrapper>
+      );
+      await waitFor(() => {
+        expect(mockActions.getSenderDetailsRequested).toHaveBeenCalledWith({
+          channel: CHANNELS.EMAIL,
+          orgUnitId: -1,
+        });
+      });
+    });
+
+    it('should call getSenderDetailsRequested and getWeCrmAccountsRequested when show and channel is WHATSAPP', async () => {
+      render(
+        <TestWrapper>
+          <CommonTestAndPreview {...defaultProps} channel={CHANNELS.WHATSAPP} />
+        </TestWrapper>
+      );
+      await waitFor(() => {
+        expect(mockActions.getSenderDetailsRequested).toHaveBeenCalledWith({
+          channel: CHANNELS.WHATSAPP,
+          orgUnitId: -1,
+        });
+        expect(mockActions.getWeCrmAccountsRequested).toHaveBeenCalledWith({
+          sourceName: CHANNELS.WHATSAPP,
+        });
+      });
+    });
+
+    it('should not call getSenderDetailsRequested when channel is INAPP', async () => {
+      render(
+        <TestWrapper>
+          <CommonTestAndPreview {...defaultProps} channel={CHANNELS.INAPP} />
+        </TestWrapper>
+      );
+      await waitFor(() => {
+        expect(screen.getByTestId('left-panel')).toBeTruthy();
+      });
+      expect(mockActions.getSenderDetailsRequested).not.toHaveBeenCalled();
+      expect(mockActions.getWeCrmAccountsRequested).not.toHaveBeenCalled();
+    });
+
+    it('should pass orgUnitId to getSenderDetailsRequested when provided', async () => {
+      render(
+        <TestWrapper>
+          <CommonTestAndPreview {...defaultProps} channel={CHANNELS.SMS} orgUnitId={100} />
+        </TestWrapper>
+      );
+      await waitFor(() => {
+        expect(mockActions.getSenderDetailsRequested).toHaveBeenCalledWith({
+          channel: CHANNELS.SMS,
+          orgUnitId: 100,
+        });
+      });
+    });
+
+    it('should not call getSenderDetailsRequested when show is false', async () => {
+      render(
+        <TestWrapper>
+          <CommonTestAndPreview {...defaultProps} show={false} channel={CHANNELS.SMS} />
+        </TestWrapper>
+      );
+      await waitFor(() => {
+        expect(screen.queryByTestId('left-panel')).toBeNull();
+      });
+      expect(mockActions.getSenderDetailsRequested).not.toHaveBeenCalled();
+    });
+
+    it('should pass delivery-related props to SendTestMessage for SMS channel', async () => {
+      const senderDetailsByChannel = {
+        [CHANNELS.SMS]: [{ domainId: 1, domainName: 'SMS Dom', gsmSenders: [], cdmaSenders: [] }],
+      };
+      render(
+        <TestWrapper>
+          <CommonTestAndPreview
+            {...defaultProps}
+            channel={CHANNELS.SMS}
+            senderDetailsByChannel={senderDetailsByChannel}
+            wecrmAccounts={[]}
+          />
+        </TestWrapper>
+      );
+      await waitFor(() => {
+        expect(screen.getByTestId('send-test-message')).toBeTruthy();
+      });
+      expect(lastSendTestMessageProps).toBeDefined();
+      expect(lastSendTestMessageProps.deliverySettings).toBeDefined();
+      expect(lastSendTestMessageProps.senderDetailsOptions).toEqual(senderDetailsByChannel[CHANNELS.SMS]);
+      expect(lastSendTestMessageProps.wecrmAccounts).toEqual([]);
+      expect(typeof lastSendTestMessageProps.onSaveDeliverySettings).toBe('function');
+      expect(lastSendTestMessageProps.isLoadingSenderDetails).toBe(false);
+    });
+
+    it('should pass formDataForSendTest (formData when provided) to SendTestMessage', async () => {
+      render(
+        <TestWrapper>
+          <CommonTestAndPreview {...defaultProps} channel={CHANNELS.EMAIL} />
+        </TestWrapper>
+      );
+      await waitFor(() => {
+        expect(lastSendTestMessageProps).toBeDefined();
+      });
+      expect(lastSendTestMessageProps.formData).toEqual(defaultProps.formData);
+    });
+
+    it('should auto-set SMS delivery settings from TRAI registered sender IDs when DLT is enabled', async () => {
+      const senderDetailsByChannel = {
+        [CHANNELS.SMS]: [
+          {
+            domainId: 1,
+            dgmId: 11,
+            gsmSenders: [{ value: 'SENDER_A' }],
+            cdmaSenders: [{ value: 'CDMA_A' }],
+          },
+          {
+            domainId: 2,
+            dgmId: 22,
+            gsmSenders: [{ value: 'SENDER_B' }, { value: 'SENDER_C' }],
+            cdmaSenders: [{ value: 'CDMA_B' }],
+          },
+        ],
+      };
+
+      render(
+        <TestWrapper>
+          <CommonTestAndPreview
+            {...defaultProps}
+            channel={CHANNELS.SMS}
+            formData={{
+              templateConfigs: {
+                traiDltEnabled: true,
+                registeredSenderIds: ['SENDER_B'],
+              },
+            }}
+            senderDetailsByChannel={senderDetailsByChannel}
+          />
+        </TestWrapper>
+      );
+
+      await waitFor(() => {
+        expect(lastSendTestMessageProps.deliverySettings).toEqual({
+          domainId: 2,
+          domainGatewayMapId: 22,
+          gsmSenderId: 'SENDER_B',
+          cdmaSenderId: 'CDMA_B',
+        });
+      });
+    });
+
+    it('should preserve existing SMS auto-set logic when TRAI DLT is not enabled', async () => {
+      const senderDetailsByChannel = {
+        [CHANNELS.SMS]: [
+          {
+            domainId: 1,
+            dgmId: 11,
+            gsmSenders: [{ value: 'SENDER_A' }, { value: 'SENDER_A_DEFAULT', default: true }],
+            cdmaSenders: [{ value: 'CDMA_A', default: true }],
+          },
+          {
+            domainId: 2,
+            dgmId: 22,
+            gsmSenders: [{ value: 'SENDER_B' }],
+            cdmaSenders: [{ value: 'CDMA_B' }],
+          },
+        ],
+      };
+
+      render(
+        <TestWrapper>
+          <CommonTestAndPreview
+            {...defaultProps}
+            channel={CHANNELS.SMS}
+            formData={{
+              templateConfigs: {
+                traiDltEnabled: false,
+                registeredSenderIds: ['SENDER_B'],
+              },
+            }}
+            senderDetailsByChannel={senderDetailsByChannel}
+          />
+        </TestWrapper>
+      );
+
+      await waitFor(() => {
+        expect(lastSendTestMessageProps.deliverySettings).toEqual({
+          domainId: 1,
+          domainGatewayMapId: 11,
+          gsmSenderId: 'SENDER_A_DEFAULT',
+          cdmaSenderId: 'CDMA_A',
+        });
+      });
+    });
+
+    it('should keep SMS delivery settings empty when DLT is enabled and no registered sender ID matches', async () => {
+      const senderDetailsByChannel = {
+        [CHANNELS.SMS]: [
+          {
+            domainId: 1,
+            dgmId: 11,
+            gsmSenders: [{ value: 'SENDER_A' }],
+            cdmaSenders: [{ value: 'CDMA_A' }],
+          },
+        ],
+      };
+
+      render(
+        <TestWrapper>
+          <CommonTestAndPreview
+            {...defaultProps}
+            channel={CHANNELS.SMS}
+            formData={{
+              templateConfigs: {
+                traiDltEnabled: true,
+                registeredSenderIds: ['SENDER_X'],
+              },
+            }}
+            senderDetailsByChannel={senderDetailsByChannel}
+          />
+        </TestWrapper>
+      );
+
+      await waitFor(() => {
+        expect(lastSendTestMessageProps).toBeDefined();
+      });
+
+      expect(lastSendTestMessageProps.deliverySettings).toEqual({
+        domainId: null,
+        domainGatewayMapId: null,
+        gsmSenderId: '',
+        cdmaSenderId: '',
+      });
+    });
+
+    it('should auto-set WhatsApp delivery settings from formData accountName when matching account exists', async () => {
+      const senderDetailsByChannel = {
+        [CHANNELS.WHATSAPP]: [
+          {
+            domainId: 1,
+            sourceAccountIdentifier: 'waba-1',
+            gsmSenders: [{ value: '+1111111111' }],
+          },
+          {
+            domainId: 2,
+            sourceAccountIdentifier: 'waba-2',
+            gsmSenders: [{ value: '+2222222222' }],
+          },
+        ],
+      };
+      const wecrmAccounts = [
+        { name: 'Account One', sourceAccountIdentifier: 'waba-1' },
+        { name: 'Account Two', sourceAccountIdentifier: 'waba-2' },
+      ];
+
+      render(
+        <TestWrapper>
+          <CommonTestAndPreview
+            {...defaultProps}
+            channel={CHANNELS.WHATSAPP}
+            formData={{ accountName: 'Account Two', templateMsg: 'WhatsApp test' }}
+            senderDetailsByChannel={senderDetailsByChannel}
+            wecrmAccounts={wecrmAccounts}
+          />
+        </TestWrapper>
+      );
+
+      await waitFor(() => {
+        expect(lastSendTestMessageProps).toBeDefined();
+        expect(lastSendTestMessageProps.deliverySettings).toEqual({
+          domainId: 2,
+          senderMobNum: '+2222222222',
+          sourceAccountIdentifier: 'waba-2',
+        });
+      });
+    });
+
+    it('should include delivery settings in payload when handleSendTestMessage is called for EMAIL', async () => {
+      render(
+        <TestWrapper>
+          <CommonTestAndPreview {...defaultProps} channel={CHANNELS.EMAIL} />
+        </TestWrapper>
+      );
+      await waitFor(() => {
+        expect(lastSendTestMessageProps).toBeDefined();
+        expect(typeof lastSendTestMessageProps.handleSendTestMessage).toBe('function');
+      });
+      lastSendTestMessageProps.handleSendTestMessage();
+      expect(mockActions.createMessageMetaRequested).toHaveBeenCalled();
+      const [initialPayload] = mockActions.createMessageMetaRequested.mock.calls[0];
+      expect(initialPayload.emailDeliverySettings).toBeDefined();
+      expect(initialPayload.emailDeliverySettings.channelSettings).toBeDefined();
+      expect(initialPayload.emailDeliverySettings.channelSettings.channel).toBe(CHANNELS.EMAIL);
+    });
+
+    it('should include delivery settings in payload when handleSendTestMessage is called for SMS', async () => {
+      render(
+        <TestWrapper>
+          <CommonTestAndPreview
+            {...defaultProps}
+            channel={CHANNELS.SMS}
+            formData={{ 'sms-editor': 'Test SMS' }}
+          />
+        </TestWrapper>
+      );
+      await waitFor(() => {
+        expect(lastSendTestMessageProps).toBeDefined();
+      });
+      lastSendTestMessageProps.handleSendTestMessage();
+      expect(mockActions.createMessageMetaRequested).toHaveBeenCalled();
+      const [initialPayload] = mockActions.createMessageMetaRequested.mock.calls[0];
+      expect(initialPayload.smsDeliverySettings).toBeDefined();
+      expect(initialPayload.smsDeliverySettings.channelSettings).toBeDefined();
+      expect(initialPayload.smsDeliverySettings.channelSettings.channel).toBe(CHANNELS.SMS);
+    });
+  });
+
   describe('Component Rendering', () => {
     it('should render when show is true', async () => {
       render(

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

@@ -35,6 +35,13 @@ import {
   GET_PREFILLED_VALUES_FAILURE,
   CLEAR_PREFILLED_VALUES,
   CLEAR_PREVIEW_ERRORS,
+  GET_SENDER_DETAILS_REQUESTED,
+  GET_SENDER_DETAILS_SUCCESS,
+  GET_SENDER_DETAILS_FAILURE,
+  GET_WECRM_ACCOUNTS_REQUESTED,
+  GET_WECRM_ACCOUNTS_SUCCESS,
+  GET_WECRM_ACCOUNTS_FAILURE,
+  CHANNELS,
 } from '../constants';
 
 describe('previewAndTestReducer', () => {
@@ -80,6 +87,15 @@ describe('previewAndTestReducer', () => {
       isFetchingPrefilledValues: false,
       fetchPrefilledValuesError: null,
       fetchPrefilledValuesErrors: [],
+      senderDetailsByChannel: fromJS({
+        [CHANNELS.SMS]: [],
+        [CHANNELS.EMAIL]: [],
+        [CHANNELS.WHATSAPP]: [],
+      }),
+      wecrmAccounts: fromJS([]),
+      isLoadingSenderDetails: false,
+      fetchSenderDetailsError: null,
+      fetchWeCrmAccountsError: null,
     });
   });
 
@@ -773,6 +789,108 @@ describe('previewAndTestReducer', () => {
     });
   });
 
+  describe('GET_SENDER_DETAILS_REQUESTED', () => {
+    it('should set isLoadingSenderDetails to true and clear fetchSenderDetailsError', () => {
+      const action = {
+        type: GET_SENDER_DETAILS_REQUESTED,
+        payload: { channel: CHANNELS.SMS, orgUnitId: 123 },
+      };
+      const result = previewAndTestReducer(initialState, action);
+
+      expect(result.get('isLoadingSenderDetails')).toBe(true);
+      expect(result.get('fetchSenderDetailsError')).toBeNull();
+    });
+  });
+
+  describe('GET_SENDER_DETAILS_SUCCESS', () => {
+    it('should store domains for channel and set loading to false', () => {
+      const domains = [
+        { domainId: 1, domainName: 'Domain 1', gsmSenders: [] },
+      ];
+      const action = {
+        type: GET_SENDER_DETAILS_SUCCESS,
+        payload: { channel: CHANNELS.SMS, domains },
+      };
+      const result = previewAndTestReducer(initialState, action);
+
+      expect(result.getIn(['senderDetailsByChannel', CHANNELS.SMS])).toEqual(fromJS(domains));
+      expect(result.get('isLoadingSenderDetails')).toBe(false);
+      expect(result.get('fetchSenderDetailsError')).toBeNull();
+    });
+
+    it('should return state unchanged when channel is missing', () => {
+      const action = {
+        type: GET_SENDER_DETAILS_SUCCESS,
+        payload: { domains: [] },
+      };
+      const result = previewAndTestReducer(initialState, action);
+
+      expect(result).toEqual(initialState);
+    });
+  });
+
+  describe('GET_SENDER_DETAILS_FAILURE', () => {
+    it('should set loading to false and store error', () => {
+      const action = {
+        type: GET_SENDER_DETAILS_FAILURE,
+        payload: { channel: CHANNELS.EMAIL, error: 'Failed to fetch' },
+      };
+      const result = previewAndTestReducer(initialState, action);
+
+      expect(result.get('isLoadingSenderDetails')).toBe(false);
+      expect(result.get('fetchSenderDetailsError')).toBe('Failed to fetch');
+    });
+  });
+
+  describe('GET_WECRM_ACCOUNTS_REQUESTED', () => {
+    it('should clear fetchWeCrmAccountsError', () => {
+      const stateWithError = initialState.set('fetchWeCrmAccountsError', 'Error');
+      const action = {
+        type: GET_WECRM_ACCOUNTS_REQUESTED,
+        payload: { sourceName: 'WHATSAPP' },
+      };
+      const result = previewAndTestReducer(stateWithError, action);
+
+      expect(result.get('fetchWeCrmAccountsError')).toBeNull();
+    });
+  });
+
+  describe('GET_WECRM_ACCOUNTS_SUCCESS', () => {
+    it('should store wecrm accounts and clear error', () => {
+      const accounts = [{ name: 'Account 1', sourceAccountIdentifier: 'acc-1' }];
+      const action = {
+        type: GET_WECRM_ACCOUNTS_SUCCESS,
+        payload: { accounts },
+      };
+      const result = previewAndTestReducer(initialState, action);
+
+      expect(result.get('wecrmAccounts')).toEqual(fromJS(accounts));
+      expect(result.get('fetchWeCrmAccountsError')).toBeNull();
+    });
+
+    it('should handle empty accounts', () => {
+      const action = {
+        type: GET_WECRM_ACCOUNTS_SUCCESS,
+        payload: { accounts: [] },
+      };
+      const result = previewAndTestReducer(initialState, action);
+
+      expect(result.get('wecrmAccounts')).toEqual(fromJS([]));
+    });
+  });
+
+  describe('GET_WECRM_ACCOUNTS_FAILURE', () => {
+    it('should store fetchWeCrmAccountsError', () => {
+      const action = {
+        type: GET_WECRM_ACCOUNTS_FAILURE,
+        payload: { error: 'WeCRM fetch failed' },
+      };
+      const result = previewAndTestReducer(initialState, action);
+
+      expect(result.get('fetchWeCrmAccountsError')).toBe('WeCRM fetch failed');
+    });
+  });
+
   describe('CLEAR_PREVIEW_ERRORS', () => {
     it('should clear all preview-related errors', () => {
       const stateWithErrors = initialState