@capillarytech/creatives-library 9.0.56-alpha.6 → 9.0.56-betaa.0

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

@@ -1,8 +1,8 @@
 import React from 'react';
 
 jest.mock('../../../services/api', () => ({
-  createCommDefinition: jest.fn(),
-  editCommDefinition: jest.fn(),
+  createCentralCommsMetaId: jest.fn(),
+  getCentralCommsMetaIds: 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 { createCommDefinition, editCommDefinition } from '../../../services/api';
+import { createCentralCommsMetaId, getCentralCommsMetaIds } 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(/add creative/i)).not.toBeInTheDocument();
+    expect(screen.queryByText(/content template/i)).not.toBeInTheDocument();
     expect(screen.queryByText(/other controls/i)).not.toBeInTheDocument();
 
     await selectCommunicationStrategy('Single template');
 
     await waitFor(() => {
-      expect(screen.getAllByText(/add creative/i).length).toBeGreaterThan(0);
+      expect(screen.getAllByText(/content template/i).length).toBeGreaterThan(0);
     });
     expect(screen.getByText(/other controls/i)).toBeInTheDocument();
   });
@@ -359,295 +359,82 @@ describe('isSaveDisabled', () => {
 });
 
 describe('handleSave — CCS flow', () => {
-  const ccsConfig = { ...baseConfig, context: { name: 'Order Placed Notification' }, features: {} };
-
   beforeEach(() => {
-    createCommDefinition.mockResolvedValue({
-      response: { data: { id: 'cd_123', referenceId: 'ORDER_PLACED_123', status: 'DRAFT', version: { version: 1 } } },
-    });
+    createCentralCommsMetaId.mockResolvedValue({ response: { data: { id: 'meta-123' } } });
+    getCentralCommsMetaIds.mockResolvedValue({ response: { data: {} } });
   });
 
   afterEach(() => {
     jest.clearAllMocks();
   });
 
-  it('calls createCommDefinition with a SINGLE-strategy payload when useCCS is not false', async () => {
+  it('calls createCentralCommsMetaId for each content item 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: { messageBody: 'Hello' } }],
+        contentItems: [{ channel: 'sms', templateData: { smsBody: 'Hello' } }],
       },
       onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
-    expect(createCommDefinition).toHaveBeenCalledWith(
+    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalledTimes(1));
+    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
       expect.objectContaining({
-        name: 'Order Placed Notification',
-        strategyType: 'SINGLE',
-        singleChannelStrategy: expect.objectContaining({
-          variant: expect.objectContaining({
-            channel: 'SMS',
-            smsMessageContent: { channel: 'SMS', message: 'Hello' },
-          }),
-        }),
+        centralCommsPayload: expect.objectContaining({ channel: 'SMS', module: 'CAMPAIGNS' }),
       }),
     );
     expect(onSave).toHaveBeenCalledTimes(1);
   });
 
-  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: {},
-      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));
-    const payload = createCommDefinition.mock.calls[0][0];
-    expect(payload.singleChannelStrategy.variant.smsMessageContent).not.toHaveProperty('messageBody');
-  });
-
-  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();
+  it('calls getCentralCommsMetaIds when metaIds are returned from createCentralCommsMetaId', async () => {
     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,
+      initialData: { contentItems: [{ channel: 'EMAIL', templateData: {} }] },
     });
 
     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 },
-            },
-          }),
-        }),
-      }),
-    );
+    await waitFor(() => expect(getCentralCommsMetaIds).toHaveBeenCalledWith('meta-123'));
   });
 
-  it('merges ccsCommDefinition into the data passed to onSave when create succeeds', async () => {
-    const onSave = jest.fn();
+  it('skips getCentralCommsMetaIds when response contains no id', async () => {
+    createCentralCommsMetaId.mockResolvedValue({ response: { data: {} } });
     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.objectContaining({
-        ccsCommDefinition: { id: 'cd_123', referenceId: 'ORDER_PLACED_123', version: 1, status: 'DRAFT' },
-      }),
-    );
+    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
+    expect(getCentralCommsMetaIds).not.toHaveBeenCalled();
   });
 
-  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 } } },
-    });
+  it('uses ouId and module from config.context when provided', async () => {
     renderWithFlow({
       features: {},
-      config: ccsConfig,
+      config: { ...baseConfig, context: { ouId: 42, module: 'LOYALTY' }, features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
-      onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(onSave).toHaveBeenCalledWith(
+    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
+    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
       expect.objectContaining({
-        ccsCommDefinition: { id: 'cd_123', referenceId: 'ORDER_PLACED_123', version: 0, status: 'DRAFT' },
+        centralCommsPayload: expect.objectContaining({ ouId: 42, module: 'LOYALTY' }),
       }),
     );
   });
 
-  it('sends an empty referenceId/description when config.context does not supply them', async () => {
-    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('');
-    expect(payload.description).toBe('');
-  });
-
-  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: { ...ccsConfig, useCCS: false },
+      config: { ...baseConfig, useCCS: false, features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
       onSave,
     });
@@ -655,50 +442,14 @@ describe('handleSave — CCS flow', () => {
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
     await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(createCommDefinition).not.toHaveBeenCalled();
-    expect(onSave).toHaveBeenCalledWith(expect.not.objectContaining({ ccsCommDefinition: expect.anything() }));
-  });
-
-  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,
-    });
-
-    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
-
-    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(createCommDefinition).not.toHaveBeenCalled();
-  });
-
-  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();
+    expect(createCentralCommsMetaId).not.toHaveBeenCalled();
   });
 
