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