@capillarytech/creatives-library 8.0.345-alpha.16 → 8.0.345-alpha.17

package/v2Containers/CreativesContainer/tests/embeddedSlideboxUtils.test.js

@@ -0,0 +1,258 @@
+import {
+  CAP_SPACE_32,
+  CAP_SPACE_56,
+  CAP_SPACE_64,
+} from '@capillarytech/cap-ui-library/styled/variables';
+import {
+  isDeepEmpty,
+  getSlideBoxWrapperMarginFromLiquidErrors,
+  computeLiquidFooterUpdateFromFormBuilder,
+} from '../embeddedSlideboxUtils';
+import { ANDROID, IOS, MOBILE_PUSH, LIQUID_ERROR_MSG, STANDARD_ERROR_MSG } from '../constants';
+
+// ---------------------------------------------------------------------------
+// isDeepEmpty
+// ---------------------------------------------------------------------------
+
+describe('isDeepEmpty', () => {
+  it('returns true for null', () => {
+    expect(isDeepEmpty(null)).toBe(true);
+  });
+
+  it('returns true for undefined', () => {
+    expect(isDeepEmpty(undefined)).toBe(true);
+  });
+
+  it('returns true for empty string', () => {
+    expect(isDeepEmpty('')).toBe(true);
+  });
+
+  it('returns false for non-empty string', () => {
+    expect(isDeepEmpty('hello')).toBe(false);
+  });
+
+  it('returns true for empty array', () => {
+    expect(isDeepEmpty([])).toBe(true);
+  });
+
+  it('returns false for non-empty array', () => {
+    expect(isDeepEmpty(['item'])).toBe(false);
+  });
+
+  it('returns true for empty object', () => {
+    expect(isDeepEmpty({})).toBe(true);
+  });
+
+  it('returns true for object where all values are deep-empty', () => {
+    expect(isDeepEmpty({ a: null, b: '', c: [] })).toBe(true);
+  });
+
+  it('returns false for object with at least one non-empty value', () => {
+    expect(isDeepEmpty({ a: null, b: 'something' })).toBe(false);
+  });
+
+  it('returns true for nested all-empty object', () => {
+    expect(isDeepEmpty({ a: { b: null, c: [] } })).toBe(true);
+  });
+
+  it('returns false for nested object with a non-empty leaf', () => {
+    expect(isDeepEmpty({ a: { b: 'value' } })).toBe(false);
+  });
+
+  it('returns false for a number (non-null, non-string, non-array, non-object)', () => {
+    expect(isDeepEmpty(0)).toBe(false);
+    expect(isDeepEmpty(42)).toBe(false);
+  });
+
+  it('returns false for a boolean false', () => {
+    expect(isDeepEmpty(false)).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getSlideBoxWrapperMarginFromLiquidErrors
+// ---------------------------------------------------------------------------
+
+describe('getSlideBoxWrapperMarginFromLiquidErrors', () => {
+  it('returns 0 when liquidErrorMessage is null', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors(null)).toBe(0);
+  });
+
+  it('returns 0 when liquidErrorMessage is undefined', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors(undefined)).toBe(0);
+  });
+
+  it('returns 0 when both error arrays are empty', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors({
+      STANDARD_ERROR_MSG: [],
+      LIQUID_ERROR_MSG: [],
+    })).toBe(0);
+  });
+
+  it('returns 0 when neither error array is present', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors({})).toBe(0);
+  });
+
+  it('returns CAP_SPACE_64 when both STANDARD and LIQUID errors are present', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors({
+      STANDARD_ERROR_MSG: ['std error'],
+      LIQUID_ERROR_MSG: ['liquid error'],
+    })).toBe(CAP_SPACE_64);
+  });
+
+  it('returns CAP_SPACE_56 when only LIQUID errors are present', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors({
+      STANDARD_ERROR_MSG: [],
+      LIQUID_ERROR_MSG: ['liquid error'],
+    })).toBe(CAP_SPACE_56);
+  });
+
+  it('returns CAP_SPACE_32 when only STANDARD errors are present', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors({
+      STANDARD_ERROR_MSG: ['std error'],
+      LIQUID_ERROR_MSG: [],
+    })).toBe(CAP_SPACE_32);
+  });
+
+  it('returns CAP_SPACE_56 when LIQUID has multiple errors and STANDARD is absent', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors({
+      LIQUID_ERROR_MSG: ['err1', 'err2'],
+    })).toBe(CAP_SPACE_56);
+  });
+
+  it('returns CAP_SPACE_32 when STANDARD has multiple errors and LIQUID is absent', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors({
+      STANDARD_ERROR_MSG: ['err1', 'err2'],
+    })).toBe(CAP_SPACE_32);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// computeLiquidFooterUpdateFromFormBuilder
+// ---------------------------------------------------------------------------
+
+describe('computeLiquidFooterUpdateFromFormBuilder', () => {
+  const noErrors = { [LIQUID_ERROR_MSG]: [], [STANDARD_ERROR_MSG]: [] };
+  const liquidOnly = { [LIQUID_ERROR_MSG]: ['liquid err'], [STANDARD_ERROR_MSG]: [] };
+  const standardOnly = { [LIQUID_ERROR_MSG]: [], [STANDARD_ERROR_MSG]: ['std err'] };
+  const bothErrors = { [LIQUID_ERROR_MSG]: ['l'], [STANDARD_ERROR_MSG]: ['s'] };
+
+  describe('normal (non-null) returns', () => {
+    it('returns isLiquidValidationError=false when no errors', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, 1, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result).not.toBeNull();
+      expect(result.isLiquidValidationError).toBe(false);
+      expect(result.liquidErrorMessage).toEqual(noErrors);
+    });
+
+    it('sets isLiquidValidationError=true when liquid errors present', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(liquidOnly, 1, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result.isLiquidValidationError).toBe(true);
+    });
+
+    it('sets isLiquidValidationError=true when standard errors present', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(standardOnly, 1, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result.isLiquidValidationError).toBe(true);
+    });
+
+    it('sets isLiquidValidationError=true when both errors present', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(bothErrors, 1, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result.isLiquidValidationError).toBe(true);
+    });
+
+    it('maps tab 1 to ANDROID', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, 1, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result.activeFormBuilderTab).toBe(ANDROID);
+    });
+
+    it('maps tab 2 to IOS', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, 2, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result.activeFormBuilderTab).toBe(IOS);
+    });
+
+    it('maps tab 3 (or any other tab) to null', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, 3, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result.activeFormBuilderTab).toBeNull();
+    });
+
+    it('maps undefined tab to null for activeFormBuilderTab', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, undefined, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result.activeFormBuilderTab).toBeNull();
+    });
+
+    it('does NOT return null for Mobile Push when errors ARE present', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(liquidOnly, 1, {
+        previousIsLiquidValidationError: true,
+        currentChannelUpper: MOBILE_PUSH,
+      });
+      expect(result).not.toBeNull();
+      expect(result.isLiquidValidationError).toBe(true);
+    });
+
+    it('does NOT return null for non-Mobile Push channel even with previousIsLiquidValidationError', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, 1, {
+        previousIsLiquidValidationError: true,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result).not.toBeNull();
+      expect(result.isLiquidValidationError).toBe(false);
+    });
+
+    it('works without options argument (uses defaults)', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, 1);
+      expect(result).not.toBeNull();
+      expect(result.isLiquidValidationError).toBe(false);
+    });
+  });
+
+  describe('Mobile Push OLD clear (returns null)', () => {
+    it('returns null when no errors and previousIsLiquidValidationError is true for MOBILEPUSH', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, 1, {
+        previousIsLiquidValidationError: true,
+        currentChannelUpper: MOBILE_PUSH,
+      });
+      expect(result).toBeNull();
+    });
+
+    it('does NOT return null when previousIsLiquidValidationError is false for MOBILEPUSH', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, 1, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: MOBILE_PUSH,
+      });
+      expect(result).not.toBeNull();
+    });
+
+    it('does NOT return null when only standard errors cleared but liquid error remains for MOBILEPUSH', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(liquidOnly, 1, {
+        previousIsLiquidValidationError: true,
+        currentChannelUpper: MOBILE_PUSH,
+      });
+      // hasLiquid = true → condition !hasLiquid is false → does not return null
+      expect(result).not.toBeNull();
+    });
+  });
+});

