@capillarytech/creatives-library 8.0.113 → 8.0.114-alpha.1

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

@@ -6,171 +6,257 @@ import * as types from "../constants";
 
 
 describe("zalo reducer", () => {
-  let state;
-  const action = {};
-  beforeEach(() => {
-    state = fromJS({
-      uploadedAssetData: {},
-      createTemplateInProgress: false,
-      editTemplateInProgress: false,
-    });
-  });
-
   describe("Reducer : INAPP_TEMPLATE_CREATE_REQUEST", () => {
-    it("should handle INAPP_TEMPLATE_CREATE_REQUEST action", () => {
-      state = state
+    it.concurrent("should handle INAPP_TEMPLATE_CREATE_REQUEST action", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        editTemplateInProgress: false,
+      });
+      const expectedResult = state
         .set("createTemplateInProgress", true)
         .set("createTemplateError", false)
         .set("createTemplateErrorMessage", "");
-      const expectedResult = state;
-      expect(inAppReducer(state, actions.createInAppTemplate({}))).toEqual(
-        expectedResult
-      );
+      expect(inAppReducer(state, actions.createInAppTemplate({}))).toEqual(expectedResult);
     });
-    it("should handle INAPP_TEMPLATE_CREATE_SUCCESS action", () => {
-      action.type = types.INAPP_TEMPLATE_CREATE_SUCCESS;
-      action.data = 'data';
-      state = state
+
+    it.concurrent("should handle INAPP_TEMPLATE_CREATE_SUCCESS action", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        editTemplateInProgress: false,
+      });
+      const action = {
+        type: types.INAPP_TEMPLATE_CREATE_SUCCESS,
+        data: 'data',
+      };
+      const expectedResult = state
         .set("createTemplateInProgress", false)
         .set("createTemplateError", false)
         .set("createTemplateErrorMessage", undefined)
         .set('response', 'data');
-      const expectedResult = state;
       expect(inAppReducer(state, action)).toEqual(expectedResult);
     });
-    it("should handle INAPP_TEMPLATE_CREATE_FAILURE action", () => {
-      action.type = types.INAPP_TEMPLATE_CREATE_FAILURE;
-      action.errorMsg = 'error';
-      state = state
+
+    it.concurrent("should handle INAPP_TEMPLATE_CREATE_FAILURE action", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        editTemplateInProgress: false,
+      });
+      const action = {
+        type: types.INAPP_TEMPLATE_CREATE_FAILURE,
+        errorMsg: 'error',
+      };
+      const expectedResult = state
         .set("createTemplateInProgress", false)
         .set('createTemplateError', true)
         .set('createTemplateErrorMessage', fromJS(action.errorMsg));
-      const expectedResult = state;
       expect(inAppReducer(state, action)).toEqual(expectedResult);
     });
   });
   describe("Reducer : INAPP_EDIT_TEMPLATE_REQUEST", () => {
-    it("should handle INAPP_EDIT_TEMPLATE_REQUEST action", () => {
-      state = state
+    it.concurrent("should handle INAPP_EDIT_TEMPLATE_REQUEST action", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        editTemplateInProgress: false,
+      });
+      const expectedResult = state
         .set("editTemplateInProgress", true)
         .set("editTemplateError", false)
         .set("editTemplateErrorMessage", "");
-      const expectedResult = state;
       expect(inAppReducer(state, actions.editTemplate({}))).toEqual(
         expectedResult
       );
     });
-    it("should handle INAPP_EDIT_TEMPLATE_SUCCESS action", () => {
-      action.type = types.INAPP_EDIT_TEMPLATE_SUCCESS;
-      action.data = 'data';
-      action.statusCode = 200;
-      state = state
+    it.concurrent("should handle INAPP_EDIT_TEMPLATE_SUCCESS action", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        editTemplateInProgress: false,
+      });
+      const action = {
+        type: types.INAPP_EDIT_TEMPLATE_SUCCESS,
+        data: 'data',
+        statusCode: 200,
+      };
+      const expectedResult = state
         .set("editTemplateInProgress", false)
         .set("editTemplateError", false)
-        .set("editTemplateErrorMessage", 'error')
+        .set("editTemplateErrorMessage", undefined)
         .set('editResponse', 'data');
-      const expectedResult = state;
       expect(inAppReducer(state, action)).toEqual(expectedResult);
     });
