attachment page navigation fix

Issue-ID: SDC-1239
Change-Id: Ib597238233e9a035944b7a56a56601cdfd624ca2
Signed-off-by: svishnev <shlomo-stanisla.vishnevetskiy@amdocs.com>

1 files changed, 692 insertions, 441 deletions

diff --git a/openecomp-ui/test/licenseModel/entitlementPools/test.js b/openecomp-ui/test/licenseModel/entitlementPools/test.js
index dc56b11f1b..63eab1f7b9 100644
--- a/openecomp-ui/test/licenseModel/entitlementPools/test.js
+++ b/openecomp-ui/test/licenseModel/entitlementPools/test.js
@@ -1,455 +1,706 @@
-/*!
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+/*
+ * Copyright © 2016-2018 European Support Limited
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
- * or implied. See the License for the specific language governing
- * permissions and limitations under the License.
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 import deepFreeze from 'deep-freeze';
 import mockRest from 'test-utils/MockRest.js';
-import {cloneAndSet, buildListFromFactory} from 'test-utils/Util.js';
-import {storeCreator} from 'sdc-app/AppStore.js';
+import { cloneAndSet, buildListFromFactory } from 'test-utils/Util.js';
+import { storeCreator } from 'sdc-app/AppStore.js';
 import EntitlementPoolsActionHelper from 'sdc-app/onboarding/licenseModel/entitlementPools/EntitlementPoolsActionHelper.js';
-import {EntitlementPoolStoreFactory, EntitlementPoolPostFactory} from 'test-utils/factories/licenseModel/EntitlementPoolFactories.js';
+import {
+    EntitlementPoolStoreFactory,
+    EntitlementPoolPostFactory
+} from 'test-utils/factories/licenseModel/EntitlementPoolFactories.js';
 import VersionFactory from 'test-utils/factories/common/VersionFactory.js';
-import {LimitItemFactory, LimitPostFactory} from 'test-utils/factories/licenseModel/LimitFactories.js';
-import {getStrValue} from 'nfvo-utils/getValue.js';
-import {SyncStates} from 'sdc-app/common/merge/MergeEditorConstants.js';
+import {
+    LimitItemFactory,
+    LimitPostFactory
+} from 'test-utils/factories/licenseModel/LimitFactories.js';
+import { getStrValue } from 'nfvo-utils/getValue.js';
+import { SyncStates } from 'sdc-app/common/merge/MergeEditorConstants.js';
 import CurrentScreenFactory from 'test-utils/factories/common/CurrentScreenFactory.js';
 
-describe('Entitlement Pools Module Tests', function () {
-
-	const LICENSE_MODEL_ID = '555';
-	const version = VersionFactory.build();
-	const itemPermissionAndProps = CurrentScreenFactory.build({}, {version});
-	const returnedVersionFields = {baseId: version.baseId, description: version.description, id: version.id, name: version.name, status: version.status};
-
-	it('Load Entitlement Pools List', () => {
-
-		const entitlementPoolsList = buildListFromFactory(EntitlementPoolStoreFactory);
-		deepFreeze(entitlementPoolsList);
-		const store = storeCreator();
-		deepFreeze(store.getState());
-
-		const expectedStore = cloneAndSet(store.getState(), 'licenseModel.entitlementPool.entitlementPoolsList', entitlementPoolsList);
-
-		mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools`);
-			expect(data).toEqual(undefined);
-			expect(options).toEqual(undefined);
-			return {results: entitlementPoolsList};
-		});
-
-		return EntitlementPoolsActionHelper.fetchEntitlementPoolsList(store.dispatch, {licenseModelId: LICENSE_MODEL_ID, version}).then(() => {
-			expect(store.getState()).toEqual(expectedStore);
-		});
-	});
-
-	it('Delete Entitlement Pool', () => {
-
-		const entitlementPoolsList = buildListFromFactory(EntitlementPoolStoreFactory,1);
-		deepFreeze(entitlementPoolsList);
-		const store = storeCreator({
-			currentScreen: {...itemPermissionAndProps},
-			licenseModel: {
-				entitlementPool: {
-					entitlementPoolsList
-				}
-			}
-		});
-		deepFreeze(store.getState());
-
-		const expectedCurrentScreenProps = {
-			...itemPermissionAndProps,
-			itemPermission: {
-				...itemPermissionAndProps.itemPermission,
-				isDirty: true
-			}
-		};
-
-		let expectedStore = cloneAndSet(store.getState(), 'licenseModel.entitlementPool.entitlementPoolsList', []);
-		expectedStore = cloneAndSet(expectedStore, 'currentScreen.itemPermission', expectedCurrentScreenProps.itemPermission);
-
-		mockRest.addHandler('destroy', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${entitlementPoolsList[0].id}`);
-			expect(data).toEqual(undefined);
-			expect(options).toEqual(undefined);
-			return {
-				results: {
-					returnCode: 'OK'
-				}
-			};
-		});
-		
-		mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${version.id}`);
-			expect(data).toEqual(undefined);
-			expect(options).toEqual(undefined);
-			return {...returnedVersionFields, state: {synchronizationState: SyncStates.UP_TO_DATE, dirty: true}};
-		});
-		
-		return EntitlementPoolsActionHelper.deleteEntitlementPool(store.dispatch, {
-			licenseModelId: LICENSE_MODEL_ID,
-			version,
-			entitlementPoolId: entitlementPoolsList[0].id
-		}).then(() => {
-			expect(store.getState()).toEqual(expectedStore);
-		});
-	});
-
-	it('Add Entitlement Pool', () => {
-
-		const store = storeCreator({
-			currentScreen: {...itemPermissionAndProps}
-		});
-		deepFreeze(store.getState());
-
-		const EntitlementPoolPostRequest = EntitlementPoolPostFactory.build();
-
-		deepFreeze(EntitlementPoolPostRequest);
-
-		const entitlementPoolIdFromResponse = 'ADDED_ID';
-		const entitlementPoolAfterAdd = EntitlementPoolStoreFactory.build({id: entitlementPoolIdFromResponse});
-		deepFreeze(entitlementPoolAfterAdd);
-
-		const expectedCurrentScreenProps = {
-			...itemPermissionAndProps,
-			itemPermission: {
-				...itemPermissionAndProps.itemPermission,
-				isDirty: true
-			}
-		};
-
-		let expectedStore = cloneAndSet(store.getState(), 'licenseModel.entitlementPool.entitlementPoolsList', [entitlementPoolAfterAdd]);
-		expectedStore = cloneAndSet(expectedStore, 'currentScreen.itemPermission', expectedCurrentScreenProps.itemPermission);
-
-		mockRest.addHandler('post', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools`);
-			expect(data).toEqual(EntitlementPoolPostRequest);
-			expect(options).toEqual(undefined);
-			return {
-				returnCode: 'OK',
-				value: entitlementPoolIdFromResponse
-			};
-		});
-
-		mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${version.id}`);
-			expect(data).toEqual(undefined);
-			expect(options).toEqual(undefined);
-			return {...returnedVersionFields, state: {synchronizationState: SyncStates.UP_TO_DATE, dirty: true}};
-		});
-
-		
-
-		return EntitlementPoolsActionHelper.saveEntitlementPool(store.dispatch,
-			{
-				licenseModelId: LICENSE_MODEL_ID,
-				version,
-				previousEntitlementPool: null,
-				entitlementPool: EntitlementPoolPostRequest
-			}
-		).then(() => {
-			expect(store.getState()).toEqual(expectedStore);
-		});
-	});
-
-	it('Update Entitlement Pool', () => {
-
-		const entitlementPoolsList = buildListFromFactory(EntitlementPoolStoreFactory, 1);
-		deepFreeze(entitlementPoolsList);
-
-		const store = storeCreator({
-			currentScreen: {...itemPermissionAndProps},
-			licenseModel: {
-				entitlementPool: {
-					entitlementPoolsList
-				}
-			}
-		});
-
-		deepFreeze(store.getState());
-
-		const toBeUpdatedEntitlementPoolId = entitlementPoolsList[0].id;
-		const previousEntitlementPoolData = entitlementPoolsList[0];
-		const entitlementPoolUpdateData = EntitlementPoolStoreFactory.build({name: 'ep1_UPDATED', description: 'string_UPDATED', id: toBeUpdatedEntitlementPoolId});
-		deepFreeze(entitlementPoolUpdateData);
-
-		const entitlementPoolPutRequest = EntitlementPoolPostFactory.build({name: 'ep1_UPDATED', description: 'string_UPDATED'});
-		deepFreeze(entitlementPoolPutRequest);
-
-		const expectedCurrentScreenProps = {
-			...itemPermissionAndProps,
-			itemPermission: {
-				...itemPermissionAndProps.itemPermission,
-				isDirty: true
-			}
-		};
-
-		let expectedStore = cloneAndSet(store.getState(), 'licenseModel.entitlementPool.entitlementPoolsList', [entitlementPoolUpdateData]);
-		expectedStore = cloneAndSet(expectedStore, 'currentScreen.itemPermission', expectedCurrentScreenProps.itemPermission);
-
-
-		mockRest.addHandler('put', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${toBeUpdatedEntitlementPoolId}`);
-			expect(data).toEqual(entitlementPoolPutRequest);
-			expect(options).toEqual(undefined);
-			return {returnCode: 'OK'};
-		});
-
-		mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${version.id}`);
-			expect(data).toEqual(undefined);
-			expect(options).toEqual(undefined);
-			return {...returnedVersionFields, state: {synchronizationState: SyncStates.UP_TO_DATE, dirty: true}};
-		});
-
-		return EntitlementPoolsActionHelper.saveEntitlementPool(store.dispatch, {
-			licenseModelId: LICENSE_MODEL_ID,
-			version,
-			previousEntitlementPool: previousEntitlementPoolData,
-			entitlementPool: entitlementPoolUpdateData
-		}).then(() => {
-			expect(store.getState()).toEqual(expectedStore);
-		});
-	});
-
-	it('Load Limits List', () => {
-
-		const limitsList = LimitItemFactory.buildList(3);
-		deepFreeze(limitsList);
-		const store = storeCreator();
-		deepFreeze(store.getState());
-
-		const expectedStore = cloneAndSet(store.getState(), 'licenseModel.entitlementPool.entitlementPoolEditor.limitsList', limitsList);
-		const entitlementPool = EntitlementPoolStoreFactory.build();
-		mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${entitlementPool.id}/limits`);
-			expect(data).toEqual(undefined);
-			expect(options).toEqual(undefined);
-			return {results: limitsList};
-		 });
-
-		return EntitlementPoolsActionHelper.fetchLimits(store.dispatch, {licenseModelId: LICENSE_MODEL_ID, version, entitlementPool}).then(() => {
-			expect(store.getState()).toEqual(expectedStore);
-		 });
-	});
-
-	it('Add Limit', () => {
-
-		const store = storeCreator({
-			currentScreen: {...itemPermissionAndProps}
-		});
-		deepFreeze(store.getState());
-
-		const limitToAdd = LimitPostFactory.build();
-		let limitFromBE = {...limitToAdd};
-		limitFromBE.metric = getStrValue(limitFromBE.metric);
-		limitFromBE.unit = getStrValue(limitFromBE.unit);
-
-		deepFreeze(limitToAdd);
-		deepFreeze(limitFromBE);
-
-		const LimitIdFromResponse = 'ADDED_ID';
-		const limitAddedItem = {...limitToAdd, id: LimitIdFromResponse};
-		deepFreeze(limitAddedItem);
-		const entitlementPool = EntitlementPoolStoreFactory.build();
-
-		const expectedCurrentScreenProps = {
-			...itemPermissionAndProps,
-			itemPermission: {
-				...itemPermissionAndProps.itemPermission,
-				isDirty: true
-			}
-		};
-
-		let expectedStore = cloneAndSet(store.getState(), 'licenseModel.entitlementPool.entitlementPoolEditor.limitsList', [limitAddedItem]);
-		expectedStore = cloneAndSet(expectedStore, 'currentScreen.itemPermission', expectedCurrentScreenProps.itemPermission);
-
-		mockRest.addHandler('post', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${entitlementPool.id}/limits`);
-			expect(data).toEqual(limitFromBE);
-			expect(options).toEqual(undefined);
-			return {
-				returnCode: 'OK',
-				value: LimitIdFromResponse
-			};
-		});
-
-		mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${entitlementPool.id}/limits`);
-			expect(data).toEqual(undefined);
-			expect(options).toEqual(undefined);
-			return {results: [limitAddedItem]};
-		 });
-
-		mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${version.id}`);
-			expect(data).toEqual(undefined);
-			expect(options).toEqual(undefined);
-			return {...returnedVersionFields, state: {synchronizationState: SyncStates.UP_TO_DATE, dirty: true}};
-		});
-
-		return EntitlementPoolsActionHelper.submitLimit(store.dispatch,
-			{
-				licenseModelId: LICENSE_MODEL_ID,
-				version,
-				entitlementPool,
-				limit: limitToAdd
-			}
-		).then(() => {
-			expect(store.getState()).toEqual(expectedStore);
-		});
-	});
-
-
-	it('Delete Limit', () => {
-
-		const limitsList = LimitItemFactory.buildList(1);
-		deepFreeze(limitsList);
-
-		const store = storeCreator({
-			currentScreen: {...itemPermissionAndProps},
-			licenseModel: {
-				entitlementPool: {
-					entitlementPoolEditor: {
-						limitsList
-					}
-				}
-			}
-		});
-		deepFreeze(store.getState());
-
-		const entitlementPool = EntitlementPoolStoreFactory.build();
-
-		const expectedCurrentScreenProps = {
-			...itemPermissionAndProps,
-			itemPermission: {
-				...itemPermissionAndProps.itemPermission,
-				isDirty: true
-			}
-		};
-
-		let expectedStore = cloneAndSet(store.getState(), 'licenseModel.entitlementPool.entitlementPoolEditor.limitsList', []);
-		expectedStore = cloneAndSet(expectedStore, 'currentScreen.itemPermission', expectedCurrentScreenProps.itemPermission);
-
-		mockRest.addHandler('destroy', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${entitlementPool.id}/limits/${limitsList[0].id}`);
-			expect(data).toEqual(undefined);
-			expect(options).toEqual(undefined);
-			return {
-				results: {
-					returnCode: 'OK'
-				}
-			};
-		});
-
-		mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${entitlementPool.id}/limits`);
-			expect(data).toEqual(undefined);
-			expect(options).toEqual(undefined);
-			return {results: []};
-		 });
-
-		mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${version.id}`);
-			expect(data).toEqual(undefined);
-			expect(options).toEqual(undefined);
-			return {...returnedVersionFields, state: {synchronizationState: SyncStates.UP_TO_DATE, dirty: true}};
-		});
-
-		return EntitlementPoolsActionHelper.deleteLimit(store.dispatch, {
-			licenseModelId: LICENSE_MODEL_ID,
-			version,
-			entitlementPool,
-			limit: limitsList[0]
-		}).then(() => {
-			expect(store.getState()).toEqual(expectedStore);
-		});
-	});
-
-	it('Update Limit', () => {
-
-		const limitsList = LimitItemFactory.buildList(1);
-		deepFreeze(limitsList);
-		const entitlementPool = EntitlementPoolStoreFactory.build();
-		const store = storeCreator({
-			currentScreen: {...itemPermissionAndProps},
-			licenseModel: {
-				entitlementPool: {
-					entitlementPoolEditor: {
-						limitsList
-					}
-				}
-			}
-		});
-
-		deepFreeze(store.getState());
-
-
-		const previousData = limitsList[0];
-
-		deepFreeze(previousData);
-		const limitId = limitsList[0].id;
-
-		let updatedLimit = {...previousData, name: 'updatedLimit'};
-
-		const updatedLimitForPut = {...updatedLimit, id: undefined};
-		updatedLimit.metric = {choice: updatedLimit.metric, other: ''};
-		updatedLimit.unit = {choice: updatedLimit.unit, other: ''};
-		deepFreeze(updatedLimit);
-
-		const expectedCurrentScreenProps = {
-			...itemPermissionAndProps,
-			itemPermission: {
-				...itemPermissionAndProps.itemPermission,
-				isDirty: true
-			}
-		};
-
-		let expectedStore = cloneAndSet(store.getState(), 'licenseModel.entitlementPool.entitlementPoolEditor.limitsList', [updatedLimitForPut]);
-		expectedStore = cloneAndSet(expectedStore, 'currentScreen.itemPermission', expectedCurrentScreenProps.itemPermission);
-
-
-		mockRest.addHandler('put', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${entitlementPool.id}/limits/${limitId}`);
-			expect(data).toEqual(updatedLimitForPut);
-			expect(options).toEqual(undefined);
-			return {returnCode: 'OK'};
-		});
-
-		mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${entitlementPool.id}/limits`);
-			expect(data).toEqual(undefined);
-			expect(options).toEqual(undefined);
-			return {results: [updatedLimitForPut]};
-		 });
-
-		mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
-			expect(baseUrl).toEqual(`/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${version.id}`);
-			expect(data).toEqual(undefined);
-			expect(options).toEqual(undefined);
-			return {...returnedVersionFields, state: {synchronizationState: SyncStates.UP_TO_DATE, dirty: true}};
-		});
-
-		return EntitlementPoolsActionHelper.submitLimit(store.dispatch,
-			{
-				licenseModelId: LICENSE_MODEL_ID,
-				version,
-				entitlementPool,
-				limit: updatedLimit
-			}
-		).then(() => {
-			expect(store.getState()).toEqual(expectedStore);
-		});
-	});
-
+describe('Entitlement Pools Module Tests', function() {
+    const LICENSE_MODEL_ID = '555';
+    const version = VersionFactory.build();
+    const itemPermissionAndProps = CurrentScreenFactory.build({}, { version });
+    const returnedVersionFields = {
+        baseId: version.baseId,
+        description: version.description,
+        id: version.id,
+        name: version.name,
+        status: version.status
+    };
+
+    it('Load Entitlement Pools List', () => {
+        const entitlementPoolsList = buildListFromFactory(
+            EntitlementPoolStoreFactory
+        );
+        deepFreeze(entitlementPoolsList);
+        const store = storeCreator();
+        deepFreeze(store.getState());
+
+        const expectedStore = cloneAndSet(
+            store.getState(),
+            'licenseModel.entitlementPool.entitlementPoolsList',
+            entitlementPoolsList
+        );
+
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }/entitlement-pools`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return { results: entitlementPoolsList };
+        });
+
+        return EntitlementPoolsActionHelper.fetchEntitlementPoolsList(
+            store.dispatch,
+            { licenseModelId: LICENSE_MODEL_ID, version }
+        ).then(() => {
+            expect(store.getState()).toEqual(expectedStore);
+        });
+    });
+
+    it('Delete Entitlement Pool', () => {
+        const entitlementPoolsList = buildListFromFactory(
+            EntitlementPoolStoreFactory,
+            1
+        );
+        deepFreeze(entitlementPoolsList);
+        const store = storeCreator({
+            currentScreen: { ...itemPermissionAndProps },
+            licenseModel: {
+                entitlementPool: {
+                    entitlementPoolsList
+                }
+            }
+        });
+        deepFreeze(store.getState());
+
+        const expectedCurrentScreenProps = {
+            ...itemPermissionAndProps,
+            itemPermission: {
+                ...itemPermissionAndProps.itemPermission,
+                isDirty: true
+            }
+        };
+
+        let expectedStore = cloneAndSet(
+            store.getState(),
+            'licenseModel.entitlementPool.entitlementPoolsList',
+            []
+        );
+        expectedStore = cloneAndSet(
+            expectedStore,
+            'currentScreen.itemPermission',
+            expectedCurrentScreenProps.itemPermission
+        );
+
+        mockRest.addHandler('destroy', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }/entitlement-pools/${entitlementPoolsList[0].id}`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return {
+                results: {
+                    returnCode: 'OK'
+                }
+            };
+        });
+
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return {
+                ...returnedVersionFields,
+                state: {
+                    synchronizationState: SyncStates.UP_TO_DATE,
+                    dirty: true
+                }
+            };
+        });
+
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return {
+                ...returnedVersionFields
+            };
+        });
+
+        return EntitlementPoolsActionHelper.deleteEntitlementPool(
+            store.dispatch,
+            {
+                licenseModelId: LICENSE_MODEL_ID,
+                version,
+                entitlementPoolId: entitlementPoolsList[0].id
+            }
+        ).then(() => {
+            expect(store.getState()).toEqual(expectedStore);
+        });
+    });
+
+    it('Add Entitlement Pool', () => {
+        const store = storeCreator({
+            currentScreen: { ...itemPermissionAndProps }
+        });
+        deepFreeze(store.getState());
+
+        const EntitlementPoolPostRequest = EntitlementPoolPostFactory.build();
+
+        deepFreeze(EntitlementPoolPostRequest);
+
+        const entitlementPoolIdFromResponse = 'ADDED_ID';
+        const entitlementPoolAfterAdd = EntitlementPoolStoreFactory.build({
+            id: entitlementPoolIdFromResponse
+        });
+        deepFreeze(entitlementPoolAfterAdd);
+
+        const expectedCurrentScreenProps = {
+            ...itemPermissionAndProps,
+            itemPermission: {
+                ...itemPermissionAndProps.itemPermission,
+                isDirty: true
+            }
+        };
+
+        let expectedStore = cloneAndSet(
+            store.getState(),
+            'licenseModel.entitlementPool.entitlementPoolsList',
+            [entitlementPoolAfterAdd]
+        );
+        expectedStore = cloneAndSet(
+            expectedStore,
+            'currentScreen.itemPermission',
+            expectedCurrentScreenProps.itemPermission
+        );
+
+        mockRest.addHandler('post', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }/entitlement-pools`
+            );
+            expect(data).toEqual(EntitlementPoolPostRequest);
+            expect(options).toEqual(undefined);
+            return {
+                returnCode: 'OK',
+                value: entitlementPoolIdFromResponse
+            };
+        });
+
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return {
+                ...returnedVersionFields,
+                state: {
+                    synchronizationState: SyncStates.UP_TO_DATE,
+                    dirty: true
+                }
+            };
+        });
+
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return {
+                ...returnedVersionFields
+            };
+        });
+
+        return EntitlementPoolsActionHelper.saveEntitlementPool(
+            store.dispatch,
+            {
+                licenseModelId: LICENSE_MODEL_ID,
+                version,
+                previousEntitlementPool: null,
+                entitlementPool: EntitlementPoolPostRequest
+            }
+        ).then(() => {
+            expect(store.getState()).toEqual(expectedStore);
+        });
+    });
+
+    it('Update Entitlement Pool', () => {
+        const entitlementPoolsList = buildListFromFactory(
+            EntitlementPoolStoreFactory,
+            1
+        );
+        deepFreeze(entitlementPoolsList);
+
+        const store = storeCreator({
+            currentScreen: { ...itemPermissionAndProps },
+            licenseModel: {
+                entitlementPool: {
+                    entitlementPoolsList
+                }
+            }
+        });
+
+        deepFreeze(store.getState());
+
+        const toBeUpdatedEntitlementPoolId = entitlementPoolsList[0].id;
+        const previousEntitlementPoolData = entitlementPoolsList[0];
+        const entitlementPoolUpdateData = EntitlementPoolStoreFactory.build({
+            name: 'ep1_UPDATED',
+            description: 'string_UPDATED',
+            id: toBeUpdatedEntitlementPoolId
+        });
+        deepFreeze(entitlementPoolUpdateData);
+
+        const entitlementPoolPutRequest = EntitlementPoolPostFactory.build({
+            name: 'ep1_UPDATED',
+            description: 'string_UPDATED'
+        });
+        deepFreeze(entitlementPoolPutRequest);
+
+        const expectedCurrentScreenProps = {
+            ...itemPermissionAndProps,
+            itemPermission: {
+                ...itemPermissionAndProps.itemPermission,
+                isDirty: true
+            }
+        };
+
+        let expectedStore = cloneAndSet(
+            store.getState(),
+            'licenseModel.entitlementPool.entitlementPoolsList',
+            [entitlementPoolUpdateData]
+        );
+        expectedStore = cloneAndSet(
+            expectedStore,
+            'currentScreen.itemPermission',
+            expectedCurrentScreenProps.itemPermission
+        );
+
+        mockRest.addHandler('put', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }/entitlement-pools/${toBeUpdatedEntitlementPoolId}`
+            );
+            expect(data).toEqual(entitlementPoolPutRequest);
+            expect(options).toEqual(undefined);
+            return { returnCode: 'OK' };
+        });
+
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return {
+                ...returnedVersionFields,
+                state: {
+                    synchronizationState: SyncStates.UP_TO_DATE,
+                    dirty: true
+                }
+            };
+        });
+
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return {
+                ...returnedVersionFields
+            };
+        });
+
+        return EntitlementPoolsActionHelper.saveEntitlementPool(
+            store.dispatch,
+            {
+                licenseModelId: LICENSE_MODEL_ID,
+                version,
+                previousEntitlementPool: previousEntitlementPoolData,
+                entitlementPool: entitlementPoolUpdateData
+            }
+        ).then(() => {
+            expect(store.getState()).toEqual(expectedStore);
+        });
+    });
+
+    it('Load Limits List', () => {
+        const limitsList = LimitItemFactory.buildList(3);
+        deepFreeze(limitsList);
+        const store = storeCreator();
+        deepFreeze(store.getState());
+
+        const expectedStore = cloneAndSet(
+            store.getState(),
+            'licenseModel.entitlementPool.entitlementPoolEditor.limitsList',
+            limitsList
+        );
+        const entitlementPool = EntitlementPoolStoreFactory.build();
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }/entitlement-pools/${entitlementPool.id}/limits`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return { results: limitsList };
+        });
+
+        return EntitlementPoolsActionHelper.fetchLimits(store.dispatch, {
+            licenseModelId: LICENSE_MODEL_ID,
+            version,
+            entitlementPool
+        }).then(() => {
+            expect(store.getState()).toEqual(expectedStore);
+        });
+    });
+
+    it('Add Limit', () => {
+        const store = storeCreator({
+            currentScreen: { ...itemPermissionAndProps }
+        });
+        deepFreeze(store.getState());
+
+        const limitToAdd = LimitPostFactory.build();
+        let limitFromBE = { ...limitToAdd };
+        limitFromBE.metric = getStrValue(limitFromBE.metric);
+        limitFromBE.unit = getStrValue(limitFromBE.unit);
+
+        deepFreeze(limitToAdd);
+        deepFreeze(limitFromBE);
+
+        const LimitIdFromResponse = 'ADDED_ID';
+        const limitAddedItem = { ...limitToAdd, id: LimitIdFromResponse };
+        deepFreeze(limitAddedItem);
+        const entitlementPool = EntitlementPoolStoreFactory.build();
+
+        const expectedCurrentScreenProps = {
+            ...itemPermissionAndProps,
+            itemPermission: {
+                ...itemPermissionAndProps.itemPermission,
+                isDirty: true
+            }
+        };
+
+        let expectedStore = cloneAndSet(
+            store.getState(),
+            'licenseModel.entitlementPool.entitlementPoolEditor.limitsList',
+            [limitAddedItem]
+        );
+        expectedStore = cloneAndSet(
+            expectedStore,
+            'currentScreen.itemPermission',
+            expectedCurrentScreenProps.itemPermission
+        );
+
+        mockRest.addHandler('post', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }/entitlement-pools/${entitlementPool.id}/limits`
+            );
+            expect(data).toEqual(limitFromBE);
+            expect(options).toEqual(undefined);
+            return {
+                returnCode: 'OK',
+                value: LimitIdFromResponse
+            };
+        });
+
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }/entitlement-pools/${entitlementPool.id}/limits`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return { results: [limitAddedItem] };
+        });
+
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return {
+                ...returnedVersionFields,
+                state: {
+                    synchronizationState: SyncStates.UP_TO_DATE,
+                    dirty: true
+                }
+            };
+        });
+
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return {
+                ...returnedVersionFields
+            };
+        });
+
+        return EntitlementPoolsActionHelper.submitLimit(store.dispatch, {
+            licenseModelId: LICENSE_MODEL_ID,
+            version,
+            entitlementPool,
+            limit: limitToAdd
+        }).then(() => {
+            expect(store.getState()).toEqual(expectedStore);
+        });
+    });
+
+    it('Delete Limit', () => {
+        const limitsList = LimitItemFactory.buildList(1);
+        deepFreeze(limitsList);
+
+        const store = storeCreator({
+            currentScreen: { ...itemPermissionAndProps },
+            licenseModel: {
+                entitlementPool: {
+                    entitlementPoolEditor: {
+                        limitsList
+                    }
+                }
+            }
+        });
+        deepFreeze(store.getState());
+
+        const entitlementPool = EntitlementPoolStoreFactory.build();
+
+        const expectedCurrentScreenProps = {
+            ...itemPermissionAndProps,
+            itemPermission: {
+                ...itemPermissionAndProps.itemPermission,
+                isDirty: true
+            }
+        };
+
+        let expectedStore = cloneAndSet(
+            store.getState(),
+            'licenseModel.entitlementPool.entitlementPoolEditor.limitsList',
+            []
+        );
+        expectedStore = cloneAndSet(
+            expectedStore,
+            'currentScreen.itemPermission',
+            expectedCurrentScreenProps.itemPermission
+        );
+
+        mockRest.addHandler('destroy', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }/entitlement-pools/${entitlementPool.id}/limits/${
+                    limitsList[0].id
+                }`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return {
+                results: {
+                    returnCode: 'OK'
+                }
+            };
+        });
+
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }/entitlement-pools/${entitlementPool.id}/limits`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return { results: [] };
+        });
+
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return {
+                ...returnedVersionFields,
+                state: {
+                    synchronizationState: SyncStates.UP_TO_DATE,
+                    dirty: true
+                }
+            };
+        });
+
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return {
+                ...returnedVersionFields
+            };
+        });
+
+        return EntitlementPoolsActionHelper.deleteLimit(store.dispatch, {
+            licenseModelId: LICENSE_MODEL_ID,
+            version,
+            entitlementPool,
+            limit: limitsList[0]
+        }).then(() => {
+            expect(store.getState()).toEqual(expectedStore);
+        });
+    });
+
+    it('Update Limit', () => {
+        const limitsList = LimitItemFactory.buildList(1);
+        deepFreeze(limitsList);
+        const entitlementPool = EntitlementPoolStoreFactory.build();
+        const store = storeCreator({
+            currentScreen: { ...itemPermissionAndProps },
+            licenseModel: {
+                entitlementPool: {
+                    entitlementPoolEditor: {
+                        limitsList
+                    }
+                }
+            }
+        });
+
+        deepFreeze(store.getState());
+
+        const previousData = limitsList[0];
+
+        deepFreeze(previousData);
+        const limitId = limitsList[0].id;
+
+        let updatedLimit = { ...previousData, name: 'updatedLimit' };
+
+        const updatedLimitForPut = { ...updatedLimit, id: undefined };
+        updatedLimit.metric = { choice: updatedLimit.metric, other: '' };
+        updatedLimit.unit = { choice: updatedLimit.unit, other: '' };
+        deepFreeze(updatedLimit);
+
+        const expectedCurrentScreenProps = {
+            ...itemPermissionAndProps,
+            itemPermission: {
+                ...itemPermissionAndProps.itemPermission,
+                isDirty: true
+            }
+        };
+
+        let expectedStore = cloneAndSet(
+            store.getState(),
+            'licenseModel.entitlementPool.entitlementPoolEditor.limitsList',
+            [updatedLimitForPut]
+        );
+        expectedStore = cloneAndSet(
+            expectedStore,
+            'currentScreen.itemPermission',
+            expectedCurrentScreenProps.itemPermission
+        );
+
+        mockRest.addHandler('put', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }/entitlement-pools/${entitlementPool.id}/limits/${limitId}`
+            );
+            expect(data).toEqual(updatedLimitForPut);
+            expect(options).toEqual(undefined);
+            return { returnCode: 'OK' };
+        });
+
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }/entitlement-pools/${entitlementPool.id}/limits`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return { results: [updatedLimitForPut] };
+        });
+
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${
+                    version.id
+                }`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return {
+                ...returnedVersionFields,
+                state: {
+                    synchronizationState: SyncStates.UP_TO_DATE,
+                    dirty: true
+                }
+            };
+        });
+
+        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
+            expect(baseUrl).toEqual(
+                `/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}`
+            );
+            expect(data).toEqual(undefined);
+            expect(options).toEqual(undefined);
+            return {
+                ...returnedVersionFields
+            };
+        });
+
+        return EntitlementPoolsActionHelper.submitLimit(store.dispatch, {
+            licenseModelId: LICENSE_MODEL_ID,
+            version,
+            entitlementPool,
+            limit: updatedLimit
+        }).then(() => {
+            expect(store.getState()).toEqual(expectedStore);
+        });
+    });
 });