@capillarytech/creatives-library 8.0.291 → 8.0.292

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

@@ -0,0 +1,222 @@
+/**
+ * Tests for DeliverySettings component (sender ID / delivery settings summary + slidebox)
+ * @jest-environment jsdom
+ */
+
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import { IntlProvider } from 'react-intl';
+import DeliverySettings from '../../DeliverySettings';
+import { CHANNELS } from '../../constants';
+
+jest.mock('../../DeliverySettings/DeliverySettings.scss', () => ({}));
+
+jest.mock('@capillarytech/cap-ui-library', () => ({
+  CapRow: ({ children, className, ...rest }) => <div className={className} data-testid="cap-row" {...rest}>{children}</div>,
+  CapHeading: ({ children }) => <div data-testid="cap-heading">{children}</div>,
+  CapIcon: ({ onClick, className, 'data-testid': testId }) => <button type="button" onClick={onClick} className={className} data-testid={testId || 'cap-icon'} aria-label="edit" />,
+  CapLabel: ({ children, type }) => <span data-type={type}>{children}</span>,
+  CapSlideBox: ({ show, content, handleClose }) => (show ? (
+    <div data-testid="cap-slidebox">
+      <button type="button" onClick={handleClose} data-testid="slidebox-close">Close</button>
+      {content}
+    </div>
+  ) : null),
+}));
+
+const mockModifyDeliverySettings = jest.fn();
+jest.mock('../../DeliverySettings/ModifyDeliverySettings', () => function MockModifyDeliverySettings(props) {
+  mockModifyDeliverySettings(props);
+  return (
+    <div data-testid="modify-delivery-settings">
+      <button type="button" onClick={() => props.onSaveDeliverySettings({ domainId: 1 })} data-testid="modify-done">Done</button>
+      <button type="button" onClick={props.onClose} data-testid="modify-close">Cancel</button>
+    </div>
+  );
+});
+
+const defaultFormatMessage = (msg) => msg?.defaultMessage || msg?.id || '';
+
+describe('DeliverySettings', () => {
+  const defaultProps = {
+    channel: CHANNELS.SMS,
+    deliverySettings: {},
+    senderDetailsOptions: [],
+    wecrmAccounts: [],
+    onSaveDeliverySettings: jest.fn(),
+    isLoadingSenderDetails: false,
+    formatMessage: defaultFormatMessage,
+    smsTraiDltEnabled: false,
+    registeredSenderIds: [],
+    whatsappAccountFromForm: undefined,
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('channel visibility', () => {
+    it('should return null when channel is not in CHANNELS_WITH_DELIVERY_SETTINGS', () => {
+      const { container } = render(
+        <DeliverySettings {...defaultProps} channel="INAPP" />
+      );
+      expect(container.firstChild).toBeNull();
+    });
+
+    it('should render when channel is SMS', () => {
+      render(<DeliverySettings {...defaultProps} channel={CHANNELS.SMS} />);
+      expect(screen.getByTestId('cap-heading')).toBeTruthy();
+    });
+
+    it('should render when channel is EMAIL', () => {
+      render(<DeliverySettings {...defaultProps} channel={CHANNELS.EMAIL} />);
+      expect(screen.getByTestId('cap-heading')).toBeTruthy();
+    });
+
+    it('should render when channel is WHATSAPP', () => {
+      render(<DeliverySettings {...defaultProps} channel={CHANNELS.WHATSAPP} />);
+      expect(screen.getByTestId('cap-heading')).toBeTruthy();
+    });
+  });
+
+  describe('summary display', () => {
+    it('should show not configured when no delivery values for SMS', () => {
+      render(<DeliverySettings {...defaultProps} channel={CHANNELS.SMS} />);
+      expect(screen.getByText('Not configured')).toBeTruthy();
+    });
+
+    it('should show summary values for SMS when deliverySettings and senderDetailsOptions match', () => {
+      const senderDetailsOptions = [{ domainId: 1, domainName: 'SMS Domain' }];
+      const deliverySettings = { domainId: 1, gsmSenderId: 'SENDER1' };
+      render(
+        <DeliverySettings
+          {...defaultProps}
+          channel={CHANNELS.SMS}
+          deliverySettings={deliverySettings}
+          senderDetailsOptions={senderDetailsOptions}
+        />
+      );
+      expect(screen.getAllByText(/SMS Domain/).length).toBeGreaterThan(0);
+      expect(screen.getAllByText(/SENDER1/).length).toBeGreaterThan(0);
+    });
+
+    it('should show not configured for EMAIL when empty', () => {
+      render(<DeliverySettings {...defaultProps} channel={CHANNELS.EMAIL} />);
+      expect(screen.getByText('Not configured')).toBeTruthy();
+    });
+
+    it('should show summary for EMAIL when has domain and sender', () => {
+      const senderDetailsOptions = [{ domainId: 2, domainName: 'Email Domain' }];
+      const deliverySettings = {
+        domainId: 2,
+        senderEmail: 'noreply@test.com',
+        senderLabel: 'Test',
+        senderReplyTo: 'reply@test.com',
+      };
+      render(
+        <DeliverySettings
+          {...defaultProps}
+          channel={CHANNELS.EMAIL}
+          deliverySettings={deliverySettings}
+          senderDetailsOptions={senderDetailsOptions}
+        />
+      );
+      expect(screen.getAllByText(/Email Domain/).length).toBeGreaterThan(0);
+      expect(screen.getAllByText(/noreply@test\.com/).length).toBeGreaterThan(0);
+    });
+
+    it('should show summary for WHATSAPP when has account and sender', () => {
+      const wecrmAccounts = [{ name: 'WABA One', sourceAccountIdentifier: 'waba-1' }];
+      const deliverySettings = {
+        sourceAccountIdentifier: 'waba-1',
+        senderMobNum: '+1234567890',
+      };
+      render(
+        <DeliverySettings
+          {...defaultProps}
+          channel={CHANNELS.WHATSAPP}
+          deliverySettings={deliverySettings}
+          wecrmAccounts={wecrmAccounts}
+        />
+      );
+      expect(screen.getAllByText(/WABA One/).length).toBeGreaterThan(0);
+      expect(screen.getAllByText(/\+1234567890/).length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('edit and slidebox', () => {
+    it('should open slidebox when edit icon is clicked', () => {
+      render(<DeliverySettings {...defaultProps} channel={CHANNELS.SMS} />);
+      expect(screen.queryByTestId('cap-slidebox')).toBeNull();
+      fireEvent.click(screen.getByTestId('delivery-settings-edit'));
+      expect(screen.getByTestId('cap-slidebox')).toBeTruthy();
+      expect(screen.getByTestId('modify-delivery-settings')).toBeTruthy();
+    });
+
+    it('should pass correct props to ModifyDeliverySettings', () => {
+      render(<DeliverySettings {...defaultProps} channel={CHANNELS.SMS} />);
+      fireEvent.click(screen.getByTestId('delivery-settings-edit'));
+      expect(mockModifyDeliverySettings).toHaveBeenCalledWith(
+        expect.objectContaining({
+          channel: CHANNELS.SMS,
+          deliverySettings: {},
+          senderDetailsOptions: [],
+          wecrmAccounts: [],
+          isLoading: false,
+          smsTraiDltEnabled: false,
+          registeredSenderIds: [],
+          whatsappAccountFromForm: undefined,
+        })
+      );
+    });
+
+    it('should call onSaveDeliverySettings and close slidebox when Done is clicked', () => {
+      const onSave = jest.fn();
+      render(
+        <DeliverySettings
+          {...defaultProps}
+          channel={CHANNELS.SMS}
+          onSaveDeliverySettings={onSave}
+        />
+      );
+      fireEvent.click(screen.getByTestId('delivery-settings-edit'));
+      fireEvent.click(screen.getByTestId('modify-done'));
+      expect(onSave).toHaveBeenCalledWith({ domainId: 1 });
+      expect(screen.queryByTestId('cap-slidebox')).toBeNull();
+    });
+
+    it('should pass whatsappAccountFromForm to ModifyDeliverySettings', () => {
+      render(
+        <DeliverySettings
+          {...defaultProps}
+          channel={CHANNELS.WHATSAPP}
+          whatsappAccountFromForm={{ accountName: 'My WABA' }}
+        />
+      );
+      fireEvent.click(screen.getByTestId('delivery-settings-edit'));
+      expect(mockModifyDeliverySettings).toHaveBeenCalledWith(
+        expect.objectContaining({
+          whatsappAccountFromForm: { accountName: 'My WABA' },
+        })
+      );
+    });
+
+    it('should pass SMS TRAI props to ModifyDeliverySettings', () => {
+      render(
+        <DeliverySettings
+          {...defaultProps}
+          channel={CHANNELS.SMS}
+          smsTraiDltEnabled
+          registeredSenderIds={['HPCLTD']}
+        />
+      );
+      fireEvent.click(screen.getByTestId('delivery-settings-edit'));
+      expect(mockModifyDeliverySettings).toHaveBeenCalledWith(
+        expect.objectContaining({
+          smsTraiDltEnabled: true,
+          registeredSenderIds: ['HPCLTD'],
+        })
+      );
+    });
+  });
+});

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

@@ -0,0 +1,235 @@
+/**
+ * Tests for parseSenderDetailsResponse
+ * Covers sender ID / delivery settings response parsing for SMS, EMAIL, WHATSAPP
+ */
+
+import { parseSenderDetailsResponse } from '../../../DeliverySettings/utils/parseSenderDetailsResponse';
+
+describe('parseSenderDetailsResponse', () => {
+  describe('when entity is missing or null', () => {
+    it('should return empty domains when response is null', () => {
+      expect(parseSenderDetailsResponse('SMS', null)).toEqual({ domains: [] });
+    });
+
+    it('should return empty domains when response is undefined', () => {
+      expect(parseSenderDetailsResponse('SMS', undefined)).toEqual({ domains: [] });
+    });
+
+    it('should return empty domains when entity is missing', () => {
+      expect(parseSenderDetailsResponse('SMS', {})).toEqual({ domains: [] });
+    });
+  });
+
+  describe('when entity is object with channel key', () => {
+    it('should parse SMS channel entity array', () => {
+      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]).toMatchObject({
+        dgmId: 10,
+        domainName: 'SMS Domain 1',
+        domainId: 100,
+        priority: 1,
+      });
+      expect(result.domains[0].gsmSenders).toHaveLength(1);
+      expect(result.domains[0].gsmSenders[0].value).toBe('GSM1');
+      expect(result.domains[0].cdmaSenders).toHaveLength(1);
+      expect(result.domains[0].cdmaSenders[0].value).toBe('CDMA1');
+    });
+
+    it('should parse EMAIL channel entity array', () => {
+      const response = {
+        entity: {
+          EMAIL: [
+            {
+              id: 20,
+              priority: 0,
+              domainProperties: {
+                domainName: 'Email Domain',
+                id: 200,
+                contactInfo: [
+                  { type: 'sender_id', valid: true, value: 'noreply@example.com' },
+                  { type: 'reply_to_id', valid: true, value: 'reply@example.com' },
+                ],
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('EMAIL', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0]).toMatchObject({
+        dgmId: 20,
+        domainName: 'Email Domain',
+        domainId: 200,
+        priority: 0,
+      });
+      expect(result.domains[0].emailSenders).toHaveLength(1);
+      expect(result.domains[0].emailSenders[0].value).toBe('noreply@example.com');
+      expect(result.domains[0].emailRepliers).toHaveLength(1);
+      expect(result.domains[0].emailRepliers[0].value).toBe('reply@example.com');
+    });
+
+    it('should parse WHATSAPP channel with sourceAccountIdentifier', () => {
+      const response = {
+        entity: {
+          WHATSAPP: [
+            {
+              id: 30,
+              priority: 0,
+              domainProperties: {
+                domainName: 'WABA Domain',
+                id: 300,
+                contactInfo: [],
+                connectionProperties: {
+                  sourceAccountIdentifier: 'waba-123',
+                },
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('WHATSAPP', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0].sourceAccountIdentifier).toBe('waba-123');
+      expect(result.domains[0].gsmSenders).toEqual([]);
+      expect(result.domains[0].cdmaSenders).toEqual([]);
+    });
+  });
+
+  describe('when entity is direct array', () => {
+    it('should use entity as channelSenderDetails when entity is array', () => {
+      const response = {
+        entity: [
+          {
+            id: 1,
+            priority: 0,
+            domainProperties: { domainName: 'Direct Domain', id: 1 },
+          },
+        ],
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0].domainName).toBe('Direct Domain');
+    });
+  });
+
+  describe('filtering and sorting', () => {
+    it('should filter contactInfo by type and valid', () => {
+      const response = {
+        entity: {
+          SMS: [
+            {
+              id: 1,
+              priority: 0,
+              domainProperties: {
+                domainName: 'D1',
+                id: 1,
+                contactInfo: [
+                  { type: 'gsm_sender_id', valid: true, value: 'A' },
+                  { type: 'gsm_sender_id', valid: false, value: 'B' },
+                  { type: 'other', valid: true, value: 'C' },
+                ],
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains[0].gsmSenders).toHaveLength(1);
+      expect(result.domains[0].gsmSenders[0].value).toBe('A');
+    });
+
+    it('should sort domains by priority', () => {
+      const response = {
+        entity: {
+          SMS: [
+            { id: 1, priority: 2, domainProperties: { domainName: 'Second', id: 1 } },
+            { id: 2, priority: 0, domainProperties: { domainName: 'First', id: 2 } },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains[0].domainName).toBe('First');
+      expect(result.domains[1].domainName).toBe('Second');
+    });
+
+    it('should dedupe by domainName keeping first occurrence', () => {
+      const response = {
+        entity: {
+          SMS: [
+            { id: 1, priority: 0, domainProperties: { domainName: 'Same', id: 1 } },
+            { id: 2, priority: 1, domainProperties: { domainName: 'Same', id: 2 } },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0].domainId).toBe(1);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should return empty domains when channel key has no array', () => {
+      const response = { entity: { SMS: null } };
+      expect(parseSenderDetailsResponse('SMS', response)).toEqual({ domains: [] });
+    });
+
+    it('should return empty domains when channel key is missing and entity is not array', () => {
+      const response = { entity: { EMAIL: [] } };
+      expect(parseSenderDetailsResponse('SMS', response)).toEqual({ domains: [] });
+    });
+
+    it('should handle missing domainProperties with defaults', () => {
+      const response = {
+        entity: {
+          SMS: [{ id: 1, priority: 0 }],
+        },
+      };
+      const result = parseSenderDetailsResponse('SMS', response);
+      expect(result.domains).toHaveLength(1);
+      expect(result.domains[0].domainId).toBe(-1);
+      expect(result.domains[0].domainName).toBeUndefined();
+      expect(result.domains[0].gsmSenders).toEqual([]);
+      expect(result.domains[0].cdmaSenders).toEqual([]);
+    });
+
+    it('should use wabaId when sourceAccountIdentifier missing for WHATSAPP', () => {
+      const response = {
+        entity: {
+          WHATSAPP: [
+            {
+              id: 1,
+              priority: 0,
+              domainProperties: {
+                domainName: 'W',
+                id: 1,
+                connectionProperties: { wabaId: 'waba-456' },
+              },
+            },
+          ],
+        },
+      };
+      const result = parseSenderDetailsResponse('WHATSAPP', response);
+      expect(result.domains[0].sourceAccountIdentifier).toBe('waba-456');
+    });
+  });
+});

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

@@ -2,6 +2,7 @@
  * Tests for SendTestMessage Component
  *
  * Tests the component that handles sending test messages
+ * @jest-environment jsdom
  */
 
 import React from 'react';
@@ -11,8 +12,34 @@ import {
 import { IntlProvider } from 'react-intl';
 import PropTypes from 'prop-types';
 import isEmpty from 'lodash/isEmpty';
+// Mock cap-ui-library so SendTestMessage can load (Jest hoists mocks)
+jest.mock('@capillarytech/cap-ui-library/CapRow', () => ({ children, ...rest }) => <div {...rest}>{children}</div>);
+jest.mock('@capillarytech/cap-ui-library/CapButton', () => ({ children, ...rest }) => <button type="button" {...rest}>{children}</button>);
+jest.mock('@capillarytech/cap-ui-library/CapHeader', () => ({ title, description }) => <div><span>{title}</span>{description}</div>);
+jest.mock('@capillarytech/cap-ui-library/CapTreeSelect', () => ({ treeData, onChange, value, placeholder }) => (
+  <div data-testid="cap-tree-select"><input onChange={(e) => onChange && onChange(e.target.value)} placeholder={placeholder} /></div>
+));
+
 import SendTestMessage from '../SendTestMessage';
 
+// Mock DeliverySettings to assert props
+jest.mock('../DeliverySettings', () => function MockDeliverySettings(props) {
+  return (
+    <div data-testid="delivery-settings" data-props={JSON.stringify({
+      channel: props.channel,
+      hasDeliverySettings: !!props.deliverySettings,
+      senderDetailsLength: (props.senderDetailsOptions || []).length,
+      wecrmAccountsLength: (props.wecrmAccounts || []).length,
+      hasOnSave: typeof props.onSaveDeliverySettings === 'function',
+      isLoadingSenderDetails: props.isLoadingSenderDetails,
+      smsTraiDltEnabled: props.smsTraiDltEnabled,
+      registeredSenderIds: props.registeredSenderIds,
+      whatsappAccountFromForm: props.whatsappAccountFromForm,
+    })}
+    />
+  );
+});
+
 // Mock CapStepsAccordian to always render content expanded
 jest.mock('@capillarytech/cap-ui-library/CapStepsAccordian', () => {
   // eslint-disable-next-line global-require, import/no-extraneous-dependencies
@@ -100,6 +127,14 @@ describe('SendTestMessage', () => {
     },
     isSendingTestMessage: false,
     formatMessage: jest.fn((msg) => msg.defaultMessage || msg.id),
+    channel: 'EMAIL',
+    deliverySettings: {},
+    senderDetailsOptions: [],
+    wecrmAccounts: [],
+    onSaveDeliverySettings: jest.fn(),
+    isLoadingSenderDetails: false,
+    smsTraiDltEnabled: false,
+    registeredSenderIds: [],
   };
 
   beforeEach(() => {
@@ -162,6 +197,106 @@ describe('SendTestMessage', () => {
     });
   });
 
+  describe('DeliverySettings (sender ID / delivery settings)', () => {
+    it('should render DeliverySettings when channel is SMS', () => {
+      render(
+        <TestWrapper>
+          <SendTestMessage {...defaultProps} channel="SMS" />
+        </TestWrapper>
+      );
+      const el = screen.getByTestId('delivery-settings');
+      expect(el).toBeTruthy();
+      const data = JSON.parse(el.getAttribute('data-props'));
+      expect(data.channel).toBe('SMS');
+      expect(data.hasOnSave).toBe(true);
+    });
+
+    it('should render DeliverySettings when channel is EMAIL', () => {
+      render(
+        <TestWrapper>
+          <SendTestMessage {...defaultProps} channel="EMAIL" />
+        </TestWrapper>
+      );
+      expect(screen.getByTestId('delivery-settings')).toBeTruthy();
+    });
+
+    it('should render DeliverySettings when channel is WHATSAPP', () => {
+      render(
+        <TestWrapper>
+          <SendTestMessage {...defaultProps} channel="WHATSAPP" />
+        </TestWrapper>
+      );
+      expect(screen.getByTestId('delivery-settings')).toBeTruthy();
+    });
+
+    it('should not render DeliverySettings when channel is INAPP', () => {
+      render(
+        <TestWrapper>
+          <SendTestMessage {...defaultProps} channel="INAPP" />
+        </TestWrapper>
+      );
+      expect(screen.queryByTestId('delivery-settings')).toBeNull();
+    });
+
+    it('should pass whatsappAccountFromForm when channel is WHATSAPP and formData has accountName', () => {
+      render(
+        <TestWrapper>
+          <SendTestMessage
+            {...defaultProps}
+            channel="WHATSAPP"
+            formData={{ ...defaultProps.formData, accountName: 'My WABA' }}
+          />
+        </TestWrapper>
+      );
+      const el = screen.getByTestId('delivery-settings');
+      const data = JSON.parse(el.getAttribute('data-props'));
+      expect(data.whatsappAccountFromForm).toEqual({ accountName: 'My WABA' });
+    });
+
+    it('should pass whatsappAccountFromForm undefined when channel is WHATSAPP and formData has no accountName', () => {
+      render(
+        <TestWrapper>
+          <SendTestMessage
+            {...defaultProps}
+            channel="WHATSAPP"
+            formData={{ ...defaultProps.formData, accountName: undefined }}
+          />
+        </TestWrapper>
+      );
+      const el = screen.getByTestId('delivery-settings');
+      const data = JSON.parse(el.getAttribute('data-props'));
+      expect(data.whatsappAccountFromForm).toBeUndefined();
+    });
+
+    it('should pass delivery props to DeliverySettings', () => {
+      const onSave = jest.fn();
+      render(
+        <TestWrapper>
+          <SendTestMessage
+            {...defaultProps}
+            channel="SMS"
+            deliverySettings={{ domainId: 1 }}
+            senderDetailsOptions={[{ domainId: 1, domainName: 'SMS Dom' }]}
+            wecrmAccounts={[]}
+            onSaveDeliverySettings={onSave}
+            isLoadingSenderDetails={true}
+            smsTraiDltEnabled
+            registeredSenderIds={['ID1']}
+          />
+        </TestWrapper>
+      );
+      const el = screen.getByTestId('delivery-settings');
+      const data = JSON.parse(el.getAttribute('data-props'));
+      expect(data.hasDeliverySettings).toBe(true);
+      expect(data.senderDetailsLength).toBe(1);
+      expect(data.wecrmAccountsLength).toBe(0);
+      expect(data.hasOnSave).toBe(true);
+      expect(data.isLoadingSenderDetails).toBe(true);
+      expect(data.smsTraiDltEnabled).toBe(true);
+      expect(data.registeredSenderIds).toEqual(['ID1']);
+    });
+  });
+
   describe('Loading States', () => {
     it('should show loading when fetching test customers', () => {
       const props = {

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

@@ -17,6 +17,8 @@ import {
   getPrefilledValuesRequested,
   clearPrefilledValues,
   clearPreviewErrors,
+  getSenderDetailsRequested,
+  getWeCrmAccountsRequested,
 } from '../actions';
 
 import {
@@ -32,6 +34,8 @@ import {
   GET_PREFILLED_VALUES_REQUESTED,
   CLEAR_PREFILLED_VALUES,
   CLEAR_PREVIEW_ERRORS,
+  GET_SENDER_DETAILS_REQUESTED,
+  GET_WECRM_ACCOUNTS_REQUESTED,
 } from '../constants';
 
 describe('CommonTestAndPreview Actions', () => {
@@ -321,4 +325,50 @@ describe('CommonTestAndPreview Actions', () => {
       expect(clearPreviewErrors()).toEqual(expectedAction);
     });
   });
+
+  describe('getSenderDetailsRequested', () => {
+    it('should create an action to request sender details with channel and orgUnitId', () => {
+      const payload = { channel: 'SMS', orgUnitId: 123 };
+      const expectedAction = {
+        type: GET_SENDER_DETAILS_REQUESTED,
+        payload,
+      };
+      expect(getSenderDetailsRequested(payload)).toEqual(expectedAction);
+    });
+
+    it('should handle EMAIL channel', () => {
+      const payload = { channel: 'EMAIL', orgUnitId: -1 };
+      expect(getSenderDetailsRequested(payload)).toEqual({
+        type: GET_SENDER_DETAILS_REQUESTED,
+        payload,
+      });
+    });
+
+    it('should handle WHATSAPP channel', () => {
+      const payload = { channel: 'WHATSAPP', orgUnitId: 456 };
+      expect(getSenderDetailsRequested(payload)).toEqual({
+        type: GET_SENDER_DETAILS_REQUESTED,
+        payload,
+      });
+    });
+  });
+
+  describe('getWeCrmAccountsRequested', () => {
+    it('should create an action to request WeCRM accounts with sourceName', () => {
+      const payload = { sourceName: 'WHATSAPP' };
+      const expectedAction = {
+        type: GET_WECRM_ACCOUNTS_REQUESTED,
+        payload,
+      };
+      expect(getWeCrmAccountsRequested(payload)).toEqual(expectedAction);
+    });
+
+    it('should handle empty payload', () => {
+      const payload = {};
+      expect(getWeCrmAccountsRequested(payload)).toEqual({
+        type: GET_WECRM_ACCOUNTS_REQUESTED,
+        payload: {},
+      });
+    });
+  });
 });