-    it("should handle INAPP_EDIT_TEMPLATE_FAILURE action", () => {
-      action.type = types.INAPP_EDIT_TEMPLATE_FAILURE;
-      action.errorMsg = 'error';
-      state = state
+    it.concurrent("should handle INAPP_EDIT_TEMPLATE_FAILURE action", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        editTemplateInProgress: false,
+      });
+      const action = {
+        type: types.INAPP_EDIT_TEMPLATE_FAILURE,
+        errorMsg: 'error',
+      };
+      const expectedResult = state
         .set("editTemplateInProgress", false)
         .set('editTemplateError', true)
         .set('editTemplateErrorMessage', fromJS(action.errorMsg));
-      const expectedResult = state;
       expect(inAppReducer(state, action)).toEqual(expectedResult);
     });
 
-    it("should handle default action", () => {
-      action.type = "deafult_action";
+    it.concurrent("should handle default action", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        editTemplateInProgress: false,
+      });
+      const action = {
+        type: "deafult_action",
+      };
       const expectedResult = state;
       expect(inAppReducer(state, action)).toEqual(expectedResult);
     });
   });
   describe("Reducer : GET_TEMPLATE_DETAILS_REQUEST", () => {
-    it("should handle GET_TEMPLATE_DETAILS_REQUEST action", () => {
-      state = state
-        .set("getTemplateDetailsInProgress", true);
+    it.concurrent("should handle GET_TEMPLATE_DETAILS_REQUEST action", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        editTemplateInProgress: false,
+        getTemplateDetailsInProgress: true,
+      });
       const expectedResult = state;
       expect(inAppReducer(state, actions.getTemplateDetails({}))).toEqual(
         expectedResult
       );
     });
-    it("should handle INAPP_EDIT_TEMPLATE_SUCCESS action", () => {
-      action.type = types.GET_INAPP_TEMPLATE_DETAILS_SUCCESS;
-      action.data = 'data';
-      action.statusCode = 200;
-      state = state
-        .set("getTemplateDetailsInProgress", false)
-        .set('templateDetails', 'data');
+    it.concurrent("should handle INAPP_EDIT_TEMPLATE_SUCCESS action", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        editTemplateInProgress: false,
+        getTemplateDetailsInProgress: false,
+        templateDetails: 'data',
+      });
+      const action = {
+        type: types.GET_INAPP_TEMPLATE_DETAILS_SUCCESS,
+        data: 'data',
+        statusCode: 200,
+      };
       const expectedResult = state;
       expect(inAppReducer(state, action)).toEqual(expectedResult);
     });
-    it("should handle GET_TEMPLATE_DETAILS_FAILURE action", () => {
-      action.type = types.GET_INAPP_TEMPLATE_DETAILS_FAILURE;
-      action.errorMsg = 'error';
-      state = state
-        .set("getTemplateDetailsInProgress", false);
+    it.concurrent("should handle GET_TEMPLATE_DETAILS_FAILURE action", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        editTemplateInProgress: false,
+        getTemplateDetailsInProgress: false,
+      });
+      const action = {
+        type: types.GET_INAPP_TEMPLATE_DETAILS_FAILURE,
+        errorMsg: 'error',
+      };
       const expectedResult = state;
       expect(inAppReducer(state, action)).toEqual(expectedResult);
     });
-    it("should handle CLEAR_CREATE_RESPONSE_REQUEST action", () => {
-      action.type = types.CLEAR_CREATE_RESPONSE_REQUEST;
-      state = state
-        .set("response", {});
-      const expectedResult = state;
+    it.concurrent("should handle CLEAR_CREATE_RESPONSE_REQUEST action", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        editTemplateInProgress: false,
+        response: {},
+      });
+      const action = {
+        type: types.CLEAR_CREATE_RESPONSE_REQUEST,
+      };
+      const expectedResult = state.set("response", {});
       expect(inAppReducer(state, action)).toEqual(expectedResult);
     });
