@capillarytech/creatives-library 8.0.290-alpha.3 → 8.0.290

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,210 @@ 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 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

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

@@ -25,9 +25,17 @@ import {
   watchFetchTestGroups,
   watchCreateMessageMeta,
   watchGetPrefilledValues,
+  getSenderDetailsSaga,
+  getWeCrmAccountsSaga,
+  watchGetSenderDetails,
+  watchGetWeCrmAccounts,
   commonTestAndPreviewSaga,
 } from '../sagas';
 import * as Api from '../../../services/api';
+jest.mock('../DeliverySettings/utils/parseSenderDetailsResponse', () => ({
+  parseSenderDetailsResponse: jest.fn((channel, response) => ({ domains: response?.entity?.[channel] || [] })),
+}));
+import { parseSenderDetailsResponse } from '../DeliverySettings/utils/parseSenderDetailsResponse';
 import {
   SEARCH_CUSTOMERS_SUCCESS,
   SEARCH_CUSTOMERS_FAILURE,
@@ -45,6 +53,10 @@ import {
   CREATE_MESSAGE_META_FAILURE,
   GET_PREFILLED_VALUES_SUCCESS,
   GET_PREFILLED_VALUES_FAILURE,
+  GET_SENDER_DETAILS_SUCCESS,
+  GET_SENDER_DETAILS_FAILURE,
+  GET_WECRM_ACCOUNTS_SUCCESS,
+  GET_WECRM_ACCOUNTS_FAILURE,
 } from '../constants';
 
 describe('CommonTestAndPreview Sagas', () => {
@@ -1694,6 +1706,137 @@ describe('CommonTestAndPreview Sagas', () => {
       );
       expect(generator.next().done).toBe(true);
     });
+
+    it('should watch for GET_SENDER_DETAILS_REQUESTED', () => {
+      const generator = watchGetSenderDetails();
+      expect(generator.next().value).toEqual(
+        takeLatest('app/CommonTestAndPreview/GET_SENDER_DETAILS_REQUESTED', getSenderDetailsSaga)
+      );
+      expect(generator.next().done).toBe(true);
+    });
+
+    it('should watch for GET_WECRM_ACCOUNTS_REQUESTED', () => {
+      const generator = watchGetWeCrmAccounts();
+      expect(generator.next().value).toEqual(
+        takeLatest('app/CommonTestAndPreview/GET_WECRM_ACCOUNTS_REQUESTED', getWeCrmAccountsSaga)
+      );
+      expect(generator.next().done).toBe(true);
+    });
+  });
+
+  describe('getSenderDetailsSaga', () => {
+    it('should fetch sender details and put SUCCESS with parsed domains', () => {
+      const action = { payload: { channel: 'SMS', orgUnitId: 100 } };
+      const apiResponse = { entity: { SMS: [{ id: 1, domainProperties: {} }] } };
+      parseSenderDetailsResponse.mockReturnValue({ domains: [{ domainId: 1 }] });
+
+      const generator = getSenderDetailsSaga(action);
+
+      expect(generator.next().value).toEqual(call(Api.getSenderDetails, 'SMS', 100));
+      expect(generator.next(apiResponse).value).toEqual(
+        put({ type: GET_SENDER_DETAILS_SUCCESS, payload: { channel: 'SMS', domains: [{ domainId: 1 }] } })
+      );
+      expect(generator.next().done).toBe(true);
+    });
+
+    it('should use orgUnitId -1 when not provided', () => {
+      const action = { payload: { channel: 'EMAIL' } };
+      const apiResponse = { entity: { EMAIL: [] } };
+      parseSenderDetailsResponse.mockReturnValue({ domains: [] });
+
+      const generator = getSenderDetailsSaga(action);
+
+      expect(generator.next().value).toEqual(call(Api.getSenderDetails, 'EMAIL', -1));
+      generator.next(apiResponse);
+      expect(generator.next().done).toBe(true);
+    });
+
+    it('should return early when channel is missing', () => {
+      const action = { payload: {} };
+      const generator = getSenderDetailsSaga(action);
+      expect(generator.next().done).toBe(true);
+    });
+
+    it('should put FAILURE when response has errors', () => {
+      const action = { payload: { channel: 'SMS' } };
+      const apiResponse = { errors: [{ message: 'Forbidden' }] };
+
+      const generator = getSenderDetailsSaga(action);
+      generator.next();
+      expect(generator.next(apiResponse).value).toEqual(
+        put({
+          type: GET_SENDER_DETAILS_FAILURE,
+          payload: { channel: 'SMS', error: [{ message: 'Forbidden' }] },
+        })
+      );
+      expect(generator.next().done).toBe(true);
+    });
+
+    it('should put FAILURE on throw', () => {
+      const action = { payload: { channel: 'WHATSAPP' } };
+      const generator = getSenderDetailsSaga(action);
+      generator.next();
+      const err = generator.throw(new Error('Network error'));
+      expect(err.value).toEqual(
+        put({
+          type: GET_SENDER_DETAILS_FAILURE,
+          payload: { channel: 'WHATSAPP', error: 'Network error' },
+        })
+      );
+      expect(generator.next().done).toBe(true);
+    });
+  });
+
+  describe('getWeCrmAccountsSaga', () => {
+    it('should fetch wecrm accounts and put SUCCESS with list from response', () => {
+      const action = { payload: { sourceName: 'WHATSAPP' } };
+      const apiResult = { response: [{ name: 'WABA1', sourceAccountIdentifier: 'waba-1' }] };
+
+      const generator = getWeCrmAccountsSaga(action);
+
+      expect(generator.next().value).toEqual(call(Api.fetchWeCrmAccounts, 'WHATSAPP'));
+      expect(generator.next(apiResult).value).toEqual(
+        put({ type: GET_WECRM_ACCOUNTS_SUCCESS, payload: { accounts: [{ name: 'WABA1', sourceAccountIdentifier: 'waba-1' }] } })
+      );
+      expect(generator.next().done).toBe(true);
+    });
+
+    it('should use WHATSAPP when sourceName not provided', () => {
+      const action = { payload: {} };
+      const generator = getWeCrmAccountsSaga(action);
+      expect(generator.next().value).toEqual(call(Api.fetchWeCrmAccounts, 'WHATSAPP'));
+    });
+
+    it('should use entity when response not present', () => {
+      const action = { payload: {} };
+      const apiResult = { entity: [{ name: 'Acc1' }] };
+
+      const generator = getWeCrmAccountsSaga(action);
+      generator.next();
+      expect(generator.next(apiResult).value).toEqual(
+        put({ type: GET_WECRM_ACCOUNTS_SUCCESS, payload: { accounts: [{ name: 'Acc1' }] } })
+      );
+    });
+
+    it('should put empty array when result has no list', () => {
+      const action = { payload: {} };
+      const generator = getWeCrmAccountsSaga(action);
+      generator.next();
+      expect(generator.next({}).value).toEqual(
+        put({ type: GET_WECRM_ACCOUNTS_SUCCESS, payload: { accounts: [] } })
+      );
+    });
+
+    it('should put FAILURE on throw', () => {
+      const action = { payload: {} };
+      const generator = getWeCrmAccountsSaga(action);
+      generator.next();
+      const err = generator.throw(new Error('API failed'));
+      expect(err.value).toEqual(
+        put({ type: GET_WECRM_ACCOUNTS_FAILURE, payload: { error: 'API failed' } })
+      );
+      expect(generator.next().done).toBe(true);
+    });
   });
 
   describe('commonTestAndPreviewSaga', () => {
@@ -1710,6 +1853,8 @@ describe('CommonTestAndPreview Sagas', () => {
           watchFetchTestGroups(),
           watchCreateMessageMeta(),
           watchGetPrefilledValues(),
+          watchGetSenderDetails(),
+          watchGetWeCrmAccounts(),
         ])
       );