vid-webpack-master/src/app/drawingBoard/service-planning/objectsToTree/models/network/network.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 {NetworkModelInfo} from "./network.model.info";
   5 import {DynamicInputsService} from "../../dynamicInputs.service";
   6 import {SharedTreeService} from "../../shared.tree.service";
   7 import {NgRedux} from "@angular-redux/store";
   8 import {NetworkPopupService} from "../../../../../shared/components/genericFormPopup/genericFormServices/network/network.popup.service";
   9 import {DialogService} from "ng2-bootstrap-modal";
  10 import {AvailableNodeIcons} from "../../../available-models-tree/available-models-tree.service";
  11 import {DrawingBoardModes} from "../../../drawing-board.modes";
  12 import {IframeService} from "../../../../../shared/utils/iframe.service";
  13 import {DuplicateService} from "../../../duplicate/duplicate.service";
  14 import {ModelInformationItem} from "../../../../../shared/components/model-information/model-information.component";
  15 import {FeatureFlagsService} from "../../../../../shared/services/featureFlag/feature-flags.service";
  16 import {NetworkModel} from "../../../../../shared/models/networkModel";
  17
  18 class MockAppStore<T> {
  19   getState() {
  20     return {
  21       global: {
  22         'drawingBoardStatus': DrawingBoardModes.CREATE
  23       },
  24       service: {
  25         serviceHierarchy: {
  26           'servicedId': {
  27             'networks': {
  28               'networkName': {
  29                 'properties': {
  30                   'max_instances': 1
  31                 }
  32               }
  33             }
  34           }
  35         },
  36         serviceInstance: {
  37           'servicedId': {
  38             'existingNetworksCounterMap': {
  39               'networkId': 1
  40             },
  41             'networks': {
  42               'networkName': {
  43                 'action': 'Create',
  44                 'originalName': 'networkName'
  45               }
  46             }
  47           }
  48         }
  49       }
  50     }
  51   }
  52 }
  53
  54 class MockFeatureFlagsService extends FeatureFlagsService {
  55   getAllFlags(): { [p: string]: boolean } {
  56     return {};
  57   }
  58 }
  59
  60
  61 describe('Network Model Info', () => {
  62   let injector;
  63   let _dynamicInputsService: DynamicInputsService;
  64   let _sharedTreeService: SharedTreeService;
  65   let networkModel: NetworkModelInfo;
  66   let _dialogService: DialogService;
  67   let _networkPopupService: NetworkPopupService;
  68   let _duplicateService: DuplicateService;
  69   let _iframeService: IframeService;
  70   let _featureFlagsService: FeatureFlagsService;
  71
  72   beforeAll(done => (async () => {
  73     TestBed.configureTestingModule({
  74       imports: [HttpClientTestingModule, NgReduxTestingModule],
  75       providers: [
  76         DynamicInputsService,
  77         SharedTreeService,
  78         DialogService,
  79         NetworkPopupService,
  80         IframeService,
  81         DuplicateService,
  82         {provide: NgRedux, useClass: MockAppStore},
  83         {provide: FeatureFlagsService, useClass: MockFeatureFlagsService},
  84         MockNgRedux]
  85     });
  86     await TestBed.compileComponents();
  87
  88     injector = getTestBed();
  89     _sharedTreeService = injector.get(SharedTreeService);
  90     _featureFlagsService = injector.get(FeatureFlagsService);
  91
  92     networkModel = new NetworkModelInfo(_dynamicInputsService, _sharedTreeService, _dialogService, _networkPopupService, _duplicateService, null, _iframeService, _featureFlagsService, MockNgRedux.getInstance());
  93   })().then(done).catch(done.fail));
  94
  95   test('NetworkModelInfo should be defined', () => {
  96     expect(NetworkModelInfo).toBeDefined();
  97   });
  98
  99   test('NetworkModelInfo should defined extra details', () => {
 100     expect(networkModel.name).toEqual('networks');
 101     expect(networkModel.type).toEqual('Network');
 102   });
 103
 104   test('isEcompGeneratedNaming should return true if = isEcompGeneratedNaming is "true" ', () => {
 105     let isEcompGeneratedNaming: boolean = networkModel.isEcompGeneratedNaming({
 106       properties: {
 107         ecomp_generated_naming: 'true'
 108       }
 109     });
 110     expect(isEcompGeneratedNaming).toBeTruthy();
 111   });
 112
 113   test('isEcompGeneratedNaming should return false if isEcompGeneratedNaming is "false"', () => {
 114     let isEcompGeneratedNaming: boolean = networkModel.isEcompGeneratedNaming({
 115       properties: {
 116         ecomp_generated_naming: 'false'
 117       }
 118     });
 119     expect(isEcompGeneratedNaming).toBeFalsy();
 120   });
 121
 122   test('isEcompGeneratedNaming should return false if isEcompGeneratedNaming is not defined', () => {
 123     let isEcompGeneratedNaming: boolean = networkModel.isEcompGeneratedNaming({
 124       properties: {}
 125     });
 126     expect(isEcompGeneratedNaming).toBeFalsy();
 127   });
 128
 129   test('getTooltip should return "VF"', () => {
 130     let tooltip: string = networkModel.getTooltip();
 131     expect(tooltip).toEqual('Network');
 132   });
 133
 134   test('getType should return "VF"', () => {
 135     let tooltip: string = networkModel.getType();
 136     expect(tooltip).toEqual('Network');
 137   });
 138
 139   test('getNextLevelObject should return null', () => {
 140     let nextLevel = networkModel.getNextLevelObject();
 141     expect(nextLevel).toBeNull();
 142   });
 143
 144   test('updateDynamicInputsDataFromModel should return empty array', () => {
 145     let dynamicInputs = networkModel.updateDynamicInputsDataFromModel({});
 146     expect(dynamicInputs).toEqual([]);
 147   });
 148
 149   test('getModel should return Network model', () => {
 150     expect(networkModel.getModel({})).toBeInstanceOf(NetworkModel);
 151   });
 152
 153   test('showNodeIcons should return false if reachLimit of max', () => {
 154     let serviceId: string = 'servicedId';
 155     let node = {
 156       data: {
 157         id: 'networkId',
 158         name: 'networkName',
 159         modelCustomizationId: 'modelCustomizationId'
 160       }
 161     };
 162     jest.spyOn(_sharedTreeService, 'getExistingInstancesWithDeleteMode').mockReturnValue(0);
 163     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 164       global: {},
 165       service: {
 166         serviceHierarchy: {
 167           'servicedId': {
 168             'networks': {
 169               'networkName': {
 170                 'properties': {
 171                   'max_instances': 1
 172                 }
 173               }
 174             }
 175           }
 176         },
 177         serviceInstance: {
 178           'servicedId': {
 179             'existingNetworksCounterMap': {
 180               'modelCustomizationId': 1
 181             },
 182             'networks': {
 183               'networkName': {}
 184             }
 185           }
 186         }
 187       }
 188     });
 189
 190     let result = networkModel.showNodeIcons(<any>node, serviceId);
 191     expect(result).toEqual(new AvailableNodeIcons(true, false));
 192   });
 193
 194   test('showNodeIcons should return true if not reachLimit of max', () => {
 195     let serviceId: string = 'servicedId';
 196     let node = {
 197       data: {
 198         id: 'networkId',
 199         name: 'networkName'
 200       }
 201     };
 202     jest.spyOn(_sharedTreeService, 'getExistingInstancesWithDeleteMode').mockReturnValue(0);
 203     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 204       global: {},
 205       service: {
 206         serviceHierarchy: {
 207           'servicedId': {
 208             'networks': {
 209               'networkName': {
 210                 'properties': {
 211                   'max_instances': 2
 212                 }
 213               }
 214             }
 215           }
 216         },
 217         serviceInstance: {
 218           'servicedId': {
 219             'existingNetworksCounterMap': {
 220               'networkId': 1
 221             },
 222             'networks': {
 223               'networkName': {}
 224             }
 225           }
 226         }
 227       }
 228     });
 229
 230     let result = networkModel.showNodeIcons(<any>node, serviceId);
 231     expect(result).toEqual(new AvailableNodeIcons(true, false));
 232   });
 233
 234   test('getNodeCount should return number of nodes', () => {
 235     let serviceId: string = 'servicedId';
 236     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 237       global: {},
 238       service: {
 239         serviceHierarchy: {
 240           'servicedId': {
 241             'networks': {
 242               'networkName': {
 243                 'properties': {
 244                   'max_instances': 1
 245                 }
 246               }
 247             }
 248           }
 249         },
 250         serviceInstance: {
 251           'servicedId': {
 252             'existingNetworksCounterMap': {
 253               'modelCustomizationId': 1
 254             },
 255             'networks': {
 256               'networkName': {
 257                 'action': 'Create',
 258                 'originalName': 'networkName'
 259               }
 260             }
 261           }
 262         }
 263       }
 264     });
 265
 266     let node = {
 267       data: {
 268         id: 'networkId',
 269         name: 'networkName',
 270         action: 'Create',
 271         modelCustomizationId: "modelCustomizationId",
 272         modelUniqueId: "modelCustomizationId"
 273       }
 274     };
 275     let result = networkModel.getNodeCount(<any>node, serviceId);
 276     expect(result).toEqual(1);
 277
 278     node.data.modelCustomizationId = 'networkId_notExist';
 279     node.data.modelUniqueId = 'networkId_notExist';
 280     result = networkModel.getNodeCount(<any>node, serviceId);
 281     expect(result).toEqual(0);
 282   });
 283
 284   test('getMenuAction: showAuditInfoNetwork', () => {
 285
 286     jest.spyOn(MockNgRedux.getInstance(), 'getState').mockReturnValue({
 287       global: {
 288         "drawingBoardStatus": DrawingBoardModes.RETRY
 289       }
 290     });
 291     jest.spyOn(_sharedTreeService, 'isRetryMode').mockReturnValue(true);
 292     let node = {
 293       data: {
 294         "modelId": "6b528779-44a3-4472-bdff-9cd15ec93450",
 295         "action": "Create",
 296         "isFailed": true,
 297       }
 298     };
 299     let serviceModelId = "6b528779-44a3-4472-bdff-9cd15ec93450";
 300     let result = networkModel.getMenuAction(<any>node, serviceModelId);
 301     spyOn(result['showAuditInfo'], 'method');
 302     expect(result['showAuditInfo']).toBeDefined();
 303     expect(result['showAuditInfo'].visible(node)).toBeTruthy();
 304     expect(result['showAuditInfo'].enable(node)).toBeTruthy();
 305     result['showAuditInfo']['method'](node, serviceModelId);
 306     expect(result['showAuditInfo']['method']).toHaveBeenCalledWith(node, serviceModelId);
 307   });
 308
 309   test('Info for network should be correct', () => {
 310     const model = getNetworkModel();
 311     const instance = getNetworkInstance();
 312     let actualNetworkInfo = networkModel.getInfo(model, instance);
 313     let expectedNetworkInfo = [
 314       ModelInformationItem.createInstance("Min instances", "0"),
 315       ModelInformationItem.createInstance("Max instances", "1"),
 316       ModelInformationItem.createInstance('Network role', "network role 1, network role 2"),
 317       ModelInformationItem.createInstance("Route target id", null),
 318       ModelInformationItem.createInstance("Route target role", null),
 319     ];
 320     expect(actualNetworkInfo).toEqual(expectedNetworkInfo);
 321   });
 322
 323   test('When there is no max Max instances text is: Unlimited (default)', () => {
 324     let actualVNFInfo = networkModel.getInfo({just:"not empty"},null);
 325     const maxInstancesItem = actualVNFInfo.find((item)=> item.label == 'Max instances');
 326     expect(maxInstancesItem.values[0]).toEqual('Unlimited (default)');
 327   });
 328
 329   function getNetworkModel() {
 330     return {
 331       "customizationUuid": "94fdd893-4a36-4d70-b16a-ec29c54c184f",
 332       "name": "ExtVL",
 333       "version": "37.0",
 334       "description": "ECOMP generic virtual link (network) base type for all other service-level and global networks",
 335       "uuid": "ddc3f20c-08b5-40fd-af72-c6d14636b986",
 336       "invariantUuid": "379f816b-a7aa-422f-be30-17114ff50b7c",
 337       "max": 1,
 338       "min": 0,
 339       "isEcompGeneratedNaming": false,
 340       "type": "VL",
 341       "modelCustomizationName": "ExtVL 0",
 342       "roles": ["network role 1", " network role 2"],
 343       "properties": {
 344         "network_role": "network role 1, network role 2",
 345         "network_assignments":
 346           "{is_external_network=false, ipv4_subnet_default_assignment={min_subnets_count=1}, ecomp_generated_network_assignment=false, ipv6_subnet_default_assignment={min_subnets_count=1}}",
 347         "exVL_naming": "{ecomp_generated_naming=true}",
 348         "network_flows": "{is_network_policy=false, is_bound_to_vpn=false}",
 349         "network_homing": "{ecomp_selected_instance_node_target=false}"
 350       }
 351     };
 352
 353   }
 354
 355   function getNetworkInstance() {
 356     return {
 357       "modelCustomizationId": "94fdd893-4a36-4d70-b16a-ec29c54c184f",
 358       "modelId": "ddc3f20c-08b5-40fd-af72-c6d14636b986",
 359       "modelUniqueId": "94fdd893-4a36-4d70-b16a-ec29c54c184f",
 360       "missingData": true,
 361       "id": "NETWORK4_INSTANCE_ID",
 362       "action": "None",
 363       "orchStatus": "Created",
 364       "provStatus": "preprov",
 365       "inMaint": false,
 366       "instanceId": "NETWORK4_INSTANCE_ID",
 367       "instanceType": "CONTRAIL30_HIMELGUARD",
 368       "instanceName": "NETWORK4_INSTANCE_NAME",
 369       "name": "NETWORK4_INSTANCE_NAME",
 370       "modelName": "ExtVL 0",
 371       "type": "VL",
 372       "isEcompGeneratedNaming": false,
 373       "networkStoreKey": "NETWORK4_INSTANCE_ID",
 374       "typeName": "N",
 375       "menuActions": {"edit": {}, "showAuditInfo": {}, "duplicate": {}, "remove": {}, "delete": {}, "undoDelete": {}},
 376       "isFailed": false,
 377       "statusMessage": "",
 378       "statusProperties": [{"key": "Prov Status:", "value": "preprov", "testId": "provStatus"}, {
 379         "key": "Orch Status:",
 380         "value": "Created",
 381         "testId": "orchStatus"
 382       }],
 383       "trackById": "1wvr73xl999",
 384       "parentType": "",
 385       "componentInfoType": "Network",
 386       "errors": {}
 387     };
 388   }
 389
 390 });