-    it("should handle RESET_EDIT_TEMPLATE action", () => {
-      action.type = types.RESET_EDIT_TEMPLATE;
-      state = state
-        .set("templateDetails", {});
-      const expectedResult = state;
+    it.concurrent("should handle RESET_EDIT_TEMPLATE action", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        editTemplateInProgress: false,
+        templateDetails: {},
+      });
+      const action = {
+        type: types.RESET_EDIT_TEMPLATE,
+      };
+      const expectedResult = state.set("templateDetails", {});
       expect(inAppReducer(state, action)).toEqual(expectedResult);
     });
   });
   describe("Reducer : UPLOAD_INAPP_ASSET_REQUEST", () => {
-    it("should handle UPLOAD_INAPP_ASSET_REQUEST action", () => {
-      state = state
-        .set("uploadAssetSuccess", false)
-        .set("assetUploading", true);
+    it.concurrent("should handle UPLOAD_INAPP_ASSET_REQUEST action", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        editTemplateInProgress: false,
+        uploadAssetSuccess: false,
+        assetUploading: true,
+      });
       const expectedResult = state;
       expect(inAppReducer(state, actions.uploadInAppAsset({}))).toEqual(
         expectedResult
       );
     });
-    it("should handle UPLOAD_INAPP_ASSET_SUCCESS action", () => {
-      action.type = types.UPLOAD_INAPP_ASSET_SUCCESS;
-      action.data = 'data';
-      action.statusCode = 200;
-      state = state
+    it.concurrent("should handle UPLOAD_INAPP_ASSET_SUCCESS action", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        editTemplateInProgress: false,
+        getTemplateDetailsInProgress: false,
+        assetUploading: false,
+        uploadAssetSuccess: false,
+      });
+      const action = {
+        type: types.UPLOAD_INAPP_ASSET_SUCCESS,
+        data: 'data',
+        statusCode: 200,
+      };
+      const expectedResult = state
         .set("getTemplateDetailsInProgress", false)
         .set('assetUploading', false)
         .set('uploadAssetSuccess', true)
         .set('uploadedAssetData', 'data');
-      const expectedResult = state;
       expect(inAppReducer(state, action)).toEqual(expectedResult);
     });
-    it("should handle UPLOAD_INAPP_ASSET_FAILURE action", () => {
-      action.type = types.UPLOAD_INAPP_ASSET_FAILURE;
-      action.errorMsg = 'error';
-      state = state
+    it.concurrent("should handle UPLOAD_INAPP_ASSET_FAILURE action", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        editTemplateInProgress: false,
+        uploadAssetSuccess: false,
+        assetUploading: false,
+      });
+      const action = {
+        type: types.UPLOAD_INAPP_ASSET_FAILURE,
+        errorMsg: 'error',
+      };
+      const expectedResult = state
         .set("assetUploading", false)
         .set('uploadAssetSuccess', false);
-      const expectedResult = state;
       expect(inAppReducer(state, action)).toEqual(expectedResult);
     });
-    it("should handle CLEAR_INAPP_ASSET action", () => {
-      action.type = types.CLEAR_INAPP_ASSET;
-      action.errorMsg = 'error';
-      action.data = 'data';
-      state = state
+    it.concurrent("should handle CLEAR_INAPP_ASSET action", () => {
+      const state = fromJS({
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        editTemplateInProgress: false,
+        assetUploading: false,
+        uploadAssetSuccess: false,
+      });
+      const action = {
+        type: types.CLEAR_INAPP_ASSET,
+        errorMsg: 'error',
+        data: 'data',
+      };
+      const expectedResult = state
         .set("assetUploading", false)
         .delete('uploadedAssetData', {})
         .set('uploadAssetSuccess', false);
-      const expectedResult = state;
       expect(inAppReducer(state, action)).toEqual(expectedResult);
     });
   });

package/v2Containers/InApp/tests/sagas.test.js

