@capillarytech/creatives-library 9.0.14-beta.0 → 9.0.14

package/v2Containers/CommunicationFlow/CommunicationFlowCard.js

@@ -0,0 +1,240 @@
+/**
+ * CommunicationFlowCard
+ *
+ * Card-based entry point for CommunicationFlow.
+ * - Empty state: shows an "Add" button that opens CommunicationFlow in a CapSlideBox (create mode)
+ * - Configured state: shows a two-column CapCard with pen icon, channel preview (left), dynamic controls (right)
+ */
+
+import React, { useState, useCallback } from 'react';
+import PropTypes from 'prop-types';
+import { injectIntl } from 'react-intl';
+import { CAP_G09 } from '@capillarytech/cap-ui-library/styled/variables';
+import CapButton from '@capillarytech/cap-ui-library/CapButton';
+import CapCard from '@capillarytech/cap-ui-library/CapCard';
+import CapColumn from '@capillarytech/cap-ui-library/CapColumn';
+import CapImage from '@capillarytech/cap-ui-library/CapImage';
+import CapRow from '@capillarytech/cap-ui-library/CapRow';
+import CapIcon from '@capillarytech/cap-ui-library/CapIcon';
+import CapLabel from '@capillarytech/cap-ui-library/CapLabel';
+import CapHeader from '@capillarytech/cap-ui-library/CapHeader';
+import CapSlideBox from '@capillarytech/cap-ui-library/CapSlideBox';
+import CommunicationFlow from './index';
+import { CHANNELS, DEFAULT_COMMUNICATION_STRATEGY_OPTIONS, DYNAMIC_CONTROLS_CONFIG } from './constants';
+import {
+  VIBER, SMS, EMAIL, WHATSAPP, RCS, ZALO,
+} from '../CreativesContainer/constants';
+import getContentBody from './utils/getContentBody';
+import messages from './messages';
+import addCreativesIllustration from '../Assets/images/addCreativesIllustration.svg';
+import './CommunicationFlow.scss';
+
+const resolveValue = (val) => {
+  if (val == null || val === '') return null;
+  if (Array.isArray(val)) return resolveValue(val[0]);
+  if (typeof val === 'object') {
+    const inner = val.value ?? val.label;
+    return inner != null ? resolveValue(inner) : null;
+  }
+  return String(val) || null;
+};
+
+const SENDER_ID_RESOLVERS = {
+  [SMS]: (setting) => resolveValue(setting?.gsmSenderId),
+  [EMAIL]: (setting) => resolveValue(setting?.senderEmail),
+  [VIBER]: (setting) => resolveValue(setting?.sender) || resolveValue(setting?.gsmSenderId),
+  [WHATSAPP]: (setting) => resolveValue(setting?.senderMobNum),
+  [RCS]: (setting) => resolveValue(setting?.senderMobNum) || resolveValue(setting?.rcsSender),
+  [ZALO]: (setting) => resolveValue(setting?.zaloSenderId),
+};
+
+const getSenderIdValue = (item, savedData) => {
+  const channel = item?.channel?.toUpperCase();
+  const channelSetting = savedData?.deliverySetting?.channelSetting?.[channel] || {};
+  return SENDER_ID_RESOLVERS[channel]?.(channelSetting) ?? null;
+};
+
+const getStrategyLabel = (config, strategyValue) => {
+  const options = config?.features?.communicationStrategyData?.options || DEFAULT_COMMUNICATION_STRATEGY_OPTIONS;
+  const match = options.find((option) => option.value === strategyValue);
+  return match?.label || strategyValue || '';
+};
+
+const getMessageTypeLabel = (config, messageTypeValue) => {
+  const options = config?.features?.messageTypeData?.options || [];
+  const match = options.find((option) => option.value === messageTypeValue);
+  return match?.label || messageTypeValue || null;
+};
+
+const CommunicationFlowCard = ({
+  config,
+  initialData,
+  onSave,
+  onCancel,
+  onChange,
+  cap,
+  intl,
+}) => {
+  const { formatMessage } = intl || {};
+  const [showSlideBox, setShowSlideBox] = useState(false);
+  const [savedData, setSavedData] = useState(initialData || null);
+
+  const handleSave = useCallback((data) => {
+    setSavedData(data);
+    setShowSlideBox(false);
+    onSave?.(data);
+  }, [onSave]);
+
+  const handleClose = useCallback(() => {
+    setShowSlideBox(false);
+    onCancel?.();
+  }, [onCancel]);
+
+  const handleOpen = useCallback(() => {
+    setShowSlideBox(true);
+  }, []);
+
+  const firstItem = savedData?.contentItems?.[0];
+  const channelConfig = firstItem
+    ? CHANNELS.find((c) => c.value === firstItem.channel || c.channelProp === firstItem.channel?.toLowerCase())
+    : null;
+
+  const renderSummaryCard = () => {
+    if (!firstItem) return null;
+
+    const strategyLabel = getStrategyLabel(config, savedData?.communicationStrategy);
+    const messageTypeLabel = getMessageTypeLabel(config, savedData?.messageType);
+    const senderIdValue = getSenderIdValue(firstItem, savedData);
+    const controls = config?.features?.dynamicControlsData?.controls || DYNAMIC_CONTROLS_CONFIG;
+    const dynamicControlKeys = Object.keys(savedData?.dynamicControls || {});
+    const channel = firstItem.channel?.toUpperCase();
+    const senderLabel = [WHATSAPP, RCS].includes(channel)
+      ? formatMessage(messages.senderNumberLabel)
+      : formatMessage(messages.senderIdLabel);
+
+    return (
+      <CapCard
+        className="communication-flow-summary-card"
+        title={(
+          <CapRow type="flex" align="middle" className="summary-card-title-row">
+            <CapLabel type="label8">Message:</CapLabel>
+            <CapLabel type="label2">{strategyLabel}</CapLabel>
+            {messageTypeLabel && (
+              <CapLabel type="label1">({messageTypeLabel})</CapLabel>
+            )}
+          </CapRow>
+        )}
+        extra={(
+          <CapIcon
+            type="edit"
+            onClick={handleOpen}
+            style={{ cursor: 'pointer' }}
+          />
+        )}
+        headStyle={{ background: CAP_G09, width: '100%' }}
+        bodyStyle={{ padding: 0 }}
+      >
+        <CapRow gutter={0} className="card-body-row">
+          <CapColumn span={12} className="card-body-left-col">
+            <CapRow type="flex" align="middle" className="channel-header-row">
+              <CapIcon type={channelConfig?.iconType || 'sms'} size="s" />
+              <CapLabel type="label8">{channelConfig?.label || firstItem.channel}</CapLabel>
+              {senderIdValue && (
+                <CapLabel type="label1">({senderLabel}: {senderIdValue})</CapLabel>
+              )}
+            </CapRow>
+            {getContentBody(firstItem)}
+          </CapColumn>
+          <CapColumn span={12} className="card-body-right-col">
+            <CapLabel type="label8">{formatMessage(messages.dynamicControlsTitle)}</CapLabel>
+            {dynamicControlKeys.map((key) => {
+              const controlConfig = controls.find((c) => c.key === key);
+              if (!controlConfig) return null;
+              return (
+                <CapRow key={key} type="flex" justify="space-between" className="control-row">
+                  <CapLabel type="label2">{controlConfig.label}</CapLabel>
+                  <CapLabel type="label2">
+                    {savedData.dynamicControls[key]
+                      ? formatMessage(messages.yes)
+                      : formatMessage(messages.no)}
+                  </CapLabel>
+                </CapRow>
+              );
+            })}
+          </CapColumn>
+        </CapRow>
+      </CapCard>
+    );
+  };
+
+  const flowMode = savedData ? 'edit' : 'create';
+  const flowConfig = { ...config, mode: flowMode };
+
+  return (
+    <>
+      {!firstItem ? (
+        <CapCard
+          className="communication-flow-card-empty"
+          bodyStyle={{ padding: 0, height: 152 }}
+        >
+          <CapRow type="flex" align="middle" gutter={0} className="empty-card-body-row">
+            <CapColumn span={10} className="empty-card-illustration-col">
+              <CapImage src={addCreativesIllustration} />
+            </CapColumn>
+            <CapColumn span={14} className="empty-card-action-col">
+              <CapButton type="secondary" onClick={handleOpen}>
+                {formatMessage(messages.addCreatives)}
+              </CapButton>
+            </CapColumn>
+          </CapRow>
+        </CapCard>
+      ) : (
+        renderSummaryCard()
+      )}
+
+      <CapRow className="slide-box-wrapper">
+        <CapSlideBox
+          show={showSlideBox}
+          handleClose={handleClose}
+          size="size-xl"
+          header={(
+            <CapHeader
+              title={formatMessage(messages.addMessage)}
+              handleClose={handleClose}
+            />
+          )}
+          content={(
+            <CommunicationFlow
+              config={flowConfig}
+              initialData={savedData}
+              onSave={handleSave}
+              onCancel={handleClose}
+              onChange={onChange}
+              cap={cap}
+            />
+          )}
+        />
+      </CapRow>
+    </>
+  );
+};
+
+CommunicationFlowCard.propTypes = {
+  config: PropTypes.object.isRequired,
+  initialData: PropTypes.object,
+  onSave: PropTypes.func,
+  onCancel: PropTypes.func,
+  onChange: PropTypes.func,
+  cap: PropTypes.object,
+  intl: PropTypes.object.isRequired,
+};
+
+CommunicationFlowCard.defaultProps = {
+  initialData: null,
+  onSave: null,
+  onCancel: null,
+  onChange: null,
+  cap: null,
+};
+
+export default injectIntl(CommunicationFlowCard);

package/v2Containers/CommunicationFlow/DemoPage.js

@@ -0,0 +1,47 @@
+import React from 'react';
+import { CommunicationFlowCard } from './index';
+
+const CommunicationFlowDemoPage = () => {
+  const config = {
+    consumer: 'PROGRAM',
+    mode: 'create',
+    useCCS: true,
+    features: {
+      messageTypeData: {
+        required: false,
+      },
+      communicationStrategyData: {
+        required: true,
+        disabled: false,
+      },
+      contentTemplateData: {
+        required: true,
+        channelsToHide: [],
+        channelsToDisable: [],
+      },
+      incentivesData: {
+        required: false,
+      },
+      deliverySettingsData: {
+        required: false,
+        deliverySettings: [{}],
+      },
+      showDynamicControls: true,
+    },
+    context: {
+      orgUnitId: '1231',
+      campaignId: '456789',
+    },
+  };
+
+  const handleSave = (data) => {
+    // eslint-disable-next-line no-console
+    console.log('Save called with data:', data);
+  };
+
+  return (
+    <CommunicationFlowCard config={config} onSave={handleSave} />
+  );
+};
+
+export default CommunicationFlowDemoPage;

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();
+  });
 });