@capillarytech/creatives-library 8.0.342 → 8.0.343-alpha.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@capillarytech/creatives-library",
   "author": "meharaj",
-  "version": "8.0.342",
+  "version": "8.0.343-alpha.0",
   "description": "Capillary creatives ui",
   "main": "./index.js",
   "module": "./index.es.js",

package/v2Containers/Email/reducer.js

@@ -109,8 +109,7 @@ function emailReducer(state = initialState, action) {
         .set('fetchingCmsData', false)
         .set('fetchingCmsDataFailed', true);
     case types.GET_CMS_ACCOUNTS_REQUEST:
-      return state
-        .set('isBeeEnabled', false); // default to false
+      return state; // preserve null — "still pending", only update on SUCCESS/FAILURE
     case types.GET_CMS_ACCOUNTS_SUCCESS:
       return state
         .set('isBeeEnabled', action.isBeeEnabled);

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

@@ -16,15 +16,15 @@ describe('emailReducer', () => {
     expect(emailReducer(undefined, action)).toMatchSnapshot();
   });
 
-  it.concurrent('it handles GET_CMS_ACCOUNTS_REQUEST action (line 111-113)', () => {
+  it.concurrent('it handles GET_CMS_ACCOUNTS_REQUEST action (does not change isBeeEnabled)', () => {
     const initialState = fromJS({
-      isBeeEnabled: true, // Start with true to verify it gets set to false
+      isBeeEnabled: true, // preserved during request — "still pending"
     });
     const action = {
       type: types.GET_CMS_ACCOUNTS_REQUEST,
     };
     const result = emailReducer(initialState, action);
-    expect(result.get('isBeeEnabled')).toBe(false);
+    expect(result.get('isBeeEnabled')).toBe(true);
   });
 
   it.concurrent('it handles GET_CMS_ACCOUNTS_SUCCESS action (line 114-116)', () => {

package/v2Containers/EmailWrapper/hooks/useEmailWrapper.js

@@ -200,7 +200,9 @@ const useEmailWrapper = ({
     if (!isEditEmail) {
       return;
     }
-    const hasParamsId = params?.id || location?.query?.id || location?.params?.id || location?.pathname?.includes('/edit/');
+    const explicitId = params?.id || location?.query?.id || location?.params?.id;
+    const pathnameId = !explicitId && location?.pathname?.match(/\/edit\/([^/]+)/)?.[1];
+    const hasParamsId = explicitId || (pathnameId && pathnameId !== 'undefined');
     const hasTemplateDetails = Email?.templateDetails && !isEmpty(Email.templateDetails);
     const hasTemplateDataProp = templateData && !isEmpty(templateData);
     const isTemplateLoading = Email?.getTemplateDetailsInProgress;
@@ -230,13 +232,18 @@ const useEmailWrapper = ({
     // New flow: When template details are loaded and it's a BEE template, set it in Templates.BEETemplate
     // This allows Email component to properly initialize and call getCmsSetting
     const hasTemplateDetails = Email?.templateDetails && !isEmpty(Email.templateDetails);
+    const hasTemplateProp = templateData && !isEmpty(templateData);
     // Note: We check Email?.BEETemplate as a proxy, but the actual BEETemplate is in Templates reducer
     // The Email component will detect it via this.props.Templates.BEETemplate
     const hasBEETemplate = Email?.BEETemplate && !isEmpty(Email.BEETemplate);
 
-    if (hasTemplateDetails && !hasBEETemplate && templatesActions?.setBEETemplate && !beeTemplateSetRef.current) {
+    // Use Email.templateDetails when available (edit-by-ID flow), otherwise fall back to
+    // the templateData prop (BEE free template flow — template passed directly by consumer)
+    const editTemplateSource = hasTemplateDetails ? Email.templateDetails : (hasTemplateProp ? templateData : null);
+
+    if (editTemplateSource && !hasBEETemplate && templatesActions?.setBEETemplate && !beeTemplateSetRef.current) {
       // Check if it's a BEE template
-      const editTemplateData = Email.templateDetails;
+      const editTemplateData = editTemplateSource;
       const getIsDragDrop = (data) => {
         if (!data) return false;
         const baseDragDrop = get(data, 'versions.base.is_drag_drop', false);
@@ -265,13 +272,17 @@ const useEmailWrapper = ({
           || activeTabData.id
           || get(editTemplateData, 'versions.base.drag_drop_id')
           || get(editTemplateData, 'versions.base.id')
+          || get(editTemplateData, 'base.drag_drop_id')
+          || get(editTemplateData, 'base.id')
           || editTemplateData._id;
 
         const isBEESupport = (location?.query?.isBEESupport !== "false") || false;
         // IMPORTANT: isBEEAppEnable should be consistent across full mode and library mode
         // It represents whether BEE is enabled for the organization, not the mode
         // This ensures the same template behaves the same way in both modes
-        const isBEEAppEnable = checkBeeEditorEnabled();
+        // isDragDrop is always true here — pass true directly rather than relying on
+        // checkBeeEditorEnabled() which may return false while getCmsAccounts is pending
+        const isBEEAppEnable = isDragDrop || checkBeeEditorEnabled();
         // Check if we're in edit mode - check multiple sources for id
         const hasParamsId = params?.id
           || location?.query?.id
@@ -291,11 +302,11 @@ const useEmailWrapper = ({
       }
     }
 
-    // Reset ref when template changes (template details cleared)
-    if (!hasTemplateDetails && beeTemplateSetRef.current) {
+    // Reset ref when all template sources are gone (prevents duplicate calls on re-render)
+    if (!hasTemplateDetails && !hasTemplateProp && beeTemplateSetRef.current) {
       beeTemplateSetRef.current = false;
     }
-  }, [Email?.templateDetails, Email?.BEETemplate, Email?.getTemplateDetailsInProgress, Email?.fetchingCmsSettings, templatesActions, emailActions, params?.id, location?.query, checkBeeEditorEnabled, isFullMode]);
+  }, [Email?.templateDetails, Email?.BEETemplate, Email?.getTemplateDetailsInProgress, Email?.fetchingCmsSettings, templatesActions, emailActions, params?.id, location?.query, checkBeeEditorEnabled, isFullMode, templateData]);
 
   const onChange = useCallback((e) => {
     const { target: { value } } = e;

package/v2Containers/Viber/constants.js

@@ -3,6 +3,7 @@ import React from 'react';
 import CapHeading from "@capillarytech/cap-ui-library/CapHeading";
 import CapLabel from "@capillarytech/cap-ui-library/CapLabel";
 import messages from "./messages";
+import { createAsyncAssetUploadConstants } from '../../utils/asyncAssetUpload';
 
 export const DEFAULT_ACTION = 'app/v2Containers/Viber/DEFAULT_ACTION';
 export const ALLOWED_EXTENSIONS_REGEX = (/\.(jpe?g|png)$/i);
@@ -16,6 +17,13 @@ export const UPLOAD_VIBER_ASSET_REQUEST = 'app/v2Containers/Viber/UPLOAD_ASSET_R
 export const UPLOAD_VIBER_ASSET_SUCCESS = 'app/v2Containers/Viber/UPLOAD_ASSET_SUCCESS';
 export const UPLOAD_VIBER_ASSET_FAILURE = 'app/v2Containers/Viber/UPLOAD_ASSET_FAILURE';
 
+const viberAsyncPrefix = 'app/v2Containers/Viber';
+const asyncUploadConstants = createAsyncAssetUploadConstants('VIBER', viberAsyncPrefix);
+export const UPLOAD_VIBER_ASSET_PROCESSING = asyncUploadConstants.UPLOAD_VIBER_ASSET_PROCESSING;
+export const UPLOAD_VIBER_ASSET_COMPLETED = asyncUploadConstants.UPLOAD_VIBER_ASSET_COMPLETED;
+export const UPLOAD_VIBER_ASSET_FAILED = asyncUploadConstants.UPLOAD_VIBER_ASSET_FAILED;
+export const UPLOAD_VIBER_ASSET_TIMEOUT = asyncUploadConstants.UPLOAD_VIBER_ASSET_TIMEOUT;
+
 
 export const CREATE_VIBER_TEMPLATE_REQUEST = 'app/v2Containers/Viber/CREATE_VIBER_TEMPLATE_REQUEST';
 export const CREATE_VIBER_TEMPLATE_SUCCESS = 'app/v2Containers/Viber/CREATE_VIBER_TEMPLATE_SUCCESS';

package/v2Containers/Viber/index.js

@@ -419,6 +419,7 @@ export const Viber = (props) => {
       channel={VIBER}
       errorMessage={formatMessage(messages.videoErrorMessage)}
       showVideoNameAndDuration
+      assetUploading={viber?.assetUploading}
     />
   );
 
@@ -795,6 +796,10 @@ export const Viber = (props) => {
     ) {
       return true;
     }
+    // block submit while a media asset upload is still in progress
+    if ((isMediaTypeImage || isMediaTypeVideo) && viber?.assetUploading) {
+      return true;
+    }
     if (isBtnTypeCta && !isCtaSaved) {
       return true;
     }

package/v2Containers/Viber/messages.js

@@ -210,4 +210,8 @@ export default defineMessages({
     id: `${scope}.cancel`,
     defaultMessage: 'Cancel',
   },
+  assetIdMissingError: {
+    id: `${scope}.assetIdMissingError`,
+    defaultMessage: 'Asset upload initiated but no asset ID was returned from the server. Unable to track processing status.',
+  },
 });

package/v2Containers/Viber/reducer.js

@@ -6,10 +6,19 @@
 
 import { fromJS } from 'immutable';
 import * as types from './constants';
+import { createAsyncAssetUploadReducerCases } from '../../utils/asyncAssetUpload';
+
+const asyncUploadCases = createAsyncAssetUploadReducerCases({
+  PROCESSING: types.UPLOAD_VIBER_ASSET_PROCESSING,
+  COMPLETED: types.UPLOAD_VIBER_ASSET_COMPLETED,
+  FAILED: types.UPLOAD_VIBER_ASSET_FAILED,
+  TIMEOUT: types.UPLOAD_VIBER_ASSET_TIMEOUT,
+});
 
 const initialState = fromJS({
   uploadedAssetData: {},
   createTemplateInProgress: false,
+  assetProcessing: {},
 });
 
 function viberReducer(state = initialState, action) {
@@ -37,14 +46,25 @@ function viberReducer(state = initialState, action) {
       return state
       .set('uploadAssetSuccess', (action.statusCode !== undefined && action.statusCode !== '' && action.statusCode < 300))
       .set('assetUploading', false)
-      .set(action.templateType !== undefined ? `uploadedAssetData${action.templateType}` : 'uploadedAssetData', action.data);
+      .set(action.templateType !== undefined ? `uploadedAssetData${action.templateType}` : 'uploadedAssetData', fromJS(action.data));
     case types.UPLOAD_VIBER_ASSET_FAILURE:
       return state
       .set('uploadAssetSuccess', false)
       .set('assetUploading', false);
+    case asyncUploadCases.PROCESSING:
+      return asyncUploadCases.handleProcessing(state, action);
+    case asyncUploadCases.COMPLETED:
+      return asyncUploadCases.handleCompleted(state, action);
+    case asyncUploadCases.FAILED:
+      return asyncUploadCases.handleFailed(state, action);
+    case asyncUploadCases.TIMEOUT:
+      return asyncUploadCases.handleTimeout(state, action);
     case types.CLEAR_VIBER_ASSET:
       return state
-        .delete(action.templateType !== undefined ? `uploadedAssetData${action.templateType}` : 'uploadedAssetData');
+      .delete(action.templateType !== undefined ? `uploadedAssetData${action.templateType}` : 'uploadedAssetData')
+        .set('assetProcessing', fromJS({}))
+        .set('assetUploading', false)
+        .set('uploadAssetSuccess', false);
     // FOR EDIT
     case types.EDIT_VIBER_TEMPLATE_REQUEST:
       return state
@@ -75,7 +95,10 @@ function viberReducer(state = initialState, action) {
       return state
         .delete('uploadedAssetData')
         .delete('metaEntities')
-        .delete('templateDetails');
+        .delete('templateDetails')
+        .set('assetProcessing', fromJS({}))
+        .set('assetUploading', false)
+        .set('uploadAssetSuccess', false);
     default:
       return state;
   }

package/v2Containers/Viber/sagas.js

@@ -2,17 +2,59 @@ import {
   call, put, takeLatest, all,
 } from 'redux-saga/effects';
 import * as Api from '../../services/api';
+import { pollAssetStatus } from '../../sagas/assetPolling';
+import { createPollingConfig } from '../../utils/asyncAssetUpload';
+import { ASSET_STATUS } from '../../utils/assetStatusConstants';
 import * as types from './constants';
+import messages from './messages';
 
-export function* uploadViberAsset(file, assetType, fileParams ) {
+export function* uploadViberAsset(params) {
   try {
-    const result = yield call(Api.uploadFile, file, assetType, fileParams);
-    yield put({
-      type: types.UPLOAD_VIBER_ASSET_SUCCESS,
-      data: result.response.asset,
-      statusCode: result.status ? result.status.code : '',
-      templateType: file.templateType,
-    });
+    const result = yield call(Api.uploadFile, params);
+    const responseData = result?.response || {};
+    const statusCode = result?.status?.code || result?.statusCode;
+    const asset = responseData?.asset || responseData;
+
+    if (statusCode === 202 || responseData?.processingStatus === ASSET_STATUS.PROCESSING) {
+      const assetId = asset?._id || responseData?.assetId;
+      const { templateType } = params || {};
+      const assetType = params?.assetType || asset?.type?.toLowerCase() || 'image';
+
+      if (assetId) {
+        yield put({
+          type: types.UPLOAD_VIBER_ASSET_PROCESSING,
+          payload: {
+            assetId,
+            asset,
+            processingStatus: ASSET_STATUS.PROCESSING,
+          },
+        });
+
+        const actionTypes = {
+          COMPLETED: types.UPLOAD_VIBER_ASSET_COMPLETED,
+          FAILED: types.UPLOAD_VIBER_ASSET_FAILED,
+          TIMEOUT: types.UPLOAD_VIBER_ASSET_TIMEOUT,
+        };
+        const pollingConfig = createPollingConfig(assetType, assetId, actionTypes, templateType);
+        yield call(pollAssetStatus, pollingConfig);
+      } else {
+        yield put({
+          type: types.UPLOAD_VIBER_ASSET_FAILED,
+          payload: {
+            assetId: undefined,
+            error: messages.assetIdMissingError,
+          },
+          templateType,
+        });
+      }
+    } else {
+      yield put({
+        type: types.UPLOAD_VIBER_ASSET_SUCCESS,
+        data: asset,
+        statusCode,
+        templateType: params?.templateType,
+      });
+    }
   } catch (error) {
     yield put({ type: types.UPLOAD_VIBER_ASSET_FAILURE, error });
   }

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

@@ -303,4 +303,84 @@ describe('Test Viber container', () => {
     });
     expect(doneBtn).toBeDisabled();
   });
+
+  it('disables Done while a replacement video asset is uploading (finding 1)', async () => {
+    renderComponent({
+      actions: mockActions,
+      globalActions: mockGlobalActions,
+      templateData: { mode: 'create' },
+      viber: {
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        templateDetails: templateDetailsVideo,
+        // a new upload has started after the template was loaded
+        assetUploading: true,
+      },
+      location: {
+        pathname: '/sms/edit',
+        query: { type: false, module: 'default' },
+        search: '',
+      },
+      isFullMode: true,
+      params: { id: 'test' },
+      handleClose: jest.fn(),
+      metaEntities,
+      getDefaultTags,
+      injectedTags,
+    });
+    const doneBtn = screen.getByRole('button', { name: /done/i });
+    expect(doneBtn).toBeDisabled();
+  });
+
+  it('disables Done while an image asset is uploading (finding 1)', async () => {
+    renderComponent({
+      actions: mockActions,
+      globalActions: mockGlobalActions,
+      templateData: { mode: 'create' },
+      viber: {
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        templateDetails: templateDetailsImage,
+        assetUploading: true,
+      },
+      location: {
+        pathname: '/sms/edit',
+        query: { type: false, module: 'default' },
+        search: '',
+      },
+      isFullMode: true,
+      params: { id: 'test' },
+      handleClose: jest.fn(),
+    });
+    const doneBtn = screen.getByRole('button', { name: /done/i });
+    expect(doneBtn).toBeDisabled();
+  });
+
+  it('keeps Done enabled when assetUploading is true but media type is text', async () => {
+    renderComponent({
+      actions: mockActions,
+      globalActions: mockGlobalActions,
+      templateData: { mode: 'create' },
+      viber: {
+        uploadedAssetData: {},
+        createTemplateInProgress: false,
+        templateDetails: templateDetailsText,
+        // stale upload flag, but the form has no media so submission is safe
+        assetUploading: true,
+      },
+      location: {
+        pathname: '/sms/edit',
+        query: { type: false, module: 'default' },
+        search: '',
+      },
+      isFullMode: true,
+      params: { id: 'test' },
+      handleClose: jest.fn(),
+      metaEntities,
+      getDefaultTags,
+      injectedTags,
+    });
+    const doneBtn = screen.getByRole('button', { name: /done/i });
+    expect(doneBtn).toBeEnabled();
+  });
 });

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

@@ -0,0 +1,297 @@
+import { fromJS } from 'immutable';
+import viberReducer from '../reducer';
+import * as types from '../constants';
+import { ASSET_STATUS } from '../../../utils/assetStatusConstants';
+
+const initialState = fromJS({
+  uploadedAssetData: {},
+  createTemplateInProgress: false,
+  assetProcessing: {},
+});
+
+describe('viberReducer', () => {
+  it('returns initial state for unknown action', () => {
+    expect(viberReducer(undefined, { type: '@@INIT' })).toEqual(initialState);
+  });
+
+  describe('CREATE_VIBER_TEMPLATE_*', () => {
+    it('handles CREATE_VIBER_TEMPLATE_REQUEST', () => {
+      const next = viberReducer(initialState, {
+        type: types.CREATE_VIBER_TEMPLATE_REQUEST,
+      });
+      expect(next.get('createTemplateInProgress')).toBe(true);
+      expect(next.get('createTemplateError')).toBe(false);
+      expect(next.get('createTemplateErrorMessage')).toEqual(fromJS(''));
+    });
+
+    it('handles CREATE_VIBER_TEMPLATE_SUCCESS with status > 300', () => {
+      const next = viberReducer(initialState, {
+        type: types.CREATE_VIBER_TEMPLATE_SUCCESS,
+        data: { id: 'x' },
+        statusCode: 400,
+        errorMsg: 'oops',
+      });
+      expect(next.get('createTemplateInProgress')).toBe(false);
+      expect(next.get('response')).toEqual({ id: 'x' });
+      expect(next.get('createTemplateError')).toBe(true);
+      expect(next.get('createTemplateErrorMessage')).toEqual(fromJS('oops'));
+    });
+
+    it('handles CREATE_VIBER_TEMPLATE_SUCCESS with status <= 300', () => {
+      const next = viberReducer(initialState, {
+        type: types.CREATE_VIBER_TEMPLATE_SUCCESS,
+        data: { id: 'x' },
+        statusCode: 200,
+        errorMsg: '',
+      });
+      expect(next.get('createTemplateError')).toBe(false);
+    });
+
+    it('handles CREATE_VIBER_TEMPLATE_FAILURE', () => {
+      const next = viberReducer(initialState, {
+        type: types.CREATE_VIBER_TEMPLATE_FAILURE,
+        errorMsg: 'bad',
+      });
+      expect(next.get('createTemplateInProgress')).toBe(false);
+      expect(next.get('createTemplateError')).toBe(true);
+      expect(next.get('createTemplateErrorMessage')).toEqual(fromJS('bad'));
+    });
+  });
+
+  describe('UPLOAD_VIBER_ASSET_*', () => {
+    it('handles UPLOAD_VIBER_ASSET_REQUEST', () => {
+      const next = viberReducer(initialState, {
+        type: types.UPLOAD_VIBER_ASSET_REQUEST,
+      });
+      expect(next.get('uploadAssetSuccess')).toBe(false);
+      expect(next.get('assetUploading')).toBe(true);
+    });
+
+    it('handles UPLOAD_VIBER_ASSET_SUCCESS and wraps data with fromJS (finding 2)', () => {
+      const payload = { url: 'https://cdn/x.png', meta: { size: 100 } };
+      const next = viberReducer(initialState, {
+        type: types.UPLOAD_VIBER_ASSET_SUCCESS,
+        data: payload,
+        statusCode: 200,
+      });
+      expect(next.get('assetUploading')).toBe(false);
+      expect(next.get('uploadAssetSuccess')).toBe(true);
+      // must be wrapped in Immutable (same as asyncUploadCases.handleCompleted)
+      const stored = next.get('uploadedAssetData');
+      expect(stored).toEqual(fromJS(payload));
+      // verify it's actually an Immutable Map, not a plain JS object
+      expect(stored.toJS).toBeDefined();
+      expect(typeof stored.toJS).toBe('function');
+      expect(stored.get('url')).toBe(payload.url);
+    });
+
+    it('handles UPLOAD_VIBER_ASSET_SUCCESS with templateType key wrapped in fromJS', () => {
+      const payload = { url: 'https://cdn/y.mp4' };
+      const next = viberReducer(initialState, {
+        type: types.UPLOAD_VIBER_ASSET_SUCCESS,
+        data: payload,
+        statusCode: 200,
+        templateType: 3,
+      });
+      const stored = next.get('uploadedAssetData3');
+      expect(stored).toEqual(fromJS(payload));
+      expect(stored.get('url')).toBe(payload.url);
+    });
+
+    it('UPLOAD_VIBER_ASSET_SUCCESS sets uploadAssetSuccess false when status >= 300', () => {
+      const next = viberReducer(initialState, {
+        type: types.UPLOAD_VIBER_ASSET_SUCCESS,
+        data: {},
+        statusCode: 500,
+      });
+      expect(next.get('uploadAssetSuccess')).toBe(false);
+    });
+
+    it('UPLOAD_VIBER_ASSET_SUCCESS sync and async produce same shape', () => {
+      const asset = { url: 'https://cdn/same.png' };
+      const sync = viberReducer(initialState, {
+        type: types.UPLOAD_VIBER_ASSET_SUCCESS,
+        data: asset,
+        statusCode: 200,
+      });
+      const async_ = viberReducer(initialState, {
+        type: types.UPLOAD_VIBER_ASSET_COMPLETED,
+        payload: { assetId: 'a1', asset },
+      });
+      // Both paths should store uploadedAssetData as Immutable fromJS(asset)
+      expect(sync.get('uploadedAssetData')).toEqual(async_.get('uploadedAssetData'));
+    });
+
+    it('handles UPLOAD_VIBER_ASSET_FAILURE', () => {
+      const next = viberReducer(initialState, {
+        type: types.UPLOAD_VIBER_ASSET_FAILURE,
+      });
+      expect(next.get('uploadAssetSuccess')).toBe(false);
+      expect(next.get('assetUploading')).toBe(false);
+    });
+  });
+
+  describe('async polling cases', () => {
+    it('handles UPLOAD_VIBER_ASSET_PROCESSING', () => {
+      const next = viberReducer(initialState, {
+        type: types.UPLOAD_VIBER_ASSET_PROCESSING,
+        payload: { assetId: 'a1', asset: { id: 'a1' } },
+      });
+      expect(next.get('assetUploading')).toBe(true);
+      expect(next.get('uploadAssetSuccess')).toBe(false);
+      expect(next.getIn(['assetProcessing', 'a1', 'status'])).toBe(ASSET_STATUS.PROCESSING);
+    });
+
+    it('handles UPLOAD_VIBER_ASSET_COMPLETED', () => {
+      const next = viberReducer(initialState, {
+        type: types.UPLOAD_VIBER_ASSET_COMPLETED,
+        payload: { assetId: 'a1', asset: { url: 'https://cdn/x.png' } },
+      });
+      expect(next.get('assetUploading')).toBe(false);
+      expect(next.get('uploadAssetSuccess')).toBe(true);
+      expect(next.getIn(['assetProcessing', 'a1', 'status'])).toBe(ASSET_STATUS.COMPLETED);
+      expect(next.get('uploadedAssetData')).toEqual(fromJS({ url: 'https://cdn/x.png' }));
+    });
+
+    it('handles UPLOAD_VIBER_ASSET_FAILED', () => {
+      const next = viberReducer(initialState, {
+        type: types.UPLOAD_VIBER_ASSET_FAILED,
+        payload: { assetId: 'a1', error: 'boom' },
+      });
+      expect(next.get('assetUploading')).toBe(false);
+      expect(next.get('uploadAssetSuccess')).toBe(false);
+      expect(next.getIn(['assetProcessing', 'a1', 'status'])).toBe(ASSET_STATUS.FAILED);
+      expect(next.getIn(['assetProcessing', 'a1', 'error'])).toBe('boom');
+    });
+
+    it('handles UPLOAD_VIBER_ASSET_TIMEOUT', () => {
+      const next = viberReducer(initialState, {
+        type: types.UPLOAD_VIBER_ASSET_TIMEOUT,
+        payload: { assetId: 'a1', message: 'timed out' },
+      });
+      expect(next.get('assetUploading')).toBe(false);
+      expect(next.getIn(['assetProcessing', 'a1', 'status'])).toBe(ASSET_STATUS.TIMEOUT);
+      expect(next.getIn(['assetProcessing', 'a1', 'error'])).toBe('timed out');
+    });
+  });
+
+  describe('CLEAR_VIBER_ASSET (finding 3)', () => {
+    const dirtyState = initialState
+      .set('assetUploading', true)
+      .set('uploadAssetSuccess', true)
+      .set('uploadedAssetData', fromJS({ url: 'x' }))
+      .set('uploadedAssetData2', fromJS({ url: 'y' }))
+      .setIn(['assetProcessing', 'a1'], fromJS({ status: 'processing' }));
+
+    it('clears default uploadedAssetData and resets upload flags', () => {
+      const next = viberReducer(dirtyState, { type: types.CLEAR_VIBER_ASSET });
+      expect(next.has('uploadedAssetData')).toBe(false);
+      expect(next.get('assetProcessing')).toEqual(fromJS({}));
+      expect(next.get('assetUploading')).toBe(false);
+      expect(next.get('uploadAssetSuccess')).toBe(false);
+    });
+
+    it('clears templateType-specific uploadedAssetData and resets upload flags', () => {
+      const next = viberReducer(dirtyState, {
+        type: types.CLEAR_VIBER_ASSET,
+        templateType: 2,
+      });
+      expect(next.has('uploadedAssetData2')).toBe(false);
+      // default key untouched by specific clear
+      expect(next.has('uploadedAssetData')).toBe(true);
+      expect(next.get('assetProcessing')).toEqual(fromJS({}));
+      expect(next.get('assetUploading')).toBe(false);
+      expect(next.get('uploadAssetSuccess')).toBe(false);
+    });
+  });
+
+  describe('CLEAR_VIBER_DATA (finding 3 mirror)', () => {
+    it('clears assetProcessing, assetUploading, uploadAssetSuccess', () => {
+      const dirtyState = initialState
+        .set('assetUploading', true)
+        .set('uploadAssetSuccess', true)
+        .set('metaEntities', fromJS({ some: 'data' }))
+        .set('templateDetails', fromJS({ id: 'x' }))
+        .setIn(['assetProcessing', 'a1'], fromJS({ status: 'processing' }));
+      const next = viberReducer(dirtyState, { type: types.CLEAR_VIBER_DATA });
+      expect(next.has('uploadedAssetData')).toBe(false);
+      expect(next.has('metaEntities')).toBe(false);
+      expect(next.has('templateDetails')).toBe(false);
+      expect(next.get('assetProcessing')).toEqual(fromJS({}));
+      expect(next.get('assetUploading')).toBe(false);
+      expect(next.get('uploadAssetSuccess')).toBe(false);
+    });
+  });
+
+  describe('EDIT_VIBER_TEMPLATE_*', () => {
+    it('handles EDIT_VIBER_TEMPLATE_REQUEST', () => {
+      const next = viberReducer(initialState, {
+        type: types.EDIT_VIBER_TEMPLATE_REQUEST,
+      });
+      expect(next.get('editTemplateInProgress')).toBe(true);
+      expect(next.get('editTemplateError')).toBe(false);
+    });
+
+    it('handles EDIT_VIBER_TEMPLATE_SUCCESS', () => {
+      const next = viberReducer(initialState, {
+        type: types.EDIT_VIBER_TEMPLATE_SUCCESS,
+        data: { id: 'e' },
+        statusCode: 200,
+        errorMsg: '',
+      });
+      expect(next.get('editTemplateInProgress')).toBe(false);
+      expect(next.get('editResponse')).toEqual({ id: 'e' });
+      expect(next.get('editTemplateError')).toBe(false);
+    });
+
+    it('handles EDIT_VIBER_TEMPLATE_SUCCESS error status', () => {
+      const next = viberReducer(initialState, {
+        type: types.EDIT_VIBER_TEMPLATE_SUCCESS,
+        data: {},
+        statusCode: 500,
+        errorMsg: 'err',
+      });
+      expect(next.get('editTemplateError')).toBe(true);
+    });
+
+    it('handles EDIT_VIBER_TEMPLATE_FAILURE', () => {
+      const next = viberReducer(initialState, {
+        type: types.EDIT_VIBER_TEMPLATE_FAILURE,
+        errorMsg: 'nope',
+      });
+      expect(next.get('editTemplateError')).toBe(true);
+    });
+  });
+
+  describe('GET/CLEAR branches', () => {
+    it('handles GET_VIBER_TEMPLATE_DETAILS_REQUEST', () => {
+      const next = viberReducer(initialState, {
+        type: types.GET_VIBER_TEMPLATE_DETAILS_REQUEST,
+      });
+      expect(next.get('getTemplateDetailsInProgress')).toBe(true);
+    });
+
+    it('handles GET_VIBER_TEMPLATE_DETAILS_SUCCESS', () => {
+      const next = viberReducer(initialState, {
+        type: types.GET_VIBER_TEMPLATE_DETAILS_SUCCESS,
+        data: { id: 'd' },
+      });
+      expect(next.get('getTemplateDetailsInProgress')).toBe(false);
+      expect(next.get('templateDetails')).toEqual({ id: 'd' });
+    });
+
+    it('handles GET_VIBER_TEMPLATE_DETAILS_FAILURE / CLEAR_VIBER_EDIT_RESPONSE_REQUEST', () => {
+      const next = viberReducer(initialState, {
+        type: types.CLEAR_VIBER_EDIT_RESPONSE_REQUEST,
+      });
+      expect(next.get('editResponse')).toEqual({});
+    });
+
+    it('handles CLEAR_VIBER_CREATE_RESPONSE_REQUEST', () => {
+      const next = viberReducer(initialState, {
+        type: types.CLEAR_VIBER_CREATE_RESPONSE_REQUEST,
+      });
+      expect(next.get('response')).toEqual({});
+    });
+  });
+});

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

@@ -1,50 +1,305 @@
 import { expectSaga } from 'redux-saga-test-plan';
-import { call, put } from 'redux-saga/effects';
+import * as matchers from 'redux-saga-test-plan/matchers';
+import { call } from 'redux-saga/effects';
 import { throwError } from 'redux-saga-test-plan/providers';
 import * as Api from '../../../services/api';
 import * as sagas from '../sagas';
-import { v2ViberSagas } from '../sagas';
 import * as types from '../constants';
+import { pollAssetStatus } from '../../../sagas/assetPolling';
+import { ASSET_STATUS } from '../../../utils/assetStatusConstants';
+import messages from '../messages';
 
 describe('Viber Sagas', () => {
-  
   describe('uploadViberAsset Saga', () => {
-    const file = new Blob(['file contents'], { type: 'text/plain' });
-    const assetType = 'image';
-    const fileParams = { directory: 'profile', templateType: 'viber' };
+    const mockAsset = {
+      _id: 'asset-123',
+      type: 'IMAGE',
+      url: 'https://example.com/image.jpg',
+    };
 
-    it('handles uploading asset successfully', () => {
-      const fakeResponse = {
-        response: { asset: { id: 1, url: 'http://example.com/image.png' } },
-        status: { code: 200 }
+    const mockParams = {
+      file: new File(['test'], 'test.jpg', { type: 'image/jpeg' }),
+      assetType: 'image',
+      fileParams: {},
+      templateType: 0,
+    };
+
+    it('handles async upload (202) with polling', () => {
+      const mockResponse = {
+        status: { code: 202 },
+        response: {
+          assetId: 'asset-123',
+          asset: mockAsset,
+          processingStatus: ASSET_STATUS.PROCESSING,
+        },
+      };
+
+      return expectSaga(sagas.uploadViberAsset, mockParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+          [matchers.call.fn(pollAssetStatus), undefined],
+        ])
+        .put({
+          type: types.UPLOAD_VIBER_ASSET_PROCESSING,
+          payload: {
+            assetId: 'asset-123',
+            asset: mockAsset,
+            processingStatus: ASSET_STATUS.PROCESSING,
+          },
+        })
+        .call.fn(Api.uploadFile)
+        .call.fn(pollAssetStatus)
+        .run();
+    });
+
+    it('handles async when processingStatus is processing with 200 status', () => {
+      const mockResponse = {
+        status: { code: 200 },
+        response: {
+          assetId: 'asset-123',
+          asset: mockAsset,
+          processingStatus: ASSET_STATUS.PROCESSING,
+        },
       };
 
-      return expectSaga(sagas.uploadViberAsset, file, assetType, fileParams)
+      return expectSaga(sagas.uploadViberAsset, mockParams)
         .provide([
-          [call(Api.uploadFile, file, assetType, fileParams), fakeResponse]
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+          [matchers.call.fn(pollAssetStatus), undefined],
+        ])
+        .put({
+          type: types.UPLOAD_VIBER_ASSET_PROCESSING,
+          payload: {
+            assetId: 'asset-123',
+            asset: mockAsset,
+            processingStatus: ASSET_STATUS.PROCESSING,
+          },
+        })
+        .call.fn(pollAssetStatus)
+        .run();
+    });
+
+    it('handles sync upload (201) without polling', () => {
+      const mockResponse = {
+        status: { code: 201 },
+        response: {
+          asset: mockAsset,
+        },
+      };
+
+      return expectSaga(sagas.uploadViberAsset, mockParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
         ])
         .put({
           type: types.UPLOAD_VIBER_ASSET_SUCCESS,
-          data: fakeResponse.response.asset,
-          statusCode: fakeResponse.status.code,
-          templateType: undefined
+          data: mockAsset,
+          statusCode: 201,
+          templateType: 0,
         })
+        .not.call(pollAssetStatus)
         .run();
     });
 
-    it('handles asset upload failure', () => {
-      const error = new Error('Upload failed');
+    it('extracts assetId from asset._id when assetId omitted', () => {
+      const mockResponse = {
+        status: { code: 202 },
+        response: {
+          asset: { ...mockAsset, _id: 'asset-456' },
+          processingStatus: ASSET_STATUS.PROCESSING,
+        },
+      };
 
-      return expectSaga(sagas.uploadViberAsset, file, assetType, fileParams)
+      return expectSaga(sagas.uploadViberAsset, mockParams)
         .provide([
-          [call(Api.uploadFile, file, assetType, fileParams), throwError(error)]
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+          [matchers.call.fn(pollAssetStatus), undefined],
+        ])
+        .put({
+          type: types.UPLOAD_VIBER_ASSET_PROCESSING,
+          payload: {
+            assetId: 'asset-456',
+            asset: { ...mockAsset, _id: 'asset-456' },
+            processingStatus: ASSET_STATUS.PROCESSING,
+          },
+        })
+        .run();
+    });
+
+    it('dispatches FAILED when assetId missing on async response', () => {
+      const mockResponse = {
+        status: { code: 202 },
+        response: {
+          processingStatus: ASSET_STATUS.PROCESSING,
+        },
+      };
+
+      return expectSaga(sagas.uploadViberAsset, mockParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+        ])
+        .put({
+          type: types.UPLOAD_VIBER_ASSET_FAILED,
+          payload: {
+            assetId: undefined,
+            error: messages.assetIdMissingError,
+          },
+          templateType: 0,
+        })
+        .not.call(pollAssetStatus)
+        .run();
+    });
+
+    it('handles upload error', () => {
+      const uploadError = new Error('Upload failed');
+
+      return expectSaga(sagas.uploadViberAsset, mockParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), throwError(uploadError)],
         ])
         .put({
           type: types.UPLOAD_VIBER_ASSET_FAILURE,
-          error
+          error: uploadError,
+        })
+        .run();
+    });
+
+    it('falls back to statusCode on response when status object missing', () => {
+      const mockResponse = {
+        statusCode: 201,
+        response: { asset: mockAsset },
+      };
+      return expectSaga(sagas.uploadViberAsset, mockParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+        ])
+        .put({
+          type: types.UPLOAD_VIBER_ASSET_SUCCESS,
+          data: mockAsset,
+          statusCode: 201,
+          templateType: 0,
+        })
+        .run();
+    });
+
+    it('passes undefined statusCode through when no status info present (no default)', () => {
+      const mockResponse = { response: { asset: mockAsset } };
+      return expectSaga(sagas.uploadViberAsset, mockParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+        ])
+        .put({
+          type: types.UPLOAD_VIBER_ASSET_SUCCESS,
+          data: mockAsset,
+          statusCode: undefined,
+          templateType: 0,
         })
         .run();
     });
+
+    it('handles empty response object', () => {
+      const mockResponse = { status: { code: 201 } };
+      return expectSaga(sagas.uploadViberAsset, mockParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+        ])
+        .put({
+          type: types.UPLOAD_VIBER_ASSET_SUCCESS,
+          data: {},
+          statusCode: 201,
+          templateType: 0,
+        })
+        .run();
+    });
+
+    it('normalizes a flat async response (asset fields at top level) for polling', () => {
+      // API returns a flat asset object instead of { asset: {...} }
+      const flatResponse = {
+        status: { code: 202 },
+        response: {
+          _id: 'flat-asset-789',
+          type: 'VIDEO',
+          processingStatus: ASSET_STATUS.PROCESSING,
+        },
+      };
+      return expectSaga(sagas.uploadViberAsset, { ...mockParams, assetType: undefined })
+        .provide([
+          [matchers.call.fn(Api.uploadFile), flatResponse],
+          [matchers.call.fn(pollAssetStatus), undefined],
+        ])
+        .put({
+          type: types.UPLOAD_VIBER_ASSET_PROCESSING,
+          payload: {
+            assetId: 'flat-asset-789',
+            asset: flatResponse.response,
+            processingStatus: ASSET_STATUS.PROCESSING,
+          },
+        })
+        .call.fn(pollAssetStatus)
+        .run();
+    });
+
+    it('normalizes a flat sync response (asset fields at top level)', () => {
+      const flatAsset = { _id: 'flat-sync-1', url: 'https://cdn/x.jpg' };
+      const flatResponse = {
+        status: { code: 201 },
+        response: flatAsset,
+      };
+      return expectSaga(sagas.uploadViberAsset, mockParams)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), flatResponse],
+        ])
+        .put({
+          type: types.UPLOAD_VIBER_ASSET_SUCCESS,
+          data: flatAsset,
+          statusCode: 201,
+          templateType: 0,
+        })
+        .run();
+    });
+
+    it('derives assetType from asset.type when params.assetType omitted', () => {
+      const paramsWithoutType = {
+        file: new File(['v'], 'v.mp4', { type: 'video/mp4' }),
+        fileParams: {},
+        templateType: 1,
+      };
+      const mockResponse = {
+        status: { code: 202 },
+        response: {
+          assetId: 'asset-vid',
+          asset: { _id: 'asset-vid', type: 'VIDEO' },
+        },
+      };
+      return expectSaga(sagas.uploadViberAsset, paramsWithoutType)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+          [matchers.call.fn(pollAssetStatus), undefined],
+        ])
+        .call.fn(pollAssetStatus)
+        .run();
+    });
+
+    it('defaults assetType to image when no type info available', () => {
+      const paramsWithoutType = {
+        file: new File(['x'], 'x', { type: '' }),
+        fileParams: {},
+        templateType: 0,
+      };
+      const mockResponse = {
+        status: { code: 202 },
+        response: {
+          assetId: 'asset-noop',
+        },
+      };
+      return expectSaga(sagas.uploadViberAsset, paramsWithoutType)
+        .provide([
+          [matchers.call.fn(Api.uploadFile), mockResponse],
+          [matchers.call.fn(pollAssetStatus), undefined],
+        ])
+        .call.fn(pollAssetStatus)
+        .run();
+    });
   });
 
   describe('createViberTemplate Saga', () => {
@@ -54,18 +309,18 @@ describe('Viber Sagas', () => {
     it('handles creating template successfully', () => {
       const fakeResponse = {
         response: { id: 2, content: template.content },
-        status: { code: 201 }
+        status: { code: 201 },
       };
 
       return expectSaga(sagas.createViberTemplate, { template, callback })
         .provide([
-          [call(Api.createViberTemplate, { template }), fakeResponse]
+          [call(Api.createViberTemplate, { template }), fakeResponse],
         ])
         .put({
           type: types.CREATE_VIBER_TEMPLATE_SUCCESS,
           data: fakeResponse.response,
           statusCode: fakeResponse.status.code,
-          errorMsg: undefined
+          errorMsg: undefined,
         })
         .run()
         .then(() => {
@@ -76,21 +331,74 @@ describe('Viber Sagas', () => {
     it('handles failure in creating template', () => {
       const error = new Error({ message: 'Creation failed', status: { code: 400 } });
 
-        const errorMsg = 'Creation failed';
       return expectSaga(sagas.createViberTemplate, { template, callback })
         .provide([
-          [call(Api.createViberTemplate, { template }), throwError(error)]
+          [call(Api.createViberTemplate, { template }), throwError(error)],
         ])
         .put({
           type: types.CREATE_VIBER_TEMPLATE_FAILURE,
           error,
-          errorMsg : undefined
+          errorMsg: undefined,
         })
         .run()
         .then(() => {
           expect(callback).toHaveBeenCalledWith(null, undefined);
         });
     });
+
+    it('handles 4xx API response (treated as failure)', () => {
+      const cb = jest.fn();
+      const fakeResponse = {
+        response: {},
+        status: { code: 400 },
+        message: 'bad request',
+      };
+      return expectSaga(sagas.createViberTemplate, { template, callback: cb })
+        .provide([
+          [call(Api.createViberTemplate, { template }), fakeResponse],
+        ])
+        .put({
+          type: types.CREATE_VIBER_TEMPLATE_FAILURE,
+          error: 'bad request',
+          errorMsg: 'bad request',
+        })
+        .run()
+        .then(() => {
+          expect(cb).toHaveBeenCalledWith(null, 'bad request');
+        });
+    });
+
+    it('handles success when no callback is supplied', () => {
+      const fakeResponse = {
+        response: { id: 42 },
+        status: { code: 201 },
+      };
+      return expectSaga(sagas.createViberTemplate, { template })
+        .provide([
+          [call(Api.createViberTemplate, { template }), fakeResponse],
+        ])
+        .put({
+          type: types.CREATE_VIBER_TEMPLATE_SUCCESS,
+          data: fakeResponse.response,
+          statusCode: 201,
+          errorMsg: undefined,
+        })
+        .run();
+    });
+
+    it('handles failure when no callback is supplied', () => {
+      const error = new Error('Creation failed');
+      return expectSaga(sagas.createViberTemplate, { template })
+        .provide([
+          [call(Api.createViberTemplate, { template }), throwError(error)],
+        ])
+        .put({
+          type: types.CREATE_VIBER_TEMPLATE_FAILURE,
+          error,
+          errorMsg: undefined,
+        })
+        .run();
+    });
   });
 
   describe('editTemplate Saga', () => {
@@ -100,18 +408,18 @@ describe('Viber Sagas', () => {
     it('handles editing template successfully', () => {
       const fakeResponse = {
         response: { updated: true },
-        status: { code: 200 }
+        status: { code: 200 },
       };
 
       return expectSaga(sagas.editTemplate, { template, callback })
         .provide([
-          [call(Api.createViberTemplate, { template }), fakeResponse]
+          [call(Api.createViberTemplate, { template }), fakeResponse],
         ])
         .put({
           type: types.EDIT_VIBER_TEMPLATE_SUCCESS,
           data: fakeResponse.response,
           statusCode: fakeResponse.status.code,
-          errorMsg: undefined
+          errorMsg: undefined,
         })
         .run()
         .then(() => {
@@ -123,7 +431,7 @@ describe('Viber Sagas', () => {
       const errorMsg = 'Error in editing template';
       return expectSaga(sagas.editTemplate, { template, callback })
         .provide([
-          [call(Api.createViberTemplate, { template }), throwError({ message: errorMsg, status: { code: 400 } })]
+          [call(Api.createViberTemplate, { template }), throwError({ message: errorMsg, status: { code: 400 } })],
         ])
         .put({
           type: types.EDIT_VIBER_TEMPLATE_FAILURE,
@@ -135,6 +443,60 @@ describe('Viber Sagas', () => {
           expect(callback).toHaveBeenCalledWith(null, undefined);
         });
     });
+
+    it('handles 4xx API response (treated as failure)', () => {
+      const cb = jest.fn();
+      const fakeResponse = {
+        response: {},
+        status: { code: 422 },
+        message: 'invalid payload',
+      };
+      return expectSaga(sagas.editTemplate, { template, callback: cb })
+        .provide([
+          [call(Api.createViberTemplate, { template }), fakeResponse],
+        ])
+        .put({
+          type: types.EDIT_VIBER_TEMPLATE_FAILURE,
+          error: 'invalid payload',
+          errorMsg: 'invalid payload',
+        })
+        .run()
+        .then(() => {
+          expect(cb).toHaveBeenCalledWith(null, 'invalid payload');
+        });
+    });
+
+    it('handles success when no callback is supplied', () => {
+      const fakeResponse = {
+        response: { updated: true },
+        status: { code: 200 },
+      };
+      return expectSaga(sagas.editTemplate, { template })
+        .provide([
+          [call(Api.createViberTemplate, { template }), fakeResponse],
+        ])
+        .put({
+          type: types.EDIT_VIBER_TEMPLATE_SUCCESS,
+          data: fakeResponse.response,
+          statusCode: 200,
+          errorMsg: undefined,
+        })
+        .run();
+    });
+
+    it('handles failure when no callback is supplied', () => {
+      const error = new Error('Edit failed');
+      return expectSaga(sagas.editTemplate, { template })
+        .provide([
+          [call(Api.createViberTemplate, { template }), throwError(error)],
+        ])
+        .put({
+          type: types.EDIT_VIBER_TEMPLATE_FAILURE,
+          error,
+          errorMsg: undefined,
+        })
+        .run();
+    });
   });
 
   describe('getTemplateDetails Saga', () => {
@@ -143,16 +505,16 @@ describe('Viber Sagas', () => {
 
     it('handles fetching template details successfully', () => {
       const fakeResponse = {
-        response: { id: id, name: 'Detailed Template' }
+        response: { id, name: 'Detailed Template' },
       };
 
       return expectSaga(sagas.getTemplateDetails, { id, callback })
         .provide([
-          [call(Api.getTemplateDetails, { id, channel: 'VIBER' }), fakeResponse]
+          [call(Api.getTemplateDetails, { id, channel: 'VIBER' }), fakeResponse],
         ])
         .put({
           type: types.GET_VIBER_TEMPLATE_DETAILS_SUCCESS,
-          data: fakeResponse.response
+          data: fakeResponse.response,
         })
         .run()
         .then(() => {
@@ -165,23 +527,33 @@ describe('Viber Sagas', () => {
 
       return expectSaga(sagas.getTemplateDetails, { id, callback })
         .provide([
-          [call(Api.getTemplateDetails, { id, channel: 'VIBER' }), throwError(error)]
+          [call(Api.getTemplateDetails, { id, channel: 'VIBER' }), throwError(error)],
         ])
         .put({
           type: types.GET_VIBER_TEMPLATE_DETAILS_FAILURE,
-          error
+          error,
         })
         .run()
         .then(() => {
           expect(callback).not.toHaveBeenCalledWith();
         });
     });
-  });
 
-  describe('v2ViberSagas Combined', () => {
-    it('should initialize all Viber-related watcher sagas without error', () => {
-      return expectSaga(v2ViberSagas).run();
+    it('handles success without a callback', () => {
+      const fakeResponse = { response: { id, name: 'No CB' } };
+      return expectSaga(sagas.getTemplateDetails, { id })
+        .provide([
+          [call(Api.getTemplateDetails, { id, channel: 'VIBER' }), fakeResponse],
+        ])
+        .put({
+          type: types.GET_VIBER_TEMPLATE_DETAILS_SUCCESS,
+          data: fakeResponse.response,
+        })
+        .run();
     });
   });
 
-});
+  describe('v2ViberSagas Combined', () => {
+    it('should initialize all Viber-related watcher sagas without error', () => expectSaga(sagas.v2ViberSagas).run());
+  });
+});