@@ -387,7 +387,7 @@ describe('test for getTemplateDetails', () => {
     expect(gen.next().value).toEqual(
       takeLatest(types.GET_INAPP_TEMPLATE_DETAILS_REQUEST, sagas.getTemplateDetails),
     );
-    console.log('gen.next().value', gen.next());
+
     // Pass the mock task to the takeLatest effect
     expect(gen.next(mockTask).done).toBe(true);
 

package/v2Containers/InApp/tests/utils.test.js

@@ -0,0 +1,41 @@
+import { hasPlatformErrors } from "../utils";
+
+describe("hasPlatformErrors", () => {
+  it("Happy case for hasPlatformErrors", () => {
+    const result = hasPlatformErrors();
+    expect(result).toBe(false);
+  });
+  it("returns false when called with no arguments", () => {
+    expect(hasPlatformErrors()).toBe(false);
+  });
+
+  it("returns false when given null or undefined", () => {
+    expect(hasPlatformErrors(null)).toBe(false);
+    expect(hasPlatformErrors(undefined)).toBe(false);
+  });
+
+  it("returns false for empty error groups", () => {
+    const emptyGroup = { ANDROID: [], IOS: [], GENERIC: [] };
+    expect(hasPlatformErrors(emptyGroup)).toBe(false);
+  });
+
+  it("detects Android errors", () => {
+    const data = { ANDROID: ["e1"], IOS: [], GENERIC: [] };
+    expect(hasPlatformErrors(data)).toBe(true);
+  });
+
+  it("detects iOS errors", () => {
+    const data = { ANDROID: [], IOS: ["e1"], GENERIC: [] };
+    expect(hasPlatformErrors(data)).toBe(true);
+  });
+
+  it("detects generic errors", () => {
+    const data = { ANDROID: [], IOS: [], GENERIC: ["e1"] };
+    expect(hasPlatformErrors(data)).toBe(true);
+  });
+
+  it("detects mixed platform errors", () => {
+    const data = { ANDROID: ["a"], IOS: ["i"], GENERIC: [] };
+    expect(hasPlatformErrors(data)).toBe(true);
+  });
+});

package/v2Containers/InApp/utils.js

@@ -10,3 +10,40 @@ export const getCtaObject = (ctaData) =>
     };
     return obj;
   });
+
+// Helper functions to check for errors
+/**
+ * Checks if a platform-specific error group (like STANDARD_ERROR_MSG or LIQUID_ERROR_MSG)
+ * contains any errors for ANDROID, IOS, or GENERIC platforms.
+ *
+ * @param {object} platformErrorGroup - The error group object (e.g., errorMessage.STANDARD_ERROR_MSG).
+ * @returns {boolean} True if any platform has errors, false otherwise.
+ */
+export const hasPlatformErrors = (platformErrorGroup) => {
+  if (!platformErrorGroup) {
+    return false;
+  }
+  return (
+    platformErrorGroup.ANDROID?.length > 0
+    || platformErrorGroup.IOS?.length > 0
+    || platformErrorGroup.GENERIC?.length > 0
+  );
+};
+
+
+/**
+   * Checks the main errorMessage object for any standard or liquid errors
+   * across all supported platforms.
+   *
+   * @param {object} errorMessage - The main error object.
+   * @returns {boolean} True if any errors are present, false otherwise.
+   */
+export const hasAnyErrors = (errorMessage) => {
+  if (!errorMessage) {
+    return false;
+  }
+  return (
+    hasPlatformErrors(errorMessage.STANDARD_ERROR_MSG)
+    || hasPlatformErrors(errorMessage.LIQUID_ERROR_MSG)
+  );
+};

package/v2Containers/LanguageProvider/tests/actions.test.js