package/v2Containers/CreativesContainer/tests/index.test.js

@@ -173,19 +173,35 @@ describe('Test SlideBoxContent container', () => {
     expect(getCreativesData).toHaveBeenCalledWith({ channel: 'RCS' });
   });
 
-  it('RCS getFormData does not attach smsFallBackContent to templateData', async () => {
-    renderFunction('RCS', 'editTemplate', rcsTemplates, rcsEditTemplateData);
+  it('RCS getFormData mirrors smsFallBackContent onto templateData for library round-trip', async () => {
+    renderedComponent = shallowWithIntl(
+      <Creatives
+        loyaltyMetaData={loyaltyMetaData}
+        Templates={rcsTemplates}
+        channel="RCS"
+        slidBoxContent="editTemplate"
+        templateData={rcsEditTemplateData}
+        handleCloseCreatives={handleCloseCreatives}
+        getCreativesData={getCreativesData}
+        isFullMode={false}
+        templateActions={{
+          getCdnTransformationConfig,
+        }}
+      />,
+    );
     renderedComponent.instance().onEditTemplate();
 
     const mockValue = {
+      validity: true,
       value: {
         name: 'rcs_creative_name',
+        type: 'RCS',
         versions: {
           base: {
             content: {
               RCS: {
                 rcsContent: { contentType: 'RICHCARD', cardType: 'STANDALONE', cardSettings: {}, cardContent: [{}] },
-                smsFallBackContent: { message: 'should-not-be-copied' },
+                smsFallBackContent: { message: 'fallback-body' },
               },
             },
           },
@@ -193,16 +209,62 @@ describe('Test SlideBoxContent container', () => {
       },
     };
 
-    renderedComponent
-      .find('CapSlideBox')
-      .props()
-      .content.props.getFormData(mockValue);
+    // Call getFormData on the container instance — shallow CapSlideBox `content` shape can differ across wrappers
+    renderedComponent.instance().getFormData(mockValue);
     await tick();
 
     const instance = renderedComponent.instance();
     expect(instance.state.templateData).toBeDefined();
-    // sms fallback content should not be set on templateData per current logic
-    expect(instance.state.templateData.smsFallBackContent).toBeUndefined();
+    expect(instance.state.templateData.smsFallBackContent).toEqual({ message: 'fallback-body' });
+  });
+
+  it('RCS getFormData mirrors rcsCardVarMapped onto templateData for campaign reopen', async () => {
+    renderedComponent = shallowWithIntl(
+      <Creatives
+        loyaltyMetaData={loyaltyMetaData}
+        Templates={rcsTemplates}
+        channel="RCS"
+        slidBoxContent="editTemplate"
+        templateData={rcsEditTemplateData}
+        handleCloseCreatives={handleCloseCreatives}
+        getCreativesData={getCreativesData}
+        isFullMode={false}
+        templateActions={{
+          getCdnTransformationConfig,
+        }}
+      />,
+    );
+    renderedComponent.instance().onEditTemplate();
+
+    const cardVarMapped = { 1: '[Name]', user_name: '[Name]' };
+    const mockValue = {
+      validity: true,
+      value: {
+        name: 'rcs_creative_name',
+        type: 'RCS',
+        versions: {
+          base: {
+            content: {
+              RCS: {
+                rcsContent: {
+                  contentType: 'RICHCARD',
+                  cardType: 'STANDALONE',
+                  cardSettings: {},
+                  cardContent: [{ title: 'Hi {{user_name}}', cardVarMapped }],
+                },
+                smsFallBackContent: {},
+              },
+            },
+          },
+        },
+      },
+    };
+
+    renderedComponent.instance().getFormData(mockValue);
+    await tick();
+
+    const instance = renderedComponent.instance();
+    expect(instance.state.templateData.rcsCardVarMapped).toEqual(cardVarMapped);
   });
 
   it('Text getCreatives data for rcs, data from creatives done to campaigns', async () => {

package/v2Containers/CreativesContainer/tests/useLocalTemplatesProp.test.js

@@ -0,0 +1,125 @@
+/**
+ * Covers local-templates flag resolution: nested `localTemplatesConfig.useLocalTemplates`
+ * vs top-level `useLocalTemplates` (embedded consumers / SlideBoxContent).
+ */
+import React from 'react';
+import { shallowWithIntl } from '../../../helpers/intl-enzym-test-helpers';
+import { Creatives } from '../index';
+import mockdata from '../../mockdata';
+
+const { smsTemplates, loyaltyMetaData } = mockdata;
+
+jest.mock('../../../v2Components/FormBuilder', () => ({
+  __esModule: true,
+  default: (props) => (
+    <div className="FormBuilder-mock" {...props}>
+      FormBuilder
+    </div>
+  ),
+}));
+
+const baseProps = {
+  loyaltyMetaData,
+  Templates: smsTemplates,
+  channel: 'SMS',
+  creativesMode: 'create',
+  templateData: null,
+  isFullMode: true,
+  handleCloseCreatives: jest.fn(),
+  getCreativesData: jest.fn(),
+  templateActions: {
+    getCdnTransformationConfig: jest.fn(),
+    resetTemplateStoreData: jest.fn(),
+  },
+  globalActions: {
+    clearMetaEntities: jest.fn(),
+  },
+};
+
+describe('CreativesContainer useLocalTemplates prop resolution', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('initial slidebox is templates when only top-level useLocalTemplates is true', () => {
+    const wrapper = shallowWithIntl(
+      <Creatives
+        {...baseProps}
+        useLocalTemplates
+      />,
+    );
+    expect(wrapper.instance().state.slidBoxContent).toBe('templates');
+  });
+
+  it('initial slidebox is templates when localTemplatesConfig.useLocalTemplates is true', () => {
+    const wrapper = shallowWithIntl(
+      <Creatives
+        {...baseProps}
+        localTemplatesConfig={{ useLocalTemplates: true }}
+      />,
+    );
+    expect(wrapper.instance().state.slidBoxContent).toBe('templates');
+  });
+
+  it('does not reset template store on unmount when embedded and top-level useLocalTemplates is true', () => {
+    const wrapper = shallowWithIntl(
+      <Creatives
+        {...baseProps}
+        location={{ query: { type: 'embedded' } }}
+        useLocalTemplates
+      />,
+    );
+    wrapper.unmount();
+    expect(baseProps.templateActions.resetTemplateStoreData).not.toHaveBeenCalled();
+    expect(baseProps.globalActions.clearMetaEntities).toHaveBeenCalled();
+  });
+
+  it('resets template store on unmount when embedded and local templates are not used', () => {
+    const wrapper = shallowWithIntl(
+      <Creatives
+        {...baseProps}
+        location={{ query: { type: 'embedded' } }}
+        useLocalTemplates={false}
+      />,
+    );
+    wrapper.unmount();
+    expect(baseProps.templateActions.resetTemplateStoreData).toHaveBeenCalled();
+    expect(baseProps.globalActions.clearMetaEntities).toHaveBeenCalled();
+  });
+
+  it('prefers nested localTemplatesConfig.useLocalTemplates=false over top-level true (not local list mode)', () => {
+    const wrapper = shallowWithIntl(
+      <Creatives
+        {...baseProps}
+        localTemplatesConfig={{ useLocalTemplates: false }}
+        useLocalTemplates
+      />,
+    );
+    expect(wrapper.instance().state.slidBoxContent).toBe('createTemplate');
+  });
+
+  it('uses top-level useLocalTemplates when localTemplatesConfig omits the flag', () => {
+    const wrapper = shallowWithIntl(
+      <Creatives
+        {...baseProps}
+        localTemplatesConfig={{}}
+        useLocalTemplates
+      />,
+    );
+    expect(wrapper.instance().state.slidBoxContent).toBe('templates');
+  });
+
+  it('resets template store when nested useLocalTemplates is false even if top-level is true', () => {
+    const wrapper = shallowWithIntl(
+      <Creatives
+        {...baseProps}
+        location={{ query: { type: 'embedded' } }}
+        localTemplatesConfig={{ useLocalTemplates: false }}
+        useLocalTemplates
+      />,
+    );
+    wrapper.unmount();
+    expect(baseProps.templateActions.resetTemplateStoreData).toHaveBeenCalled();
+    expect(baseProps.globalActions.clearMetaEntities).toHaveBeenCalled();
+  });
+});

package/v2Containers/Email/reducer.js

@@ -12,8 +12,6 @@ const initialState = fromJS({
   createTemplateInProgress: false,
   createResponse: {},
   isBeeEnabled: null,
-  fetchingCmsAccounts: false,
-  cmsAccountsLoaded: false,
 });
 
 function emailReducer(state = initialState, action) {
@@ -87,7 +85,6 @@ function emailReducer(state = initialState, action) {
     case types.GET_CMS_EDITOR_DETAILS_SUCCESS:
       return state
         .set('fetchingCmsSettings', false)
-        .set('isBeeEnabled', action.isBeeEnabled)
         .set('CmsSettings', fromJS(action.settings));
     case types.GET_CMS_EDITOR_DETAILS_FAILURE:
       return state
@@ -113,19 +110,13 @@ function emailReducer(state = initialState, action) {
         .set('fetchingCmsDataFailed', true);
     case types.GET_CMS_ACCOUNTS_REQUEST:
       return state
-        .set('isBeeEnabled', false)
-        .set('fetchingCmsAccounts', true)
-        .set('cmsAccountsLoaded', false);
+        .set('isBeeEnabled', false); // default to false
     case types.GET_CMS_ACCOUNTS_SUCCESS:
       return state
-        .set('isBeeEnabled', action.isBeeEnabled)
-        .set('fetchingCmsAccounts', false)
-        .set('cmsAccountsLoaded', true);
+        .set('isBeeEnabled', action.isBeeEnabled);
     case types.GET_CMS_ACCOUNTS_FAILURE:
       return state
-        .set('isBeeEnabled', false)
-        .set('fetchingCmsAccounts', false)
-        .set('cmsAccountsLoaded', true);
+        .set('isBeeEnabled', false);
     case types.CLEAR_EMAIL_CRUD_RESPONSE_REQUEST:
       return state
         .set('createResponse', fromJS({}));

package/v2Containers/Email/sagas.js

@@ -1,5 +1,5 @@
 import {
-  call, put, takeLatest, takeEvery, all, select, take,
+  call, put, takeLatest, takeEvery, all,
 } from 'redux-saga/effects';
 import CapNotification from '@capillarytech/cap-ui-library/CapNotification';
 import * as Api from '../../services/api';
@@ -103,19 +103,14 @@ export function* getAllAssets(assetType, queryParams) {
 }
 
 export function* getCmsSetting({
-  cmsType, projectId, cmsMode, langId, isEdmSupport, isBEEAppEnable: isBEEAppEnableFromAction,
+  cmsType, projectId, cmsMode, langId, isEdmSupport, isBEEAppEnable,
 }) {
   try {
-    const emailState = yield select((state) => state.get('email'));
-    if (!emailState.get('cmsAccountsLoaded') && emailState.get('fetchingCmsAccounts')) {
-      yield take([types.GET_CMS_ACCOUNTS_SUCCESS, types.GET_CMS_ACCOUNTS_FAILURE]);
-    }
-    const updatedState = yield select((state) => state.get('email'));
-    const isBEEAppEnable = updatedState.get('isBeeEnabled') ?? isBEEAppEnableFromAction;
     const result = yield call(Api.getCmsTemplateSettingsV2, cmsType, projectId, cmsMode, langId, isEdmSupport, isBEEAppEnable);
     const cmsAccountDetail = result.data?.response.cmsDetails || {};
     const isBeeEnabled = cmsAccountDetail?.type === cmsType;
-    yield put({ type: types.GET_CMS_EDITOR_DETAILS_SUCCESS, settings: cmsAccountDetail, isBeeEnabled });
+    yield put({ type: types.GET_CMS_ACCOUNTS_SUCCESS, isBeeEnabled });
+    yield put({ type: types.GET_CMS_EDITOR_DETAILS_SUCCESS, settings: result.data.response.cmsDetails });
   } catch (error) {
     yield put({ type: types.GET_CMS_EDITOR_DETAILS_FAILURE, error });
   }

package/v2Containers/Email/tests/__snapshots__/reducer.test.js.snap

@@ -5,8 +5,6 @@ Immutable.Map {
   "createTemplateInProgress": false,
   "createResponse": Immutable.Map {},
   "isBeeEnabled": null,
-  "fetchingCmsAccounts": false,
-  "cmsAccountsLoaded": false,
 }
 `;
 
@@ -15,7 +13,5 @@ Immutable.Map {
   "createTemplateInProgress": true,
   "createResponse": Immutable.Map {},
   "isBeeEnabled": null,
-  "fetchingCmsAccounts": false,
-  "cmsAccountsLoaded": false,
 }
 `;

package/v2Containers/Email/tests/reducer.test.js

@@ -16,53 +16,6 @@ describe('emailReducer', () => {
     expect(emailReducer(undefined, action)).toMatchSnapshot();
   });
 
-  it.concurrent('it handles GET_CMS_EDITOR_DETAILS_SUCCESS action — sets isBeeEnabled true and CmsSettings', () => {
-    const initialState = fromJS({ isBeeEnabled: null, fetchingCmsSettings: true });
-    const action = {
-      type: types.GET_CMS_EDITOR_DETAILS_SUCCESS,
-      isBeeEnabled: true,
-      settings: { isDragDrop: true, editorType: 'bee' },
-    };
-    const result = emailReducer(initialState, action);
-    expect(result.get('fetchingCmsSettings')).toBe(false);
-    expect(result.get('isBeeEnabled')).toBe(true);
-    expect(result.getIn(['CmsSettings', 'isDragDrop'])).toBe(true);
-  });
-
-  it.concurrent('it handles GET_CMS_EDITOR_DETAILS_SUCCESS action — sets isBeeEnabled false', () => {
-    const initialState = fromJS({ isBeeEnabled: true, fetchingCmsSettings: true });
-    const action = {
-      type: types.GET_CMS_EDITOR_DETAILS_SUCCESS,
-      isBeeEnabled: false,
-      settings: {},
-    };
-    const result = emailReducer(initialState, action);
-    expect(result.get('fetchingCmsSettings')).toBe(false);
-    expect(result.get('isBeeEnabled')).toBe(false);
-  });
-
-  it.concurrent('it handles GET_CMS_EDITOR_DETAILS_SUCCESS action — overwrites stale isBeeEnabled from CLEAR_ALL_VALUES (null)', () => {
-    const initialState = fromJS({ isBeeEnabled: null, fetchingCmsSettings: true });
-    const action = {
-      type: types.GET_CMS_EDITOR_DETAILS_SUCCESS,
-      isBeeEnabled: true,
-      settings: { type: 'bee' },
-    };
-    const result = emailReducer(initialState, action);
-    expect(result.get('isBeeEnabled')).toBe(true);
-  });
-
-  it.concurrent('it handles GET_CMS_EDITOR_DETAILS_SUCCESS action — sets CmsSettings to empty object when settings is {}', () => {
-    const initialState = fromJS({ CmsSettings: { old: 'data' } });
-    const action = {
-      type: types.GET_CMS_EDITOR_DETAILS_SUCCESS,
-      isBeeEnabled: false,
-      settings: {},
-    };
-    const result = emailReducer(initialState, action);
-    expect(result.get('CmsSettings').toJS()).toEqual({});
-  });
-
   it.concurrent('it handles GET_CMS_ACCOUNTS_REQUEST action (line 111-113)', () => {
     const initialState = fromJS({
       isBeeEnabled: true, // Start with true to verify it gets set to false