-  it('still calls onSave (without ccsCommDefinition) when createCommDefinition rejects', async () => {
-    createCommDefinition.mockRejectedValue(new Error('Network error'));
+  it('still calls onSave when createCentralCommsMetaId rejects', async () => {
+    createCentralCommsMetaId.mockRejectedValue(new Error('Network error'));
     const onSave = jest.fn();
     renderWithFlow({
       features: {},
-      config: ccsConfig,
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
       onSave,
     });
@@ -706,35 +457,12 @@ describe('handleSave — CCS flow', () => {
     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 () => {
+  it('skips createCentralCommsMetaId when contentItems is empty', async () => {
     const onSave = jest.fn();
     renderWithFlow({
       features: {},
-      config: ccsConfig,
       initialData: { contentItems: [] },
       onSave,
     });
@@ -742,13 +470,12 @@ describe('handleSave — CCS flow', () => {
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
     await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(createCommDefinition).not.toHaveBeenCalled();
+    expect(createCentralCommsMetaId).not.toHaveBeenCalled();
   });
 
-  it('places additionalSettings derived from dynamicControls under settings.additionalSettings (not delivery settings)', async () => {
+  it('includes additionalSettings derived from dynamicControls in the payload', async () => {
     renderWithFlow({
       features: {},
-      config: ccsConfig,
       initialData: {
         contentItems: [{ channel: 'SMS', templateData: {} }],
         dynamicControls: {
@@ -762,118 +489,14 @@ describe('handleSave — CCS flow', () => {
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(createCommDefinition).toHaveBeenCalled());
-    const payload = createCommDefinition.mock.calls[0][0];
-    expect(payload.settings.additionalSettings).toEqual({
+    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,
     });
-    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', description: 'desc', 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({
-        referenceId: 'ORDER_PLACED',
-        description: 'desc',
-        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();
   });
 });
 
@@ -929,34 +552,39 @@ describe('optional chaining safety', () => {
     jest.clearAllMocks();
   });
 
-  it('does not crash and skips CCS when config.context is entirely absent', async () => {
-    const onSave = jest.fn();
+  it('defaults ouId to -1 when config.context is absent', async () => {
+    createCentralCommsMetaId.mockResolvedValue({ response: { data: { id: 'x' } } });
     renderWithFlow({
       features: {},
-      config: { ...baseConfig, features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
-      onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(createCommDefinition).not.toHaveBeenCalled();
+    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
+    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
+      expect.objectContaining({
+        centralCommsPayload: expect.objectContaining({ ouId: -1 }),
+      }),
+    );
   });
 
-  it('does not crash when config.context is present but empty', async () => {
-    const onSave = jest.fn();
+  it('defaults module to consumer.toUpperCase() when config.context.module absent', async () => {
+    createCentralCommsMetaId.mockResolvedValue({ response: { data: { id: 'x' } } });
     renderWithFlow({
       features: {},
-      config: { ...baseConfig, context: {}, features: {} },
+      config: { ...baseConfig, consumer: 'loyalty', features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
-      onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(createCommDefinition).not.toHaveBeenCalled();
+    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', () => {
@@ -1000,51 +628,3 @@ 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);
-  });
-
-  it('omits the divider after ChannelSelectionStep when no content has been added yet', () => {
-    const { container } = renderWithFlow({
-      features: {
-        communicationStrategyData: { required: true, options: STRATEGY_OPTIONS },
-        contentTemplateData: { required: true, channels: CHANNELS },
-      },
-      initialData: {
-        communicationStrategy: SINGLE_TEMPLATE,
-        contentItems: [],
-      },
-    });
-    // Neither divider renders — both CommunicationStrategyStep's and ChannelSelectionStep's
-    // own trailing dividers are conditional on content existing, to avoid a dangling line
-    // around an empty "Add creative" state.
-    expect(container.querySelectorAll('.ant-divider')).toHaveLength(0);
-  });
-
-  it('renders the divider after CommunicationStrategyStep unconditionally when no CHANNEL_SELECTION step follows', () => {
-    const { container } = renderWithFlow({
-      features: {
-        communicationStrategyData: { required: true, options: STRATEGY_OPTIONS },
-        // contentTemplateData.required omitted — no CHANNEL_SELECTION step in this flow.
-      },
-      initialData: {
-        communicationStrategy: SINGLE_TEMPLATE,
-      },
-    });
-    expect(container.querySelectorAll('.ant-divider')).toHaveLength(1);
-  });
-});