@@ -8,7 +8,7 @@ import {
 
 describe('LanguageProvider actions', () => {
   describe('Change Local Action', () => {
-    it('has a type of CHANGE_LOCALE', () => {
+    test.concurrent('has a type of CHANGE_LOCALE', () => {
       const expected = {
         type: CHANGE_LOCALE,
         locale: 'de',

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

@@ -7,7 +7,7 @@ import {
 } from '../constants';
 
 describe('languageProviderReducer', () => {
-  it('returns the initial state', () => {
+  it.concurrent('returns the initial state', () => {
     expect(languageProviderReducer(undefined, {})).toEqual(fromJS({
       locale: 'en',
       languageLocale: 'en',
@@ -16,7 +16,7 @@ describe('languageProviderReducer', () => {
     }));
   });
 
-  it('changes the locale', () => {
+  it.concurrent('changes the locale', () => {
     expect(languageProviderReducer(undefined, { type: CHANGE_LOCALE, locale: 'en', languageLocale: 'en' }).toJS()).toEqual({
       locale: "en",
       languageLocale: "en",
@@ -25,7 +25,7 @@ describe('languageProviderReducer', () => {
     });
   });
 
-  it('make locize message request', () => {
+  it.concurrent('make locize message request', () => {
     expect(languageProviderReducer(undefined, { type: GET_LOCIZ_MESSAGE_REQUEST, locale: 'en', languageLocale: 'en' }).toJS()).toEqual({
       locale: "en",
       languageLocale: 'en',

package/v2Containers/LanguageProvider/tests/saga.test.js

@@ -9,7 +9,7 @@ describe('getLocizMessage saga', () => {
   const locale = 'en-US';
   const action = { locale };
 
-  it('handles successful API call', () => {
+  it.concurrent('handles successful API call', () => {
     const response = { messages: { hello: "Hello" } }; // Example response structure
 
     return expectSaga(getLocizMessage, action)
@@ -24,7 +24,7 @@ describe('getLocizMessage saga', () => {
       .run();
   });
 
-  it('handles failure when API call fails', () => {
+  it.concurrent('handles failure when API call fails', () => {
     const error = new Error('Failed to fetch localization messages');
 
     return expectSaga(getLocizMessage, action)

package/v2Containers/LanguageProvider/tests/selectors.test.js

@@ -5,7 +5,7 @@ import {
 } from '../selectors';
 
 describe('selectLanguage', () => {
-  it('should select the global state', () => {
+  it.concurrent('should select the global state', () => {
     const globalState = fromJS({});
     const mockedState = fromJS({
       language: globalState,

package/v2Containers/Line/Container/ImageCarousel/tests/utils.test.js

@@ -1,13 +1,13 @@
 import { calculateAspectRatio } from '../utils';
 
 describe('calculateAspectRatio -- Test', () => {
-  it('Should return aspect ratio 1:1', () =>
+  it.concurrent('Should return aspect ratio 1:1', () =>
     expect(calculateAspectRatio(400, 400)).toEqual('1:1'));
-  it('Should return aspect ratio 1:2', () =>
+  it.concurrent('Should return aspect ratio 1:2', () =>
     expect(calculateAspectRatio(400, 800)).toEqual('1:2'));
 });
 
 describe('calculateGCD -- Test', () => {
-  it('Should return gcd', () =>
+  it.concurrent('Should return gcd', () =>
     expect(calculateAspectRatio(400, 400)).toEqual('1:1'));
 });

package/v2Containers/Line/Container/Sticker/tests/utils.test.js

@@ -9,29 +9,29 @@ import {
 } from './mockData';
 
 describe('groupLineStickers', () => {
-  it('should return empty object when input is empty', () => {
+  it.concurrent('should return empty object when input is empty', () => {
     expect(groupLineStickers(emptyInputs.emptyObject)).toEqual(emptyInputs.expectedOutput);
     expect(groupLineStickers(emptyInputs.nullInput)).toEqual(emptyInputs.expectedOutput);
     expect(groupLineStickers(emptyInputs.undefinedInput)).toEqual(emptyInputs.expectedOutput);
   });
 
-  it('should handle input with no valid packageIds', () => {
+  it.concurrent('should handle input with no valid packageIds', () => {
     expect(groupLineStickers(noValidPackageIdsInput.input)).toEqual(noValidPackageIdsInput.expectedOutput);
   });
 
-  it('should group stickers by packageId within single category', () => {
+  it.concurrent('should group stickers by packageId within single category', () => {
     expect(groupLineStickers(singleCategoryInput.input)).toEqual(singleCategoryInput.expectedOutput);
   });
 
-  it('should group stickers by packageId across multiple categories', () => {
+  it.concurrent('should group stickers by packageId across multiple categories', () => {
     expect(groupLineStickers(multipleCategoriesInput.input)).toEqual(multipleCategoriesInput.expectedOutput);
   });
 
-  it('should skip non-array categories', () => {
+  it.concurrent('should skip non-array categories', () => {
     expect(groupLineStickers(nonArrayCategoriesInput.input)).toEqual(nonArrayCategoriesInput.expectedOutput);
   });
 
-  it('should handle mixed valid and invalid sticker data', () => {
+  it.concurrent('should handle mixed valid and invalid sticker data', () => {
     expect(groupLineStickers(mixedStickerDataInput.input)).toEqual(mixedStickerDataInput.expectedOutput);
   });
 }); 

package/v2Containers/MobilePush/Create/index.js

@@ -208,7 +208,7 @@ export class Create extends React.Component { // eslint-disable-line react/prefe
         formData: newFormData,
         tabCount,
         isSchemaChanged:
-          compareValue.toLowerCase() === EXTERNAL_LINK_LOWERCASE ||
+          compareValue?.toLowerCase() === EXTERNAL_LINK_LOWERCASE ||
           !this.state?.isSchemaChanged,
       },
       () => {
@@ -386,6 +386,7 @@ export class Create extends React.Component { // eslint-disable-line react/prefe
     return response;
   };
   setFormValidity = (isFormValid, errorData) => {
+
     const newState = {isFormValid, errorData};
     this.setState(newState);
   };
@@ -1485,26 +1486,26 @@ export class Create extends React.Component { // eslint-disable-line react/prefe
     } = obj || {};
     const label = this.props.location.pathname.indexOf('image') >= 0 ? 'image' : 'text';
     this.props.actions.createTemplate(obj, (response) => {
-      const timeTaken = GA.timeTracker.stopTimer(TRACK_CREATE_MPUSH, {
-        category: 'Creatives',
-        action: TRACK_CREATE_MPUSH,
-        label,
-      });
-      gtmPush('creativeDetails', {
-        id: response.templateId,
-        name: obj.name,
-        channel: MOBILE_PUSH,
-        timeTaken,
-        content,
-        mode: CREATE,
-        imageAdded: definitionMode === 'image',
-      });
+    const timeTaken = GA.timeTracker.stopTimer(TRACK_CREATE_MPUSH, {
+      category: 'Creatives',
+      action: TRACK_CREATE_MPUSH,
+      label,
+    });
+    gtmPush('creativeDetails', {
+      id: response.templateId,
+      name: obj.name,
+      channel: MOBILE_PUSH,
+      timeTaken,
+      content,
+      mode: CREATE,
+      imageAdded: definitionMode === 'image',
+    });
 
-      this.discardValues();
-      const message = this.props.intl.formatMessage(messages.messageCreateSuccess);
-      CapNotification.success({message, key: 'createMpushSuccess'});
-      this.props.actions.clearCreateResponse();
-      this.props.getFormLibraryData({validity: true});
+    this.discardValues();
+    const message = this.props.intl.formatMessage(messages.messageCreateSuccess);
+    CapNotification.success({message, key: 'createMpushSuccess'});
+    this.props.actions.clearCreateResponse();
+    this.props.getFormLibraryData({validity: true});
     });
   };
   deleteSecondaryCtaIos = (callback) => {
@@ -1776,7 +1777,9 @@ export class Create extends React.Component { // eslint-disable-line react/prefe
           <CapRow>
             <CapColumn>
               <FormBuilder
+                channel={MOBILE_PUSH}
                 key={"form builder"}
+                showLiquidErrorInFooter={this.props.showLiquidErrorInFooter}
                 schema={this.state.schema}
                 onSubmit={this.saveFormData}
                 onChange={this.onFormDataChange}
@@ -1902,6 +1905,7 @@ Create.propTypes = {
   onPreviewContentClicked: PropTypes.func,
   onTestContentClicked: PropTypes.func,
   eventContextTags: PropTypes.array,
+  showLiquidErrorInFooter: PropTypes.func,
 };
 
 const mapStateToProps = createStructuredSelector({

package/v2Containers/MobilePush/Create/test/saga.test.js

@@ -7,12 +7,12 @@ import {
 
 describe("MPUSH Sagas", () => {
   describe("v2MobilePushCreateSagas Combined", () => {
-    it("should initialize all mpush-related watcher sagas without error", () => {
+    it.concurrent("should initialize all mpush-related watcher sagas without error", () => {
       return expectSaga(v2MobilePushCreateSagas).run();
     });
   });
   describe("v2MobilePushWatchDuplicateTemplateSaga Combined", () => {
-    it("should initialize all mpush-related watcher sagas without error", () => {
+    it.concurrent("should initialize all mpush-related watcher sagas without error", () => {
       return expectSaga(v2MobilePushWatchDuplicateTemplateSaga).run();
     });
   });