npm - @capillarytech/creatives-library - Versions diffs - 9.0.54-alpha.4 → 9.0.54 - Mend

@capillarytech/creatives-library 9.0.54-alpha.4 → 9.0.54

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

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

@@ -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,
@@ -359,241 +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,
       initialData: {
-        contentItems: [{ channel: 'sms', templateData: { message: '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 EMAIL content from the legacy editor shape (emailSubject) to CCS\'s messageSubject', async () => {
-    const onSave = jest.fn();
+  it('calls getCentralCommsMetaIds when metaIds are returned from createCentralCommsMetaId', async () => {
     renderWithFlow({
       features: {},
-      config: ccsConfig,
-      initialData: {
-        contentItems: [{
-          channel: 'EMAIL',
-          templateData: { emailSubject: 'Order Confirmed', emailBody: '<html>Hi</html>' },
-        }],
-      },
-      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: 'EMAIL',
-            emailMessageContent: {
-              channel: 'EMAIL',
-              messageSubject: 'Order Confirmed',
-              messageBody: '<html>Hi</html>',
-            },
-          }),
-        }),
-      }),
-    );
+    await waitFor(() => expect(getCentralCommsMetaIds).toHaveBeenCalledWith('meta-123'));
   });
-  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: [] };
+  it('skips getCentralCommsMetaIds when response contains no id', async () => {
+    createCentralCommsMetaId.mockResolvedValue({ response: { data: {} } });
     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(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('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: { ...ccsConfig, useCCS: false },
+      config: { ...baseConfig, useCCS: false, features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
       onSave,
     });
@@ -601,15 +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() }));
+    expect(createCentralCommsMetaId).not.toHaveBeenCalled();
   });
-  it('skips createCommDefinition when config.context.name is absent (mandatory)', async () => {
+  it('still calls onSave when createCentralCommsMetaId rejects', async () => {
+    createCentralCommsMetaId.mockRejectedValue(new Error('Network error'));
     const onSave = jest.fn();
     renderWithFlow({
       features: {},
-      config: { ...baseConfig, features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
       onSave,
     });
@@ -617,70 +457,12 @@ 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 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'));
+  it('skips createCentralCommsMetaId when contentItems is empty', 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(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,
     });
@@ -688,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: {
@@ -708,116 +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', 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();
   });
 });
@@ -873,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', () => {

package/v2Containers/CommunicationFlow/Tests/CommunicationFlowCard.test.js CHANGED Viewed

@@ -108,22 +108,6 @@ describe('CommunicationFlowCard', () => {
       fireEvent.click(screen.getByText('Add creatives'));
       expect(screen.getByTestId('comm-flow-mock')).toHaveAttribute('data-mode', 'create');
     });
-    it('disables the Add creatives button when disabled prop is true', () => {
-      renderCard({ disabled: true, disabledTooltip: 'Enter an Alert name to add content' });
-      expect(screen.getByText('Add creatives').closest('button')).toBeDisabled();
-    });
-    it('does not open SlideBox when Add creatives is clicked while disabled', () => {
-      renderCard({ disabled: true, disabledTooltip: 'Enter an Alert name to add content' });
-      fireEvent.click(screen.getByText('Add creatives'));
-      expect(screen.queryByTestId('slide-box')).not.toBeInTheDocument();
-    });
-    it('Add creatives button is enabled by default (disabled prop absent)', () => {
-      renderCard();
-      expect(screen.getByText('Add creatives').closest('button')).not.toBeDisabled();
-    });
   });
   describe('configured state (initialData provided)', () => {
@@ -247,11 +231,11 @@ describe('CommunicationFlowCard', () => {
       expect(screen.getByText(/Sender ID/)).toBeInTheDocument();
     });
-    it('shows senderId for EMAIL with Sender ID label', () => {
+    it('shows senderEmail for EMAIL with Sender ID label', () => {
       renderCard({
         initialData: makeSavedData({
           contentItems: [{ channel: 'EMAIL', templateData: {} }],
-          deliverySetting: { channelSetting: { EMAIL: { senderId: 'test@example.com' } } },
+          deliverySetting: { channelSetting: { EMAIL: { senderEmail: 'test@example.com' } } },
         }),
       });
       expect(screen.getByText(/test@example.com/)).toBeInTheDocument();