openecomp-ui/test/licenseModel/entitlementPools/test.js

   1 /*!
   2  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  13  * or implied. See the License for the specific language governing
  14  * permissions and limitations under the License.
  15  */
  16 import deepFreeze from 'deep-freeze';
  17 import mockRest from 'test-utils/MockRest.js';
  18 import {cloneAndSet, buildListFromFactory} from 'test-utils/Util.js';
  19 import {storeCreator} from 'sdc-app/AppStore.js';
  20 import EntitlementPoolsActionHelper from 'sdc-app/onboarding/licenseModel/entitlementPools/EntitlementPoolsActionHelper.js';
  21 import {EntitlementPoolStoreFactory, EntitlementPoolPostFactory} from 'test-utils/factories/licenseModel/EntitlementPoolFactories.js';
  22 import VersionFactory from 'test-utils/factories/common/VersionFactory.js';
  23 import {LimitItemFactory, LimitPostFactory} from 'test-utils/factories/licenseModel/LimitFactories.js';
  24 import {getStrValue} from 'nfvo-utils/getValue.js';
  25 import {SyncStates} from 'sdc-app/common/merge/MergeEditorConstants.js';
  26 import CurrentScreenFactory from 'test-utils/factories/common/CurrentScreenFactory.js';
  27
  28 describe('Entitlement Pools Module Tests', function () {
  29
  30         const LICENSE_MODEL_ID = '555';
  31         const version = VersionFactory.build();
  32         const itemPermissionAndProps = CurrentScreenFactory.build({}, {version});
  33         const returnedVersionFields = {baseId: version.baseId, description: version.description, id: version.id, name: version.name, status: version.status};
  34
  35         it('Load Entitlement Pools List', () => {
  36
  37                 const entitlementPoolsList = buildListFromFactory(EntitlementPoolStoreFactory);
  38                 deepFreeze(entitlementPoolsList);
  39                 const store = storeCreator();
  40                 deepFreeze(store.getState());
  41
  42                 const expectedStore = cloneAndSet(store.getState(), 'licenseModel.entitlementPool.entitlementPoolsList', entitlementPoolsList);
  43
  44                 mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
  45                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools`);
  46                         expect(data).toEqual(undefined);
  47                         expect(options).toEqual(undefined);
  48                         return {results: entitlementPoolsList};
  49                 });
  50
  51                 return EntitlementPoolsActionHelper.fetchEntitlementPoolsList(store.dispatch, {licenseModelId: LICENSE_MODEL_ID, version}).then(() => {
  52                         expect(store.getState()).toEqual(expectedStore);
  53                 });
  54         });
  55
  56         it('Delete Entitlement Pool', () => {
  57
  58                 const entitlementPoolsList = buildListFromFactory(EntitlementPoolStoreFactory,1);
  59                 deepFreeze(entitlementPoolsList);
  60                 const store = storeCreator({
  61                         currentScreen: {...itemPermissionAndProps},
  62                         licenseModel: {
  63                                 entitlementPool: {
  64                                         entitlementPoolsList
  65                                 }
  66                         }
  67                 });
  68                 deepFreeze(store.getState());
  69
  70                 const expectedCurrentScreenProps = {
  71                         ...itemPermissionAndProps,
  72                         itemPermission: {
  73                                 ...itemPermissionAndProps.itemPermission,
  74                                 isDirty: true
  75                         }
  76                 };
  77
  78                 let expectedStore = cloneAndSet(store.getState(), 'licenseModel.entitlementPool.entitlementPoolsList', []);
  79                 expectedStore = cloneAndSet(expectedStore, 'currentScreen.itemPermission', expectedCurrentScreenProps.itemPermission);
  80
  81                 mockRest.addHandler('destroy', ({data, options, baseUrl}) => {
  82                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${entitlementPoolsList[0].id}`);
  83                         expect(data).toEqual(undefined);
  84                         expect(options).toEqual(undefined);
  85                         return {
  86                                 results: {
  87                                         returnCode: 'OK'
  88                                 }
  89                         };
  90                 });
  91
  92                 mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
  93                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${version.id}`);
  94                         expect(data).toEqual(undefined);
  95                         expect(options).toEqual(undefined);
  96                         return {...returnedVersionFields, state: {synchronizationState: SyncStates.UP_TO_DATE, dirty: true}};
  97                 });
  98
  99                 return EntitlementPoolsActionHelper.deleteEntitlementPool(store.dispatch, {
 100                         licenseModelId: LICENSE_MODEL_ID,
 101                         version,
 102                         entitlementPoolId: entitlementPoolsList[0].id
 103                 }).then(() => {
 104                         expect(store.getState()).toEqual(expectedStore);
 105                 });
 106         });
 107
 108         it('Add Entitlement Pool', () => {
 109
 110                 const store = storeCreator({
 111                         currentScreen: {...itemPermissionAndProps}
 112                 });
 113                 deepFreeze(store.getState());
 114
 115                 const EntitlementPoolPostRequest = EntitlementPoolPostFactory.build();
 116
 117                 deepFreeze(EntitlementPoolPostRequest);
 118
 119                 const entitlementPoolIdFromResponse = 'ADDED_ID';
 120                 const entitlementPoolAfterAdd = EntitlementPoolStoreFactory.build({id: entitlementPoolIdFromResponse});
 121                 deepFreeze(entitlementPoolAfterAdd);
 122
 123                 const expectedCurrentScreenProps = {
 124                         ...itemPermissionAndProps,
 125                         itemPermission: {
 126                                 ...itemPermissionAndProps.itemPermission,
 127                                 isDirty: true
 128                         }
 129                 };
 130
 131                 let expectedStore = cloneAndSet(store.getState(), 'licenseModel.entitlementPool.entitlementPoolsList', [entitlementPoolAfterAdd]);
 132                 expectedStore = cloneAndSet(expectedStore, 'currentScreen.itemPermission', expectedCurrentScreenProps.itemPermission);
 133
 134                 mockRest.addHandler('post', ({data, options, baseUrl}) => {
 135                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools`);
 136                         expect(data).toEqual(EntitlementPoolPostRequest);
 137                         expect(options).toEqual(undefined);
 138                         return {
 139                                 returnCode: 'OK',
 140                                 value: entitlementPoolIdFromResponse
 141                         };
 142                 });
 143
 144                 mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
 145                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${version.id}`);
 146                         expect(data).toEqual(undefined);
 147                         expect(options).toEqual(undefined);
 148                         return {...returnedVersionFields, state: {synchronizationState: SyncStates.UP_TO_DATE, dirty: true}};
 149                 });
 150
 151                 return EntitlementPoolsActionHelper.saveEntitlementPool(store.dispatch,
 152                         {
 153                                 licenseModelId: LICENSE_MODEL_ID,
 154                                 version,
 155                                 previousEntitlementPool: null,
 156                                 entitlementPool: EntitlementPoolPostRequest
 157                         }
 158                 ).then(() => {
 159                         expect(store.getState()).toEqual(expectedStore);
 160                 });
 161         });
 162
 163         it('Update Entitlement Pool', () => {
 164
 165                 const entitlementPoolsList = buildListFromFactory(EntitlementPoolStoreFactory, 1);
 166                 deepFreeze(entitlementPoolsList);
 167
 168                 const store = storeCreator({
 169                         currentScreen: {...itemPermissionAndProps},
 170                         licenseModel: {
 171                                 entitlementPool: {
 172                                         entitlementPoolsList
 173                                 }
 174                         }
 175                 });
 176
 177                 deepFreeze(store.getState());
 178
 179                 const toBeUpdatedEntitlementPoolId = entitlementPoolsList[0].id;
 180                 const previousEntitlementPoolData = entitlementPoolsList[0];
 181                 const entitlementPoolUpdateData = EntitlementPoolStoreFactory.build({name: 'ep1_UPDATED', description: 'string_UPDATED', id: toBeUpdatedEntitlementPoolId});
 182                 deepFreeze(entitlementPoolUpdateData);
 183
 184                 const entitlementPoolPutRequest = EntitlementPoolPostFactory.build({name: 'ep1_UPDATED', description: 'string_UPDATED'});
 185                 deepFreeze(entitlementPoolPutRequest);
 186
 187                 const expectedCurrentScreenProps = {
 188                         ...itemPermissionAndProps,
 189                         itemPermission: {
 190                                 ...itemPermissionAndProps.itemPermission,
 191                                 isDirty: true
 192                         }
 193                 };
 194
 195                 let expectedStore = cloneAndSet(store.getState(), 'licenseModel.entitlementPool.entitlementPoolsList', [entitlementPoolUpdateData]);
 196                 expectedStore = cloneAndSet(expectedStore, 'currentScreen.itemPermission', expectedCurrentScreenProps.itemPermission);
 197
 198
 199                 mockRest.addHandler('put', ({data, options, baseUrl}) => {
 200                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${toBeUpdatedEntitlementPoolId}`);
 201                         expect(data).toEqual(entitlementPoolPutRequest);
 202                         expect(options).toEqual(undefined);
 203                         return {returnCode: 'OK'};
 204                 });
 205
 206                 mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
 207                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${version.id}`);
 208                         expect(data).toEqual(undefined);
 209                         expect(options).toEqual(undefined);
 210                         return {...returnedVersionFields, state: {synchronizationState: SyncStates.UP_TO_DATE, dirty: true}};
 211                 });
 212
 213                 return EntitlementPoolsActionHelper.saveEntitlementPool(store.dispatch, {
 214                         licenseModelId: LICENSE_MODEL_ID,
 215                         version,
 216                         previousEntitlementPool: previousEntitlementPoolData,
 217                         entitlementPool: entitlementPoolUpdateData
 218                 }).then(() => {
 219                         expect(store.getState()).toEqual(expectedStore);
 220                 });
 221         });
 222
 223         it('Load Limits List', () => {
 224
 225                 const limitsList = LimitItemFactory.buildList(3);
 226                 deepFreeze(limitsList);
 227                 const store = storeCreator();
 228                 deepFreeze(store.getState());
 229
 230                 const expectedStore = cloneAndSet(store.getState(), 'licenseModel.entitlementPool.entitlementPoolEditor.limitsList', limitsList);
 231                 const entitlementPool = EntitlementPoolStoreFactory.build();
 232                 mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
 233                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${entitlementPool.id}/limits`);
 234                         expect(data).toEqual(undefined);
 235                         expect(options).toEqual(undefined);
 236                         return {results: limitsList};
 237                  });
 238
 239                 return EntitlementPoolsActionHelper.fetchLimits(store.dispatch, {licenseModelId: LICENSE_MODEL_ID, version, entitlementPool}).then(() => {
 240                         expect(store.getState()).toEqual(expectedStore);
 241                  });
 242         });
 243
 244         it('Add Limit', () => {
 245
 246                 const store = storeCreator({
 247                         currentScreen: {...itemPermissionAndProps}
 248                 });
 249                 deepFreeze(store.getState());
 250
 251                 const limitToAdd = LimitPostFactory.build();
 252                 let limitFromBE = {...limitToAdd};
 253                 limitFromBE.metric = getStrValue(limitFromBE.metric);
 254                 limitFromBE.unit = getStrValue(limitFromBE.unit);
 255
 256                 deepFreeze(limitToAdd);
 257                 deepFreeze(limitFromBE);
 258
 259                 const LimitIdFromResponse = 'ADDED_ID';
 260                 const limitAddedItem = {...limitToAdd, id: LimitIdFromResponse};
 261                 deepFreeze(limitAddedItem);
 262                 const entitlementPool = EntitlementPoolStoreFactory.build();
 263
 264                 const expectedCurrentScreenProps = {
 265                         ...itemPermissionAndProps,
 266                         itemPermission: {
 267                                 ...itemPermissionAndProps.itemPermission,
 268                                 isDirty: true
 269                         }
 270                 };
 271
 272                 let expectedStore = cloneAndSet(store.getState(), 'licenseModel.entitlementPool.entitlementPoolEditor.limitsList', [limitAddedItem]);
 273                 expectedStore = cloneAndSet(expectedStore, 'currentScreen.itemPermission', expectedCurrentScreenProps.itemPermission);
 274
 275                 mockRest.addHandler('post', ({data, options, baseUrl}) => {
 276                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${entitlementPool.id}/limits`);
 277                         expect(data).toEqual(limitFromBE);
 278                         expect(options).toEqual(undefined);
 279                         return {
 280                                 returnCode: 'OK',
 281                                 value: LimitIdFromResponse
 282                         };
 283                 });
 284
 285                 mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
 286                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${entitlementPool.id}/limits`);
 287                         expect(data).toEqual(undefined);
 288                         expect(options).toEqual(undefined);
 289                         return {results: [limitAddedItem]};
 290                  });
 291
 292                 mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
 293                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${version.id}`);
 294                         expect(data).toEqual(undefined);
 295                         expect(options).toEqual(undefined);
 296                         return {...returnedVersionFields, state: {synchronizationState: SyncStates.UP_TO_DATE, dirty: true}};
 297                 });
 298
 299                 return EntitlementPoolsActionHelper.submitLimit(store.dispatch,
 300                         {
 301                                 licenseModelId: LICENSE_MODEL_ID,
 302                                 version,
 303                                 entitlementPool,
 304                                 limit: limitToAdd
 305                         }
 306                 ).then(() => {
 307                         expect(store.getState()).toEqual(expectedStore);
 308                 });
 309         });
 310
 311
 312         it('Delete Limit', () => {
 313
 314                 const limitsList = LimitItemFactory.buildList(1);
 315                 deepFreeze(limitsList);
 316
 317                 const store = storeCreator({
 318                         currentScreen: {...itemPermissionAndProps},
 319                         licenseModel: {
 320                                 entitlementPool: {
 321                                         entitlementPoolEditor: {
 322                                                 limitsList
 323                                         }
 324                                 }
 325                         }
 326                 });
 327                 deepFreeze(store.getState());
 328
 329                 const entitlementPool = EntitlementPoolStoreFactory.build();
 330
 331                 const expectedCurrentScreenProps = {
 332                         ...itemPermissionAndProps,
 333                         itemPermission: {
 334                                 ...itemPermissionAndProps.itemPermission,
 335                                 isDirty: true
 336                         }
 337                 };
 338
 339                 let expectedStore = cloneAndSet(store.getState(), 'licenseModel.entitlementPool.entitlementPoolEditor.limitsList', []);
 340                 expectedStore = cloneAndSet(expectedStore, 'currentScreen.itemPermission', expectedCurrentScreenProps.itemPermission);
 341
 342                 mockRest.addHandler('destroy', ({data, options, baseUrl}) => {
 343                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${entitlementPool.id}/limits/${limitsList[0].id}`);
 344                         expect(data).toEqual(undefined);
 345                         expect(options).toEqual(undefined);
 346                         return {
 347                                 results: {
 348                                         returnCode: 'OK'
 349                                 }
 350                         };
 351                 });
 352
 353                 mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
 354                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${entitlementPool.id}/limits`);
 355                         expect(data).toEqual(undefined);
 356                         expect(options).toEqual(undefined);
 357                         return {results: []};
 358                  });
 359
 360                 mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
 361                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${version.id}`);
 362                         expect(data).toEqual(undefined);
 363                         expect(options).toEqual(undefined);
 364                         return {...returnedVersionFields, state: {synchronizationState: SyncStates.UP_TO_DATE, dirty: true}};
 365                 });
 366
 367                 return EntitlementPoolsActionHelper.deleteLimit(store.dispatch, {
 368                         licenseModelId: LICENSE_MODEL_ID,
 369                         version,
 370                         entitlementPool,
 371                         limit: limitsList[0]
 372                 }).then(() => {
 373                         expect(store.getState()).toEqual(expectedStore);
 374                 });
 375         });
 376
 377         it('Update Limit', () => {
 378
 379                 const limitsList = LimitItemFactory.buildList(1);
 380                 deepFreeze(limitsList);
 381                 const entitlementPool = EntitlementPoolStoreFactory.build();
 382                 const store = storeCreator({
 383                         currentScreen: {...itemPermissionAndProps},
 384                         licenseModel: {
 385                                 entitlementPool: {
 386                                         entitlementPoolEditor: {
 387                                                 limitsList
 388                                         }
 389                                 }
 390                         }
 391                 });
 392
 393                 deepFreeze(store.getState());
 394
 395
 396                 const previousData = limitsList[0];
 397
 398                 deepFreeze(previousData);
 399                 const limitId = limitsList[0].id;
 400
 401                 let updatedLimit = {...previousData, name: 'updatedLimit'};
 402
 403                 const updatedLimitForPut = {...updatedLimit, id: undefined};
 404                 updatedLimit.metric = {choice: updatedLimit.metric, other: ''};
 405                 updatedLimit.unit = {choice: updatedLimit.unit, other: ''};
 406                 deepFreeze(updatedLimit);
 407
 408                 const expectedCurrentScreenProps = {
 409                         ...itemPermissionAndProps,
 410                         itemPermission: {
 411                                 ...itemPermissionAndProps.itemPermission,
 412                                 isDirty: true
 413                         }
 414                 };
 415
 416                 let expectedStore = cloneAndSet(store.getState(), 'licenseModel.entitlementPool.entitlementPoolEditor.limitsList', [updatedLimitForPut]);
 417                 expectedStore = cloneAndSet(expectedStore, 'currentScreen.itemPermission', expectedCurrentScreenProps.itemPermission);
 418
 419
 420                 mockRest.addHandler('put', ({data, options, baseUrl}) => {
 421                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${entitlementPool.id}/limits/${limitId}`);
 422                         expect(data).toEqual(updatedLimitForPut);
 423                         expect(options).toEqual(undefined);
 424                         return {returnCode: 'OK'};
 425                 });
 426
 427                 mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
 428                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/vendor-license-models/${LICENSE_MODEL_ID}/versions/${version.id}/entitlement-pools/${entitlementPool.id}/limits`);
 429                         expect(data).toEqual(undefined);
 430                         expect(options).toEqual(undefined);
 431                         return {results: [updatedLimitForPut]};
 432                  });
 433
 434                 mockRest.addHandler('fetch', ({data, options, baseUrl}) => {
 435                         expect(baseUrl).toEqual(`/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${version.id}`);
 436                         expect(data).toEqual(undefined);
 437                         expect(options).toEqual(undefined);
 438                         return {...returnedVersionFields, state: {synchronizationState: SyncStates.UP_TO_DATE, dirty: true}};
 439                 });
 440
 441                 return EntitlementPoolsActionHelper.submitLimit(store.dispatch,
 442                         {
 443                                 licenseModelId: LICENSE_MODEL_ID,
 444                                 version,
 445                                 entitlementPool,
 446                                 limit: updatedLimit
 447                         }
 448                 ).then(() => {
 449                         expect(store.getState()).toEqual(expectedStore);
 450                 });
 451         });
 452
 453 });