vid-webpack-master/src/app/drawingBoard/service-planning/objectsToTree/models/vfModule/vfModule.model.info.spec.ts

   1 import {HttpClientTestingModule} from "@angular/common/http/testing";
   2 import {getTestBed, TestBed} from "@angular/core/testing";
   3 import {MockNgRedux, NgReduxTestingModule} from "@angular-redux/store/testing";
   4 import {VFModuleModelInfo} from "./vfModule.model.info";
   5 import {DynamicInputsService} from "../../dynamicInputs.service";
   6 import {SharedTreeService} from "../../shared.tree.service";
   7 import {VfModulePopupService} from "../../../../../shared/components/genericFormPopup/genericFormServices/vfModule/vfModule.popup.service";
   8 import {DialogService} from "ng2-bootstrap-modal";
   9 import {NgRedux} from "@angular-redux/store";
  10 import {AvailableNodeIcons} from "../../../available-models-tree/available-models-tree.service";
  11 import {MessageBoxService} from "../../../../../shared/components/messageBox/messageBox.service";
  12 import {DrawingBoardModes} from "../../../drawing-board.modes";
  13 import {IframeService} from "../../../../../shared/utils/iframe.service";
  14 import {ComponentInfoService} from "../../../component-info/component-info.service";
  15 import {ModelInformationItem} from "../../../../../shared/components/model-information/model-information.component";
  16 import {AaiService} from "../../../../../shared/services/aaiService/aai.service";
  17 import {HttpClient, HttpHandler} from "@angular/common/http";
  18 import {FeatureFlagsService} from "../../../../../shared/services/featureFlag/feature-flags.service";
  19 import {VfModuleUpgradePopupService} from "../../../../../shared/components/genericFormPopup/genericFormServices/vfModuleUpgrade/vfModule.upgrade.popuop.service";
  20 import {instance, mock, when} from "ts-mockito";
  21 import each from "jest-each";
  22 import {VfModule} from "../../../../../shared/models/vfModule";
  23
  24 class MockAppStore<T> {
  25   getState() {
  26     return {
  27       global: {
  28         'drawingBoardStatus': DrawingBoardModes.CREATE
  29       }
  30     }
  31   }
  32 }
  33
  34 describe('VFModule Model Info', () => {
  35   let injector;
  36   let  _dynamicInputsService : DynamicInputsService;
  37   let  _sharedTreeService : SharedTreeService;
  38   let  vfModuleModel: VFModuleModelInfo;
  39   let _dialogService : DialogService;
  40   let _vfModulePopupService : VfModulePopupService;
  41   let _vfModuleUpgradePopupService : VfModuleUpgradePopupService;
  42   let _iframeService : IframeService;
  43   let _componentInfoService : ComponentInfoService;
  44   let mockFeatureFlagsService: FeatureFlagsService = mock(FeatureFlagsService);
  45   let mockFeatureFlagsServiceInstance: FeatureFlagsService = instance(mockFeatureFlagsService);
  46
  47
  48   beforeAll(done => (async () => {
  49     TestBed.configureTestingModule({
  50       imports: [HttpClientTestingModule, NgReduxTestingModule],
  51       providers: [
  52         DynamicInputsService,
  53         DialogService,
  54         VfModulePopupService,
  55         VfModuleUpgradePopupService,
  56         SharedTreeService,
  57         IframeService,
  58         {provide: NgRedux, useClass: MockAppStore},
  59         MockNgRedux,
  60         AaiService,
  61         HttpClient,
  62         HttpHandler,
  63         {provide: FeatureFlagsService, useValue: mockFeatureFlagsServiceInstance},
  64         ComponentInfoService
  65       ]
  66     });
  67     await TestBed.compileComponents();
  68
  69     injector = getTestBed();
  70     _sharedTreeService = injector.get(SharedTreeService);
  71     _componentInfoService = injector.get(ComponentInfoService);
  72     vfModuleModel = new VFModuleModelInfo(_dynamicInputsService, _sharedTreeService, _dialogService, _vfModulePopupService, _vfModuleUpgradePopupService,
  73       _iframeService, mockFeatureFlagsServiceInstance,  MockNgRedux.getInstance(),_componentInfoService);
  74
  75   })().then(done).catch(done.fail));
  76
  77
  78
  79   test('VFModuleModelInfo should be defined', () => {
  80     expect(VFModuleModelInfo).toBeDefined();
  81   });
  82
  83   test('VnfModelInfo should defined extra details', () => {
  84     expect(vfModuleModel.name).toEqual('vfModules');
  85     expect(vfModuleModel.type).toEqual('Module');
  86   });
  87
  88   test('isEcompGeneratedNaming should return true if vnf has isEcompGeneratedNaming is "true" ', () => {
  89     let isEcompGeneratedNaming : boolean = vfModuleModel.isEcompGeneratedNaming({}, {
  90       properties: {
  91         ecomp_generated_naming: 'true'
  92       }
  93     });
  94     expect(isEcompGeneratedNaming).toBeTruthy();
  95   });
  96
  97   test('isEcompGeneratedNaming should return false if isEcompGeneratedNaming is "false"', () => {
  98     let isEcompGeneratedNaming : boolean = vfModuleModel.isEcompGeneratedNaming({}, {
  99       properties: {
 100         ecomp_generated_naming: 'false'
 101       }
 102     });
 103     expect(isEcompGeneratedNaming).toBeFalsy();
 104   });
 105
 106   test('isEcompGeneratedNaming should return false if isEcompGeneratedNaming is not defined', () => {
 107     let isEcompGeneratedNaming : boolean = vfModuleModel.isEcompGeneratedNaming({}, {
 108       properties: {
 109       }
 110     });
 111     expect(isEcompGeneratedNaming).toBeFalsy();
 112   });
 113
 114
 115   test('getTooltip should return "VFModule"', () => {
 116     let tooltip: string = vfModuleModel.getTooltip();
 117     expect(tooltip).toEqual('VFmodule');
 118   });
 119
 120   test('getType should return "VFModule"', () => {
 121     let tooltip: string = vfModuleModel.getType();
 122     expect(tooltip).toEqual('VFmodule');
 123   });
 124
 125   test('getNextLevelObject should return null', () => {
 126     let nextLevel = vfModuleModel.getNextLevelObject();
 127     expect(nextLevel).toBeNull();
 128   });
 129
 130   test('getModel should return Module model', () => {
 131     let model = vfModuleModel.getModel({
 132       "uuid": "25284168-24bb-4698-8cb4-3f509146eca5",
 133       "invariantUuid": "7253ff5c-97f0-4b8b-937c-77aeb4d79aa1",
 134       "customizationUuid": "f7e7c365-60cf-49a9-9ebf-a1aa11b9d401",
 135       "description": null,
 136       "name": "2017488PasqualeVpe..PASQUALE_vRE_BV..module-1",
 137       "version": "6",
 138       "modelCustomizationName": "2017488PasqualeVpe..PASQUALE_vRE_BV..module-1",
 139       "properties": {
 140         "minCountInstances": 2,
 141         "maxCountInstances": 3,
 142         "initialCount": 0,
 143         "vfModuleLabel": "PASQUALE_vRE_BV",
 144         "baseModule": false
 145       },
 146       "inputs": {
 147         "vnf_config_template_version": {
 148           "type": "string"
 149         }
 150       },
 151       "volumeGroupAllowed": true
 152     });
 153     expect(model).toBeInstanceOf(VfModule);
 154     expect(model.uuid).toEqual('25284168-24bb-4698-8cb4-3f509146eca5');
 155     expect(model.min).toBe(2);
 156     expect(model.max).toBe(3);
 157     expect(model.baseModule).toBeFalsy();
 158     expect(model.inputs).toEqual(
 159       {"vnf_config_template_version": {
 160         "type": "string"
 161       }});
 162     expect(model.volumeGroupAllowed).toBeTruthy();
 163   });
 164
 165   test('showNodeIcons should return false false if reachLimit of max', ()=>{
 166     let serviceId : string = 'servicedId';
 167     let node = {
 168       parent : {
 169         data : {
 170           id : 'vnfId',
 171           name : 'vnfName'
 172         }
 173       },
 174       data : {
 175         id : 'vnfId',
 176         name : 'vnfName'
 177       }
 178     };
 179     _sharedTreeService.setSelectedVNF({
 180       data : {
 181         id : 'vfModuleId',
 182         name : 'VfModuleName'
 183       }
 184     });
 185     jest.spyOn(vfModuleModel, 'getOptionalVNFs').mockReturnValue([]);
 186     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 187       global : {},
 188       service : {
 189         serviceHierarchy : {
 190           'servicedId' : {
 191             'vnfs' : {
 192               'vnfName' : {
 193                 'properties' : {
 194                   'max_instances' : 1
 195                 }
 196               }
 197             }
 198           }
 199         },
 200         serviceInstance : {
 201           'servicedId' : {
 202             'existingVNFCounterMap' : {
 203               'vnfId' : 1
 204             },
 205             'vnfs' : {
 206               'vnfName' :{
 207
 208               }
 209             }
 210           }
 211         }
 212       }
 213     });
 214
 215     let result = vfModuleModel.showNodeIcons(<any>node, serviceId);
 216     expect(result).toEqual(new AvailableNodeIcons(false , false));
 217   });
 218
 219   test('showNodeIcons should return true, false if reachLimit of max', ()=>{
 220     let node = {
 221       data : {
 222         id : 'vfModuleId',
 223         modelUniqueId : 'vfModuleCustomizationId'
 224       },
 225       parent : {
 226         data : {
 227           id : 'vnfId',
 228           modelUniqueId : 'vnfCustomizationId'
 229         }
 230       }
 231     };
 232     jest.spyOn(_sharedTreeService, 'getSelectedVNF').mockReturnValue('vnfName');
 233     jest.spyOn(_sharedTreeService, 'modelUniqueId').mockReturnValue('vnfCustomizationId');
 234     jest.spyOn(vfModuleModel, 'getOptionalVNFs').mockReturnValue([{vnfStoreKey: 'vnfName'}]);
 235     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 236       global : {},
 237       service : {
 238         serviceHierarchy : {
 239           'servicedId' : {
 240             'vnfs' : {
 241               'vnfName' : {
 242                 modelInfo: {
 243                   modelCustomizationId: 'vnfCustomizationId'
 244                 },
 245                 'properties' : {
 246                   'max_instances' : 1
 247                 }
 248               }
 249             },
 250             'vfModules' : {
 251               'vfModuleName' : {
 252                 modelInfo: {
 253                   modelCustomizationId: 'vfModuleCustomizationId'
 254                 },
 255                 'properties' : {
 256                   maxCountInstances : 2
 257                 }
 258               }
 259             }
 260           }
 261         },
 262         serviceInstance : {
 263           'servicedId' : {
 264             'existingVNFCounterMap' : {
 265               'vnfId' : 1
 266             },
 267             'vnfs' : {
 268               'vnfName' :{
 269                   'vfModules' : {
 270                     'vfModuleName' : {
 271
 272                     }
 273                   }
 274               }
 275             }
 276           }
 277         }
 278       }
 279     });
 280
 281     let result = vfModuleModel.showNodeIcons(<any>node, 'servicedId');
 282     expect(result).toEqual(new AvailableNodeIcons(true , false));
 283   });
 284
 285
 286   test('getOptionalVNFs should instance if exist', ()=>{
 287     let serviceId : string = 'servicedId';
 288     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 289       global : {},
 290       service : {
 291         serviceHierarchy : {
 292           'servicedId' : {
 293             'vnfs' : {
 294               'vnfName' : {
 295                 'properties' : {
 296                   'max_instances' : 1
 297                 }
 298               }
 299             },
 300             'vfModules' : {
 301               'vfModuleName' : {
 302                 'properties' : {
 303                   maxCountInstances : 2
 304                 }
 305               }
 306             }
 307           }
 308         },
 309         serviceInstance : {
 310           'servicedId' : {
 311             'existingVNFCounterMap' : {
 312               'vnfId' : 1
 313             },
 314             'vnfs' : {
 315               'vnfName' :{
 316                 'originalName' : 'vnfName',
 317                 'vfModules' : {
 318                   'vfModuleName' : {
 319
 320                   }
 321                 }
 322               }
 323             }
 324           }
 325         }
 326       }
 327     });
 328
 329     let node = {
 330       data : {
 331         id : 'vfModuleId',
 332         name : 'vfModuleName'
 333       },
 334       parent : {
 335         data : {
 336           id : 'vnfId',
 337           name : 'vnfName'
 338         }
 339       }
 340     };
 341     let result = vfModuleModel.getOptionalVNFs(serviceId , 'vnfName');
 342     expect(result.length).toEqual(1);
 343   });
 344
 345   test('getNodeCount should return number of nodes', ()=>{
 346     let serviceId : string = 'servicedId';
 347     let vfModuleModelUniqueId = 'vfModuleCustomizationId';
 348     jest.spyOn(_sharedTreeService, 'modelUniqueId').mockReturnValue(vfModuleModelUniqueId);
 349     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 350       global : {},
 351       service : {
 352         serviceHierarchy : {
 353           'servicedId' : {
 354             'vnfs' : {
 355               'vnfName' : {
 356                 modelInfo: {
 357                   modelCustomizationId: 'vnfCustomizationId'
 358                 },
 359                 'properties' : {
 360                   'max_instances' : 1
 361                 }
 362               }
 363             },
 364             'vfModules' : {
 365               'vfModuleName' : {
 366                 modelInfo: {
 367                   modelCustomizationId: vfModuleModelUniqueId
 368                 },
 369                 'properties' : {
 370                   maxCountInstances : 2
 371                 }
 372               }
 373             }
 374           }
 375         },
 376         serviceInstance : {
 377           'servicedId' : {
 378             'existingVNFCounterMap' : {
 379               'vnfId' : 1
 380             },
 381             'vnfs' : {
 382               'vnfName' :{
 383                 'action': 'Create',
 384                 'originalName' : 'vnfName',
 385                 'vfModules' : {
 386                   'vfModuleName' : {
 387                       'vnfModuleName_111': {
 388                         'action': 'Create',
 389                         'modelInfo' : {
 390                           modelCustomizationId : vfModuleModelUniqueId
 391                         }
 392                       },
 393                       'vnfModuleName_111_1': {
 394                         'action': 'Create',
 395                         'modelInfo' : {
 396                           modelCustomizationId : vfModuleModelUniqueId
 397                         }
 398                       }
 399                   }
 400                 }
 401               },
 402               'vnfName_1' :{
 403                 'action': 'Create',
 404                 'originalName' : 'vnfName',
 405                 'vfModules' : {
 406                   'vfModuleName' : {
 407                     'vnfModuleName_111': {
 408                       'action': 'Create',
 409                       'modelInfo' : {
 410                         modelCustomizationId : vfModuleModelUniqueId
 411                       }
 412                     },
 413                     'vnfModuleName_111_1': {
 414                       'action': 'Create',
 415                       'modelInfo' : {
 416                         modelCustomizationId : vfModuleModelUniqueId
 417                       }
 418                     }
 419                   }
 420                 }
 421               }
 422             }
 423           }
 424         }
 425       }
 426     });
 427
 428     let node = {
 429       data : {
 430         id : 'vfModuleId',
 431         modelUniqueId: vfModuleModelUniqueId,
 432         'action': 'Create',
 433       },
 434       parent : {
 435         data : {
 436           id : 'vnfId',
 437           modelUniqueId: 'vnfCustomizationId',
 438           'action': 'Create',
 439         }
 440       }
 441     };
 442     let result = vfModuleModel.getNodeCount(<any>node , serviceId);
 443     expect(result).toEqual(2);
 444   });
 445
 446
 447   test('getNodeCount should return number of nodes : there is selectedVNF', ()=>{
 448     let serviceId : string = 'servicedId';
 449     let vfModuleModelUniqueId = 'vfModuleCustomizationId';
 450     jest.spyOn(_sharedTreeService, 'modelUniqueId').mockReturnValue(vfModuleModelUniqueId);
 451     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 452       global : {},
 453       service : {
 454         serviceHierarchy : {
 455           'servicedId' : {
 456             'vnfs' : {
 457               'vnfName' : {
 458                 'properties' : {
 459                   'max_instances' : 1
 460                 }
 461               }
 462             },
 463             'vfModules' : {
 464               'vfModuleName' : {
 465                 'properties' : {
 466                   maxCountInstances : 2
 467                 }
 468               }
 469             }
 470           }
 471         },
 472         serviceInstance : {
 473           'servicedId' : {
 474             'existingVNFCounterMap' : {
 475               'vnfId' : 1
 476             },
 477             'vnfs' : {
 478               'vnfName' :{
 479                 'action': 'Create',
 480                 'originalName' : 'vnfName',
 481                 'vfModules' : {
 482                   'vfModuleName' : {
 483                     'vnfModuleName_111': {
 484                       'action': 'Create',
 485                       'modelInfo' : {
 486                         modelCustomizationId : vfModuleModelUniqueId
 487                       }
 488                     },
 489                     'vnfModuleName_111_1': {
 490                       'action': 'Create',
 491                       'modelInfo' : {
 492                         modelCustomizationId : vfModuleModelUniqueId
 493                       }
 494                     }
 495                   }
 496                 }
 497               },
 498               'vnfName_1' :{
 499                 'action': 'Create',
 500                 'originalName' : 'vnfName',
 501                 'vfModules' : {
 502                   'vfModuleName' : {
 503                     'vnfModuleName_111': {
 504                       'action': 'Create',
 505                       'modelInfo' : {
 506                         modelCustomizationId: vfModuleModelUniqueId
 507                       }
 508                     }
 509                   }
 510                 }
 511               }
 512             }
 513           }
 514         }
 515       }
 516     });
 517     jest.spyOn(_sharedTreeService, 'getSelectedVNF').mockReturnValue('vnfName_1');
 518
 519     let node = {
 520       data : {
 521         id : 'vfModuleId',
 522         modelUniqueId: vfModuleModelUniqueId,
 523         'action': 'Create',
 524       },
 525       parent : {
 526         data : {
 527           id : 'vnfId',
 528           modelUniqueId: 'vnfCustomizationId',
 529           'action': 'Create',
 530         }
 531       }
 532     };
 533     let result = vfModuleModel.getNodeCount(<any>node , serviceId);
 534     expect(result).toEqual(1);
 535   });
 536
 537
 538   test('onClickAdd should open message box if no vnfStoreKey', ()=>{
 539     jest.spyOn(_sharedTreeService, 'getSelectedVNF').mockReturnValue(null);
 540     jest.spyOn(vfModuleModel, 'getDefaultVNF').mockReturnValue(null);
 541     jest.spyOn(MessageBoxService.openModal, 'next');
 542     vfModuleModel.onClickAdd(<any>{}, 'serviceId');
 543     expect(MessageBoxService.openModal.next).toHaveBeenCalled();
 544   });
 545
 546   test('getMenuAction: showAuditInfoVfModule', ()=>{
 547     jest.spyOn(_sharedTreeService, 'isRetryMode').mockReturnValue(true);
 548
 549     let node = {
 550       data : {
 551         "modelId": "6b528779-44a3-4472-bdff-9cd15ec93450",
 552         "action": "Create",
 553         "isFailed": true,
 554       }
 555     };
 556     let serviceModelId = "6b528779-44a3-4472-bdff-9cd15ec93450";
 557     let result = vfModuleModel.getMenuAction(<any>node, serviceModelId);
 558     spyOn(result['showAuditInfo'], 'method');
 559     expect(result['showAuditInfo']).toBeDefined();
 560     expect(result['showAuditInfo'].visible(node)).toBeTruthy();
 561     expect(result['showAuditInfo'].enable(node)).toBeTruthy();
 562     result['showAuditInfo']['method'](node, serviceModelId);
 563     expect(result['showAuditInfo']['method']).toHaveBeenCalledWith(node, serviceModelId);
 564   });
 565
 566   test('Info for vfModule should be correct', () => {
 567     const model = getVFModule();
 568     const instance = getVFModuleInstance();
 569     let actualVNFInfo = vfModuleModel.getInfo(model,instance);
 570     let expectedVNFInfo = [
 571       ModelInformationItem.createInstance('Base module', false),
 572       ModelInformationItem.createInstance('Min instances', "0"),
 573       ModelInformationItem.createInstance("Max instances", 'Unlimited (default)'),
 574       ModelInformationItem.createInstance('Initial instances count',"0")
 575     ];
 576     expect(actualVNFInfo).toEqual(expectedVNFInfo);
 577   });
 578
 579   each([
 580     ["maxCountInstances 3, currentNodeCount 1, flag on",{maxCountInstances:3}, 1, {FLAG_2002_UNLIMITED_MAX: true}, false],
 581     ["maxCountInstances 3, currentNodeCount 3, flag on",{maxCountInstances:3}, 3, {FLAG_2002_UNLIMITED_MAX: true}, true],
 582     ["no maxCountInstances, currentNodeCount 0, flag off",{}, 0, {FLAG_2002_UNLIMITED_MAX: false}, false],
 583     ["no maxCountInstances, currentNodeCount 1, flag off",{}, 1, {FLAG_2002_UNLIMITED_MAX: false}, true],
 584     ["no maxCountInstances, currentNodeCount 1, no flags",{}, 1, null, true],
 585     ["no maxCountInstances, currentNodeCount 0, flag on",{}, 0, {FLAG_2002_UNLIMITED_MAX: true}, false],
 586     ["no maxCountInstances, currentNodeCount 1, flag on",{}, 1, {FLAG_2002_UNLIMITED_MAX: true}, false],
 587     ["no maxCountInstances, currentNodeCount 1000, flag on",{}, 1000, {FLAG_2002_UNLIMITED_MAX: true}, false],
 588   ]).test('isVFModuleReachedLimit: %s', (desc, properties, currentNodeCount, flags, expected) => {
 589
 590     const node = { data: {
 591         name : 'vfModuleName'
 592     }};
 593
 594     const serviceHierarchy = {
 595       servicedId :{
 596         vfModules : {
 597           vfModuleName : {
 598             properties
 599      }}}};
 600
 601     when(mockFeatureFlagsService.getAllFlags()).thenReturn(flags);
 602
 603     expect(vfModuleModel.isVFModuleReachedLimit(node, serviceHierarchy, 'servicedId', currentNodeCount)).toEqual(expected);
 604   });
 605
 606   function getVFModule(): Partial<VfModule>{
 607     return {
 608       "uuid":"522159d5-d6e0-4c2a-aa44-5a542a12a830",
 609       "invariantUuid":"98a7c88b-b577-476a-90e4-e25a5871e02b",
 610       "customizationUuid":"55b1be94-671a-403e-a26c-667e9c47d091",
 611       "description":null,
 612       "name":"VfVgeraldine..vflorence_vlc..module-1",
 613       "version":"2",
 614       "modelCustomizationName":"VfVgeraldine..vflorence_vlc..module-1",
 615       "min":0,
 616       "max":null,
 617       "initial":0,
 618       "baseModule":false,
 619       "inputs":{},
 620       "volumeGroupAllowed":false
 621     };
 622   }
 623
 624   function getVFModuleInstance() {
 625     return {
 626       "action":"None",
 627       "instanceName":"ss820f_0918_db",
 628       "instanceId":"2c1ca484-cbc2-408b-ab86-25a2c15ce280",
 629       "orchStatus":"deleted",
 630       "productFamilyId":null,
 631       "lcpCloudRegionId":null,
 632       "tenantId":null,
 633       "modelInfo":{
 634         "modelCustomizationName":"VfVgeraldine..vflorence_vlc..module-1",
 635         "modelCustomizationId":"b200727a-1bf9-4e7c-bd06-b5f4c9d920b9",
 636         "modelInvariantId":"09edc9ef-85d0-4b26-80de-1f569d49e750",
 637         "modelVersionId":"522159d5-d6e0-4c2a-aa44-5a542a12a830",
 638         "modelType":"vfModule"
 639       },
 640       "instanceType":null,
 641       "provStatus":null,
 642       "inMaint":true,
 643       "uuid":"522159d5-d6e0-4c2a-aa44-5a542a12a830",
 644       "originalName":"VfVgeraldine..vflorence_vlc..module-1",
 645       "legacyRegion":null,
 646       "lineOfBusiness":null,
 647       "platformName":null,
 648       "trackById":"vf_vgeraldine0..VfVgeraldine..vflorence_vlc..module-1:008",
 649       "isBase":false,
 650       "volumeGroupName":null
 651     };
 652   }
 653
 654 });