@capillarytech/creatives-library 1.0.0 → 1.0.1-alpha.0

package/components/pages/Cap/tests/saga.test.js

@@ -0,0 +1,2661 @@
+import { expectSaga } from 'redux-saga-test-plan';
+import { takeLatest } from 'redux-saga/effects';
+import * as matchers from 'redux-saga-test-plan/matchers';
+import { throwError } from 'redux-saga-test-plan/providers';
+import * as utilsLocalStorageApi from '@capillarytech/cap-ui-utils/utils/utilsLocalStorageApi';
+import * as api from '../../../../services/api';
+import * as constants from '../../App/constants';
+import {
+  GET_CUSTOM_LABELS_REQUEST,
+  GET_CUSTOM_LABELS_SUCCESS,
+  GET_CUSTOM_LABELS_FAILURE,
+  UPSERT_CUSTOM_LABELS_REQUEST,
+  UPSERT_CUSTOM_LABELS_SUCCESS,
+  UPSERT_CUSTOM_LABELS_FAILURE,
+  CHECK_RECONFIGURE_REQUEST,
+  CHECK_RECONFIGURE_SUCCESS,
+  CHECK_RECONFIGURE_FAILURE,
+  GET_TIME_ZONE_REQUEST,
+  GET_TIME_ZONE_SUCCESS,
+  GET_TIME_ZONE_FAILURE,
+  GET_SIDEBAR_MENU_DATA_REQUEST,
+  GET_SIDEBAR_MENU_DATA_SUCCESS,
+  GET_SIDEBAR_MENU_DATA_FAILURE,
+  GET_TOPBAR_MENU_DATA_REQUEST,
+  GET_TOPBAR_MENU_DATA_SUCCESS,
+  GET_TOPBAR_MENU_DATA_FAILURE,
+  SWITCH_ORG_REQUEST,
+  SWITCH_ORG_SUCCESS,
+  SWITCH_ORG_FAILURE,
+  GET_TIER_REQUEST,
+  GET_TIER_SUCCESS,
+  GET_TIER_FAILURE,
+  GET_USER_LIST_REQUEST,
+  GET_USER_LIST_SUCCESS,
+  GET_USER_LIST_FAILURE,
+  GET_CUSTOMER_ACTIVITY_REQUEST,
+  GET_CUSTOMER_ACTIVITY_SUCCESS,
+  GET_CUSTOMER_ACTIVITY_FAILURE,
+  GET_ALL_SENDER_DETAILS_REQUEST,
+  GET_ALL_SENDER_DETAILS_SUCCESS,
+  GET_ALL_SENDER_DETAILS_FAILURE,
+  GET_STRATEGY_NO_REFRESH_REQUEST,
+  GET_PROGRAMS_REQUEST,
+  GET_PROGRAMS_SUCCESS,
+  GET_PROGRAMS_FAILURE,
+  GET_BULK_CONFIG_STATUS_REQUEST,
+  GET_BULK_CONFIG_STATUS_SUCCESS,
+  GET_BULK_CONFIG_STATUS_FAILURE,
+  GET_USER_GROUP_V2_STATUS_REQUEST,
+  GET_USER_GROUP_V2_STATUS_SUCCESS,
+  GET_USER_GROUP_V2_STATUS_FAILURE,
+  GET_EMF_STATUS_REQUEST,
+  GET_EMF_STATUS_SUCCESS,
+  GET_EMF_STATUS_FAILURE,
+  UPSERT_ACTION_REQUEST,
+  UPSERT_ACTION_SUCCESS,
+  UPSERT_ACTION_FAILURE,
+  GET_STRATEGY_REQUEST,
+  GET_STRATEGY_SUCCESS,
+  GET_STRATEGY_FAILURE,
+  GET_SENDER_DETAILS_REQUEST,
+  GET_SENDER_DETAILS_SUCCESS,
+  GET_SENDER_DETAILS_FAILURE,
+  GET_MAPPED_ENTITIES_REQUEST,
+  GET_MAPPED_ENTITIES_SUCCESS,
+  GET_MAPPED_ENTITIES_FAILURE,
+  GET_FIELD_DATA_REQUEST,
+  GET_FIELD_DATA_SUCCESS,
+  GET_FIELD_DATA_FAILURE,
+  GET_PROGRAM_FILTER_TYPE_REQUEST,
+  GET_PROGRAM_FILTER_TYPE_SUCCESS,
+  GET_PROGRAM_FILTER_TYPE_FAILURE,
+  GET_ORG_KPI_CONFIG_REQUEST,
+  GET_ORG_KPI_CONFIG_SUCCESS,
+  GET_ORG_KPI_CONFIG_FAILURE,
+  LAST_SYNC_TIME_REQUEST,
+  LAST_SYNC_TIME_SUCCESS,
+  LAST_SYNC_TIME_FAILURE,
+  GET_USER_DATA_REQUEST,
+  GET_USER_DATA_SUCCESS,
+  GET_USER_DATA_FAILURE,
+  LOGOUT_REQUEST,
+  LOGIN_SUCCESS,
+  LOGOUT_SUCCESS,
+  LOGOUT_FAILURE,
+  GET_SUPPORT_VIDEOS_CONFIG_REQUEST,
+  GET_SUPPORT_VIDEOS_CONFIG_SUCCESS,
+  GET_SUPPORT_VIDEOS_CONFIG_FAILURE,
+  GET_GROUP_REDEMPTION_STATUS_REQUEST,
+  GET_GROUP_REDEMPTION_STATUS_SUCCESS,
+  GET_GROUP_REDEMPTION_STATUS_FAILURE,
+  ALTERNATE_CURRENCY_FLAG_REQUEST,
+  ALTERNATE_CURRENCY_FLAG_SUCCESS,
+  ALTERNATE_CURRENCY_FLAG_FAILURE,
+  GET_PROGRAM_CONFIG_REQUEST,
+  GET_PROGRAM_CONFIG_SUCCESS,
+  GET_PROGRAM_CONFIG_FAILURE,
+  SAVE_PROGRAM_CONFIG_REQUEST,
+  SAVE_PROGRAM_CONFIG_SUCCESS,
+  SAVE_PROGRAM_CONFIG_FAILURE,
+  GET_CDN_TRANSFORMATION_CONFIG_REQUEST,
+  GET_MULTIPLE_EXTENDED_FIELDS_SUCCESS,
+  GET_MULTIPLE_EXTENDED_FIELDS_FAILURE,
+  GET_MULTIPLE_EXTENDED_FIELDS_REQUEST,
+  GET_ADDITIONAL_SLAB_UPGRADE_RENEWAL_FAILURE,
+  GET_ADDITIONAL_SLAB_UPGRADE_RENEWAL_SUCCESS,
+  GET_ADDITIONAL_SLAB_UPGRADE_RENEWAL_REQUEST,
+  SEGREGATE_PROMOTIONS_FLAG_REQUEST,
+  SEGREGATE_PROMOTIONS_FLAG_SUCCESS,
+  SEGREGATE_PROMOTIONS_FLAG_FAILURE,
+} from '../constants';
+import {
+  getCustomLabels,
+  watchForGetCustomLabels,
+  upsertCustomLabel,
+  watchForUpsertCustomLabel,
+  checkReconfigureProgram,
+  watchForCheckReconfigurationProgram,
+  getTimeZone,
+  watchForGetTimeZone,
+  getSidebarMenuData,
+  watchGetSidebarMenuData,
+  getTopbarMenuData,
+  watchGetTopbarMenuData,
+  switchOrgSuccess,
+  watchForOrgChangeSuccess,
+  getTier,
+  watchForGetTier,
+  getUsersByIds,
+  watchForGetUsersByIds,
+  getCustomerActivity,
+  watchGetCustomerActivityRequest,
+  getAllSenderDetails,
+  watchForGetAllSenderDetails,
+  getStrategiesDataNoRefresh,
+  watchForGetStrategiesNoRefresh,
+  getPrograms,
+  watchForGetPrograms,
+  getBulkConfigStatus,
+  watchForBulkConfigStatus,
+  getUserGroupV2Status,
+  watchForUserGroupV2Status,
+  getEMFStatus,
+  watchForEMFStatus,
+  upsertAction,
+  watchForUpsertAction,
+  getStrategies,
+  watchForGetStrategies,
+  getSenderDetails,
+  watchGetSenderDetails,
+  getMappedEntities,
+  watchForGetMappedEntities,
+  getProgramFieldData,
+  watchForGetProgramFieldData,
+  getProgramFilterType,
+  watchForGetProgramFilterType,
+  getOrgKpiConfig,
+  watchForGetOrgKpiConfig,
+  getLastSyncTime,
+  watchForGetLastSyncTime,
+  fetchUserInfo,
+  watchForFetchUserInfo,
+  switchOrg,
+  watchForOrgChange,
+  logoutFlow,
+  watchForLogoutFlow,
+  loginSuccess,
+  watchForLoginSuccess,
+  logoutSuccess,
+  watchForLogoutSuccess,
+  watchForGetVideosConfig,
+  getSupportVideosConfig,
+  getGroupRedemptionStatus,
+  watchForGroupRedemptionStatus,
+  getAlternateCurrencyFlag,
+  watchForAlternateCurrencyFlag,
+  saveProgramConfig,
+  watchForSaveProgramConfig,
+  getProgramConfig,
+  watchForGetProgramConfig,
+  watchForGetCDNConfig,
+  getCdnTransformationConfig,
+  watchGetExtendedField,
+  getMultipleExtendedFields,
+  getAdditionalSlabUpgradeAndRenewal,
+  watchForAdditionalSlabUpgradeAndRenewal,
+  watchForSegregatePromotionsFlag,
+  getSegregatePromotionsFlag,
+} from '../saga';
+import {
+  validResponseGetSupportVideoConfig,
+  customLabelsResult,
+  error,
+  upsertCustomLabelResult,
+  upsertCustomLabelPayload,
+  getTimeZoneResult,
+  getSidebarMenuDataResult,
+  getTopbarMenuDataResult,
+  switchOrgSuccessResult,
+  getTierResult,
+  getUsersByIdsResult,
+  getCustomerActivityResult,
+  getAllSenderDetailsResult,
+  getStrategiesDataNoRefreshResult,
+  getProgramsResult,
+  getBulkConfigStatusResult,
+  getUserGroupV2StatusResult,
+  getAlternateCurrencyFlagResult,
+  getEMFStatusResult,
+  upsertActionResult,
+  getStrategiesResult,
+  getSenderDetailsResult,
+  getMappedEntitiesResult,
+  getProgramFieldDataResult,
+  getProgramFilterTypeResult,
+  getOrgKpiConfigResult,
+  getLastSyncTimeResult,
+  fetchUserInfoResult,
+  switchOrgResult,
+  logoutFlowResult,
+  loginSuccessResult,
+  logoutSuccessResult,
+  loginFlowResult,
+  authorizeResult,
+  mockData,
+  getSegregatePromotionsFlagResult,
+} from '../mocks/data';
+import { setAuthenticationDetails } from '../../../../utils/authWrapper';
+import { mockAPIResponseCDN } from '../../../organisms/AlternateCurrencyList/tests/mockData';
+
+const { getTopbarMenuDataValue, getSettingsMenuData } = constants;
+
+const {
+  callback,
+  successCallback,
+  programId,
+  userIds,
+  orgID,
+  source,
+  actionType,
+  payload,
+  filter,
+  channels,
+  orgUnitId,
+  filterType,
+  res,
+  user,
+} = mockData;
+
+describe('getCustomLabels saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getCustomLabels)
+      .provide([
+        [
+          matchers.call.fn(api.getCustomLabels),
+          { customLabelsResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_CUSTOM_LABELS_SUCCESS,
+        result: customLabelsResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getCustomLabels)
+      .provide([
+        [
+          matchers.call.fn(api.getCustomLabels),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_CUSTOM_LABELS_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getCustomLabels)
+      .provide([[matchers.call.fn(api.getCustomLabels), throwError(error)]])
+      .put({
+        type: GET_CUSTOM_LABELS_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+//////////////////////
+describe('getTimeZone saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getTimeZone)
+      .provide([
+        [
+          matchers.call.fn(api.getTimeZone),
+          { getTimeZoneResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_TIME_ZONE_SUCCESS,
+        result: getTimeZoneResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getTimeZone)
+      .provide([
+        [
+          matchers.call.fn(api.getTimeZone),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_TIME_ZONE_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getTimeZone)
+      .provide([[matchers.call.fn(api.getTimeZone), throwError(error)]])
+      .put({
+        type: GET_TIME_ZONE_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getSidebarMenuData saga', () => {
+  it('handle valid response', () => {
+    expectSaga(getSidebarMenuData)
+      .provide([
+        [
+          matchers.call.fn(getSidebarMenuData),
+          { getSidebarMenuDataResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_SIDEBAR_MENU_DATA_SUCCESS,
+        result: getSidebarMenuDataResult,
+      })
+      .run();
+  });
+
+  it('handle error response', () => {
+    expectSaga(getSidebarMenuData)
+      .provide([
+        [
+          matchers.call.fn(getSidebarMenuData),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_SIDEBAR_MENU_DATA_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response', () => {
+    expectSaga(getSidebarMenuData)
+      .provide([[matchers.call.fn(getSettingsMenuData), throwError(error)]])
+      .put({
+        type: GET_SIDEBAR_MENU_DATA_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getTopbarMenuData saga', () => {
+  it('handle valid response', () => {
+    expectSaga(getTopbarMenuData, {
+      hasNewUIPromotionEnabled: true,
+      hasBulkConfigEnabled: true,
+    })
+      .provide([
+        [
+          matchers.call.fn(getTopbarMenuData),
+          { getTopbarMenuDataResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_TOPBAR_MENU_DATA_SUCCESS,
+        result: getTopbarMenuDataResult,
+      })
+      .run();
+  });
+  it('handle error response', () => {
+    expectSaga(getTopbarMenuData, {
+      hasNewUIPromotionEnabled: true,
+      hasBulkConfigEnabled: true,
+    })
+      .provide([
+        [
+          matchers.call.fn(getTopbarMenuData),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_TOPBAR_MENU_DATA_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+  it('handle error response', () => {
+    expectSaga(getTopbarMenuData, {
+      hasNewUIPromotionEnabled: true,
+      hasBulkConfigEnabled: true,
+    })
+      .provide([[matchers.call.fn(getTopbarMenuDataValue), throwError(error)]])
+      .put({
+        type: GET_TOPBAR_MENU_DATA_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getTier saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getTier, {
+      programId,
+    })
+      .provide([
+        [matchers.call.fn(api.getTier), { getTierResult, success: true }],
+      ])
+      .put({
+        type: GET_TIER_SUCCESS,
+        result: getTierResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getTier, {
+      programId,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getTier),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_TIER_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getTier, {
+      programId,
+    })
+      .provide([[matchers.call.fn(api.getTier), throwError(error)]])
+      .put({
+        type: GET_TIER_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getUsersByIds saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getUsersByIds, {
+      userIds,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getUsersByIds),
+          { getUsersByIdsResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_USER_LIST_SUCCESS,
+        result: getUsersByIdsResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getUsersByIds, {
+      userIds,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getUsersByIds),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_USER_LIST_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getUsersByIds, {
+      userIds,
+    })
+      .provide([[matchers.call.fn(api.getUsersByIds), throwError(error)]])
+      .put({
+        type: GET_USER_LIST_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getCustomerActivity saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getCustomerActivity, {
+      programId,
+      source,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getCustomerActivity),
+          { getCustomerActivityResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_CUSTOMER_ACTIVITY_SUCCESS,
+        result: getCustomerActivityResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getCustomerActivity, {
+      programId,
+      source,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getCustomerActivity),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_CUSTOMER_ACTIVITY_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getCustomerActivity, {
+      programId,
+      source,
+    })
+      .provide([[matchers.call.fn(api.getCustomerActivity), throwError(error)]])
+      .put({
+        type: GET_CUSTOMER_ACTIVITY_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getAllSenderDetails saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getAllSenderDetails)
+      .provide([
+        [
+          matchers.call.fn(api.getAllSenderDetails),
+          { getAllSenderDetailsResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_ALL_SENDER_DETAILS_SUCCESS,
+        result: getAllSenderDetailsResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getAllSenderDetails)
+      .provide([
+        [
+          matchers.call.fn(api.getAllSenderDetails),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_ALL_SENDER_DETAILS_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getAllSenderDetails)
+      .provide([[matchers.call.fn(api.getAllSenderDetails), throwError(error)]])
+      .put({
+        type: GET_ALL_SENDER_DETAILS_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getStrategiesDataNoRefresh saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getStrategiesDataNoRefresh, {
+      programId,
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getStrategies),
+          { getStrategiesDataNoRefreshResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_STRATEGY_NO_REFRESH_REQUEST,
+        result: getStrategiesDataNoRefreshResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getStrategiesDataNoRefresh, {
+      programId,
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getStrategies),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getStrategiesDataNoRefresh, {
+      programId,
+      callback,
+    })
+      .provide([[matchers.call.fn(api.getStrategies), throwError(error)]])
+      .put({
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getPrograms saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getPrograms)
+      .provide([
+        [
+          matchers.call.fn(api.getPrograms),
+          { getProgramsResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_PROGRAMS_SUCCESS,
+        result: getProgramsResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getPrograms)
+      .provide([
+        [
+          matchers.call.fn(api.getPrograms),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_PROGRAMS_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getPrograms)
+      .provide([[matchers.call.fn(api.getPrograms), throwError(error)]])
+      .put({
+        type: GET_PROGRAMS_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getBulkConfigStatus saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getBulkConfigStatus, {
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getBulkConfigStatus),
+          { getBulkConfigStatusResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_BULK_CONFIG_STATUS_SUCCESS,
+        result: getBulkConfigStatusResult,
+      })
+      .run();
+  });
+
+  it('handle response - "0" from api', () => {
+    expectSaga(getBulkConfigStatus, {
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getBulkConfigStatus),
+          { result: '0', success: true },
+        ],
+      ])
+      .put({
+        type: GET_BULK_CONFIG_STATUS_SUCCESS,
+        result: getBulkConfigStatusResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getBulkConfigStatus, {
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getBulkConfigStatus),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_BULK_CONFIG_STATUS_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getBulkConfigStatus, {
+      callback,
+    })
+      .provide([[matchers.call.fn(api.getBulkConfigStatus), throwError(error)]])
+      .put({
+        type: GET_BULK_CONFIG_STATUS_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getUserGroupV2Status saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getUserGroupV2Status, {
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getUserGroupV2Status),
+          { getUserGroupV2StatusResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_USER_GROUP_V2_STATUS_SUCCESS,
+        result: getUserGroupV2StatusResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getUserGroupV2Status, {
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getUserGroupV2Status),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_USER_GROUP_V2_STATUS_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getUserGroupV2Status, {
+      callback,
+    })
+      .provide([
+        [matchers.call.fn(api.getUserGroupV2Status), throwError(error)],
+      ])
+      .put({
+        type: GET_USER_GROUP_V2_STATUS_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getEMFStatus saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getEMFStatus, {
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getEMFStatus),
+          { getEMFStatusResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_EMF_STATUS_SUCCESS,
+        result: getEMFStatusResult,
+      })
+      .run();
+  });
+
+  it('handle valid response from api when result is "0"', () => {
+    const customResult = '0';
+    expectSaga(getEMFStatus, {
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getEMFStatus),
+          { result: customResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_EMF_STATUS_SUCCESS,
+        result: customResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getEMFStatus, {
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getEMFStatus),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_EMF_STATUS_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getEMFStatus, {
+      callback,
+    })
+      .provide([[matchers.call.fn(api.getEMFStatus), throwError(error)]])
+      .put({
+        type: GET_EMF_STATUS_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('upsertAction saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(upsertAction, {
+      payload,
+      programId,
+      actionType,
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.upsertRulesetAction),
+          { upsertActionResult, success: true },
+        ],
+      ])
+      .put({
+        type: UPSERT_ACTION_SUCCESS,
+        result: upsertActionResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(upsertAction, {
+      payload,
+      programId,
+      actionType,
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.upsertRulesetAction),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: UPSERT_ACTION_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(upsertAction, {
+      payload,
+      programId,
+      actionType,
+      callback,
+    })
+      .provide([[matchers.call.fn(api.upsertRulesetAction), throwError(error)]])
+      .put({
+        type: UPSERT_ACTION_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getStrategies saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getStrategies, {
+      programId,
+      filter,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getStrategies),
+          { getStrategiesResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_STRATEGY_SUCCESS,
+        result: getStrategiesResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getStrategies, {
+      programId,
+      filter,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getStrategies),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_STRATEGY_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getStrategies, {
+      programId,
+      filter,
+    })
+      .provide([[matchers.call.fn(api.getStrategies), throwError(error)]])
+      .put({
+        type: GET_STRATEGY_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getSenderDetails saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getSenderDetails, {
+      channels,
+      orgUnitId,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getSenderDetails),
+          { getSenderDetailsResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_SENDER_DETAILS_SUCCESS,
+        result: getStrategiesResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getSenderDetails, {
+      channels,
+      orgUnitId,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getSenderDetails),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_SENDER_DETAILS_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getSenderDetails, {
+      channels,
+      orgUnitId,
+    })
+      .provide([[matchers.call.fn(api.getSenderDetails), throwError(error)]])
+      .put({
+        type: GET_SENDER_DETAILS_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getMappedEntities saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getMappedEntities, {
+      filterType,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getMappedEntities),
+          { getMappedEntitiesResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_MAPPED_ENTITIES_SUCCESS,
+        result: getMappedEntitiesResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getMappedEntities, {
+      filterType,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getMappedEntities),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_MAPPED_ENTITIES_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getMappedEntities, {
+      filterType,
+    })
+      .provide([[matchers.call.fn(api.getMappedEntities), throwError(error)]])
+      .put({
+        type: GET_MAPPED_ENTITIES_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getProgramFieldData saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getProgramFieldData, {
+      filterType,
+      programId,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getProgramFieldData),
+          { getProgramFieldDataResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_FIELD_DATA_SUCCESS,
+        result: getProgramFieldDataResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getProgramFieldData, {
+      filterType,
+      programId,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getProgramFieldData),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_FIELD_DATA_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getProgramFieldData, {
+      filterType,
+      programId,
+    })
+      .provide([[matchers.call.fn(api.getProgramFieldData), throwError(error)]])
+      .put({
+        type: GET_FIELD_DATA_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getProgramFilterType saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getProgramFilterType, {
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getProgramFilterType),
+          { getProgramFilterTypeResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_PROGRAM_FILTER_TYPE_SUCCESS,
+        result: getProgramFilterTypeResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getProgramFilterType, {
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getProgramFilterType),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_PROGRAM_FILTER_TYPE_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getProgramFilterType, {
+      callback,
+    })
+      .provide([
+        [matchers.call.fn(api.getProgramFilterType), throwError(error)],
+      ])
+      .put({
+        type: GET_PROGRAM_FILTER_TYPE_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getOrgKpiConfig saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getOrgKpiConfig, {
+      programId,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getOrgKpiConfig),
+          { getOrgKpiConfigResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_ORG_KPI_CONFIG_SUCCESS,
+        result: getProgramFilterTypeResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getOrgKpiConfig, {
+      programId,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getOrgKpiConfig),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_ORG_KPI_CONFIG_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getOrgKpiConfig, {
+      programId,
+    })
+      .provide([[matchers.call.fn(api.getOrgKpiConfig), throwError(error)]])
+      .put({
+        type: GET_ORG_KPI_CONFIG_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getLastSyncTime saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getLastSyncTime)
+      .provide([
+        [
+          matchers.call.fn(api.getLastSyncTime),
+          { getLastSyncTimeResult, success: true },
+        ],
+      ])
+      .put({
+        type: LAST_SYNC_TIME_SUCCESS,
+        result: getLastSyncTimeResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getLastSyncTime)
+      .provide([
+        [
+          matchers.call.fn(api.getLastSyncTime),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: LAST_SYNC_TIME_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getLastSyncTime)
+      .provide([[matchers.call.fn(api.getLastSyncTime), throwError(error)]])
+      .put({
+        type: LAST_SYNC_TIME_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('fetchUserInfo saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(fetchUserInfo, {
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getUserData),
+          { fetchUserInfoResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_USER_DATA_SUCCESS,
+        result: fetchUserInfoResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(fetchUserInfo, {
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getUserData),
+          { errorMessage: 'error Message', success: false, status: 401 },
+        ],
+      ])
+      .put({
+        type: GET_USER_DATA_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(fetchUserInfo, {
+      callback,
+    })
+      .provide([[matchers.call.fn(api.getUserData), throwError(error)]])
+      .put({
+        type: GET_USER_DATA_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('switchOrg saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(switchOrg, {
+      orgID,
+      successCallback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.changeProxyOrg),
+          { switchOrgResult, success: true },
+        ],
+      ])
+      .put({
+        type: SWITCH_ORG_SUCCESS,
+        result: switchOrgResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(switchOrg, {
+      orgID,
+      successCallback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.changeProxyOrg),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: SWITCH_ORG_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(switchOrg, {
+      orgID,
+      successCallback,
+    })
+      .provide([[matchers.call.fn(api.changeProxyOrg), throwError(error)]])
+      .put({
+        type: SWITCH_ORG_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('switchOrgSuccess saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(switchOrgSuccess, {
+      orgID,
+    })
+      .provide([
+        [
+          matchers.call.fn(utilsLocalStorageApi.saveItem),
+          { switchOrgSuccessResult, success: true },
+        ],
+      ])
+      .put({
+        type: SWITCH_ORG_SUCCESS,
+        result: switchOrgResult,
+      })
+      .run();
+  });
+  //   expectSaga(switchOrg, {
+  //     orgID,
+  //     successCallback,
+  //   })
+  //     .provide([
+  //       [
+  //         matchers.call.fn(api.changeProxyOrg),
+  //         { errorMessage: 'error Message', success: false },
+  //       ],
+  //     ])
+  //     .put({
+  //       type: SWITCH_ORG_FAILURE,
+  //       error: 'error Message',
+  //     })
+  //     .run();
+  // });
+
+  // it('handle error response from api', () => {
+  //   expectSaga(switchOrg, {
+  //     orgID,
+  //     successCallback,
+  //   })
+  //     .provide([[matchers.call.fn(api.changeProxyOrg), throwError(error)]])
+  //     .put({
+  //       type: SWITCH_ORG_FAILURE,
+  //       error,
+  //     })
+  //     .run();
+  // });
+});
+
+describe('logoutFlow saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(logoutFlow)
+      .provide([
+        [matchers.call.fn(api.logout), { getTimeZoneResult, success: true }],
+      ])
+      .put({
+        type: LOGOUT_SUCCESS,
+        result: logoutFlowResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(logoutFlow)
+      .provide([
+        [
+          matchers.call.fn(api.logout),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: LOGOUT_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(logoutFlow)
+      .provide([[matchers.call.fn(api.logout), throwError(error)]])
+      .put({
+        type: LOGOUT_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+// describe('loginFlow saga', () => {
+//   it('handle valid response from api', () => {
+//     expectSaga(loginFlow)
+//       .provide([
+//         [matchers.call.fn(loginFlow), { loginFlowResult, success: true }],
+//       ])
+//       .put({
+//         type: LOGIN_SUCCESS,
+//         result: loginFlowResult,
+//       })
+//       .run();
+//   });
+
+//   it('handle error response from api', () => {
+//     expectSaga(loginFlow)
+//       .provide([
+//         [
+//           matchers.call.fn(loginFlow),
+//           { errorMessage: 'error Message', success: false },
+//         ],
+//       ])
+//       .put({
+//         type: LOGIN_FAILURE,
+//         error: 'error Message',
+//       })
+//       .run();
+//   });
+
+//   it('handle error response from api', () => {
+//     expectSaga(loginFlow)
+//       .provide([[matchers.call.fn(loginFlow), throwError(error)]])
+//       .put({
+//         type: LOGIN_FAILURE,
+//         error,
+//       })
+//       .run();
+//   });
+// });
+
+// describe('authorize saga', () => {
+//   it('handle valid response from api', () => {
+//     expectSaga(authorize, {
+//       user,
+//     })
+//       .provide([
+//         [matchers.call.fn(api.authorize), { authorizeResult, success: true }],
+//       ])
+//       .put({
+//         type: LOGIN_SUCCESS,
+//         result: authorizeResult,
+//       })
+//       .run();
+//   });
+
+//   it('handle error response from api', () => {
+//     expectSaga(authorize, {
+//       user,
+//     })
+//       .provide([
+//         [
+//           matchers.call.fn(api.authorize),
+//           { errorMessage: 'error Message', success: false },
+//         ],
+//       ])
+//       .put({
+//         type: LOGIN_FAILURE,
+//         error: 'error Message',
+//       })
+//       .run();
+//   });
+
+//   it('handle error response from api', () => {
+//     expectSaga(authorize, {
+//       user,
+//     })
+//       .provide([[matchers.call.fn(api.authorize), throwError(error)]])
+//       .put({
+//         type: LOGIN_FAILURE,
+//         error,
+//       })
+//       .run();
+//   });
+// });
+
+///////////////////
+
+describe('upsertCustomLabel saga', () => {
+  const callback = jest.fn(() => {});
+  it('handle valid response from saveCustomLabels api', () => {
+    expectSaga(upsertCustomLabel, {
+      payload: upsertCustomLabelPayload,
+      isUpdate: false,
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.saveCustomLabels),
+          { result: upsertCustomLabelResult, success: true },
+        ],
+      ])
+      .put({
+        type: UPSERT_CUSTOM_LABELS_SUCCESS,
+        result: upsertCustomLabelResult,
+      })
+      .run();
+    expect(callback.mock.calls.length).toBe(1);
+  });
+
+  it('handle valid response from updateCustomLabels api', () => {
+    expectSaga(upsertCustomLabel, {
+      payload: upsertCustomLabelPayload,
+      isUpdate: true,
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.updateCustomLabels),
+          { result: undefined, success: true },
+        ],
+      ])
+      .put({
+        type: UPSERT_CUSTOM_LABELS_SUCCESS,
+        result: undefined,
+      })
+      .run();
+    expect(callback.mock.calls.length).toBe(1);
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(upsertCustomLabel, {
+      payload: upsertCustomLabelPayload,
+      isUpdate: false,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.saveCustomLabels),
+          { errorMessage: 'Error message', success: false },
+        ],
+      ])
+      .put({
+        type: UPSERT_CUSTOM_LABELS_FAILURE,
+        error: 'Error message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(upsertCustomLabel, {
+      payload: upsertCustomLabelPayload,
+      isUpdate: false,
+    })
+      .provide([[matchers.call.fn(api.saveCustomLabels), throwError(error)]])
+      .put({
+        type: UPSERT_CUSTOM_LABELS_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('checkReconfigureProgram saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(checkReconfigureProgram, {
+      programId: '1074',
+      callback: () => {},
+    })
+      .provide([
+        [
+          matchers.call.fn(api.checkReconfigureProgram),
+          {
+            result: { changesMade: [], requireReconfigure: false },
+            success: true,
+          },
+        ],
+        [
+          matchers.call.fn(api.getOrgConfigDetails),
+          { data: [{}], status: { message: 'success' } },
+        ],
+      ])
+      .put({
+        type: CHECK_RECONFIGURE_SUCCESS,
+        result: {
+          requireReconfigure: true,
+          changesMade: ['Program'],
+        },
+      })
+      .run();
+  });
+
+  it('handle valid response from api when ruleset is already present', () => {
+    expectSaga(checkReconfigureProgram, {
+      programId: '1074',
+      callback: () => {},
+    })
+      .provide([
+        [
+          matchers.call.fn(api.checkReconfigureProgram),
+          {
+            result: { changesMade: ['Ruleset'], requireReconfigure: false },
+            success: true,
+          },
+        ],
+        [
+          matchers.call.fn(api.getOrgConfigDetails),
+          { data: [{}], status: { message: 'success' } },
+        ],
+      ])
+      .put({
+        type: CHECK_RECONFIGURE_SUCCESS,
+        result: {
+          requireReconfigure: true,
+          changesMade: ['Program'],
+        },
+      })
+      .run();
+  });
+
+  it('handle valid response from api when changesMade is not an array', () => {
+    expectSaga(checkReconfigureProgram, {
+      programId: '1074',
+      callback: () => {},
+    })
+      .provide([
+        [
+          matchers.call.fn(api.checkReconfigureProgram),
+          {
+            result: { changesMade: undefined, requireReconfigure: false },
+            success: true,
+          },
+        ],
+        [
+          matchers.call.fn(api.getOrgConfigDetails),
+          { data: [{}], status: { message: 'success' } },
+        ],
+      ])
+      .put({
+        type: CHECK_RECONFIGURE_SUCCESS,
+        result: {
+          requireReconfigure: true,
+          changesMade: ['Program'],
+        },
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(checkReconfigureProgram, { programId: '1074' })
+      .provide([
+        [
+          matchers.call.fn(api.checkReconfigureProgram),
+          { errorMessage: 'error Message', success: false },
+        ],
+        [
+          matchers.call.fn(api.getOrgConfigDetails),
+          { data: [], status: { message: 'success' } },
+        ],
+      ])
+      .put({
+        type: CHECK_RECONFIGURE_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(checkReconfigureProgram, { programId: '1074' })
+      .provide([
+        [matchers.call.fn(api.checkReconfigureProgram), throwError(error)],
+      ])
+      .put({
+        type: CHECK_RECONFIGURE_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getSupportVideosConfig saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getSupportVideosConfig, {
+      callback: () => {},
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getSupportVideosConfig),
+          validResponseGetSupportVideoConfig,
+        ],
+      ])
+      .put({
+        type: GET_SUPPORT_VIDEOS_CONFIG_SUCCESS,
+        data: validResponseGetSupportVideoConfig.data,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getSupportVideosConfig, { callback: () => {} })
+      .provide([
+        [
+          matchers.call.fn(api.getSupportVideosConfig),
+          {
+            success: false,
+            status: 500,
+            message: 'No config for support videos found',
+          },
+        ],
+      ])
+      .put({
+        type: GET_SUPPORT_VIDEOS_CONFIG_FAILURE,
+        error: 'No config for support videos found',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getSupportVideosConfig, {})
+      .provide([
+        [
+          matchers.call.fn(api.getSupportVideosConfig),
+          {
+            success: false,
+            status: 500,
+            message: 'No config for support videos found',
+          },
+        ],
+      ])
+      .put({
+        type: GET_SUPPORT_VIDEOS_CONFIG_FAILURE,
+        error: 'No config for support videos found',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getSupportVideosConfig, {})
+      .provide([
+        [matchers.call.fn(api.getSupportVideosConfig), throwError(error)],
+      ])
+      .put({
+        type: GET_SUPPORT_VIDEOS_CONFIG_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getGroupRedemptionStatus saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getGroupRedemptionStatus, {
+      callback: () => {},
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getGroupRedemptionStatus),
+          { success: true, result: [{}] },
+        ],
+      ])
+      .put({
+        type: GET_GROUP_REDEMPTION_STATUS_SUCCESS,
+        data: validResponseGetSupportVideoConfig.data,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getGroupRedemptionStatus, { callback: () => {} })
+      .provide([
+        [
+          matchers.call.fn(api.getGroupRedemptionStatus),
+          {
+            success: false,
+            status: 500,
+            message: 'No config for support videos found',
+          },
+        ],
+      ])
+      .put({
+        type: GET_GROUP_REDEMPTION_STATUS_FAILURE,
+        error: 'Config error',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getGroupRedemptionStatus, {})
+      .provide([
+        [
+          matchers.call.fn(api.getGroupRedemptionStatus),
+          {
+            success: false,
+            status: 500,
+            message: 'Config error',
+          },
+        ],
+      ])
+      .put({
+        type: GET_GROUP_REDEMPTION_STATUS_FAILURE,
+        error: 'Config error',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getGroupRedemptionStatus, { callback: () => {} })
+      .provide([
+        [matchers.call.fn(api.getGroupRedemptionStatus), throwError(error)],
+      ])
+      .put({
+        type: GET_GROUP_REDEMPTION_STATUS_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('getAlternateCurrencyFlag saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getAlternateCurrencyFlag, {
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getAlternateCurrencyFlag),
+          { getAlternateCurrencyFlagResult, success: true },
+        ],
+      ])
+      .put({
+        type: ALTERNATE_CURRENCY_FLAG_SUCCESS,
+        result: getAlternateCurrencyFlagResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getAlternateCurrencyFlag, {
+      callback,
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getAlternateCurrencyFlag),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: ALTERNATE_CURRENCY_FLAG_FAILURE,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getAlternateCurrencyFlag, {
+      callback,
+    })
+      .provide([
+        [matchers.call.fn(api.getAlternateCurrencyFlag), throwError(error)],
+      ])
+      .put({
+        type: ALTERNATE_CURRENCY_FLAG_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('watchForGetCustomLabels saga', () => {
+  const generator = watchForGetCustomLabels();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_CUSTOM_LABELS_REQUEST, getCustomLabels),
+    );
+  });
+});
+
+describe('watchForGetGroupRedemptionStatus saga', () => {
+  const generator = watchForGroupRedemptionStatus();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_GROUP_REDEMPTION_STATUS_REQUEST, getGroupRedemptionStatus),
+    );
+  });
+});
+
+describe('watchForUpsertCustomLabel saga', () => {
+  const generator = watchForUpsertCustomLabel();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(UPSERT_CUSTOM_LABELS_REQUEST, upsertCustomLabel),
+    );
+  });
+});
+
+describe('watchForCheckReconfgureProgram saga', () => {
+  const generator = watchForCheckReconfigurationProgram();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(CHECK_RECONFIGURE_REQUEST, checkReconfigureProgram),
+    );
+  });
+});
+
+describe('watchForgetTimeZone saga', () => {
+  const generator = watchForGetTimeZone();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_TIME_ZONE_REQUEST, getTimeZone),
+    );
+  });
+});
+
+describe('watchForgetSidebarMenuData saga', () => {
+  const generator = watchGetSidebarMenuData();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_SIDEBAR_MENU_DATA_REQUEST, getSidebarMenuData),
+    );
+  });
+});
+
+describe('watchForgetTopbarMenuData saga', () => {
+  const generator = watchGetTopbarMenuData();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_TOPBAR_MENU_DATA_REQUEST, getTopbarMenuData),
+    );
+  });
+});
+
+describe('watchForGetTier saga', () => {
+  const generator = watchForGetTier();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_TIER_REQUEST, getTier),
+    );
+  });
+});
+
+describe('watchForGetUsersByIds saga', () => {
+  const generator = watchForGetUsersByIds();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_USER_LIST_REQUEST, getUsersByIds),
+    );
+  });
+});
+
+describe('watchGetCustomerActivityRequest saga', () => {
+  const generator = watchGetCustomerActivityRequest();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_CUSTOMER_ACTIVITY_REQUEST, getCustomerActivity),
+    );
+  });
+});
+
+describe('watchForGetAllSenderDetails saga', () => {
+  const generator = watchForGetAllSenderDetails();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_ALL_SENDER_DETAILS_REQUEST, getAllSenderDetails),
+    );
+  });
+});
+
+describe('watchForGetStrategiesNoRefresh saga', () => {
+  const generator = watchForGetStrategiesNoRefresh();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_STRATEGY_NO_REFRESH_REQUEST, getStrategiesDataNoRefresh),
+    );
+  });
+});
+
+describe('watchForGetPrograms saga', () => {
+  const generator = watchForGetPrograms();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_PROGRAMS_REQUEST, getPrograms),
+    );
+  });
+});
+
+describe('watchForBulkConfigStatus saga', () => {
+  const generator = watchForBulkConfigStatus();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_BULK_CONFIG_STATUS_REQUEST, getBulkConfigStatus),
+    );
+  });
+});
+
+describe('watchForUserGroupV2Status saga', () => {
+  const generator = watchForUserGroupV2Status();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_USER_GROUP_V2_STATUS_REQUEST, getUserGroupV2Status),
+    );
+  });
+});
+
+describe('watchForEMFStatus saga', () => {
+  const generator = watchForEMFStatus();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_EMF_STATUS_REQUEST, getEMFStatus),
+    );
+  });
+});
+
+describe('watchForUpsertAction saga', () => {
+  const generator = watchForUpsertAction();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(UPSERT_ACTION_REQUEST, upsertAction),
+    );
+  });
+});
+
+describe('watchForGetStrategies saga', () => {
+  const generator = watchForGetStrategies();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_STRATEGY_REQUEST, getStrategies),
+    );
+  });
+});
+
+describe('watchGetSenderDetails saga', () => {
+  const generator = watchGetSenderDetails();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_SENDER_DETAILS_REQUEST, getSenderDetails),
+    );
+  });
+});
+
+describe('watchForGetMappedEntities saga', () => {
+  const generator = watchForGetMappedEntities();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_MAPPED_ENTITIES_REQUEST, getMappedEntities),
+    );
+  });
+});
+
+describe('watchForGetProgramFieldData saga', () => {
+  const generator = watchForGetProgramFieldData();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_FIELD_DATA_REQUEST, getProgramFieldData),
+    );
+  });
+});
+
+describe('watchForGetProgramFilterType saga', () => {
+  const generator = watchForGetProgramFilterType();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_PROGRAM_FILTER_TYPE_REQUEST, getProgramFilterType),
+    );
+  });
+});
+
+describe('watchForGetOrgKpiConfig saga', () => {
+  const generator = watchForGetOrgKpiConfig();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_ORG_KPI_CONFIG_REQUEST, getOrgKpiConfig),
+    );
+  });
+});
+
+describe('watchForGetLastSyncTime saga', () => {
+  const generator = watchForGetLastSyncTime();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(LAST_SYNC_TIME_REQUEST, getLastSyncTime),
+    );
+  });
+});
+
+describe('watchForFetchUserInfo saga', () => {
+  const generator = watchForFetchUserInfo();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_USER_DATA_REQUEST, fetchUserInfo),
+    );
+  });
+});
+
+describe('watchForOrgChange saga', () => {
+  const generator = watchForOrgChange();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(SWITCH_ORG_REQUEST, switchOrg),
+    );
+  });
+});
+
+describe('watchForOrgChangeSuccess saga', () => {
+  const generator = watchForOrgChangeSuccess();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(SWITCH_ORG_SUCCESS, switchOrgSuccess),
+    );
+  });
+});
+
+describe('watchForLogoutFlow saga', () => {
+  const generator = watchForLogoutFlow();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(LOGOUT_REQUEST, logoutFlow),
+    );
+  });
+});
+
+describe('watchForLoginSuccess saga', () => {
+  const generator = watchForLoginSuccess();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(LOGIN_SUCCESS, loginSuccess),
+    );
+  });
+});
+
+describe('login success saga', () => {
+  it('should call login success generator function', () => {
+    const generator = loginSuccess({
+      res: {
+        token: 'test',
+        user: {
+          orgID: '123',
+          id: 'abc',
+        },
+      },
+    });
+
+    expect(generator.next()).toMatchObject({ done: false, value: undefined });
+  });
+});
+
+describe('logout success saga', () => {
+  it('should call login success generator function', () => {
+    const generator = logoutSuccess();
+    expect(generator.next()).toMatchObject({ done: false, value: undefined });
+  });
+});
+
+describe('watchForLogoutSuccess saga', () => {
+  const generator = watchForLogoutSuccess();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(LOGOUT_SUCCESS, logoutSuccess),
+    );
+  });
+});
+
+describe('saveProgramConfig saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(saveProgramConfig, {
+      orgId: 0,
+      programId: 0,
+      userId: 0,
+      payload: {},
+      callback: () => {},
+    })
+      .provide([
+        [
+          matchers.call.fn(api.saveProgramConfig),
+          {
+            success: true,
+            status: { code: 200 },
+            data: { key: 'value' },
+          },
+        ],
+      ])
+      .put({
+        type: SAVE_PROGRAM_CONFIG_SUCCESS,
+        data: { key: 'value' },
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(saveProgramConfig, {
+      orgId: 0,
+      programId: 0,
+      userId: 0,
+      payload: {},
+    })
+      .provide([
+        [
+          matchers.call.fn(api.saveProgramConfig),
+          {
+            success: false,
+            status: { code: 500 },
+            message: 'Error',
+          },
+        ],
+      ])
+      .put({
+        type: SAVE_PROGRAM_CONFIG_FAILURE,
+        error: 'Error',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(saveProgramConfig, {})
+      .provide([[matchers.call.fn(api.saveProgramConfig), throwError(error)]])
+      .put({
+        type: SAVE_PROGRAM_CONFIG_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+describe('watchForSaveProgramConfig saga', () => {
+  const generator = watchForSaveProgramConfig();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(SAVE_PROGRAM_CONFIG_REQUEST, saveProgramConfig),
+    );
+  });
+});
+
+describe('getProgramConfig saga', () => {
+  it('handle valid response from api - with single program', () => {
+    expectSaga(getProgramConfig, {
+      orgId: 0,
+      programIds: [0],
+      queryParams: 'string',
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getProgramConfig),
+          {
+            success: true,
+            status: { code: 200 },
+            data: { key: 'value' },
+          },
+        ],
+      ])
+      .put({
+        type: GET_PROGRAM_CONFIG_SUCCESS,
+        data: { key: 'value' },
+      })
+      .run();
+  });
+  it('handle valid response from api - with multiple programs', () => {
+    expectSaga(getProgramConfig, {
+      orgId: 0,
+      programIds: [0, 1, 2],
+      queryParams: 'string',
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getProgramConfig),
+          {
+            success: true,
+            status: { code: 200 },
+            data: { key: 'value' },
+          },
+        ],
+      ])
+      .put({
+        type: GET_PROGRAM_CONFIG_SUCCESS,
+        data: { key: 'value' },
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getProgramConfig, {
+      orgId: 0,
+      programIds: [0],
+      queryParams: 'string',
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getProgramConfig),
+          {
+            success: false,
+            status: { code: 500 },
+            message: 'Error',
+          },
+        ],
+      ])
+      .put({
+        type: GET_PROGRAM_CONFIG_FAILURE,
+        error: 'Error',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getProgramConfig, {})
+      .provide([[matchers.call.fn(api.getProgramConfig), throwError(error)]])
+      .put({
+        type: GET_PROGRAM_CONFIG_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+describe('watchForGetProgramConfig saga', () => {
+  const generator = watchForGetProgramConfig();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(GET_PROGRAM_CONFIG_REQUEST, getProgramConfig),
+    );
+  });
+});
+describe('getAlternateCurrencyFlag saga', () => {
+  const generator = watchForAlternateCurrencyFlag();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(ALTERNATE_CURRENCY_FLAG_REQUEST, getAlternateCurrencyFlag),
+    );
+  });
+});
+
+describe('getCdnTransformationConfig saga', () => {
+  it('handles valid response from api', () => {
+    const localStorageSetItemSpy = jest.spyOn(Storage.prototype, 'setItem');
+
+    expectSaga(getCdnTransformationConfig)
+      .provide([
+        [matchers.call.fn(api.getCdnTransformationConfig), mockAPIResponseCDN],
+      ])
+      .run()
+      .then(() => {
+        expect(localStorageSetItemSpy).toHaveBeenCalledWith(
+          'CDN_BASE_URL',
+          'https://storage.crm.staging.content-cdn.io',
+        );
+      });
+  });
+
+  it('handles valid response without hostname from api', () => {
+    const localStorageRemoveItemSpy = jest.spyOn(
+      Storage.prototype,
+      'removeItem',
+    );
+
+    const mockResponseWithoutHostname = {
+      success: true,
+      status: { code: 200 },
+      response: {
+        /* No hostname */
+      },
+    };
+
+    expectSaga(getCdnTransformationConfig)
+      .provide([
+        [
+          matchers.call.fn(api.getCdnTransformationConfig),
+          mockResponseWithoutHostname,
+        ],
+      ])
+      .run()
+      .then(() => {
+        expect(localStorageRemoveItemSpy).toHaveBeenCalledWith('CDN_BASE_URL');
+      });
+  });
+
+  it('handles error response from api', () => {
+    const localStorageRemoveItemSpy = jest.spyOn(
+      Storage.prototype,
+      'removeItem',
+    );
+
+    expectSaga(getCdnTransformationConfig)
+      .provide([
+        [
+          matchers.call.fn(api.getCdnTransformationConfig),
+          { success: false, status: { code: 500 } },
+        ],
+      ])
+      .run()
+      .then(() => {
+        expect(localStorageRemoveItemSpy).toHaveBeenCalledWith('CDN_BASE_URL');
+      });
+  });
+
+  it('handles error during api call', () => {
+    const localStorageRemoveItemSpy = jest.spyOn(
+      Storage.prototype,
+      'removeItem',
+    );
+
+    expectSaga(getCdnTransformationConfig)
+      .provide([
+        [matchers.call.fn(api.getCdnTransformationConfig), throwError(error)],
+      ])
+      .run()
+      .then(() => {
+        expect(localStorageRemoveItemSpy).toHaveBeenCalledWith('CDN_BASE_URL');
+      });
+  });
+});
+
+describe('watchForGetCDNConfig', () => {
+  const generator = watchForGetCDNConfig();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(
+        GET_CDN_TRANSFORMATION_CONFIG_REQUEST,
+        getCdnTransformationConfig,
+      ),
+    );
+  });
+});
+
+describe('getMultipleExtendedFields saga', () => {
+  it('handle valid response from api - with single program', () => {
+    expectSaga(getMultipleExtendedFields, {
+      extendedFields: ['BILL_EXTENDED_FIELD', 'CUSTOMER_EXTENDED_FIELD'],
+      programId: 0,
+      allowedFieldTypes: 'DATETIME, DATE',
+      callback: jest.fn(),
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getExtendedFields),
+          {
+            success: true,
+            status: { code: 200 },
+            result: { key: 'value' },
+          },
+        ],
+      ])
+      .put({
+        type: GET_MULTIPLE_EXTENDED_FIELDS_SUCCESS,
+        result: { key: 'value' },
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getMultipleExtendedFields, {
+      extendedFields: ['BILL_EXTENDED_FIELD', 'CUSTOMER_EXTENDED_FIELD'],
+      programId: 0,
+      allowedFieldTypes: 'DATETIME, DATE',
+      callback: jest.fn(),
+    })
+      .provide([
+        [
+          matchers.call.fn(api.getExtendedFields),
+          {
+            success: false,
+            status: { code: 500 },
+            message: 'Error',
+          },
+        ],
+      ])
+      .put({
+        type: GET_MULTIPLE_EXTENDED_FIELDS_FAILURE,
+        error: 'Error',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getMultipleExtendedFields, {})
+      .provide([[matchers.call.fn(api.getExtendedFields), throwError(error)]])
+      .put({
+        type: GET_MULTIPLE_EXTENDED_FIELDS_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+describe('watchGetExtendedField saga', () => {
+  const generator = watchGetExtendedField();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(
+        GET_MULTIPLE_EXTENDED_FIELDS_REQUEST,
+        getMultipleExtendedFields,
+      ),
+    );
+  });
+});
+
+describe('getAdditionalSlabUpgradeAndRenewal saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getAdditionalSlabUpgradeAndRenewal)
+      .provide([
+        [
+          matchers.call.fn(api.getAdditionalSlabs),
+          { getAlternateCurrencyFlagResult, success: true },
+        ],
+      ])
+      .put({
+        type: GET_ADDITIONAL_SLAB_UPGRADE_RENEWAL_SUCCESS,
+        result: getAlternateCurrencyFlagResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getAdditionalSlabUpgradeAndRenewal)
+      .provide([
+        [
+          matchers.call.fn(api.getAdditionalSlabs),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: GET_ADDITIONAL_SLAB_UPGRADE_RENEWAL_SUCCESS,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getAdditionalSlabUpgradeAndRenewal)
+      .provide([
+        [matchers.call.fn(api.getAdditionalSlabs), throwError(error)],
+      ])
+      .put({
+        type: GET_ADDITIONAL_SLAB_UPGRADE_RENEWAL_FAILURE,
+        error,
+      })
+      .run();
+  });
+});
+
+describe('watchForAdditionalSlabUpgradeAndRenewal saga', () => {
+  const generator = watchForAdditionalSlabUpgradeAndRenewal();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(
+        GET_ADDITIONAL_SLAB_UPGRADE_RENEWAL_REQUEST,
+        getAdditionalSlabUpgradeAndRenewal,
+      ),
+    );
+  });
+});
+
+describe('getSegregatePromotionsFlag saga', () => {
+  const generator = watchForSegregatePromotionsFlag();
+  it('should call watchers functions', () => {
+    expect(generator.next().value).toEqual(
+      takeLatest(SEGREGATE_PROMOTIONS_FLAG_REQUEST, getSegregatePromotionsFlag),
+    );
+  });
+});
+
+describe('getSegregatePromotionsFlag saga', () => {
+  it('handle valid response from api', () => {
+    expectSaga(getSegregatePromotionsFlag)
+      .provide([
+        [
+          matchers.call.fn(api.getSegregatePromotionsFlag),
+          { getSegregatePromotionsFlagResult, success: true },
+        ],
+      ])
+      .put({
+        type: SEGREGATE_PROMOTIONS_FLAG_SUCCESS,
+        result: getSegregatePromotionsFlagResult,
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getSegregatePromotionsFlag)
+      .provide([
+        [
+          matchers.call.fn(api.getSegregatePromotionsFlag),
+          { errorMessage: 'error Message', success: false },
+        ],
+      ])
+      .put({
+        type: SEGREGATE_PROMOTIONS_FLAG_SUCCESS,
+        error: 'error Message',
+      })
+      .run();
+  });
+
+  it('handle error response from api', () => {
+    expectSaga(getSegregatePromotionsFlag)
+      .provide([
+        [matchers.call.fn(api.getSegregatePromotionsFlag), throwError(error)],
+      ])
+      .put({
+        type: SEGREGATE_PROMOTIONS_FLAG_FAILURE,
+        error,
+      })
+      .run();
+  });
+});