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

package/components/organisms/ConfigureWorkflows/tests/saga.test.js

@@ -1,2543 +0,0 @@
-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 api from '../../../../services/api';
-import {
-  SAVE_TOGGLE_ACTION_CASE_FAILURE,
-  SAVE_TOGGLE_ACTION_CASE_REQUEST,
-  SAVE_TOGGLE_ACTION_CASE_SUCCESS,
-  DOWNLOAD_RULE_SET_REQUEST,
-  DOWNLOAD_RULE_SET_SUCCESS,
-  DOWNLOAD_RULE_SET_FAILURE,
-  GET_EBILL_TEMPLATES_REQUEST,
-  GET_EBILL_TEMPLATES_SUCCESS,
-  GET_EBILL_TEMPLATES_FAILURE,
-  GET_RULESETS_REQUEST,
-  GET_RULESETS_SUCCESS,
-  GET_RULESETS_FAILURE,
-  GET_RULESETS_BY_EVENT_TYPE_REQUEST,
-  GET_RULESETS_BY_EVENT_TYPE_SUCCESS,
-  GET_RULESETS_BY_EVENT_TYPE_FAILURE,
-  GET_STRATEGY_WORKFLOW_REQUEST,
-  GET_STRATEGY_WORKFLOW_SUCCESS,
-  GET_STRATEGY_WORKFLOW_FAILURE,
-  GET_GRAMMER_REQUEST,
-  GET_GRAMMER_SUCCESS,
-  GET_GRAMMER_FAILURE,
-  CLEAR_RULESET_CACHE_REQUEST,
-  CLEAR_RULESET_CACHE_SUCCESS,
-  CLEAR_RULESET_CACHE_FAILURE,
-  GET_ACTION_DEPENDENCIES_REQUEST,
-  GET_ACTION_DEPENDENCIES_SUCCESS,
-  GET_ACTION_DEPENDENCIES_FAILURE,
-  UPSERT_RULESETS_REQUEST,
-  UPSERT_RULESETS_SUCCESS,
-  UPSERT_RULESETS_FAILURE,
-  GET_TENDER_COMBINATION_REQUEST,
-  GET_TENDER_COMBINATION_SUCCESS,
-  GET_TENDER_COMBINATION_FAILURE,
-  SAVE_CAPPING_REQUEST,
-  SAVE_CAPPING_SUCCESS,
-  SAVE_CAPPING_FAILURE,
-  GET_EXTENDED_FIELDS_REQUEST,
-  GET_EXTENDED_FIELDS_SUCCESS,
-  GET_EXTENDED_FIELDS_FAILURE,
-  GET_STORE_REQUEST,
-  GET_STORE_SUCCESS,
-  GET_STORE_FAILURE,
-  GET_CONCEPT_REQUEST,
-  GET_CONCEPT_SUCCESS,
-  GET_CONCEPT_FAILURE,
-  GET_ZONE_REQUEST,
-  GET_ZONE_SUCCESS,
-  GET_ZONE_FAILURE,
-  GET_EVENT_SOURCE_REQUEST,
-  GET_EVENT_SOURCE_SUCCESS,
-  GET_EVENT_SOURCE_FAILURE,
-  GET_CLUSTER_REQUEST,
-  GET_CLUSTER_SUCCESS,
-  GET_CLUSTER_FAILURE,
-  SAVE_SCOPING_REQUEST,
-  SAVE_SCOPING_SUCCESS,
-  SAVE_SCOPING_FAILURE,
-  CREATE_RULE_REQUEST,
-  CREATE_RULE_SUCCESS,
-  CREATE_RULE_FAILURE,
-  SAVE_RULESET_REQUEST,
-  SAVE_RULESET_SUCCESS,
-  SAVE_RULESET_FAILURE,
-  GET_LABELS_REQUEST,
-  GET_LABELS_SUCCESS,
-  GET_LABELS_FAILURE,
-  DELETE_ACTION_REQUEST,
-  DELETE_ACTION_SUCCESS,
-  DELETE_ACTION_FAILURE,
-  DELETE_CONDITION_REQUEST,
-  DELETE_CONDITION_SUCCESS,
-  DELETE_CONDITION_FAILURE,
-  SAVE_ALL_EXPRESSIONS_BY_EVENT_TYPE_REQUEST,
-  SAVE_ALL_EXPRESSIONS_BY_EVENT_TYPE_SUCCESS,
-  SAVE_ALL_EXPRESSIONS_BY_EVENT_TYPE_FAILURE,
-  SAVE_PROMOTION_REQUEST,
-  SAVE_PROMOTION_SUCCESS,
-  SAVE_PROMOTION_FAILURE,
-  GET_DEPENDENT_ENUMS_REQUEST,
-  GET_DEPENDENT_ENUMS_SUCCESS,
-  GET_DEPENDENT_ENUMS_FAILURE,
-  SAVE_RULESET_LABEL_REQUEST,
-  SAVE_RULESET_LABEL_SUCCESS,
-  SAVE_RULESET_LABEL_FAILURE,
-  GET_TARGET_GROUPS_REQUEST,
-  GET_TARGET_GROUPS_SUCCESS,
-  GET_TARGET_GROUPS_FAILURE,
-  GET_MULTIPLE_TARGETS_REQUEST,
-  GET_MULTIPLE_TARGETS_SUCCESS,
-  GET_MULTIPLE_TARGETS_FAILURE,
-  GET_TARGET_PERIODS_GROUPS_REQUEST,
-  GET_TARGET_PERIODS_GROUPS_SUCCESS,
-  GET_TARGET_PERIODS_GROUPS_FAILURE,
-  GET_GENERIC_EVENTS_REQUEST,
-  GET_GENERIC_EVENTS_SUCCESS,
-  GET_GENERIC_EVENTS_FAILURE,
-  GET_ALL_ALTERNATE_CURRENCY_SUCCESS,
-  GET_ALL_ALTERNATE_CURRENCY_FAILURE,
-  GET_ALL_ALTERNATE_CURRENCY_REQUEST,
-  GET_CDN_TRANSFORMATION_CONFIG_REQUEST,
-  UNCLAIM_BADGE_SUCCESS,
-  UNCLAIM_BADGE_FAILURE,
-  GET_CAPPING_TARGET_GROUPS_REQUEST,
-  GET_CAPPING_TARGET_GROUPS_SUCCESS,
-  GET_CAPPING_TARGET_GROUPS_FAILURE,
-} from '../constants';
-import {
-  saveToggleActionCase,
-  watchForSaveToggleActionCase,
-  downloadRuleSet,
-  watchDownloadRuleSet,
-  getEbillTemplates,
-  watchGetEbillTemplates,
-  getRulesets,
-  watchForGetRulesets,
-  getRulesetsByEventType,
-  watchForGetRulesetsByEventType,
-  getStrategiesWorkflow,
-  watchForGetStrategiesWorkflow,
-  getGrammer,
-  watchForGetGrammer,
-  clearRulesetsCache,
-  watchForClearRulesetsCache,
-  getActionDependencies,
-  watchForGetActionDependencies,
-  upsertRulesets,
-  watchForUpsertRulesets,
-  getAllTenderCombination,
-  watchForGetAllTenderCombinations,
-  saveCapping,
-  watchForSaveCapping,
-  getExtendedFields,
-  watchGetExtendedField,
-  getStores,
-  watchGetStoresRequest,
-  getConcept,
-  watchGetConceptsRequest,
-  getZone,
-  watchGetZonesRequest,
-  getEventSource,
-  watchGetEventSourceRequest,
-  getCluster,
-  watchGetClusterRequest,
-  saveScoping,
-  watchForSaveScoping,
-  createRule,
-  watchCreateRule,
-  saveRuleset,
-  watchSaveRuleset,
-  getLabels,
-  watchGetLabels,
-  deleteAction,
-  watchDeleteAction,
-  deleteCondition,
-  watchDeleteCondition,
-  saveAllExpressionsByEventType,
-  watchForSaveAllExpressionsByEventType,
-  savePromotion,
-  watchForSavePromotion,
-  getDependentEnums,
-  watchForGetDependentEnums,
-  saveRulesetLabel,
-  watchForSaveRulesetLabel,
-  getTargetGroups,
-  watchForGetCappingTargetGroups,
-  getCappingTargetGroups,
-  watchForGetTargetGroups,
-  getTargetsFromMultipleGroups,
-  watchForGetTargetsFromMultipleGroups,
-  getTargetPeriodsFromMultipleGroups,
-  watchForGetTargetPeriodsFromMultipleGroups,
-  getEventsLists,
-  watchGetEventsList,
-  getAllAlternateCurrency,
-  watchForGetAllAlternateCurrency,
-  getCdnTransformationConfig,
-  watchForGetCDNConfig,
-  unClaimBadge,
-} from '../saga';
-import {
-  downloadRuleSetResult,
-  ebillTemplates,
-  targetGroups,
-  rulesets,
-  rulesetsByEventType,
-  strategiesWorkflow,
-  grammar,
-  clearRulesetsCacheMock,
-  actionDependencies,
-  upsertRulesetsMock,
-  allTenderCombination,
-  saveCappingMock,
-  extendedFieldsData,
-  store,
-  rules,
-  mockData,
-  genericEventList,
-} from './mockData';
-import {
-  mockAPIResponse,
-  mockAPIResponseCDN,
-} from '../../AlternateCurrencyList/tests/mockData';
-
-const {
-  callback,
-  error,
-  programId,
-  eventType,
-  filter,
-  payload,
-  extendedField,
-  rulesetId,
-  source,
-  allRulesLength,
-  userId,
-  enumType,
-  label,
-} = mockData;
-
-const sagaMockData = {
-  programId: '1356',
-  eventType: 'TransactionAdd',
-  payload: {
-    type: 'TOGGLE_ACTION_CASE',
-    rulesetId: 27199,
-    ruleId: 30254,
-  },
-  callback: () => {},
-};
-
-describe('watchDownloadRuleSet saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchDownloadRuleSet();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(DOWNLOAD_RULE_SET_REQUEST, downloadRuleSet);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('downloadRuleSet saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(downloadRuleSet, {
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.downloadRuleSet),
-          { downloadRuleSetResult, success: true },
-        ],
-      ])
-      .put({
-        type: DOWNLOAD_RULE_SET_SUCCESS,
-        result: downloadRuleSetResult,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(downloadRuleSet, {
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.downloadRuleSet),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: DOWNLOAD_RULE_SET_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(downloadRuleSet, {
-      callback,
-    })
-      .provide([[matchers.call.fn(api.downloadRuleSet), throwError(error)]])
-      .put({
-        type: DOWNLOAD_RULE_SET_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchGetEbillTemplates saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchGetEbillTemplates();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(GET_EBILL_TEMPLATES_REQUEST, getEbillTemplates);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getEbillTemplates saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getEbillTemplates, {
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getEbillTemplates),
-          { ebillTemplates, success: true },
-        ],
-      ])
-      .put({
-        type: GET_EBILL_TEMPLATES_SUCCESS,
-        result: ebillTemplates,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getEbillTemplates, {
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getEbillTemplates),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_EBILL_TEMPLATES_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(getEbillTemplates, {
-      callback,
-    })
-      .provide([[matchers.call.fn(api.getEbillTemplates), throwError(error)]])
-      .put({
-        type: GET_EBILL_TEMPLATES_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchForGetRulesets saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForGetRulesets();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(GET_RULESETS_REQUEST, getRulesets);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getRulesets saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getRulesets, {
-      programId,
-      eventType,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getRulesetsByEventType),
-          { rulesets, success: true },
-        ],
-      ])
-      .put({
-        type: GET_RULESETS_SUCCESS,
-        result: rulesets,
-      })
-      .run();
-  });
-  it('handle valid response from api', () => {
-    expectSaga(getRulesets, {
-      programId,
-      eventType,
-      isV2: true,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getConfiguredRulesetsV3),
-          { rulesets, success: true },
-        ],
-      ])
-      .put({
-        type: GET_RULESETS_SUCCESS,
-        result: rulesets,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getRulesets, {
-      programId,
-      eventType,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getRulesetsByEventType),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_RULESETS_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(getRulesets, {
-      programId,
-      eventType,
-    })
-      .provide([
-        [matchers.call.fn(api.getRulesetsByEventType), throwError(error)],
-      ])
-      .put({
-        type: GET_RULESETS_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchForGetRulesetsByEventType saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForGetRulesetsByEventType();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(
-      GET_RULESETS_BY_EVENT_TYPE_REQUEST,
-      getRulesetsByEventType,
-    );
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getRulesetsByEventType saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getRulesetsByEventType, {
-      programId,
-      eventType,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getRulesetsByEventType),
-          { rulesetsByEventType, success: true },
-        ],
-      ])
-      .put({
-        type: GET_RULESETS_BY_EVENT_TYPE_SUCCESS,
-        result: rulesetsByEventType,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getRulesetsByEventType, {
-      programId,
-      eventType,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getRulesetsByEventType),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_RULESETS_BY_EVENT_TYPE_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(getRulesetsByEventType, {
-      programId,
-      eventType,
-    })
-      .provide([
-        [matchers.call.fn(api.getRulesetsByEventType), throwError(error)],
-      ])
-      .put({
-        type: GET_RULESETS_BY_EVENT_TYPE_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchForGetStrategiesWorkflow saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForGetStrategiesWorkflow();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(
-      GET_STRATEGY_WORKFLOW_REQUEST,
-      getStrategiesWorkflow,
-    );
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getStrategiesWorkflow saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getStrategiesWorkflow, {
-      programId,
-      filter,
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getStrategies),
-          { strategiesWorkflow, success: true },
-        ],
-      ])
-      .put({
-        type: GET_STRATEGY_WORKFLOW_SUCCESS,
-        result: strategiesWorkflow,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getStrategiesWorkflow, {
-      programId,
-      filter,
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getStrategies),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_STRATEGY_WORKFLOW_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(getStrategiesWorkflow, {
-      programId,
-      filter,
-      callback,
-    })
-      .provide([[matchers.call.fn(api.getStrategies), throwError(error)]])
-      .put({
-        type: GET_STRATEGY_WORKFLOW_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchForGetGrammer saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForGetGrammer();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(GET_GRAMMER_REQUEST, getGrammer);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getGrammer saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getGrammer, {
-      eventType,
-    })
-      .provide([[matchers.call.fn(api.getGrammer), { grammar, success: true }]])
-      .put({
-        type: GET_GRAMMER_SUCCESS,
-        result: grammar,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getGrammer, {
-      eventType,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getGrammer),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_GRAMMER_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(getGrammer, {
-      eventType,
-    })
-      .provide([[matchers.call.fn(api.getGrammer), throwError(error)]])
-      .put({
-        type: GET_GRAMMER_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchForClearRulesetsCache saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForClearRulesetsCache();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(
-      CLEAR_RULESET_CACHE_REQUEST,
-      clearRulesetsCache,
-    );
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('clearRulesetsCache saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(clearRulesetsCache, {
-      eventType,
-      programId,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.clearRulesetsCache),
-          { clearRulesetsCacheMock, success: true },
-        ],
-      ])
-      .put({
-        type: CLEAR_RULESET_CACHE_SUCCESS,
-        result: clearRulesetsCacheMock,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(clearRulesetsCache, {
-      programId,
-      eventType,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.clearRulesetsCache),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: CLEAR_RULESET_CACHE_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(clearRulesetsCache, {
-      programId,
-      eventType,
-    })
-      .provide([[matchers.call.fn(api.clearRulesetsCache), throwError(error)]])
-      .put({
-        type: CLEAR_RULESET_CACHE_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchForGetActionDependencies saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForGetActionDependencies();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(
-      GET_ACTION_DEPENDENCIES_REQUEST,
-      getActionDependencies,
-    );
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getActionDependencies saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getActionDependencies)
-      .provide([
-        [
-          matchers.call.fn(api.getActionDependencies),
-          { actionDependencies, success: true },
-        ],
-      ])
-      .put({
-        type: GET_ACTION_DEPENDENCIES_SUCCESS,
-        result: actionDependencies,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getActionDependencies)
-      .provide([
-        [
-          matchers.call.fn(api.getActionDependencies),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_ACTION_DEPENDENCIES_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(getActionDependencies)
-      .provide([
-        [matchers.call.fn(api.getActionDependencies), throwError(error)],
-      ])
-      .put({
-        type: GET_ACTION_DEPENDENCIES_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchForUpsertRulesets saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForUpsertRulesets();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(UPSERT_RULESETS_REQUEST, upsertRulesets);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('upsertRulesets saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(upsertRulesets, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.upsertRulesets),
-          { upsertRulesetsMock, success: true },
-        ],
-      ])
-      .put({
-        type: UPSERT_RULESETS_SUCCESS,
-        result: upsertRulesetsMock,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(upsertRulesets, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.upsertRulesets),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: UPSERT_RULESETS_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(upsertRulesets, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([[matchers.call.fn(api.upsertRulesets), throwError(error)]])
-      .put({
-        type: UPSERT_RULESETS_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchForGetAllTenderCombinations saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForGetAllTenderCombinations();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(
-      GET_TENDER_COMBINATION_REQUEST,
-      getAllTenderCombination,
-    );
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getAllTenderCombination saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getAllTenderCombination, {
-      programId,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getAllTenderCombination),
-          { allTenderCombination, success: true },
-        ],
-      ])
-      .put({
-        type: GET_TENDER_COMBINATION_SUCCESS,
-        result: allTenderCombination,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getAllTenderCombination, {
-      programId,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getAllTenderCombination),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_TENDER_COMBINATION_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(getAllTenderCombination, {
-      programId,
-    })
-      .provide([
-        [matchers.call.fn(api.getAllTenderCombination), throwError(error)],
-      ])
-      .put({
-        type: GET_TENDER_COMBINATION_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchForSaveCapping saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForSaveCapping();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(SAVE_CAPPING_REQUEST, saveCapping);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('saveCapping saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(saveCapping, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([
-        [matchers.call.fn(api.saveCapping), { saveCappingMock, success: true }],
-      ])
-      .put({
-        type: SAVE_CAPPING_SUCCESS,
-        result: saveCappingMock,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(saveCapping, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.saveCapping),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: SAVE_CAPPING_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(saveCapping, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([[matchers.call.fn(api.saveCapping), throwError(error)]])
-      .put({
-        type: SAVE_CAPPING_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchGetExtendedField saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchGetExtendedField();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(GET_EXTENDED_FIELDS_REQUEST, getExtendedFields);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getExtendedFields saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getExtendedFields, {
-      extendedField,
-      programId,
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getExtendedFields),
-          { extendedFieldsData, success: true },
-        ],
-      ])
-      .put({
-        type: GET_EXTENDED_FIELDS_SUCCESS,
-        result: extendedFieldsData,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getExtendedFields, {
-      extendedField,
-      programId,
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getExtendedFields),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_EXTENDED_FIELDS_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(getExtendedFields, {
-      extendedField,
-      programId,
-      callback,
-    })
-      .provide([[matchers.call.fn(api.getExtendedFields), throwError(error)]])
-      .put({
-        type: GET_EXTENDED_FIELDS_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchGetStoresRequest saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchGetStoresRequest();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(GET_STORE_REQUEST, getStores);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getStores saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getStores)
-      .provide([
-        [matchers.call.fn(api.getOrgEntities), { store, success: true }],
-      ])
-      .put({
-        type: GET_STORE_SUCCESS,
-        result: store,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getStores)
-      .provide([
-        [
-          matchers.call.fn(api.getOrgEntities),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_STORE_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(getStores)
-      .provide([[matchers.call.fn(api.getOrgEntities), throwError(error)]])
-      .put({
-        type: GET_STORE_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchGetConceptsRequest saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchGetConceptsRequest();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(GET_CONCEPT_REQUEST, getConcept);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getConcept saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getConcept)
-      .provide([
-        [matchers.call.fn(api.getOrgEntities), { store, success: true }],
-      ])
-      .put({
-        type: GET_CONCEPT_SUCCESS,
-        result: store,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getConcept)
-      .provide([
-        [
-          matchers.call.fn(api.getOrgEntities),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_CONCEPT_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(getConcept)
-      .provide([[matchers.call.fn(api.getOrgEntities), throwError(error)]])
-      .put({
-        type: GET_CONCEPT_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchGetZonesRequest saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchGetZonesRequest();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(GET_ZONE_REQUEST, getZone);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getZone saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getZone)
-      .provide([
-        [matchers.call.fn(api.getOrgEntities), { store, success: true }],
-      ])
-      .put({
-        type: GET_ZONE_SUCCESS,
-        result: store,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getZone)
-      .provide([
-        [
-          matchers.call.fn(api.getOrgEntities),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_ZONE_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(getZone)
-      .provide([[matchers.call.fn(api.getOrgEntities), throwError(error)]])
-      .put({
-        type: GET_ZONE_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchGetEventSourceRequest saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchGetEventSourceRequest();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(GET_EVENT_SOURCE_REQUEST, getEventSource);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getEventSource saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getEventSource)
-      .provide([
-        [matchers.call.fn(api.getScopeDependencies), { store, success: true }],
-      ])
-      .put({
-        type: GET_EVENT_SOURCE_SUCCESS,
-        result: store,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getEventSource)
-      .provide([
-        [
-          matchers.call.fn(api.getScopeDependencies),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_EVENT_SOURCE_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(getEventSource)
-      .provide([
-        [matchers.call.fn(api.getScopeDependencies), throwError(error)],
-      ])
-      .put({
-        type: GET_EVENT_SOURCE_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchGetClusterRequest saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchGetClusterRequest();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(GET_CLUSTER_REQUEST, getCluster);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getCluster saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getCluster)
-      .provide([
-        [matchers.call.fn(api.getScopeDependencies), { store, success: true }],
-      ])
-      .put({
-        type: GET_CLUSTER_SUCCESS,
-        result: store,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getCluster)
-      .provide([
-        [
-          matchers.call.fn(api.getScopeDependencies),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_CLUSTER_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(getCluster)
-      .provide([
-        [matchers.call.fn(api.getScopeDependencies), throwError(error)],
-      ])
-      .put({
-        type: GET_CLUSTER_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchForSaveScoping saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForSaveScoping();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(SAVE_SCOPING_REQUEST, saveScoping);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('saveScoping saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(saveScoping, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([[matchers.call.fn(api.saveScoping), { store, success: true }]])
-      .put({
-        type: SAVE_SCOPING_SUCCESS,
-        result: store,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(saveScoping, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.saveScoping),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: SAVE_SCOPING_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(saveScoping, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([[matchers.call.fn(api.saveScoping), throwError(error)]])
-      .put({
-        type: SAVE_SCOPING_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchCreateRule saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchCreateRule();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(CREATE_RULE_REQUEST, createRule);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('createRule saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(createRule, {
-      eventType,
-      programId,
-      rulesetId,
-      callback,
-      source,
-      allRulesLength,
-      userId,
-    })
-      .provide([[matchers.call.fn(api.createRule), { rules, success: true }]])
-      .put({
-        type: CREATE_RULE_SUCCESS,
-        result: rules,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(createRule, {
-      eventType,
-      programId,
-      rulesetId,
-      callback,
-      source,
-      allRulesLength,
-      userId,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.createRule),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: CREATE_RULE_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(createRule, {
-      eventType,
-      programId,
-      rulesetId,
-      callback,
-      source,
-      allRulesLength,
-      userId,
-    })
-      .provide([[matchers.call.fn(api.createRule), throwError(error)]])
-      .put({
-        type: CREATE_RULE_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchSaveRuleset saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchSaveRuleset();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(SAVE_RULESET_REQUEST, saveRuleset);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('saveRuleset saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(saveRuleset, {
-      eventType,
-      programId,
-      rulesetId,
-      callback,
-    })
-      .provide([[matchers.call.fn(api.saveRuleset), { store, success: true }]])
-      .put({
-        type: SAVE_RULESET_SUCCESS,
-        result: rulesets,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(saveRuleset, {
-      eventType,
-      programId,
-      rulesetId,
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.saveRuleset),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: SAVE_RULESET_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(saveRuleset, {
-      eventType,
-      programId,
-      rulesetId,
-      callback,
-    })
-      .provide([[matchers.call.fn(api.saveRuleset), throwError(error)]])
-      .put({
-        type: SAVE_RULESET_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchGetLabels saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchGetLabels();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(GET_LABELS_REQUEST, getLabels);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getLabels saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getLabels)
-      .provide([[matchers.call.fn(api.getLabels), { store, success: true }]])
-      .put({
-        type: GET_LABELS_SUCCESS,
-        result: store,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getLabels)
-      .provide([
-        [
-          matchers.call.fn(api.getLabels),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_LABELS_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(getLabels)
-      .provide([[matchers.call.fn(api.getLabels), throwError(error)]])
-      .put({
-        type: GET_LABELS_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchDeleteAction saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchDeleteAction();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(DELETE_ACTION_REQUEST, deleteAction);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('deleteAction saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(deleteAction, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([[matchers.call.fn(api.deleteAction), { store, success: true }]])
-      .put({
-        type: DELETE_ACTION_SUCCESS,
-        result: store,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(deleteAction, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.deleteAction),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: DELETE_ACTION_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(deleteAction, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([[matchers.call.fn(api.deleteAction), throwError(error)]])
-      .put({
-        type: DELETE_ACTION_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchDeleteCondition saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchDeleteCondition();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(DELETE_CONDITION_REQUEST, deleteCondition);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('deleteCondition saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(deleteCondition, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([
-        [matchers.call.fn(api.deleteCondition), { store, success: true }],
-      ])
-      .put({
-        type: DELETE_CONDITION_SUCCESS,
-        result: store,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(deleteCondition, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.deleteCondition),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: DELETE_CONDITION_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(deleteCondition, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([[matchers.call.fn(api.deleteCondition), throwError(error)]])
-      .put({
-        type: DELETE_CONDITION_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchForSaveAllExpressionsByEventType saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForSaveAllExpressionsByEventType();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(
-      SAVE_ALL_EXPRESSIONS_BY_EVENT_TYPE_REQUEST,
-      saveAllExpressionsByEventType,
-    );
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('saveAllExpressionsByEventType saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(saveAllExpressionsByEventType, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.saveAllExpressionsByEventType),
-          { store, success: true },
-        ],
-      ])
-      .put({
-        type: SAVE_ALL_EXPRESSIONS_BY_EVENT_TYPE_SUCCESS,
-        result: store,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(saveAllExpressionsByEventType, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.saveAllExpressionsByEventType),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: SAVE_ALL_EXPRESSIONS_BY_EVENT_TYPE_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(saveAllExpressionsByEventType, {
-      payload,
-      programId,
-      eventType,
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.saveAllExpressionsByEventType),
-          throwError(error),
-        ],
-      ])
-      .put({
-        type: SAVE_ALL_EXPRESSIONS_BY_EVENT_TYPE_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchForSavePromotion saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForSavePromotion();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(SAVE_PROMOTION_REQUEST, savePromotion);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('savePromotion saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(savePromotion, {
-      payload,
-      callback,
-    })
-      .provide([
-        [matchers.call.fn(api.savePromotion), { store, success: true }],
-      ])
-      .put({
-        type: SAVE_PROMOTION_SUCCESS,
-        result: store,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(savePromotion, {
-      payload,
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.savePromotion),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: SAVE_PROMOTION_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(savePromotion, {
-      payload,
-      callback,
-    })
-      .provide([[matchers.call.fn(api.savePromotion), throwError(error)]])
-      .put({
-        type: SAVE_PROMOTION_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchForGetDependentEnums saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForGetDependentEnums();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(GET_DEPENDENT_ENUMS_REQUEST, getDependentEnums);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getDependentEnums saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getDependentEnums, {
-      programId,
-      enumType,
-    })
-      .provide([
-        [matchers.call.fn(api.getDependentEnums), { store, success: true }],
-      ])
-      .put({
-        type: GET_DEPENDENT_ENUMS_SUCCESS,
-        result: store,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getDependentEnums, {
-      programId,
-      enumType,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getDependentEnums),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_DEPENDENT_ENUMS_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(getDependentEnums, {
-      programId,
-      enumType,
-    })
-      .provide([[matchers.call.fn(api.getDependentEnums), throwError(error)]])
-      .put({
-        type: GET_ACTION_DEPENDENCIES_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchForSaveRulesetLabel saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForSaveRulesetLabel();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(SAVE_RULESET_LABEL_REQUEST, saveRulesetLabel);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('saveRulesetLabel saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(saveRulesetLabel, {
-      eventType,
-      programId,
-      rulesetId,
-      label,
-      callback,
-    })
-      .provide([
-        [matchers.call.fn(api.saveRulesetLabel), { store, success: true }],
-      ])
-      .put({
-        type: SAVE_RULESET_LABEL_SUCCESS,
-        result: store,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(saveRulesetLabel, {
-      eventType,
-      programId,
-      rulesetId,
-      label,
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.saveRulesetLabel),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: SAVE_RULESET_LABEL_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(saveRulesetLabel, {
-      eventType,
-      programId,
-      rulesetId,
-      label,
-      callback,
-    })
-      .provide([[matchers.call.fn(api.saveRulesetLabel), throwError(error)]])
-      .put({
-        type: SAVE_RULESET_LABEL_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-const data = {};
-const error1 = new Error('Something went wrong');
-
-describe('saveToggleActionCase saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(saveToggleActionCase, sagaMockData)
-      .provide([
-        [
-          matchers.call.fn(api.saveToggleActionCase),
-          {
-            success: true,
-            data: {
-              data,
-            },
-          },
-        ],
-      ])
-      .put({
-        type: SAVE_TOGGLE_ACTION_CASE_SUCCESS,
-        data: data,
-      })
-      .run();
-  });
-  it('handle error response from api', () => {
-    expectSaga(saveToggleActionCase, sagaMockData)
-      .provide([
-        [
-          matchers.call.fn(api.saveToggleActionCase),
-          {
-            data: {
-              error1,
-            },
-          },
-        ],
-      ])
-      .put({
-        type: SAVE_TOGGLE_ACTION_CASE_FAILURE,
-        error: error1,
-      })
-      .run();
-  });
-  it('handles error thrown from api', () => {
-    expectSaga(saveToggleActionCase, sagaMockData)
-      .provide([[matchers.call.fn(api.getTargetGroups), throwError(error1)]])
-      .put({
-        type: SAVE_TOGGLE_ACTION_CASE_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchForSaveToggleActionCase saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForSaveToggleActionCase();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(
-      SAVE_TOGGLE_ACTION_CASE_REQUEST,
-      saveToggleActionCase,
-    );
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('watchForGetTargetGroups saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForGetTargetGroups();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(GET_TARGET_GROUPS_REQUEST, getTargetGroups);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('watchForGetCappingTargetGroups saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForGetCappingTargetGroups();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(
-      GET_CAPPING_TARGET_GROUPS_REQUEST,
-      getCappingTargetGroups,
-    );
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getCappingTargetGroups saga', () => {
-  it('handle valid response from api', () => {
-    const callback = jest.fn(() => {});
-    expectSaga(getCappingTargetGroups, {
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getCompressedTargetGroupsWithTargets),
-          { targetGroups, success: true },
-        ],
-      ])
-      .put({
-        type: GET_CAPPING_TARGET_GROUPS_SUCCESS,
-        result: targetGroups,
-      })
-      .run();
-  });
-  it('handle valid response from api without callback', () => {
-    expectSaga(getCappingTargetGroups, {
-      callback: null,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getCompressedTargetGroupsWithTargets),
-          { targetGroups, success: true },
-        ],
-      ])
-      .put({
-        type: GET_CAPPING_TARGET_GROUPS_SUCCESS,
-        result: targetGroups,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    const callback = jest.fn(() => {});
-    expectSaga(getCappingTargetGroups, {
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getCompressedTargetGroupsWithTargets),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_CAPPING_TARGET_GROUPS_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    const callback = jest.fn(() => {});
-    expectSaga(getCappingTargetGroups, {
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getCompressedTargetGroupsWithTargets),
-          throwError(error),
-        ],
-      ])
-      .put({
-        type: GET_CAPPING_TARGET_GROUPS_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('getTargetGroups saga', () => {
-  it('handle valid response from api', () => {
-    const callback = jest.fn(() => {});
-    expectSaga(getTargetGroups, {
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getTargetGroups),
-          { ebillTemplates, success: true },
-        ],
-      ])
-      .put({
-        type: GET_TARGET_GROUPS_SUCCESS,
-        result: ebillTemplates,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    const callback = jest.fn(() => {});
-    expectSaga(getTargetGroups, {
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getTargetGroups),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_TARGET_GROUPS_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    const callback = jest.fn(() => {});
-    expectSaga(getTargetGroups, {
-      callback,
-    })
-      .provide([[matchers.call.fn(api.getTargetGroups), throwError(error)]])
-      .put({
-        type: GET_TARGET_GROUPS_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('watchForGetTargetsFromMultipleGroups saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForGetTargetsFromMultipleGroups();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(
-      GET_MULTIPLE_TARGETS_REQUEST,
-      getTargetsFromMultipleGroups,
-    );
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getTargetsFromMultipleGroups saga', () => {
-  it('handle valid response from api', () => {
-    const callback = jest.fn(() => {});
-    expectSaga(getTargetsFromMultipleGroups, {
-      targetGroupIds: [775],
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getTargetsFromMultipleGroups),
-          { res: {}, success: true },
-        ],
-      ])
-      .put({
-        type: GET_MULTIPLE_TARGETS_SUCCESS,
-      })
-      .run();
-    expect(callback.mock.calls.length).toBe(1);
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getTargetsFromMultipleGroups, () => {})
-      .provide([
-        [
-          matchers.call.fn(api.getTargetsFromMultipleGroups),
-          { status: { message: 'error Message' }, success: false },
-        ],
-      ])
-      .put({
-        type: GET_MULTIPLE_TARGETS_FAILURE,
-        error: { status: { message: 'error Message' } },
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getTargetsFromMultipleGroups, () => {})
-      .provide([
-        [matchers.call.fn(api.getTargetsFromMultipleGroups), throwError(error)],
-        { success: false },
-      ])
-      .put({
-        type: GET_MULTIPLE_TARGETS_FAILURE,
-        error: error,
-      })
-      .run();
-  });
-});
-
-describe('watchForGetTargetPeriodsFromMultipleGroups saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchForGetTargetPeriodsFromMultipleGroups();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(
-      GET_TARGET_PERIODS_GROUPS_REQUEST,
-      getTargetPeriodsFromMultipleGroups,
-    );
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getTargetPeriodsFromMultipleGroups saga', () => {
-  it('handle valid response from api', () => {
-    const callback = jest.fn(() => {});
-    expectSaga(getTargetPeriodsFromMultipleGroups, {
-      targetGroupIds: [775],
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getAllPeriodsInTargetGroup),
-          { res: {}, success: true },
-        ],
-      ])
-      .put({
-        type: GET_TARGET_PERIODS_GROUPS_SUCCESS,
-      })
-      .run();
-    expect(callback.mock.calls.length).toBe(1);
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getTargetPeriodsFromMultipleGroups, () => {})
-      .provide([
-        [
-          matchers.call.fn(api.getAllPeriodsInTargetGroup),
-          { status: { message: 'error Message' }, success: false },
-        ],
-      ])
-      .put({
-        type: GET_TARGET_PERIODS_GROUPS_FAILURE,
-        error: { status: { message: 'error Message' } },
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getTargetPeriodsFromMultipleGroups, () => {})
-      .provide([
-        [matchers.call.fn(api.getAllPeriodsInTargetGroup), throwError(error)],
-        { success: false },
-      ])
-      .put({
-        type: GET_TARGET_PERIODS_GROUPS_FAILURE,
-        error: error,
-      })
-      .run();
-  });
-});
-
-describe('watchGetEventsList saga', () => {
-  let generator = null;
-  beforeEach(() => {
-    generator = watchGetEventsList();
-  });
-  it('handle valid response from api', () => {
-    const progress1 = generator.next();
-    const mockTask = takeLatest(GET_GENERIC_EVENTS_REQUEST, getEventsLists);
-    expect(progress1.value).toEqual(mockTask);
-  });
-});
-
-describe('getEventsLists saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getEventsLists)
-      .provide([
-        [
-          matchers.call.fn(api.getGenericEvents),
-          { genericEventList, success: true },
-        ],
-      ])
-      .put({
-        type: GET_GENERIC_EVENTS_SUCCESS,
-        result: genericEventList,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getEventsLists)
-      .provide([
-        [
-          matchers.call.fn(api.getGenericEvents),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_GENERIC_EVENTS_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handles error thrown from api', () => {
-    expectSaga(getEventsLists)
-      .provide([[matchers.call.fn(api.getGenericEvents), throwError(error)]])
-      .put({
-        type: GET_GENERIC_EVENTS_FAILURE,
-        error,
-      })
-      .run();
-  });
-});
-
-describe('getAllAlternateCurrency saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(getAllAlternateCurrency, {
-      pagination: {
-        pageNumber: 0,
-      },
-      queryParams: {},
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getAllAlternateCurrency),
-          { mockAPIResponse, success: true },
-        ],
-      ])
-      .put({
-        type: GET_ALL_ALTERNATE_CURRENCY_SUCCESS,
-        data: mockAPIResponse.data,
-        pageDetails: mockAPIResponse.pagination,
-        resetResults: 0,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(getAllAlternateCurrency, {
-      pagination: {
-        pageNumber: 0,
-      },
-      queryParams: {},
-    })
-      .provide([
-        [
-          matchers.call.fn(api.getAllAlternateCurrency),
-          { errorMessage: 'error Message', success: false },
-        ],
-      ])
-      .put({
-        type: GET_ALL_ALTERNATE_CURRENCY_FAILURE,
-        error: 'error Message',
-      })
-      .run();
-  });
-
-  it('handle error', () => {
-    expectSaga(getAllAlternateCurrency, {
-      pagination: {
-        pageNumber: 0,
-      },
-      queryParams: {},
-    })
-      .provide([
-        [matchers.call.fn(api.getAllAlternateCurrency), throwError(error)],
-        { success: false },
-      ])
-      .put({
-        type: GET_ALL_ALTERNATE_CURRENCY_FAILURE,
-        error: {
-          message: 'Unauthorised',
-          response: {
-            status: 401,
-          },
-        },
-      })
-      .run();
-  });
-});
-
-describe('watchForGetAllAlternateCurrency', () => {
-  const generator = watchForGetAllAlternateCurrency();
-  it('should call watchers functions', () => {
-    expect(generator.next().value).toEqual(
-      takeLatest(GET_ALL_ALTERNATE_CURRENCY_REQUEST, getAllAlternateCurrency),
-    );
-  });
-});
-
-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('unClaim Badge saga', () => {
-  it('handle valid response from api', () => {
-    expectSaga(unClaimBadge, {
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.unClaimBadges),
-          { success: true },
-        ],
-      ])
-      .put({
-        type: UNCLAIM_BADGE_SUCCESS,
-
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(unClaimBadge, {
-      callback,
-    })
-      .provide([
-        [
-          matchers.call.fn(api.unClaimBadges),
-          { success: false },
-        ],
-      ])
-      .put({
-        type: UNCLAIM_BADGE_FAILURE,
-      })
-      .run();
-  });
-
-  it('handle error response from api', () => {
-    expectSaga(unClaimBadge, {
-      callback,
-    })
-      .provide([
-        [matchers.call.fn(api.unClaimBadges), throwError(error)],
-        { success: false },
-      ])
-      .put({
-        type: UNCLAIM_BADGE_FAILURE,
-        error,
-      })
-      .run();
-  });
-});