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