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

   1 import {HttpClientTestingModule, HttpTestingController} from "@angular/common/http/testing";
   2 import {getTestBed, TestBed} from "@angular/core/testing";
   3 import {MockNgRedux, NgReduxTestingModule} from "@angular-redux/store/testing";
   4 import {PnfModelInfoExtended} from "./pnf.model.info.extended";
   5 import {DynamicInputsService} from "../../dynamicInputs.service";
   6 import {SharedTreeService} from "../../shared.tree.service";
   7 import {NgRedux} from "@angular-redux/store";
   8 import {AppState} from "../../../../../shared/store/reducers";
   9 import {DefaultDataGeneratorService} from "../../../../../shared/services/defaultDataServiceGenerator/default.data.generator.service";
  10 import {DialogService} from "ng2-bootstrap-modal";
  11 import {DuplicateService} from "../../../duplicate/duplicate.service";
  12 import {IframeService} from "../../../../../shared/utils/iframe.service";
  13 import {ComponentInfoService} from "../../../component-info/component-info.service";
  14 import {AaiService} from "../../../../../shared/services/aaiService/aai.service";
  15 import {HttpClient, HttpHandler} from "@angular/common/http";
  16 import {FeatureFlagsService} from "../../../../../shared/services/featureFlag/feature-flags.service";
  17 import {PnfPopupService} from "../../../../../shared/components/genericFormPopup/genericFormServices/pnf/pnf.popup.service";
  18 import {DrawingBoardModes} from "../../../drawing-board.modes";
  19 import {ServiceInstanceActions} from "../../../../../shared/models/serviceInstanceActions";
  20 import {PNFModel} from "../../../../../shared/models/pnfModel";
  21 import {AvailableNodeIcons} from "../../../available-models-tree/available-models-tree.service";
  22
  23 class MockFeatureFlagsService extends FeatureFlagsService {
  24   getAllFlags(): { [p: string]: boolean } {
  25     return {};
  26   }
  27 }
  28
  29 class NodeBuilder {
  30   static getPnfNode() {
  31     return this.getPnfNodeWithAction(ServiceInstanceActions.None);
  32   }
  33
  34   static getPnfNodeWithAction(action: ServiceInstanceActions) {
  35     return {
  36       data: {
  37         "action": action,
  38         "pnfStoreKey": "PNF_KEY",
  39         "children": null,
  40         "name": "pnfName",
  41         "modelUniqueId": "modelCustomizationId",
  42         "menuActions": {
  43           "delete": "",
  44           "undoDelete": ""
  45         }
  46       },
  47       children: null,
  48       type: 'PNF'
  49     };
  50   }
  51 }
  52
  53 describe('Pnf Model Info Extended', () => {
  54   let injector;
  55   let _dynamicInputsService: DynamicInputsService;
  56   let _sharedTreeService: SharedTreeService;
  57   let _dialogService: DialogService;
  58   let _pnfPopupService: PnfPopupService;
  59   let _duplicateService: DuplicateService;
  60   let _iframeService: IframeService;
  61   let _featureFlagsService: FeatureFlagsService;
  62   let _store: NgRedux<AppState>;
  63   let pnfModelExtended: PnfModelInfoExtended;
  64
  65   beforeEach(() => {
  66     TestBed.configureTestingModule({
  67       imports: [HttpClientTestingModule, NgReduxTestingModule],
  68       providers: [
  69         MockNgRedux,
  70         DynamicInputsService,
  71         DialogService,
  72         PnfPopupService,
  73         DefaultDataGeneratorService,
  74         SharedTreeService,
  75         DuplicateService,
  76         AaiService,
  77         HttpClient,
  78         HttpHandler,
  79         {provide: FeatureFlagsService, useClass: MockFeatureFlagsService},
  80         ComponentInfoService,
  81         IframeService]
  82     }).compileComponents();
  83
  84     injector = getTestBed();
  85     _sharedTreeService = injector.get(SharedTreeService);
  86     _store = injector.get(NgRedux);
  87     _featureFlagsService = injector.get(FeatureFlagsService);
  88
  89     pnfModelExtended = new PnfModelInfoExtended(
  90       _store,
  91       _sharedTreeService,
  92       _dialogService,
  93       _pnfPopupService,
  94       _iframeService,
  95       _duplicateService,
  96       null,
  97       _dynamicInputsService);
  98   });
  99
 100   test('pnfModelExtended should be defined', () => {
 101     expect(pnfModelExtended).toBeDefined();
 102   });
 103
 104   test('getMenuAction: edit should not be visible when mode is null and actions is "None"', () => {
 105     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 106       global: {}
 107     });
 108
 109     let node = NodeBuilder.getPnfNodeWithAction(ServiceInstanceActions.None);
 110     let serviceModelId = "d6557200-ecf2-4641-8094-5393ae3aae60";
 111     let menuActions = pnfModelExtended.getMenuAction(<any>node, serviceModelId);
 112
 113     expect(menuActions['edit']).toBeDefined();
 114     expect(menuActions['edit'].visible(node)).toBeFalsy();
 115     expect(menuActions['edit'].enable(node)).toBeFalsy();
 116   });
 117
 118   test('getMenuAction: edit should be visible when mode is null and action is "Create"', () => {
 119     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 120       global: {}
 121     });
 122
 123     let node = NodeBuilder.getPnfNodeWithAction(ServiceInstanceActions.Create);
 124     let serviceModelId = "d6557200-ecf2-4641-8094-5393ae3aae60";
 125     let menuActions = pnfModelExtended.getMenuAction(<any>node, serviceModelId);
 126
 127     expect(menuActions['edit']).toBeDefined();
 128     expect(menuActions['edit'].visible(node)).toBeTruthy();
 129     expect(menuActions['edit'].enable(node)).toBeTruthy();
 130   });
 131
 132   test('getMenuAction: edit should be visible when mode is "RETRY" and action is "Create"', () => {
 133     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 134       global: {
 135         drawingBoardStatus: DrawingBoardModes.RETRY
 136       }
 137     });
 138
 139     let node = NodeBuilder.getPnfNodeWithAction(ServiceInstanceActions.Create);
 140     let serviceModelId = "d6557200-ecf2-4641-8094-5393ae3aae60";
 141     let menuActions = pnfModelExtended.getMenuAction(<any>node, serviceModelId);
 142
 143     expect(menuActions['edit']).toBeDefined();
 144     expect(menuActions['edit'].visible(node)).toBeFalsy();
 145     expect(menuActions['edit'].enable(node)).toBeFalsy();
 146   });
 147
 148   test('getMenuAction: showAuditInfo should be visible when mode is "RETRY"', () => {
 149     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 150       global: {
 151         drawingBoardStatus: DrawingBoardModes.RETRY
 152       }
 153     });
 154
 155     let node = NodeBuilder.getPnfNodeWithAction(ServiceInstanceActions.Create);
 156     let serviceModelId = "d6557200-ecf2-4641-8094-5393ae3aae60";
 157     let menuActions = pnfModelExtended.getMenuAction(<any>node, serviceModelId);
 158
 159     expect(menuActions['showAuditInfo']).toBeDefined();
 160     expect(menuActions['showAuditInfo'].visible(node)).toBeTruthy();
 161     expect(menuActions['showAuditInfo'].enable(node)).toBeTruthy();
 162   });
 163
 164   test('getMenuAction: showAuditInfo should not be visible when mode is not "RETRY" and action is "CREATE"', () => {
 165     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 166       global: {
 167         drawingBoardStatus: DrawingBoardModes.EDIT
 168       }
 169     });
 170
 171     let node = NodeBuilder.getPnfNodeWithAction(ServiceInstanceActions.Create);
 172     let serviceModelId = "d6557200-ecf2-4641-8094-5393ae3aae60";
 173     let menuActions = pnfModelExtended.getMenuAction(<any>node, serviceModelId);
 174
 175     expect(menuActions['showAuditInfo']).toBeDefined();
 176     expect(menuActions['showAuditInfo'].visible(node)).toBeFalsy();
 177     expect(menuActions['showAuditInfo'].enable(node)).toBeFalsy();
 178   });
 179
 180   test('getMenuAction: remove should dispatch 2 actions with proper data', () => {
 181     let node = NodeBuilder.getPnfNodeWithAction(ServiceInstanceActions.None);
 182     let serviceModelId = "d6557200-ecf2-4641-8094-5393ae3aae60";
 183     let menuActions = pnfModelExtended.getMenuAction(<any>node, serviceModelId);
 184
 185     spyOn(_store, 'dispatch');
 186     menuActions['remove'].method(node, serviceModelId);
 187
 188     expect(_store.dispatch).toHaveBeenCalledWith(jasmine.objectContaining({
 189       type: "REMOVE_INSTANCE",
 190       storeKey: "PNF_KEY"
 191     }));
 192     expect(_store.dispatch).toHaveBeenCalledWith(jasmine.objectContaining({
 193       type: "CHANGE_INSTANCE_COUNTER",
 194       changeBy: -1
 195     }));
 196   });
 197
 198   test('getMenuAction: remove should not dispatch actions when node has children', () => {
 199     let node = NodeBuilder.getPnfNodeWithAction(ServiceInstanceActions.None);
 200     let serviceModelId = "d6557200-ecf2-4641-8094-5393ae3aae60";
 201     let menuActions = pnfModelExtended.getMenuAction(<any>node, serviceModelId);
 202     node.data.children = [
 203       {"not": "empty"}
 204     ];
 205
 206     spyOn(_store, 'dispatch');
 207     menuActions['remove'].method(node, serviceModelId);
 208
 209     expect(_store.dispatch).not.toHaveBeenCalledWith(jasmine.objectContaining({
 210       type: "REMOVE_INSTANCE",
 211       storeKey: "PNF_KEY"
 212     }));
 213     expect(_store.dispatch).not.toHaveBeenCalledWith(jasmine.objectContaining({
 214       type: "CHANGE_INSTANCE_COUNTER",
 215       changeBy: -1
 216     }));
 217   });
 218
 219   test('getMenuAction: delete should dispatch delete action', () => {
 220     let node = NodeBuilder.getPnfNodeWithAction(ServiceInstanceActions.None);
 221     let serviceModelId = "d6557200-ecf2-4641-8094-5393ae3aae60";
 222     let menuActions = pnfModelExtended.getMenuAction(<any>node, serviceModelId);
 223
 224     spyOn(_store, 'dispatch');
 225     menuActions['delete'].method(node, serviceModelId);
 226
 227     expect(_store.dispatch).toHaveBeenCalledWith(jasmine.objectContaining({
 228       type: "DELETE_PNF_INSTANCE",
 229       storeKey: "PNF_KEY"
 230     }));
 231   });
 232
 233   test('getMenuAction: delete should show modal when node has children', () => {
 234     let node = NodeBuilder.getPnfNodeWithAction(ServiceInstanceActions.None);
 235     let serviceModelId = "d6557200-ecf2-4641-8094-5393ae3aae60";
 236     let menuActions = pnfModelExtended.getMenuAction(<any>node, serviceModelId);
 237     node.data.children = [
 238       {"not": "empty"}
 239     ];
 240
 241     spyOn(_sharedTreeService, 'shouldShowDeleteInstanceWithChildrenModal');
 242     menuActions['delete'].method(node, serviceModelId);
 243
 244     expect(_sharedTreeService.shouldShowDeleteInstanceWithChildrenModal).toHaveBeenCalledWith(jasmine.objectContaining({
 245       type: "PNF"
 246     }), jasmine.anything(), jasmine.anything());
 247   });
 248
 249   test('getMenuAction: delete should not be visible when service isMacro', () => {
 250     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 251       global: {
 252         drawingBoardStatus: DrawingBoardModes.EDIT
 253       },
 254       service: {
 255         serviceInstance: {
 256           "d6557200-ecf2-4641-8094-5393ae3aae60": {
 257             isALaCarte: false
 258           }
 259         }
 260       }
 261     });
 262
 263     let node = NodeBuilder.getPnfNodeWithAction(ServiceInstanceActions.None);
 264     let serviceModelId = "d6557200-ecf2-4641-8094-5393ae3aae60";
 265     let menuActions = pnfModelExtended.getMenuAction(<any>node, serviceModelId);
 266
 267     expect(menuActions['delete']).toBeDefined();
 268     expect(menuActions['delete'].visible(node)).toBeFalsy();
 269     expect(menuActions['delete'].enable(node)).toBeFalsy();
 270   });
 271
 272   test('getMenuAction: delete should not be visible when service is aLaCarte and Action is Create', () => {
 273     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 274       global: {
 275         drawingBoardStatus: DrawingBoardModes.EDIT
 276       },
 277       service: {
 278         serviceInstance: {
 279           "d6557200-ecf2-4641-8094-5393ae3aae60": {
 280             isALaCarte: true
 281           }
 282         }
 283       }
 284     });
 285
 286     let node = NodeBuilder.getPnfNodeWithAction(ServiceInstanceActions.Create);
 287     let serviceModelId = "d6557200-ecf2-4641-8094-5393ae3aae60";
 288     let menuActions = pnfModelExtended.getMenuAction(<any>node, serviceModelId);
 289
 290     expect(menuActions['delete']).toBeDefined();
 291     expect(menuActions['delete'].visible(node)).toBeFalsy();
 292     expect(menuActions['delete'].enable(node)).toBeFalsy();
 293   });
 294
 295   test('getMenuAction: delete should be visible when service is aLaCarte and Action is None', () => {
 296     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 297       global: {
 298         drawingBoardStatus: DrawingBoardModes.EDIT
 299       },
 300       service: {
 301         serviceInstance: {
 302           "d6557200-ecf2-4641-8094-5393ae3aae60": {
 303             isALaCarte: true
 304           }
 305         }
 306       }
 307     });
 308
 309     let node = NodeBuilder.getPnfNodeWithAction(ServiceInstanceActions.None);
 310     let serviceModelId = "d6557200-ecf2-4641-8094-5393ae3aae60";
 311     let menuActions = pnfModelExtended.getMenuAction(<any>node, serviceModelId);
 312
 313     expect(menuActions['delete']).toBeDefined();
 314     expect(menuActions['delete'].visible(node)).toBeTruthy();
 315     expect(menuActions['delete'].enable(node)).toBeTruthy();
 316   });
 317
 318   test('getMenuAction: undo delete should dispatch undo delete action when no children', () => {
 319     let node = NodeBuilder.getPnfNodeWithAction(ServiceInstanceActions.None);
 320     let serviceModelId = "d6557200-ecf2-4641-8094-5393ae3aae60";
 321     let menuActions = pnfModelExtended.getMenuAction(<any>node, serviceModelId);
 322
 323     spyOn(_store, 'dispatch');
 324     menuActions['undoDelete'].method(node, serviceModelId);
 325
 326     expect(_store.dispatch).toHaveBeenCalledWith(jasmine.objectContaining({
 327       type: "UNDO_DELETE_PNF_INSTANCE",
 328       storeKey: "PNF_KEY"
 329     }));
 330   });
 331
 332   test('getMenuAction: undo delete should iterate over children when they exist', () => {
 333     let node = NodeBuilder.getPnfNodeWithAction(ServiceInstanceActions.None);
 334     node.data.children = [
 335       {"not": "empty"}
 336     ];
 337     node.children = node.data.children;
 338     let serviceModelId = "d6557200-ecf2-4641-8094-5393ae3aae60";
 339     let menuActions = pnfModelExtended.getMenuAction(<any>node, serviceModelId);
 340
 341     spyOn(_store, 'dispatch');
 342     menuActions['undoDelete'].method(node, serviceModelId);
 343
 344     expect(_store.dispatch).toHaveBeenCalledWith(jasmine.objectContaining({
 345       type: "UNDO_DELETE_PNF_INSTANCE",
 346       storeKey: "PNF_KEY"
 347     }));
 348   });
 349
 350   test('getMenuAction: undo delete should not be visible when action is Create or Delete', () => {
 351     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 352       global: {
 353         drawingBoardStatus: DrawingBoardModes.EDIT
 354       },
 355       service: {
 356         serviceInstance: {
 357           "d6557200-ecf2-4641-8094-5393ae3aae60": {}
 358         }
 359       }
 360     });
 361
 362     let node = NodeBuilder.getPnfNodeWithAction(ServiceInstanceActions.Create);
 363     let serviceModelId = "d6557200-ecf2-4641-8094-5393ae3aae60";
 364     let menuActions = pnfModelExtended.getMenuAction(<any>node, serviceModelId);
 365
 366     expect(menuActions['undoDelete']).toBeDefined();
 367     expect(menuActions['undoDelete'].visible(node)).toBeFalsy();
 368     expect(menuActions['undoDelete'].enable(node)).toBeFalsy();
 369   });
 370
 371   test('getMenuAction: undo delete should be visible when action is contains "*_Delete"', () => {
 372     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 373       global: {
 374         drawingBoardStatus: DrawingBoardModes.EDIT
 375       },
 376       service: {
 377         serviceInstance: {
 378           "d6557200-ecf2-4641-8094-5393ae3aae60": {
 379             action: ServiceInstanceActions.None
 380           }
 381         }
 382       }
 383     });
 384
 385     let node = NodeBuilder.getPnfNodeWithAction(ServiceInstanceActions.None_Delete);
 386     let serviceModelId = "d6557200-ecf2-4641-8094-5393ae3aae60";
 387     let menuActions = pnfModelExtended.getMenuAction(<any>node, serviceModelId);
 388
 389     expect(menuActions['undoDelete']).toBeDefined();
 390     expect(menuActions['undoDelete'].visible(node)).toBeTruthy();
 391     expect(menuActions['undoDelete'].enable(node, serviceModelId)).toBeTruthy();
 392   });
 393
 394   test('getModel should return PNF model', () => {
 395     expect(pnfModelExtended.getModel({})).toBeInstanceOf(PNFModel);
 396   });
 397
 398   test('getNextLevelObject should return null as there are no childs expected in PNF for now', () => {
 399     expect(pnfModelExtended.getNextLevelObject()).toBeNull();
 400   });
 401
 402   test('getNodeCount should return counter of 0 when existingPNFCounterMap doesnt exist', () => {
 403     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 404       global: {},
 405       service: {
 406         serviceInstance: {
 407           'd6557200-ecf2-4641-8094-5393ae3aae60': {}
 408         }
 409       }
 410     });
 411
 412     let serviceId: string = 'd6557200-ecf2-4641-8094-5393ae3aae60';
 413     let node = NodeBuilder.getPnfNode();
 414     let result = pnfModelExtended.getNodeCount(<any>node, serviceId);
 415     jest.spyOn(_sharedTreeService, 'getExistingInstancesWithDeleteMode').mockReturnValue(0);
 416
 417     expect(result).toEqual(0);
 418   });
 419
 420   test('getNodeCount should return counter of 1 when one node exists and no nodes in delete mode', () => {
 421     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 422       global: {},
 423       service: {
 424         serviceInstance: {
 425           'd6557200-ecf2-4641-8094-5393ae3aae60': {
 426             'existingPNFCounterMap': {
 427               'modelCustomizationId': 1
 428             }
 429           }
 430         }
 431       }
 432     });
 433
 434     let serviceId: string = 'd6557200-ecf2-4641-8094-5393ae3aae60';
 435     let node = NodeBuilder.getPnfNode();
 436     let result = pnfModelExtended.getNodeCount(<any>node, serviceId);
 437     jest.spyOn(_sharedTreeService, 'getExistingInstancesWithDeleteMode').mockReturnValue(0);
 438
 439     expect(result).toEqual(1);
 440   });
 441
 442   test('getNodeCount should return counter of 2 when three nodes exist and one node is in delete mode', () => {
 443     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 444       global: {},
 445       service: {
 446         serviceInstance: {
 447           'd6557200-ecf2-4641-8094-5393ae3aae60': {
 448             'existingPNFCounterMap': {
 449               'modelCustomizationId': 3
 450             }
 451           }
 452         }
 453       }
 454     });
 455
 456     jest.spyOn(_sharedTreeService, 'getExistingInstancesWithDeleteMode').mockReturnValue(1);
 457     let serviceId: string = 'd6557200-ecf2-4641-8094-5393ae3aae60';
 458     let node = NodeBuilder.getPnfNode();
 459     let result = pnfModelExtended.getNodeCount(<any>node, serviceId);
 460
 461     expect(result).toEqual(2);
 462   });
 463
 464   test('getTooltip should return "PNF"', () => {
 465     expect(pnfModelExtended.getTooltip()).toEqual('PNF');
 466   });
 467
 468   test('getType should return "PNF"', () => {
 469     expect(pnfModelExtended.getType()).toEqual('PNF');
 470   });
 471
 472   test('isEcompGeneratedNaming should return true if isEcompGeneratedNaming is "true" ', () => {
 473     let isEcompGeneratedNaming: boolean = pnfModelExtended.isEcompGeneratedNaming(<any>{
 474       properties: {
 475         ecomp_generated_naming: 'true'
 476       }
 477     });
 478     expect(isEcompGeneratedNaming).toBeTruthy();
 479   });
 480
 481   test('isEcompGeneratedNaming should return false if isEcompGeneratedNaming is not defined', () => {
 482     let isEcompGeneratedNaming: boolean = pnfModelExtended.isEcompGeneratedNaming({
 483       properties: {}
 484     });
 485     expect(isEcompGeneratedNaming).toBeFalsy();
 486   });
 487
 488   test('showNodeIcons should return false if reached limit of instances', () => {
 489     let serviceId: string = 'servicedId';
 490     let node = NodeBuilder.getPnfNode();
 491     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 492       global: {},
 493       service: {
 494         serviceHierarchy: {
 495           'servicedId': {
 496             'pnfs': {
 497               modelCustomizationId: "modelCustomizationId",
 498               'modelInfo': {
 499                 modelCustomizationId: "modelCustomizationId"
 500               },
 501               'pnfName': {
 502                 'properties': {
 503                   'max_instances': 1
 504                 }
 505               }
 506             }
 507           }
 508         },
 509         serviceInstance: {
 510           'servicedId': {
 511             'existingPNFCounterMap': {
 512               'modelCustomizationId': 1
 513             },
 514             'pnfs': {
 515               'pnfName': {}
 516             }
 517           }
 518         }
 519       }
 520     });
 521
 522     let result = pnfModelExtended.showNodeIcons(<any>node, serviceId);
 523     expect(result).toEqual(new AvailableNodeIcons(false, true));
 524   });
 525
 526   test('showNodeIcons should return true if limit of instances is not reached', () => {
 527     let serviceId: string = 'servicedId';
 528     let node = NodeBuilder.getPnfNode();
 529     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 530       global: {
 531         drawingBoardStatus: DrawingBoardModes.EDIT
 532       },
 533       service: {
 534         serviceHierarchy: {
 535           'servicedId': {
 536             'pnfs': {
 537               modelCustomizationId: "modelCustomizationId",
 538               'modelInfo': {
 539                 modelCustomizationId: "modelCustomizationId"
 540               },
 541               'pnfName': {
 542                 'properties': {
 543                   'max_instances': 2
 544                 }
 545               }
 546             }
 547           }
 548         },
 549         serviceInstance: {
 550           'servicedId': {
 551             'existingPNFCounterMap': {
 552               'modelCustomizationId': 1
 553             },
 554             'pnfs': {
 555               'pnfName': {}
 556             }
 557           }
 558         }
 559       }
 560     });
 561
 562     let result = pnfModelExtended.showNodeIcons(<any>node, serviceId);
 563     expect(result).toEqual(new AvailableNodeIcons(true, false));
 564   });
 565
 566   test('hasMissingData returns true instanceName is empty and ecompNameGenerating is off ', () => {
 567     let instance = {
 568       instanceName: "",
 569       platformName: "platformName"
 570     }
 571
 572     let result = pnfModelExtended.hasMissingData(instance, [], false);
 573
 574     expect(result).toBeTruthy();
 575   });
 576
 577   test('hasMissingData returns true when at least one required field is empty ', () => {
 578     let instance = {
 579       platformName: ""
 580     }
 581
 582     let result = pnfModelExtended.hasMissingData(instance, [], true);
 583
 584     expect(result).toBeTruthy();
 585   });
 586
 587   test('hasMissingData returns false when there is no missing data', () => {
 588     let instance = {
 589       platformName: "platformName"
 590     }
 591
 592     let result = pnfModelExtended.hasMissingData(instance, [], true);
 593
 594     expect(result).toBeFalsy();
 595   });
 596
 597 });