vid-app-common/src/main/webapp/app/vid/scripts/modals/new-change-management/new-change-management.controller.test.js

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * VID
   4  * ================================================================================
   5  * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 require('./new-change-management.controller');
  22 const jestMock = require('jest-mock');
  23
  24 describe('Testing workFlows from SO', () => {
  25   let $notNeeded;
  26   let $controller;
  27   let $changeManagementService;
  28   let $featureFlags;
  29
  30   beforeEach(
  31       angular.mock.module('app')
  32   );
  33
  34   beforeEach(inject(function (_$controller_) {
  35     $notNeeded = jestMock.fn();
  36
  37     // mock ChangeManagementService
  38     $changeManagementService = jestMock.fn();
  39     $changeManagementService.getAllSDCServices = jestMock.fn(() => Promise.resolve([]));
  40
  41     // mock q
  42     $q = jestMock.fn();
  43     $defer = jestMock.fn();
  44     $flags = jestMock.fn();
  45     $flags.FEATURE_FLAGS = {FLAG_HANDLE_SO_WORKFLOWS: ''};
  46     $featureFlags = jestMock.fn();
  47     $featureFlags.isOn = jestMock.fn(() => true);
  48     $q.defer = jestMock.fn(() => $defer);
  49     $defer.promise = Promise.resolve({});
  50     // mock AaiService
  51     $aaiService = jestMock.fn();
  52     $aaiService.getLoggedInUserID = jestMock.fn();
  53     $aaiService.getSubscribers = jestMock.fn();
  54     $controller = _$controller_('newChangeManagementModalController', {
  55       $uibModalInstance: $notNeeded,
  56       $uibModal: $notNeeded,
  57       $q: $q,
  58       AaiService: $aaiService,
  59       changeManagementService: $changeManagementService,
  60       Upload: $notNeeded,
  61       $log: $notNeeded,
  62       _: $notNeeded,
  63       COMPONENT: $flags,
  64       VIDCONFIGURATION: $notNeeded,
  65       DataService: $notNeeded,
  66       featureFlags: $featureFlags,
  67       $scope: $notNeeded,
  68     });
  69   }));
  70
  71   test('Verify load workflows from SO will call getSOWorkflow and return only names of workflows', () => {
  72     // given
  73     $controller.changeManagement.vnfNames = [{name: 'test1'}, {name: "test2"}];
  74     let getSOWorkflowsPromiseStub = Promise.resolve({"data": [{"id": "1", "name": "workflow 1"}, {"id": "2", "name": "workflow 2"}]});
  75     $changeManagementService.getSOWorkflows = () => getSOWorkflowsPromiseStub;
  76     $controller.workflows = [];
  77     // when
  78     return $controller.loadRemoteWorkFlows()
  79     .then(() => {
  80            remoteWorkflows = $controller.remoteWorkflows.map(item => item.name);
  81            expect(remoteWorkflows).toContain('workflow 1');
  82            expect(remoteWorkflows).toContain('workflow 2');
  83         }
  84      );
  85   });
  86
  87   test('Verify load workflows wont load parameters from local service', () => {
  88     // given
  89     let getWorkflowsStub = Promise.resolve({"data": {"workflows": ["workflow 0"]}});
  90     let getLocalWorkflowsParametersStub = Promise.resolve({"data":{
  91         "parameterDefinitions": [
  92           {
  93             "id": 1,
  94             "name": "Configuration Parameters",
  95             "required": true,
  96             "type": "text",
  97             "pattern": ".*",
  98             "msgOnPatternError": null,
  99             "msgOnContentError": null,
 100             "acceptableFileType": null
 101           }
 102         ],
 103       }});
 104     let getSOWorkflowsPromiseStub = Promise.resolve({"data":[{
 105
 106         "id": "ab6478e4-ea33-3346-ac12-ab121484a333",
 107         "workflowName": "inPlaceSoftwareUpdate",
 108         "name": "inPlaceSoftwareUpdate",
 109         "source": "sdc",
 110         "workflowInputParameters": [
 111             {
 112                 "label": "New Software Version",
 113                 "inputType": "text",
 114                 "required": true,
 115                 "soFieldName": "new_software_version",
 116                 "soPayloadLocation": "userParams",
 117                 "validation":[]
 118             }
 119         ]
 120     }]
 121     });
 122
 123     $controller.changeManagement.vnfNames = [{modelVersionId: 'test1', name:'test'}];
 124     $changeManagementService.getWorkflows = () => getWorkflowsStub;
 125     $changeManagementService.getLocalWorkflowParameter = () => getLocalWorkflowsParametersStub;
 126     $changeManagementService.getSOWorkflows = () =>  getSOWorkflowsPromiseStub;
 127     // when
 128     return $controller.loadWorkFlows().then(() => {
 129       expect($controller.workflows).toContain('inPlaceSoftwareUpdate');
 130       expect($controller.localWorkflowsParameters).toEqual(new Map());
 131     });
 132   });
 133
 134   test('Verify load workflows will set workflows and parameters', () => {
 135     // given
 136     let getWorkflowsStub = Promise.resolve({"data": {"workflows": ["workflow 0"]}});
 137     let getLocalWorkflowsParametersStub = Promise.resolve({"data": {}});
 138     let getSOWorkflowsPromiseStub = Promise.resolve({"data":[{
 139
 140             "id": "ab6478e4-ea33-3346-ac12-ab121484a333",
 141             "workflowName": "inPlaceSoftwareUpdate",
 142             "name": "inPlaceSoftwareUpdate",
 143             "source": "sdc",
 144           "workflowInputParameters": [
 145             {
 146               "label": "New Software Version",
 147               "inputType": "text",
 148               "required": true,
 149               "soFieldName": "new_software_version",
 150               "soPayloadLocation": "userParams",
 151                 "validation":[]
 152             }
 153           ]
 154         }]
 155       });
 156     $controller.changeManagement.vnfNames = [{modelVersionId: 'test1', name:'test'}];
 157     $changeManagementService.getWorkflows = () => getWorkflowsStub;
 158     $changeManagementService.getLocalWorkflowParameter = () => getLocalWorkflowsParametersStub;
 159     $changeManagementService.getSOWorkflows = () =>  getSOWorkflowsPromiseStub;
 160     $changeManagementService.getSOWorkflowParameter = () =>  getSOWorkflowsParametersPromiseStub;
 161     // when
 162     return $controller.loadWorkFlows()
 163     .then(() => {
 164       expect($controller.workflows).toEqual(["inPlaceSoftwareUpdate"]);
 165       expect($controller.remoteWorkflowsParameters).toEqual(new Map([["inPlaceSoftwareUpdate",
 166         [{
 167           "name": "New Software Version",
 168           "required": true,
 169           "id": "new_software_version",
 170           "soFieldName": "new_software_version",
 171           "maxLength": '500',
 172           "pattern": '.*',
 173           "type": "text"
 174         }]]
 175       ]));
 176     });
 177   });
 178
 179   test('Verify load workflows wont load workflows parameters from SO if feature flag is disabled', () => {
 180     // given
 181     $featureFlags.isOn = jestMock.fn(() => false);
 182     let getWorkflowsStub = Promise.resolve({"data": {"workflows": ["workflow 0"]}});
 183     let getLocalWorkflowsParametersStub = Promise.resolve({"data": {}});
 184     let getSOWorkflowsPromiseStub = Promise.resolve({"data": [{"id": "1", "name": "workflow 0"}]});
 185     let getSOWorkflowsParametersPromiseStub = Promise.resolve({"data":{"parameterDefinitions": [
 186           {"id": 1, "name": "parameter 1", "required": true, "type": "text", "pattern": "[0-9]*"},
 187           {"id": 2, "name": "parameter 2", "required": true, "type": "text", "pattern": ".*"},
 188           {"id": 3, "name": "parameter 3", "required": false, "type": "text", "pattern": "[0-9]*"}]}});
 189
 190     $controller.changeManagement.vnfNames = [{name: 'test1'}, {name: "test2"}];
 191     $changeManagementService.getWorkflows = () => getWorkflowsStub;
 192     $changeManagementService.getLocalWorkflowParameter = () => getLocalWorkflowsParametersStub;
 193     $changeManagementService.getSOWorkflows = () =>  getSOWorkflowsPromiseStub;
 194     $changeManagementService.getSOWorkflowParameter = () =>  getSOWorkflowsParametersPromiseStub;
 195     // when
 196     return $controller.loadWorkFlows()
 197     .then(() => {
 198       expect($controller.workflows).toEqual(["workflow 0"]);
 199       expect($controller.remoteWorkflowsParameters).toEqual(new Map());
 200     });
 201   });
 202
 203   test('Verify load workflows will call load workflows parameters from local service', () => {
 204     // given
 205     $featureFlags.isOn = jestMock.fn(() => false);
 206     let getWorkflowsStub = Promise.resolve({"data": {"workflows": ["VNF Scale Out"]}});
 207     let getLocalWorkflowsParametersStub = Promise.resolve({"data":{
 208         "parameterDefinitions": [
 209           {
 210             "id": 1,
 211             "name": "Configuration Parameters",
 212             "required": true,
 213             "type": "text",
 214             "pattern": ".*",
 215             "msgOnPatternError": null,
 216             "msgOnContentError": null,
 217             "acceptableFileType": null
 218           }
 219         ],
 220       }});
 221
 222     $controller.changeManagement.vnfNames = [{name: 'test1'}];
 223     $changeManagementService.getWorkflows = () => getWorkflowsStub;
 224     $changeManagementService.getLocalWorkflowParameter = () => getLocalWorkflowsParametersStub;
 225     // when
 226
 227     let result = new Map();
 228     const scaleOutResult = [
 229       {
 230         "acceptableFileType": null,
 231         "id": 1,
 232         "msgOnContentError": null,
 233         "msgOnPatternError": null,
 234         "name": "Configuration Parameters",
 235         "pattern": ".*",
 236         "required": true,
 237         "type": "text",
 238       }
 239     ];
 240     result.set("VNF Scale Out", scaleOutResult);
 241
 242     return $controller.loadWorkFlows()
 243     .then(() => {
 244       expect($controller.localWorkflowsParameters).toEqual(result);
 245     });
 246   });
 247
 248   test('Verify broken SO workflows will return empty list of workflows', () => {
 249     // given
 250     let getSOWorkflowsPromiseStub = Promise.reject(new Error("Broken SO workflows service."));
 251
 252     $controller.changeManagement.vnfNames = [{name:"any"}];
 253     $changeManagementService.getSOWorkflows = () =>  getSOWorkflowsPromiseStub;
 254     // when
 255     $controller.loadWorkFlows()
 256     .then(() => {
 257       expect($controller.workflows).toEqual([]);
 258     });
 259   });
 260
 261   test('Verify get internal workflow parameters should return an empty list if not such workflow exist', () => {
 262   // given
 263     $featureFlags.isOn = jestMock.fn(() => false);
 264     let getWorkflowsStub = Promise.resolve({"data": {"workflows": ["VNF Scale Out"]}});
 265     let getLocalWorkflowsParametersStub = Promise.resolve({"data":{
 266         "parameterDefinitions": [
 267           {
 268             "id": 1,
 269             "name": "Configuration Parameters",
 270             "required": true,
 271             "type": "text",
 272             "pattern": ".*",
 273             "msgOnPatternError": null,
 274             "msgOnContentError": null,
 275             "acceptableFileType": null
 276           }
 277         ],
 278       }});
 279
 280     $controller.changeManagement.vnfNames = [{name: 'test1'}];
 281     $changeManagementService.getWorkflows = () => getWorkflowsStub;
 282     $changeManagementService.getLocalWorkflowParameter = () => getLocalWorkflowsParametersStub;
 283     // when
 284     return $controller.loadWorkFlows()
 285     .then(() => {
 286       let internalWorkFlowParameters = $controller.getInternalWorkFlowParameters("NON-EXISTENT WF", "text");
 287       expect(internalWorkFlowParameters).toEqual([]);
 288     });
 289   });
 290
 291   test('Verify get internal workflow parameters should return an empty list if not such type exist', () => {
 292     // given
 293     $featureFlags.isOn = jestMock.fn(() => false);
 294     let getWorkflowsStub = Promise.resolve({"data": {"workflows": ["VNF Scale Out"]}});
 295     let getLocalWorkflowsParametersStub = Promise.resolve({"data":{
 296         "parameterDefinitions": [
 297           {
 298             "id": 1,
 299             "name": "Configuration Parameters",
 300             "required": true,
 301             "type": "text",
 302             "pattern": ".*",
 303             "msgOnPatternError": null,
 304             "msgOnContentError": null,
 305             "acceptableFileType": null
 306           }
 307         ],
 308       }});
 309
 310     $controller.changeManagement.vnfNames = [{name: 'test1'}];
 311     $changeManagementService.getWorkflows = () => getWorkflowsStub;
 312     $changeManagementService.getLocalWorkflowParameter = () => getLocalWorkflowsParametersStub;
 313     // when
 314     return $controller.loadWorkFlows()
 315     .then(() => {
 316       let internalWorkFlowParameters = $controller.getInternalWorkFlowParameters("VNF Scale Out", "FILE");
 317       expect(internalWorkFlowParameters).toEqual([]);
 318     });
 319   });
 320
 321   test('Verify get internal workflow parameters should return an empty list if type exist but mapped to undefined', () => {
 322     // given
 323     $featureFlags.isOn = jestMock.fn(() => false);
 324     let getWorkflowsStub = Promise.resolve({"data": {"workflows": ["VNF Scale Out"]}});
 325     let getLocalWorkflowsParametersStub = Promise.resolve({"data": undefined});
 326
 327     $controller.changeManagement.vnfNames = [{name: 'test1'}];
 328     $changeManagementService.getWorkflows = () => getWorkflowsStub;
 329     $changeManagementService.getLocalWorkflowParameter = () => getLocalWorkflowsParametersStub;
 330     // when
 331     return $controller.loadWorkFlows()
 332     .then(() => {
 333       let internalWorkFlowParameters = $controller.getInternalWorkFlowParameters("VNF Scale Out", "FILE");
 334       expect(internalWorkFlowParameters).toEqual([]);
 335     });
 336   });
 337
 338   test('Verify get internal workflow parameters should return a list if such workflow and type exist', () => {
 339     // given
 340     $featureFlags.isOn = jestMock.fn(() => false);
 341     let getWorkflowsStub = Promise.resolve({"data": {"workflows": ["VNF Scale Out"]}});
 342     let getLocalWorkflowsParametersStub = Promise.resolve({"data":{
 343         "parameterDefinitions": [
 344           {
 345             "id": 1,
 346             "name": "Configuration Parameters",
 347             "required": true,
 348             "type": "text",
 349             "pattern": ".*",
 350             "msgOnPatternError": null,
 351             "msgOnContentError": null,
 352             "acceptableFileType": null
 353           }
 354         ],
 355       }});
 356     $controller.changeManagement.vnfNames = [{name: 'test1'}];
 357     $changeManagementService.getWorkflows = () => getWorkflowsStub;
 358     $changeManagementService.getLocalWorkflowParameter = () => getLocalWorkflowsParametersStub;
 359
 360     let result = [{
 361         "acceptableFileType": null,
 362         "id": 1,
 363         "msgOnContentError": null,
 364         "msgOnPatternError": null,
 365         "name": "Configuration Parameters",
 366         "pattern": ".*",
 367         "required": true,
 368         "type": "text",
 369         }];
 370     // when
 371     return $controller.loadWorkFlows()
 372     .then(() => {
 373       let internalWorkFlowParameters = $controller.getInternalWorkFlowParameters("VNF Scale Out", "text");
 374       expect(internalWorkFlowParameters).toEqual(result);
 375     });
 376   });
 377
 378   test('Verify get remote workflow should call internal service for params when workflow is native', () =>{
 379       let getWorkflowsStub = Promise.resolve({"data": {"workflows": ["workflow 0"]}});
 380       let getLocalWorkflowsParametersStub = Promise.resolve({"data":{
 381               "parameterDefinitions": [
 382                   {
 383                       "id": 1,
 384                       "name": "Configuration Parameters",
 385                       "required": true,
 386                       "type": "text",
 387                       "pattern": ".*",
 388                       "msgOnPatternError": null,
 389                       "msgOnContentError": null,
 390                       "acceptableFileType": null
 391                   }
 392               ],
 393           }});
 394       let getSOWorkflowsPromiseStub = Promise.resolve({"data":[{
 395
 396         "id": "ab6478e4-ea33-3346-ac12-ab121484a333",
 397         "workflowName": "inPlaceSoftwareUpdate",
 398         "name": "inPlaceSoftwareUpdate",
 399         "source": "native",
 400         "workflowInputParameters": [
 401         ]
 402     }]
 403   });
 404
 405   $controller.changeManagement.vnfNames = [{modelVersionId: 'test1', name:'test'}];
 406   $changeManagementService.getWorkflows = () => getWorkflowsStub;
 407   $changeManagementService.getLocalWorkflowParameter = () => getLocalWorkflowsParametersStub;
 408   $changeManagementService.getSOWorkflows = () =>  getSOWorkflowsPromiseStub;
 409
 410   return $controller.loadWorkFlows().then(() => {
 411     expect($controller.workflows).toContain('inPlaceSoftwareUpdate');
 412     expect($controller.localWorkflowsParameters.get('inPlaceSoftwareUpdate')).toEqual([{
 413         "id": 1,
 414         "name": "Configuration Parameters",
 415         "required": true,
 416         "type": "text",
 417         "pattern": ".*",
 418         "msgOnPatternError": null,
 419         "msgOnContentError": null,
 420         "acceptableFileType": null
 421     }]);
 422   });
 423 });
 424 });