vid-webpack-master/src/app/drawingBoard/service-planning/duplicate/duplicate.service.spec.ts

   1 import { DuplicateService } from './duplicate.service';
   2 import { LogService } from '../../../shared/utils/log/log.service';
   3 import { NgRedux } from '@angular-redux/store';
   4 import {ITreeNode} from "angular-tree-component/dist/defs/api";
   5 import { SdcUiServices} from "onap-ui-angular";
   6 import {IModalConfig} from "onap-ui-angular/dist/components/common";
   7 import {AppState} from "../../../shared/store/reducers";
   8 import {getTestBed, TestBed} from "@angular/core/testing";
   9
  10 class MockAppStore<T> {
  11   getState(){
  12     return {
  13       getState() {
  14         return {
  15           service : {
  16             serviceHierarchy: {
  17               "serviceId" : {
  18                 vnfs : {
  19                   "vnfModelName" : {
  20                     properties : {
  21                       max_instances : 2
  22                     }
  23                   },
  24                   "vnfModelName2" : {
  25                     properties : {
  26                       max_instances  : 2
  27                     }
  28                   },
  29                   "vnfModelName3" : {
  30                     properties : {
  31                     }
  32                   }
  33                 }
  34               }
  35             },
  36             serviceInstance : {
  37               "serviceId" : {
  38                 existingVNFCounterMap : {
  39                   "vnfModelId" : 1,
  40                   "vnfModelId2" : 2,
  41                   "vnfModelId3" : 0
  42                 }
  43               }
  44
  45             }
  46           }
  47         }
  48       }
  49     }
  50   }
  51 }
  52
  53 class MockModalService<T> {}
  54
  55 describe('Drawing board tree service', () => {
  56   let injector;
  57   let service: DuplicateService;
  58   let store : NgRedux<AppState>;
  59   beforeAll(done => (async () => {
  60     TestBed.configureTestingModule({
  61       providers : [
  62         DuplicateService,
  63         LogService,
  64         {provide: NgRedux, useClass: MockAppStore},
  65         {provide: SdcUiServices.ModalService, useClass: MockModalService}
  66       ]
  67     });
  68     await TestBed.compileComponents();
  69
  70     injector = getTestBed();
  71     service = injector.get(DuplicateService);
  72     store = injector.get(NgRedux);
  73
  74   })().then(done).catch(done.fail));
  75
  76
  77   test('setNumberOfDuplicates should set number of duplicates', ()=>{
  78     service.setNumberOfDuplicates(10);
  79     expect(service.numberOfDuplicates).toEqual(10);
  80   });
  81
  82   test('isEnabled should return false if type is VNF and has missing data', ()=>{
  83     let node  = {
  84       data : {
  85         type : 'VF',
  86         menuActions : {
  87           duplicate : () => {
  88
  89           }
  90         }
  91       }
  92     };
  93     spyOn(node.data.menuActions, 'duplicate').and.returnValue(true);
  94     spyOn(service, 'hasMissingData').and.returnValue(true);
  95     let result : boolean = service.isEnabled(<any>node, null, null);
  96     expect(result).toBeFalsy();
  97   });
  98
  99   test('openDuplicateModal', ()=>{
 100     spyOn(service, 'getRemainsInstance').and.returnValue(1);
 101     let result : IModalConfig = service.openDuplicateModal(
 102       'currentServiceId',
 103       'currentServiceId',
 104       'currentId',
 105       'storeKey',
 106       2,
 107       null,null);
 108     expect(result.title).toEqual('Duplicate Node');
 109   });
 110
 111   test('openDuplicateModal should call getRemainsInstance with correct parameters', ()=>{
 112     spyOn(service, 'getRemainsInstance');
 113     service.openDuplicateModal(
 114       'currentServiceId',
 115       'currentServiceId',
 116       'currentId',
 117       'storeKey',
 118       2,
 119       null,null);
 120     expect(service.getRemainsInstance).toHaveBeenCalledWith('currentServiceId', 'currentId', 'currentServiceId', null, null);
 121   });
 122
 123   test('canDuplicate VNF should return true', () => {
 124     sessionStorage.setItem('reduxState' , JSON.stringify({global : { flags : {FLAG_DUPLICATE_VNF : true}}}));
 125     let node : ITreeNode = <any> {data : {type : 'VF'}};
 126
 127     let result = service.canDuplicate(node);
 128     expect(result).toBeTruthy();
 129   });
 130
 131   test('canDuplicate Network should return true', () => {
 132     sessionStorage.setItem('reduxState' , JSON.stringify({global : { flags : {FLAG_DUPLICATE_VNF : true}}}));
 133     let node : ITreeNode = <any> {data : {type : 'VL'}};
 134
 135     let result = service.canDuplicate(node);
 136     expect(result).toBeTruthy();
 137   });
 138
 139   test('canDuplicate VFModule should return false', () => {
 140     sessionStorage.setItem('reduxState' , JSON.stringify({global : { flags : {FLAG_DUPLICATE_VNF : true}}}));
 141     let node : ITreeNode = <any> {data : {type : 'VFModule'}};
 142
 143     let result = service.canDuplicate(node);
 144     expect(result).toBeFalsy();
 145   });
 146
 147   test('Drawing board tree service should be defined', () => {
 148     expect(service).toBeDefined();
 149   });
 150
 151   test('DrawingBoardDuplicateService should be defined', () => {
 152     expect(service).toBeDefined();
 153   });
 154
 155   test('Duplicate multi vnfs should save multi vnfs in redux', () => {
 156     service.existingNames = {
 157       "2017488_adiodvpe": "",
 158       "rrr": "",
 159       "ttt": ""
 160     };
 161     let newVnfs = service.cloneVnf(<any>{
 162       "vfModules": {
 163         "2017488_adiodvpe0..2017488AdiodVpe..ADIOD_vPFE_BV..module-2": {
 164           "2017488_adiodvpe0..2017488AdiodVpe..ADIOD_vPFE_BV..module-2mtlfi": {
 165             "instanceName": "rrr",
 166             "volumeGroupName": "ttt"
 167           }
 168         }
 169       },
 170       "originalName": null,
 171       "trackById": "pfs1f0len3",
 172       "instanceName": "2017488_ADIODvPE"
 173     }, "2017-488_ADIOD-vPE 0");
 174
 175     expect(newVnfs.instanceName).toBe("2017488_ADIODvPE_001");
 176     expect(newVnfs.vfModules['2017488_adiodvpe0..2017488AdiodVpe..ADIOD_vPFE_BV..module-2']['2017488_adiodvpe0..2017488AdiodVpe..ADIOD_vPFE_BV..module-2mtlfi'].instanceName).toBe("rrr_001");
 177     expect(newVnfs.vfModules['2017488_adiodvpe0..2017488AdiodVpe..ADIOD_vPFE_BV..module-2']['2017488_adiodvpe0..2017488AdiodVpe..ADIOD_vPFE_BV..module-2mtlfi'].volumeGroupName).toBe("ttt_001");
 178
 179     newVnfs = service.cloneVnf(<any>{
 180       "vfModules": {
 181         "2017488_adiodvpe0..2017488AdiodVpe..ADIOD_vPFE_BV..module-2": {
 182           "2017488_adiodvpe0..2017488AdiodVpe..ADIOD_vPFE_BV..module-2mtlfi": {
 183             "instanceName": "rrr",
 184             "volumeGroupName": "ttt"
 185           }
 186         }
 187       },
 188       "originalName": null,
 189       "trackById": "pfs1f0len3",
 190       "instanceName": "2017488_ADIODvPE"
 191     }, "2017-488_ADIOD-vPE 0");
 192
 193     expect(newVnfs.instanceName).toBe("2017488_ADIODvPE_002");
 194     expect(newVnfs.vfModules['2017488_adiodvpe0..2017488AdiodVpe..ADIOD_vPFE_BV..module-2']['2017488_adiodvpe0..2017488AdiodVpe..ADIOD_vPFE_BV..module-2mtlfi'].instanceName).toBe("rrr_002");
 195     expect(newVnfs.vfModules['2017488_adiodvpe0..2017488AdiodVpe..ADIOD_vPFE_BV..module-2']['2017488_adiodvpe0..2017488AdiodVpe..ADIOD_vPFE_BV..module-2mtlfi'].volumeGroupName).toBe("ttt_002");
 196   });
 197
 198   test('ensure name is unique - send new name - shouldn\'t change name', () => {
 199     service.existingNames = {
 200       "2017488_adiodvpe": "",
 201       "uniqueinstancename": ""
 202     };
 203     const name = "uniqueInstanceName-1";
 204     let uniqueName: string = service.ensureUniqueNameOrGenerateOne(name);
 205     expect(uniqueName).toEqual(name);
 206   });
 207
 208   test('ensure name is unique send existing name should change name', () => {
 209     service.existingNames = {
 210       "2017488_adiodvpe": "",
 211       "uniqueinstancename-1": ""
 212     };
 213     const name = "uniqueInstanceName-1";
 214     let uniqueName: string = service.ensureUniqueNameOrGenerateOne(name);
 215     expect(uniqueName).toEqual(name + "_001");
 216   });
 217
 218   test('isAlreadyExist - send new name should return false', () => {
 219     service.existingNames = {
 220       "2017488_adiodvpe": "",
 221       "uniqueinstancename": ""
 222     };
 223     const name = "uniqueinstancename-1";
 224     let isExist: boolean = service.isAlreadyExists(name, service.existingNames);
 225     expect(isExist).toBeFalsy();
 226   });
 227
 228   test('isAlreadyExist - send existing name should return true', () => {
 229     service.existingNames = {
 230       "2017488_adiodvpe": "",
 231       "uniqueinstancename-1": ""
 232     };
 233     const name = "uniqueinstancename-1";
 234     let isExist: boolean = service.isAlreadyExists(name, service.existingNames);
 235     expect(isExist).toBeTruthy();
 236   });
 237
 238   test('isAlreadyExist - send existing name case insensitive should return true', () => {
 239     service.existingNames = {
 240       "2017488_adiodvpe": "",
 241       "uniqueinstancename-1": ""
 242     };
 243     const name = "uniqueInstanceName-1";
 244     let isExist: boolean = service.isAlreadyExists(name, service.existingNames);
 245     expect(isExist).toBeTruthy();
 246   });
 247
 248   test('getNumberAsPaddingString should return 001 if padding is 000 and val is 1 string', () => {
 249     let paddingNumber: string = service.getNumberAsPaddingString(1, '0000');
 250     expect(paddingNumber).toEqual('0001');
 251   });
 252
 253   test('getNumberAsPaddingString should return 010 if padding is 000 and val is 10 string', () => {
 254     let paddingNumber: string = service.getNumberAsPaddingString(10, '0000');
 255     expect(paddingNumber).toEqual('0010');
 256   });
 257
 258   test('generateVNFUniqueName should return the next free number', () => {
 259     const vnfName: string = "VF_vMee 0";
 260     let result: string = service.generateUniqueStoreKey(
 261       "6e59c5de-f052-46fa-aa7e-2fca9d674c44",
 262       vnfName,
 263       getExistingVNFs(),
 264       {}
 265     );
 266
 267     expect(result).toEqual(vnfName + ":0003");
 268   });
 269
 270   test('generateVNFUniqueName on duplicate multi vnfs should return the next free number', () => {
 271       spyOn(service, 'openDuplicateModal');
 272       service.openDuplicateModal(null, null, null,null, 2, null, null);
 273
 274       expect(service.openDuplicateModal).toHaveBeenCalledWith(null, null, null,null, 2, null, null);
 275   });
 276
 277
 278   test('isEnabled should return false if node has  missing data', () => {
 279     let node  = {
 280       data : {
 281         missingData: true,
 282         menuActions : {
 283           duplicate : () => {
 284
 285           }
 286         }
 287       }
 288     };
 289     let result : boolean = service.isEnabled(<any>node, null, null);
 290     expect(result).toBeFalsy();
 291   });
 292
 293   test('isEnabled should return true if not reach to max', () => {
 294     let node  = {
 295       data : {
 296         missingData: false, modelName : "vnfModelName" , modelId : "vnfModelId", type : "VF", children: [], modelCustomizationId : "vnfModelId",modelUniqueId: "vnfModelId",
 297         menuActions : {
 298           duplicate : () => {
 299
 300           }
 301         }
 302       }
 303     };
 304     let result : boolean = service.isEnabled(<any>node, <any>getStoreState(), "serviceId");
 305     expect(result).toBeTruthy();
 306   });
 307
 308   test('isEnabled should return false if reach to max', () => {
 309     let node  = {
 310       data : {
 311         missingData: false, modelName : "vnfModelName2" , modelId : "vnfModelId2", type : "VF" ,children: [],
 312         menuActions : {
 313           duplicate : () => {
 314
 315           }
 316         }
 317       }
 318     };
 319     let result : boolean = service.isEnabled(<any>node, <any>getStoreState(), "serviceId");
 320     expect(result).toBeFalsy();
 321   });
 322
 323   test('isEnabled should return true if max is null', () => {
 324     let node  = {
 325       data : {
 326         missingData: false, modelName : "vnfModelName3" , modelId : "vnfModelId3",type : "VF",  children: [], modelUniqueId: "vnfModelId3",
 327         menuActions : {
 328           duplicate : () => {
 329
 330           }
 331         }
 332       }
 333     };
 334     let result : boolean = service.isEnabled(<any>node, <any>getStoreState(), "serviceId");
 335     expect(result).toBeTruthy();
 336   });
 337
 338   test('isEnabled should return false if type is vf module', () => {
 339     let node  = {
 340       data : {
 341         missingData: false, modelName : "vnfModelName3" , modelId : "vnfModelId3",type : "VFModule",  children: [],
 342         menuActions : {
 343         }
 344       }
 345     };
 346     let result : boolean = service.isEnabled(<any>node, <any>getStoreState(), "serviceId");
 347     expect(result).toBeFalsy();
 348   });
 349
 350   test('getRemainsVNFinstance should return the remains 1 VNF', () => {
 351     let result : number = service.getRemainsInstance("vnfModelId", "vnfModelName" , "serviceId" , <any>getStoreState(), <any>{data : {type : 'VF'}});
 352     expect(result).toBe(1);
 353   });
 354
 355   test('getRemainsVNFinstance should return the remains  0 VNF', () => {
 356     let result : number = service.getRemainsInstance("vnfModelId2", "vnfModelName2" , "serviceId" , <any>getStoreState(),<any>{data : {type : 'VF'}});
 357     expect(result).toBe(0);
 358   });
 359
 360   test('isVNFChildrensHasMissingData should return true if vnf missing data = true', () => {
 361     let result : boolean = service.hasMissingData(<any>getTreeNode(true,false));
 362     expect(result).toBeTruthy();
 363   });
 364
 365   test('isVNFChildrensHasMissingData return should false if vnf missing data = false', () => {
 366     let result : boolean = service.hasMissingData(<any>getTreeNode(false,false));
 367     expect(result).toBeFalsy();
 368   });
 369
 370   test('isVNFChildrensHasMissingData should return true if vfModule missing data = true', () => {
 371     let result : boolean = service.hasMissingData(<any>getTreeNode(false,true));
 372     expect(result).toBeTruthy();
 373   });
 374
 375   test('isVNFChildrensHasMissingData should return false if no children and  vfModule missing data = false', () => {
 376     let node = <any>getTreeNode(false,false);
 377     node.data.children = [];
 378     let result : boolean = service.hasMissingData(node);
 379     expect(result).toBeFalsy();
 380   });
 381
 382   function getExistingVNFs(){
 383     return {"VF_vMee 0":{"rollbackOnFailure":"true","vfModules":{"vf_vmee0..VfVmee..vmme_vlc..module-1":{"vf_vmee0..VfVmee..vmme_vlc..module-1dgbxq":{"modelInfo":{"modelInvariantId":"98a7c88b-b577-476a-90e4-e25a5871e02b","modelVersionId":"522159d5-d6e0-4c2a-aa44-5a542a12a830","modelName":"VfVmee..vmme_vlc..module-1","modelVersion":"2","modelCustomizationId":"55b1be94-671a-403e-a26c-667e9c47d091","modelCustomizationName":"VfVmee..vmme_vlc..module-1"},"instanceParams":[{}]}}},"productFamilyId":"17cc1042-527b-11e6-beb8-9e71128cae77","lcpCloudRegionId":"hvf6","tenantId":"bae71557c5bb4d5aac6743a4e5f1d054","lineOfBusiness":"ONAP","platformName":"platform","modelInfo":{"modelInvariantId":"4160458e-f648-4b30-a176-43881ffffe9e","modelVersionId":"d6557200-ecf2-4641-8094-5393ae3aae60","modelName":"VF_vMee","modelVersion":"2.0","modelCustomizationId":"91415b44-753d-494c-926a-456a9172bbb9","modelCustomizationName":"VF_vMee 0"}},"VF_vMee 0:0001":{"rollbackOnFailure":"true","vfModules":{"vf_vmee0..VfVmee..vmme_vlc..module-1":{"vf_vmee0..VfVmee..vmme_vlc..module-1dgbxq":{"modelInfo":{"modelInvariantId":"98a7c88b-b577-476a-90e4-e25a5871e02b","modelVersionId":"522159d5-d6e0-4c2a-aa44-5a542a12a830","modelName":"VfVmee..vmme_vlc..module-1","modelVersion":"2","modelCustomizationId":"55b1be94-671a-403e-a26c-667e9c47d091","modelCustomizationName":"VfVmee..vmme_vlc..module-1"},"instanceParams":[{}]}}},"productFamilyId":"17cc1042-527b-11e6-beb8-9e71128cae77","lcpCloudRegionId":"hvf6","tenantId":"bae71557c5bb4d5aac6743a4e5f1d054","lineOfBusiness":"ONAP","platformName":"platform","modelInfo":{"modelInvariantId":"4160458e-f648-4b30-a176-43881ffffe9e","modelVersionId":"d6557200-ecf2-4641-8094-5393ae3aae60","modelName":"VF_vMee","modelVersion":"2.0","modelCustomizationId":"91415b44-753d-494c-926a-456a9172bbb9","modelCustomizationName":"VF_vMee 0"},"originalName":"VF_vMee 0"},"VF_vMee 0:0002":{"rollbackOnFailure":"true","vfModules":{"vf_vmee0..VfVmee..vmme_vlc..module-1":{"vf_vmee0..VfVmee..vmme_vlc..module-1dgbxq":{"modelInfo":{"modelInvariantId":"98a7c88b-b577-476a-90e4-e25a5871e02b","modelVersionId":"522159d5-d6e0-4c2a-aa44-5a542a12a830","modelName":"VfVmee..vmme_vlc..module-1","modelVersion":"2","modelCustomizationId":"55b1be94-671a-403e-a26c-667e9c47d091","modelCustomizationName":"VfVmee..vmme_vlc..module-1"},"instanceParams":[{}]}}},"productFamilyId":"17cc1042-527b-11e6-beb8-9e71128cae77","lcpCloudRegionId":"hvf6","tenantId":"bae71557c5bb4d5aac6743a4e5f1d054","lineOfBusiness":"ONAP","platformName":"platform","modelInfo":{"modelInvariantId":"4160458e-f648-4b30-a176-43881ffffe9e","modelVersionId":"d6557200-ecf2-4641-8094-5393ae3aae60","modelName":"VF_vMee","modelVersion":"2.0","modelCustomizationId":"91415b44-753d-494c-926a-456a9172bbb9","modelCustomizationName":"VF_vMee 0"},"originalName":"VF_vMee 0"}}
 384   }
 385
 386   function getStoreState(){
 387     return {
 388       getState() {
 389         return {
 390           service : {
 391             serviceHierarchy: {
 392               "serviceId" : {
 393                 vnfs : {
 394                   "vnfModelName" : {
 395                     properties : {
 396                       ecomp_generated_naming: "false",
 397                       max_instances : 2
 398                     }
 399                   },
 400                   "vnfModelName2" : {
 401                     properties : {
 402                       ecomp_generated_naming: "false",
 403                       max_instances  : 2
 404                     }
 405                   },
 406                   "vnfModelName3" : {
 407                     properties : {
 408                       ecomp_generated_naming: "false",
 409                     }
 410                   }
 411                 }
 412               }
 413             },
 414             serviceInstance : {
 415               "serviceId" : {
 416                 existingVNFCounterMap : {
 417                   "vnfModelId" : 1,
 418                   "vnfModelId2" : 2,
 419                   "vnfModelId3" : 0
 420                 }
 421               }
 422
 423             }
 424           }
 425         }
 426       }
 427     }
 428   }
 429
 430
 431   function getTreeNode(VNfMissingData : boolean, vfModuleMissingData : boolean){
 432     return {
 433       data : {
 434         children : vfModuleMissingData ?
 435           [{
 436             missingData : true
 437           }] :
 438           [{
 439             missingData : false
 440           }
 441         ],
 442         missingData : VNfMissingData
 443       }
 444     }
 445   }
 446 });
 447
 448
 449