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     // mock ChangeManagementService
  37     $changeManagementService = jestMock.fn();
  38     $changeManagementService.getAllSDCServices = jestMock.fn(() => Promise.resolve([]));
  39
  40     // mock q
  41     $q = jestMock.fn();
  42     $defer = jestMock.fn();
  43     $flags = jestMock.fn();
  44     $flags.FEATURE_FLAGS = {FLAG_HANDLE_SO_WORKFLOWS: ''};
  45     $featureFlags = jestMock.fn();
  46     $featureFlags.isOn = jestMock.fn(() => true);
  47     $q.defer = jestMock.fn(() => $defer);
  48     $defer.promise = Promise.resolve({});
  49     // mock AaiService
  50     $aaiService = jestMock.fn();
  51     $aaiService.getLoggedInUserID = jestMock.fn();
  52     $aaiService.getSubscribers = jestMock.fn();
  53     $controller = _$controller_('newChangeManagementModalController', {
  54       $uibModalInstance: $notNeeded,
  55       $uibModal: $notNeeded,
  56       $q: $q,
  57       AaiService: $aaiService,
  58       changeManagementService: $changeManagementService,
  59       Upload: $notNeeded,
  60       $log: $notNeeded,
  61       _: $notNeeded,
  62       COMPONENT: $flags,
  63       VIDCONFIGURATION: $notNeeded,
  64       DataService: $notNeeded,
  65       featureFlags: $featureFlags,
  66       $scope: $notNeeded,
  67     });
  68   }));
  69
  70   test('Verify load workflows from SO will call getSOWorkflow and return only names of workflows', () => {
  71     // given
  72     $controller.changeManagement.vnfNames = [{name: 'test1'}, {name: "test2"}];
  73     let getSOWorkflowsPromiseStub = Promise.resolve({"data": [{"id": "1", "name": "workflow 1"}, {"id": "2", "name": "workflow 2"}]});
  74     $changeManagementService.getSOWorkflows = () => getSOWorkflowsPromiseStub;
  75     $controller.workflows = [];
  76     // when
  77     return $controller.loadRemoteWorkFlows()
  78     .then(() => {
  79            remoteWorkflows = $controller.remoteWorkflows.map(item => item.name);
  80            expect(remoteWorkflows).toContain('workflow 1');
  81            expect(remoteWorkflows).toContain('workflow 2');
  82         }
  83      );
  84   });
  85
  86   test('Verify load workflows wont load parameters from local service', () => {
  87     // given
  88     let getWorkflowsStub = Promise.resolve({"data": {"workflows": ["workflow 0"]}});
  89     let getLocalWorkflowsParametersStub = Promise.resolve({"data":{
  90         "parameterDefinitions": [
  91           {
  92             "id": 1,
  93             "name": "Configuration Parameters",
  94             "required": true,
  95             "type": "STRING",
  96             "pattern": ".*",
  97             "msgOnPatternError": null,
  98             "msgOnContentError": null,
  99             "acceptableFileType": null
 100           }
 101         ],
 102       }});
 103     let getSOWorkflowsPromiseStub = Promise.resolve({"data":[{
 104
 105         "id": "ab6478e4-ea33-3346-ac12-ab121484a333",
 106         "workflowName": "inPlaceSoftwareUpdate",
 107         "name": "inPlaceSoftwareUpdate",
 108         "source": "sdc",
 109         "workflowInputParameters": [
 110             {
 111                 "label": "New Software Version",
 112                 "inputType": "text",
 113                 "required": true,
 114                 "soFieldName": "new_software_version",
 115                 "soPayloadLocation": "userParams",
 116                 "validation":[]
 117             }
 118         ]
 119     }]
 120     });
 121
 122     $controller.changeManagement.vnfNames = [{modelVersionId: 'test1', name:'test'}];
 123     $changeManagementService.getWorkflows = () => getWorkflowsStub;
 124     $changeManagementService.getLocalWorkflowParameter = () => getLocalWorkflowsParametersStub;
 125     $changeManagementService.getSOWorkflows = () =>  getSOWorkflowsPromiseStub;
 126     // when
 127     return $controller.loadWorkFlows().then(() => {
 128       expect($controller.workflows).toContain('inPlaceSoftwareUpdate');
 129       expect($controller.localWorkflowsParameters).toBeUndefined();
 130     });
 131   });
 132
 133   test('Verify load workflows will set workflows and parameters', () => {
 134     // given
 135     let getWorkflowsStub = Promise.resolve({"data": {"workflows": ["workflow 0"]}});
 136     let getLocalWorkflowsParametersStub = Promise.resolve({"data": {}});
 137     let getSOWorkflowsPromiseStub = Promise.resolve({"data":[{
 138
 139             "id": "ab6478e4-ea33-3346-ac12-ab121484a333",
 140             "workflowName": "inPlaceSoftwareUpdate",
 141             "name": "inPlaceSoftwareUpdate",
 142             "source": "sdc",
 143           "workflowInputParameters": [
 144             {
 145               "label": "New Software Version",
 146               "inputType": "text",
 147               "required": true,
 148               "soFieldName": "new_software_version",
 149               "soPayloadLocation": "userParams",
 150                 "validation":[]
 151             }
 152           ]
 153         }]
 154       });
 155     $controller.changeManagement.vnfNames = [{modelVersionId: 'test1', name:'test'}];
 156     $changeManagementService.getWorkflows = () => getWorkflowsStub;
 157     $changeManagementService.getLocalWorkflowParameter = () => getLocalWorkflowsParametersStub;
 158     $changeManagementService.getSOWorkflows = () =>  getSOWorkflowsPromiseStub;
 159     $changeManagementService.getSOWorkflowParameter = () =>  getSOWorkflowsParametersPromiseStub;
 160     // when
 161     return $controller.loadWorkFlows()
 162     .then(() => {
 163       expect($controller.workflows).toEqual(["inPlaceSoftwareUpdate"]);
 164       expect($controller.remoteWorkflowsParameters).toEqual(new Map([["inPlaceSoftwareUpdate",
 165         [{
 166           "name": "New Software Version",
 167           "required": true,
 168           "id": "new_software_version",
 169           "soFieldName": "new_software_version",
 170           "maxLength": '500',
 171           "pattern": '.*'
 172         }]]
 173       ]));
 174     });
 175   });
 176
 177   test('Verify load workflows wont load workflows parameters from SO if feature flag is disabled', () => {
 178     // given
 179     $featureFlags.isOn = jestMock.fn(() => false);
 180     let getWorkflowsStub = Promise.resolve({"data": {"workflows": ["workflow 0"]}});
 181     let getLocalWorkflowsParametersStub = Promise.resolve({"data": {}});
 182     let getSOWorkflowsPromiseStub = Promise.resolve({"data": [{"id": "1", "name": "workflow 0"}]});
 183     let getSOWorkflowsParametersPromiseStub = Promise.resolve({"data":{"parameterDefinitions": [
 184           {"id": 1, "name": "parameter 1", "required": true, "type": "STRING", "pattern": "[0-9]*"},
 185           {"id": 2, "name": "parameter 2", "required": true, "type": "STRING", "pattern": ".*"},
 186           {"id": 3, "name": "parameter 3", "required": false, "type": "STRING", "pattern": "[0-9]*"}]}});
 187
 188     $controller.changeManagement.vnfNames = [{name: 'test1'}, {name: "test2"}];
 189     $changeManagementService.getWorkflows = () => getWorkflowsStub;
 190     $changeManagementService.getLocalWorkflowParameter = () => getLocalWorkflowsParametersStub;
 191     $changeManagementService.getSOWorkflows = () =>  getSOWorkflowsPromiseStub;
 192     $changeManagementService.getSOWorkflowParameter = () =>  getSOWorkflowsParametersPromiseStub;
 193     // when
 194     return $controller.loadWorkFlows()
 195     .then(() => {
 196       expect($controller.workflows).toEqual(["workflow 0"]);
 197       expect($controller.remoteWorkflowsParameters).toEqual(undefined);
 198     });
 199   });
 200
 201   test('Verify load workflows will call load workflows parameters from local service', () => {
 202     // given
 203     $featureFlags.isOn = jestMock.fn(() => false);
 204     let getWorkflowsStub = Promise.resolve({"data": {"workflows": ["VNF Scale Out"]}});
 205     let getLocalWorkflowsParametersStub = Promise.resolve({"data":{
 206         "parameterDefinitions": [
 207           {
 208             "id": 1,
 209             "name": "Configuration Parameters",
 210             "required": true,
 211             "type": "STRING",
 212             "pattern": ".*",
 213             "msgOnPatternError": null,
 214             "msgOnContentError": null,
 215             "acceptableFileType": null
 216           }
 217         ],
 218       }});
 219
 220     $controller.changeManagement.vnfNames = [{name: 'test1'}];
 221     $changeManagementService.getWorkflows = () => getWorkflowsStub;
 222     $changeManagementService.getLocalWorkflowParameter = () => getLocalWorkflowsParametersStub;
 223     // when
 224
 225     let result = new Map();
 226     const scaleOutResult = new Map();
 227     scaleOutResult.set("FILE", []);
 228     scaleOutResult.set("STRING", [
 229       {
 230         "acceptableFileType": null,
 231         "id": 1,
 232         "msgOnContentError": null,
 233         "msgOnPatternError": null,
 234         "name": "Configuration Parameters",
 235         "pattern": ".*",
 236         "required": true,
 237         "type": "STRING",
 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": "STRING",
 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", "STRING");
 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": "STRING",
 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 a list if such workflow and type exist', () => {
 322     // given
 323     $featureFlags.isOn = jestMock.fn(() => false);
 324     let getWorkflowsStub = Promise.resolve({"data": {"workflows": ["VNF Scale Out"]}});
 325     let getLocalWorkflowsParametersStub = Promise.resolve({"data":{
 326         "parameterDefinitions": [
 327           {
 328             "id": 1,
 329             "name": "Configuration Parameters",
 330             "required": true,
 331             "type": "STRING",
 332             "pattern": ".*",
 333             "msgOnPatternError": null,
 334             "msgOnContentError": null,
 335             "acceptableFileType": null
 336           }
 337         ],
 338       }});
 339     $controller.changeManagement.vnfNames = [{name: 'test1'}];
 340     $changeManagementService.getWorkflows = () => getWorkflowsStub;
 341     $changeManagementService.getLocalWorkflowParameter = () => getLocalWorkflowsParametersStub;
 342
 343     let result = [{
 344         "acceptableFileType": null,
 345         "id": 1,
 346         "msgOnContentError": null,
 347         "msgOnPatternError": null,
 348         "name": "Configuration Parameters",
 349         "pattern": ".*",
 350         "required": true,
 351         "type": "STRING",
 352         }];
 353     // when
 354     return $controller.loadWorkFlows()
 355     .then(() => {
 356       let internalWorkFlowParameters = $controller.getInternalWorkFlowParameters("VNF Scale Out", "STRING");
 357       expect(internalWorkFlowParameters).toEqual(result);
 358     });
 359   });
 360 });