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

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

@@ -0,0 +1,2543 @@
+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();
+  });
+});