@capillarytech/creatives-library 9.0.13 → 9.0.14

package/v2Containers/CommunicationFlow/Tests/CommunicationFlow.test.js

@@ -1,5 +1,10 @@
 import React from 'react';
 
+jest.mock('../../../services/api', () => ({
+  createCentralCommsMetaId: jest.fn(),
+  getCentralCommsMetaIds: jest.fn(),
+}));
+
 jest.mock('../../CreativesContainer', () => function MockCreativesContainer({
   getCreativesData,
   handleCloseCreatives,
@@ -33,6 +38,7 @@ import { IntlProvider } from 'react-intl';
 import history from '../../../utils/history';
 import { initialReducer } from '../../../initialReducer';
 import CommunicationFlow from '../CommunicationFlow';
+import { createCentralCommsMetaId, getCentralCommsMetaIds } from '../../../services/api';
 import { getEnabledSteps } from '../utils/getEnabledSteps';
 import {
   CHANNELS,
@@ -87,7 +93,8 @@ const FEATURES = {
   strategyContentDynamic: {
     communicationStrategyData: { required: true, options: STRATEGY_OPTIONS, disabled: false },
     contentTemplateData: { required: true, channels: CHANNELS },
-    dynamicControlsData: { required: true, controls: DYNAMIC_CONTROLS },
+    showDynamicControls: true,
+    dynamicControlsData: { controls: DYNAMIC_CONTROLS },
   },
 };
 
@@ -212,7 +219,7 @@ describe('CommunicationFlow', () => {
 
     await selectCommunicationStrategy('Single template');
 
-    await userEvent.click(screen.getByRole('button', { name: /content template/i }));
+    await userEvent.click(screen.getByRole('button', { name: /add creative/i }));
     await waitFor(() => expect(screen.getByRole('menu')).toBeInTheDocument());
     await userEvent.click(within(screen.getByRole('menu')).getByText('SMS'));
 
@@ -257,4 +264,364 @@ describe('CommunicationFlow', () => {
     });
     expect(screen.getByRole('radio', { name: /transactional/i })).toBeChecked();
   });
+
+  it('initializes messageType from messageTypeData.defaultOption.value when initialData absent', () => {
+    renderWithFlow({
+      features: {
+        messageTypeData: {
+          required: true,
+          options: MESSAGE_OPTIONS,
+          defaultOption: { value: 'transactional', label: 'Transactional' },
+        },
+      },
+    });
+    expect(screen.getByRole('radio', { name: /transactional/i })).toBeChecked();
+  });
+});
+
+describe('isSaveDisabled', () => {
+  it('is false with empty features — Save button is enabled', () => {
+    renderWithFlow({ features: {} });
+    expect(screen.getByRole('button', { name: /^save$/i })).not.toBeDisabled();
+  });
+
+  it('is true when communicationStrategy required and not yet selected', () => {
+    renderWithFlow({ features: FEATURES.strategyContent });
+    expect(screen.getByRole('button', { name: /^save$/i })).toBeDisabled();
+  });
+
+  it('is true when channel selection required, single-channel, and contentItems empty', () => {
+    renderWithFlow({
+      features: FEATURES.strategyContent,
+      initialData: { communicationStrategy: SINGLE_TEMPLATE, contentItems: [] },
+    });
+    expect(screen.getByRole('button', { name: /^save$/i })).toBeDisabled();
+  });
+
+  it('is false for multi-channel strategy even without content items', () => {
+    renderWithFlow({
+      features: FEATURES.strategyContent,
+      initialData: { communicationStrategy: CHANNEL_PRIORITY, contentItems: [] },
+    });
+    expect(screen.getByRole('button', { name: /^save$/i })).not.toBeDisabled();
+  });
+
+  it('is true when delivery settings enabled and a channel is missing sender details', () => {
+    renderWithFlow({
+      features: {
+        communicationStrategyData: { required: true, options: STRATEGY_OPTIONS },
+        contentTemplateData: { required: true, channels: CHANNELS },
+        deliverySettingsData: {},
+      },
+      initialData: {
+        communicationStrategy: SINGLE_TEMPLATE,
+        contentItems: [{ channel: 'SMS', templateData: {} }],
+        deliverySetting: {},
+      },
+    });
+    expect(screen.getByRole('button', { name: /^save$/i })).toBeDisabled();
+  });
+
+  it('is false when delivery settings enabled and all channels have sender details', () => {
+    renderWithFlow({
+      features: {
+        communicationStrategyData: { required: true, options: STRATEGY_OPTIONS },
+        contentTemplateData: { required: true, channels: CHANNELS },
+        deliverySettingsData: {},
+      },
+      initialData: {
+        communicationStrategy: SINGLE_TEMPLATE,
+        contentItems: [{ channel: 'SMS', templateData: {} }],
+        deliverySetting: { channelSetting: { SMS: { gsmSenderId: 'CAPS_SENDER' } } },
+      },
+    });
+    expect(screen.getByRole('button', { name: /^save$/i })).not.toBeDisabled();
+  });
+
+  it('skips delivery check for CHANNELS_WITHOUT_DELIVERY (e.g. MOBILEPUSH)', () => {
+    renderWithFlow({
+      features: {
+        communicationStrategyData: { required: true, options: STRATEGY_OPTIONS },
+        contentTemplateData: { required: true, channels: CHANNELS },
+        deliverySettingsData: {},
+      },
+      initialData: {
+        communicationStrategy: SINGLE_TEMPLATE,
+        contentItems: [{ channel: 'MOBILEPUSH', templateData: {} }],
+        deliverySetting: {},
+      },
+    });
+    expect(screen.getByRole('button', { name: /^save$/i })).not.toBeDisabled();
+  });
+});
+
+describe('handleSave — CCS flow', () => {
+  beforeEach(() => {
+    createCentralCommsMetaId.mockResolvedValue({ response: { data: { id: 'meta-123' } } });
+    getCentralCommsMetaIds.mockResolvedValue({ response: { data: {} } });
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('calls createCentralCommsMetaId for each content item when useCCS is not false', async () => {
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      initialData: {
+        contentItems: [{ channel: 'sms', templateData: { smsBody: 'Hello' } }],
+      },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalledTimes(1));
+    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
+      expect.objectContaining({
+        centralCommsPayload: expect.objectContaining({ channel: 'SMS', module: 'CAMPAIGNS' }),
+      }),
+    );
+    expect(onSave).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls getCentralCommsMetaIds when metaIds are returned from createCentralCommsMetaId', async () => {
+    renderWithFlow({
+      features: {},
+      initialData: { contentItems: [{ channel: 'EMAIL', templateData: {} }] },
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(getCentralCommsMetaIds).toHaveBeenCalledWith('meta-123'));
+  });
+
+  it('skips getCentralCommsMetaIds when response contains no id', async () => {
+    createCentralCommsMetaId.mockResolvedValue({ response: { data: {} } });
+    renderWithFlow({
+      features: {},
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
+    expect(getCentralCommsMetaIds).not.toHaveBeenCalled();
+  });
+
+  it('uses ouId and module from config.context when provided', async () => {
+    renderWithFlow({
+      features: {},
+      config: { ...baseConfig, context: { ouId: 42, module: 'LOYALTY' }, features: {} },
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
+    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
+      expect.objectContaining({
+        centralCommsPayload: expect.objectContaining({ ouId: 42, module: 'LOYALTY' }),
+      }),
+    );
+  });
+
+  it('skips CCS entirely when useCCS is false', async () => {
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      config: { ...baseConfig, useCCS: false, features: {} },
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(createCentralCommsMetaId).not.toHaveBeenCalled();
+  });
+
+  it('still calls onSave when createCentralCommsMetaId rejects', async () => {
+    createCentralCommsMetaId.mockRejectedValue(new Error('Network error'));
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+  });
+
+  it('skips createCentralCommsMetaId when contentItems is empty', async () => {
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      initialData: { contentItems: [] },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(createCentralCommsMetaId).not.toHaveBeenCalled();
+  });
+
+  it('includes additionalSettings derived from dynamicControls in the payload', async () => {
+    renderWithFlow({
+      features: {},
+      initialData: {
+        contentItems: [{ channel: 'SMS', templateData: {} }],
+        dynamicControls: {
+          useTinyUrl: true,
+          sendToControlCustomers: true,
+          overrideDailyLimit: true,
+          sendToBrandPocs: true,
+        },
+      },
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
+    const payload = createCentralCommsMetaId.mock.calls[0][0];
+    expect(payload.centralCommsPayload.smsDeliverySettings.additionalSettings).toEqual({
+      useTinyUrl: true,
+      encryptUrl: true,
+      linkTrackingEnabled: true,
+      userSubscriptionDisabled: true,
+    });
+  });
+});
+
+describe('renderSteps — null returns and edge cases', () => {
+  it('returns null for CHANNEL_SELECTION when communicationStrategy is null', () => {
+    renderWithFlow({
+      features: {
+        communicationStrategyData: { required: true, options: STRATEGY_OPTIONS },
+        contentTemplateData: { required: true, channels: CHANNELS },
+      },
+    });
+    expect(screen.queryByText(/content template/i)).not.toBeInTheDocument();
+  });
+
+  it('returns null for DYNAMIC_CONTROLS when communicationStrategy is null', () => {
+    renderWithFlow({ features: FEATURES.strategyContentDynamic });
+    expect(screen.queryByText(/other controls/i)).not.toBeInTheDocument();
+  });
+
+  it('does not render the Save footer when onSave is not provided', () => {
+    renderFlow(
+      <CommunicationFlow
+        config={baseConfig}
+        onCancel={jest.fn()}
+        capData={{}}
+      />,
+    );
+    expect(screen.queryByRole('button', { name: /^save$/i })).not.toBeInTheDocument();
+  });
+
+  it('passes cap prop to ChannelSelectionStep over capData when both provided', async () => {
+    const capOverride = { orgId: 999 };
+    renderWithFlow({
+      features: FEATURES.strategyContent,
+      initialData: { communicationStrategy: SINGLE_TEMPLATE },
+      cap: capOverride,
+    });
+    // Renders without crash and channel step is visible after strategy selection
+    expect(screen.queryByText(/communication strategy/i)).toBeInTheDocument();
+  });
+
+  it('renders DYNAMIC_CONTROLS step after communicationStrategy is selected', async () => {
+    renderWithFlow({ features: FEATURES.strategyContentDynamic });
+    await selectCommunicationStrategy('Single template');
+    await waitFor(() => {
+      expect(screen.getByText(/other controls/i)).toBeInTheDocument();
+    });
+  });
+});
+
+describe('optional chaining safety', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('defaults ouId to -1 when config.context is absent', async () => {
+    createCentralCommsMetaId.mockResolvedValue({ response: { data: { id: 'x' } } });
+    renderWithFlow({
+      features: {},
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
+    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
+      expect.objectContaining({
+        centralCommsPayload: expect.objectContaining({ ouId: -1 }),
+      }),
+    );
+  });
+
+  it('defaults module to consumer.toUpperCase() when config.context.module absent', async () => {
+    createCentralCommsMetaId.mockResolvedValue({ response: { data: { id: 'x' } } });
+    renderWithFlow({
+      features: {},
+      config: { ...baseConfig, consumer: 'loyalty', features: {} },
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
+    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
+      expect.objectContaining({
+        centralCommsPayload: expect.objectContaining({ module: 'LOYALTY' }),
+      }),
+    );
+  });
+
+  it('initializes channel from config.channel when initialData.channel is absent', () => {
+    renderWithFlow({
+      features: {},
+      config: { ...baseConfig, channel: 'EMAIL', features: {} },
+      initialData: {},
+    });
+    expect(screen.getByRole('button', { name: /^save$/i })).toBeInTheDocument();
+  });
+
+  it('renders without crash when config.features is absent', () => {
+    renderWithFlow({ config: { ...baseConfig, features: undefined } });
+    expect(screen.getByRole('button', { name: /^save$/i })).toBeInTheDocument();
+  });
+
+  it('handles onChange being null without crashing on step data change', async () => {
+    renderWithFlow({
+      features: FEATURES.messageType,
+      onChange: null,
+    });
+    await expect(
+      userEvent.click(screen.getByRole('radio', { name: /transactional/i })),
+    ).resolves.not.toThrow();
+  });
+
+  it('handles deliverySetting?.channelSetting absent without crashing in isSaveDisabled', () => {
+    renderWithFlow({
+      features: {
+        communicationStrategyData: { required: true, options: STRATEGY_OPTIONS },
+        contentTemplateData: { required: true, channels: CHANNELS },
+        deliverySettingsData: {},
+      },
+      initialData: {
+        communicationStrategy: SINGLE_TEMPLATE,
+        contentItems: [{ channel: 'SMS', templateData: {} }],
+        deliverySetting: null,
+      },
+    });
+    // Missing deliverySetting → channelSetting defaults to {} → SMS missing → disabled
+    expect(screen.getByRole('button', { name: /^save$/i })).toBeDisabled();
+  });
 });