@capillarytech/creatives-library 9.0.55 → 9.0.56-alpha.0

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

@@ -1,8 +1,8 @@
 import React from 'react';
 
 jest.mock('../../../services/api', () => ({
-  createCentralCommsMetaId: jest.fn(),
-  getCentralCommsMetaIds: jest.fn(),
+  createCommDefinition: jest.fn(),
+  editCommDefinition: jest.fn(),
 }));
 
 jest.mock('../../CreativesContainer', () => function MockCreativesContainer({
@@ -38,7 +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 { createCommDefinition, editCommDefinition } from '../../../services/api';
 import { getEnabledSteps } from '../utils/getEnabledSteps';
 import {
   CHANNELS,
@@ -192,13 +192,13 @@ describe('CommunicationFlow', () => {
   it('hides channel selection and dynamic controls until a communication strategy is set', async () => {
     renderWithFlow({ features: FEATURES.strategyContentDynamic });
 
-    expect(screen.queryByText(/content template/i)).not.toBeInTheDocument();
+    expect(screen.queryByText(/add creative/i)).not.toBeInTheDocument();
     expect(screen.queryByText(/other controls/i)).not.toBeInTheDocument();
 
     await selectCommunicationStrategy('Single template');
 
     await waitFor(() => {
-      expect(screen.getAllByText(/content template/i).length).toBeGreaterThan(0);
+      expect(screen.getAllByText(/add creative/i).length).toBeGreaterThan(0);
     });
     expect(screen.getByText(/other controls/i)).toBeInTheDocument();
   });
@@ -359,82 +359,297 @@ describe('isSaveDisabled', () => {
 });
 
 describe('handleSave — CCS flow', () => {
+  const ccsConfig = { ...baseConfig, context: { name: 'Order Placed Notification' }, features: {} };
+
   beforeEach(() => {
-    createCentralCommsMetaId.mockResolvedValue({ response: { data: { id: 'meta-123' } } });
-    getCentralCommsMetaIds.mockResolvedValue({ response: { data: {} } });
+    createCommDefinition.mockResolvedValue({
+      response: { data: { id: 'cd_123', referenceId: 'ORDER_PLACED_123', status: 'DRAFT', version: { version: 1 } } },
+    });
   });
 
   afterEach(() => {
     jest.clearAllMocks();
   });
 
-  it('calls createCentralCommsMetaId for each content item when useCCS is not false', async () => {
+  it('calls createCommDefinition with a SINGLE-strategy payload when useCCS is not false', async () => {
     const onSave = jest.fn();
     renderWithFlow({
       features: {},
+      config: ccsConfig,
+      // messageBody is the legacy editor's field name for the typed SMS text
+      // (see CreativesContainer/index.js's getCreativesData SMS case) — the
+      // SMS transform maps it to CCS's `message` field.
       initialData: {
-        contentItems: [{ channel: 'sms', templateData: { smsBody: 'Hello' } }],
+        contentItems: [{ channel: 'sms', templateData: { messageBody: 'Hello' } }],
       },
       onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalledTimes(1));
-    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
+    expect(createCommDefinition).toHaveBeenCalledWith(
       expect.objectContaining({
-        centralCommsPayload: expect.objectContaining({ channel: 'SMS', module: 'CAMPAIGNS' }),
+        name: 'Order Placed Notification',
+        strategyType: 'SINGLE',
+        singleChannelStrategy: expect.objectContaining({
+          variant: expect.objectContaining({
+            channel: 'SMS',
+            smsMessageContent: { channel: 'SMS', message: 'Hello' },
+          }),
+        }),
       }),
     );
     expect(onSave).toHaveBeenCalledTimes(1);
   });
 
-  it('calls getCentralCommsMetaIds when metaIds are returned from createCentralCommsMetaId', async () => {
+  it('transforms SMS content from the legacy editor shape (messageBody) to CCS\'s message field', async () => {
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      config: ccsConfig,
+      initialData: {
+        contentItems: [{
+          channel: 'SMS',
+          templateData: { messageBody: 'Hello {{name}}', channel: 'SMS' },
+        }],
+      },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
+    expect(createCommDefinition).toHaveBeenCalledWith(
+      expect.objectContaining({
+        singleChannelStrategy: expect.objectContaining({
+          variant: expect.objectContaining({
+            channel: 'SMS',
+            smsMessageContent: {
+              channel: 'SMS',
+              message: 'Hello {{name}}',
+            },
+          }),
+        }),
+      }),
+    );
+  });
+
+  it('does not carry the legacy messageBody key into smsMessageContent (regression guard against reverting to pass-through)', async () => {
+    const onSave = jest.fn();
     renderWithFlow({
       features: {},
-      initialData: { contentItems: [{ channel: 'EMAIL', templateData: {} }] },
+      config: ccsConfig,
+      initialData: {
+        contentItems: [{
+          channel: 'SMS',
+          templateData: { messageBody: 'Hello {{name}}', channel: 'SMS' },
+        }],
+      },
+      onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(getCentralCommsMetaIds).toHaveBeenCalledWith('meta-123'));
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
+    const payload = createCommDefinition.mock.calls[0][0];
+    expect(payload.singleChannelStrategy.variant.smsMessageContent).not.toHaveProperty('messageBody');
   });
 
-  it('skips getCentralCommsMetaIds when response contains no id', async () => {
-    createCentralCommsMetaId.mockResolvedValue({ response: { data: {} } });
+  it('transforms EMAIL content from the legacy editor shape (emailSubject) to CCS\'s messageSubject', async () => {
+    const onSave = jest.fn();
     renderWithFlow({
       features: {},
+      config: ccsConfig,
+      initialData: {
+        contentItems: [{
+          channel: 'EMAIL',
+          templateData: { emailSubject: 'Order Confirmed', emailBody: '<html>Hi</html>' },
+        }],
+      },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
+    expect(createCommDefinition).toHaveBeenCalledWith(
+      expect.objectContaining({
+        singleChannelStrategy: expect.objectContaining({
+          variant: expect.objectContaining({
+            channel: 'EMAIL',
+            emailMessageContent: {
+              channel: 'EMAIL',
+              messageSubject: 'Order Confirmed',
+              messageBody: '<html>Hi</html>',
+            },
+          }),
+        }),
+      }),
+    );
+  });
+
+  it('transforms WEBPUSH content from the legacy editor\'s messageContent.content wrapping to CCS\'s flat shape', async () => {
+    const onSave = jest.fn();
+    const cta = { type: 'SITE_URL', actionLink: 'https://example.com' };
+    const expandableDetails = { media: [{ url: 'https://example.com/banner.png', type: 'IMAGE' }], ctas: [] };
+    renderWithFlow({
+      features: {},
+      config: ccsConfig,
+      initialData: {
+        contentItems: [{
+          channel: 'WEBPUSH',
+          templateData: {
+            messageContent: {
+              content: {
+                channel: 'WEBPUSH',
+                accountId: 13792,
+                content: { title: 'Hi', message: 'Body', iconImageUrl: 'https://example.com/icon.png', cta, expandableDetails },
+                messageSubject: 'Subject',
+                offers: [],
+              },
+            },
+          },
+        }],
+      },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
+    expect(createCommDefinition).toHaveBeenCalledWith(
+      expect.objectContaining({
+        singleChannelStrategy: expect.objectContaining({
+          variant: expect.objectContaining({
+            channel: 'WEBPUSH',
+            webPushMessageContent: {
+              channel: 'WEBPUSH',
+              messageSubject: 'Subject',
+              accountId: 13792,
+              content: { title: 'Hi', message: 'Body', iconImageUrl: 'https://example.com/icon.png', cta, expandableDetails },
+            },
+          }),
+        }),
+      }),
+    );
+  });
+
+  it('normalizes the internal MOBILEPUSH channel to CCS\'s PUSH enum (keys stay mpush*), even when templateData/channelSetting carry their own stray channel field', async () => {
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      config: ccsConfig,
+      initialData: {
+        // `channel: 'MOBILEPUSH'` inline on templateData reproduces the real
+        // production bug: contentItem.templateData carries the UI's own
+        // internal channel identifier, which must not win over the
+        // normalized 'PUSH' enum once spread into mpushMessageContent.
+        contentItems: [{ channel: 'MOBILEPUSH', templateData: { channel: 'MOBILEPUSH', messageSubject: 'Hi' } }],
+        // Likewise, deliverySetting.channelSetting.PUSH carrying its own
+        // stray `channel` key must not win over the normalized value once
+        // spread into mpushDeliverySettings.channelSettings.
+        deliverySetting: { channelSetting: { PUSH: { channel: 'MOBILEPUSH', domainId: 2002 } } },
+      },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
+    expect(createCommDefinition).toHaveBeenCalledWith(
+      expect.objectContaining({
+        singleChannelStrategy: expect.objectContaining({
+          variant: expect.objectContaining({
+            channel: 'PUSH',
+            mpushMessageContent: { channel: 'PUSH', messageSubject: 'Hi' },
+            mpushDeliverySettings: {
+              channelSettings: { channel: 'PUSH', domainId: 2002 },
+            },
+          }),
+        }),
+      }),
+    );
+  });
+
+  it('merges ccsCommDefinition into the data passed to onSave when create succeeds', async () => {
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      config: ccsConfig,
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+      onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
-    expect(getCentralCommsMetaIds).not.toHaveBeenCalled();
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(onSave).toHaveBeenCalledWith(
+      expect.objectContaining({
+        ccsCommDefinition: { id: 'cd_123', referenceId: 'ORDER_PLACED_123', version: 1, status: 'DRAFT' },
+      }),
+    );
   });
 
-  it('uses ouId and module from config.context when provided', async () => {
+  it('preserves a real version of 0 from CCS (not coerced to 1 by a falsy-zero fallback)', async () => {
+    const onSave = jest.fn();
+    createCommDefinition.mockResolvedValueOnce({
+      response: { data: { id: 'cd_123', referenceId: 'ORDER_PLACED_123', status: 'DRAFT', version: { version: 0 } } },
+    });
     renderWithFlow({
       features: {},
-      config: { ...baseConfig, context: { ouId: 42, module: 'LOYALTY' }, features: {} },
+      config: ccsConfig,
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+      onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
-    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(onSave).toHaveBeenCalledWith(
       expect.objectContaining({
-        centralCommsPayload: expect.objectContaining({ ouId: 42, module: 'LOYALTY' }),
+        ccsCommDefinition: { id: 'cd_123', referenceId: 'ORDER_PLACED_123', version: 0, status: 'DRAFT' },
       }),
     );
   });
 
+  it('generates a referenceId from name when config.context.referenceId is absent', async () => {
+    // moduleMocks.js spies on Date.now globally, but this config's resetMocks:true
+    // clears that return value before every test — set it explicitly here.
+    jest.spyOn(Date, 'now').mockReturnValue(1612267539410);
+    renderWithFlow({
+      features: {},
+      config: ccsConfig,
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalled());
+    const payload = createCommDefinition.mock.calls[0][0];
+    expect(payload.referenceId).toBe('ORDER_PLACED_NOTIFICATION_1612267539410');
+  });
+
+  it('uses config.context.referenceId and description when provided', async () => {
+    renderWithFlow({
+      features: {},
+      config: { ...ccsConfig, context: { ...ccsConfig.context, referenceId: 'ORDER_PLACED', description: 'desc' } },
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalled());
+    expect(createCommDefinition).toHaveBeenCalledWith(
+      expect.objectContaining({ referenceId: 'ORDER_PLACED', description: 'desc' }),
+    );
+  });
+
   it('skips CCS entirely when useCCS is false', async () => {
     const onSave = jest.fn();
     renderWithFlow({
       features: {},
-      config: { ...baseConfig, useCCS: false, features: {} },
+      config: { ...ccsConfig, useCCS: false },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
       onSave,
     });
@@ -442,14 +657,15 @@ describe('handleSave — CCS flow', () => {
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
     await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(createCentralCommsMetaId).not.toHaveBeenCalled();
+    expect(createCommDefinition).not.toHaveBeenCalled();
+    expect(onSave).toHaveBeenCalledWith(expect.not.objectContaining({ ccsCommDefinition: expect.anything() }));
   });
 
-  it('still calls onSave when createCentralCommsMetaId rejects', async () => {
-    createCentralCommsMetaId.mockRejectedValue(new Error('Network error'));
+  it('skips createCommDefinition when config.context.name is absent (mandatory)', async () => {
     const onSave = jest.fn();
     renderWithFlow({
       features: {},
+      config: { ...baseConfig, features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
       onSave,
     });
@@ -457,12 +673,70 @@ describe('handleSave — CCS flow', () => {
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
     await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(createCommDefinition).not.toHaveBeenCalled();
   });
 
-  it('skips createCentralCommsMetaId when contentItems is empty', async () => {
+  it('skips createCommDefinition for multi-channel strategies (CHANNEL_PRIORITY/AB_TEST)', async () => {
     const onSave = jest.fn();
     renderWithFlow({
       features: {},
+      config: ccsConfig,
+      initialData: {
+        communicationStrategy: CHANNEL_PRIORITY,
+        channels: ['SMS', 'EMAIL'],
+        contentItems: [{ channel: 'SMS', templateData: {} }, { channel: 'EMAIL', templateData: {} }],
+      },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(createCommDefinition).not.toHaveBeenCalled();
+  });
+
+  it('still calls onSave (without ccsCommDefinition) when createCommDefinition rejects', async () => {
+    createCommDefinition.mockRejectedValue(new Error('Network error'));
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      config: ccsConfig,
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(onSave).toHaveBeenCalledWith(expect.not.objectContaining({ ccsCommDefinition: expect.anything() }));
+  });
+
+  it('blocks save and shows an error when createCommDefinition resolves with a duplicate REFERENCE_ID_EXISTS conflict', async () => {
+    createCommDefinition.mockResolvedValue({
+      success: false,
+      status: { isError: true, code: 409, message: 'REFERENCE_ID_EXISTS' },
+      message: 'REFERENCE_ID_EXISTS',
+    });
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      config: ccsConfig,
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
+    expect(await screen.findByText(/already in use in your organization/i)).toBeInTheDocument();
+    expect(onSave).not.toHaveBeenCalled();
+  });
+
+  it('skips createCommDefinition when contentItems is empty', async () => {
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      config: ccsConfig,
       initialData: { contentItems: [] },
       onSave,
     });
@@ -470,12 +744,13 @@ describe('handleSave — CCS flow', () => {
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
     await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(createCentralCommsMetaId).not.toHaveBeenCalled();
+    expect(createCommDefinition).not.toHaveBeenCalled();
   });
 
-  it('includes additionalSettings derived from dynamicControls in the payload', async () => {
+  it('places additionalSettings derived from dynamicControls under settings.additionalSettings (not delivery settings)', async () => {
     renderWithFlow({
       features: {},
+      config: ccsConfig,
       initialData: {
         contentItems: [{ channel: 'SMS', templateData: {} }],
         dynamicControls: {
@@ -489,14 +764,116 @@ describe('handleSave — CCS flow', () => {
 
     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({
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalled());
+    const payload = createCommDefinition.mock.calls[0][0];
+    expect(payload.settings.additionalSettings).toEqual({
       useTinyUrl: true,
       encryptUrl: true,
       linkTrackingEnabled: true,
       userSubscriptionDisabled: true,
     });
+    expect(payload.singleChannelStrategy.variant.smsDeliverySettings.additionalSettings).toBeUndefined();
+  });
+
+  it('includes channelSettings from deliverySetting.channelSetting in the payload', async () => {
+    renderWithFlow({
+      features: {},
+      config: ccsConfig,
+      initialData: {
+        contentItems: [{ channel: 'SMS', templateData: {} }],
+        deliverySetting: { channelSetting: { SMS: { domainId: 1001, gsmSenderId: 'BRAND1' } } },
+      },
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalled());
+    const payload = createCommDefinition.mock.calls[0][0];
+    expect(payload.singleChannelStrategy.variant.smsDeliverySettings.channelSettings).toEqual({
+      channel: 'SMS',
+      domainId: 1001,
+      gsmSenderId: 'BRAND1',
+    });
+  });
+
+  it('does not call editCommDefinition when config.context.existingCommDefinitionId is absent', async () => {
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      config: ccsConfig,
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
+    expect(editCommDefinition).not.toHaveBeenCalled();
+  });
+
+  it('calls editCommDefinition (not createCommDefinition) and merges the existing id into ccsCommDefinition when config.context.existingCommDefinitionId is set', async () => {
+    editCommDefinition.mockResolvedValue({
+      response: { data: { version: { version: 2 }, status: 'DRAFT' } },
+    });
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      config: {
+        ...ccsConfig,
+        context: { ...ccsConfig.context, referenceId: 'ORDER_PLACED', existingCommDefinitionId: 'cd_existing_1' },
+      },
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(editCommDefinition).toHaveBeenCalledTimes(1));
+    expect(editCommDefinition).toHaveBeenCalledWith(
+      'cd_existing_1',
+      expect.objectContaining({
+        strategyType: 'SINGLE',
+        settings: expect.anything(),
+        singleChannelStrategy: expect.anything(),
+      }),
+    );
+    expect(createCommDefinition).not.toHaveBeenCalled();
+
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(onSave).toHaveBeenCalledWith(
+      expect.objectContaining({
+        ccsCommDefinition: {
+          id: 'cd_existing_1',
+          referenceId: 'ORDER_PLACED',
+          version: 2,
+          status: 'DRAFT',
+        },
+      }),
+    );
+  });
+
+  it('blocks save and shows an error when editCommDefinition resolves with a duplicate REFERENCE_ID_EXISTS conflict', async () => {
+    editCommDefinition.mockResolvedValue({
+      success: false,
+      status: { isError: true, code: 409, message: 'REFERENCE_ID_EXISTS' },
+      message: 'REFERENCE_ID_EXISTS',
+    });
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      config: {
+        ...ccsConfig,
+        context: { ...ccsConfig.context, referenceId: 'ORDER_PLACED', existingCommDefinitionId: 'cd_existing_1' },
+      },
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(editCommDefinition).toHaveBeenCalledTimes(1));
+    expect(await screen.findByText(/already in use in your organization/i)).toBeInTheDocument();
+    expect(onSave).not.toHaveBeenCalled();
   });
 });
 
@@ -552,39 +929,34 @@ describe('optional chaining safety', () => {
     jest.clearAllMocks();
   });
 
-  it('defaults ouId to -1 when config.context is absent', async () => {
-    createCentralCommsMetaId.mockResolvedValue({ response: { data: { id: 'x' } } });
+  it('does not crash and skips CCS when config.context is entirely absent', async () => {
+    const onSave = jest.fn();
     renderWithFlow({
       features: {},
+      config: { ...baseConfig, features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+      onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
-    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
-      expect.objectContaining({
-        centralCommsPayload: expect.objectContaining({ ouId: -1 }),
-      }),
-    );
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(createCommDefinition).not.toHaveBeenCalled();
   });
 
-  it('defaults module to consumer.toUpperCase() when config.context.module absent', async () => {
-    createCentralCommsMetaId.mockResolvedValue({ response: { data: { id: 'x' } } });
+  it('does not crash when config.context is present but empty', async () => {
+    const onSave = jest.fn();
     renderWithFlow({
       features: {},
-      config: { ...baseConfig, consumer: 'loyalty', features: {} },
+      config: { ...baseConfig, context: {}, features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+      onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
-    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
-      expect.objectContaining({
-        centralCommsPayload: expect.objectContaining({ module: 'LOYALTY' }),
-      }),
-    );
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(createCommDefinition).not.toHaveBeenCalled();
   });
 
   it('initializes channel from config.channel when initialData.channel is absent', () => {
@@ -628,3 +1000,21 @@ describe('optional chaining safety', () => {
     expect(screen.getByRole('button', { name: /^save$/i })).toBeDisabled();
   });
 });
+
+describe('step dividers', () => {
+  it('renders a divider after CommunicationStrategyStep and after ChannelSelectionStep when both render together', () => {
+    const { container } = renderWithFlow({
+      features: {
+        communicationStrategyData: { required: true, options: STRATEGY_OPTIONS },
+        contentTemplateData: { required: true, channels: CHANNELS },
+      },
+      initialData: {
+        communicationStrategy: SINGLE_TEMPLATE,
+        contentItems: [{ channel: 'SMS', templateData: {} }],
+      },
+    });
+    // Each rendered step (CommunicationStrategyStep, ChannelSelectionStep) emits its
+    // own trailing divider.
+    expect(container.querySelectorAll('.ant-divider')).toHaveLength(2);
+  });
+});