bpmn/so-bpmn-tasks/src/test/java/org/onap/so/bpmn/infrastructure/aai/tasks/AAIUpdateTasksTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 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 package org.onap.so.bpmn.infrastructure.aai.tasks;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.mockito.Mockito.doNothing;
  25 import static org.mockito.Mockito.doThrow;
  26 import static org.mockito.Mockito.times;
  27 import static org.mockito.Mockito.verify;
  28
  29 import org.camunda.bpm.engine.delegate.BpmnError;
  30 import org.junit.Before;
  31 import org.junit.Test;
  32 import org.onap.so.adapters.nwrest.CreateNetworkResponse;
  33 import org.onap.so.bpmn.BaseTaskTest;
  34 import org.onap.so.bpmn.servicedecomposition.bbobjects.CloudRegion;
  35 import org.onap.so.bpmn.servicedecomposition.bbobjects.Configuration;
  36 import org.onap.so.bpmn.servicedecomposition.bbobjects.GenericVnf;
  37 import org.onap.so.bpmn.servicedecomposition.bbobjects.L3Network;
  38 import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
  39 import org.onap.so.bpmn.servicedecomposition.bbobjects.VfModule;
  40 import org.onap.so.bpmn.servicedecomposition.bbobjects.VolumeGroup;
  41 import org.onap.so.db.catalog.beans.OrchestrationStatus;
  42 import org.springframework.beans.factory.annotation.Autowired;
  43
  44 public class AAIUpdateTasksTest extends BaseTaskTest{
  45         @Autowired
  46         private AAIUpdateTasks aaiUpdateTasks;
  47
  48         private L3Network network;
  49         private ServiceInstance serviceInstance;
  50         private VfModule vfModule;
  51         private GenericVnf genericVnf;
  52         private VolumeGroup volumeGroup;
  53         private CloudRegion cloudRegion;
  54         private Configuration configuration;
  55
  56         @Before
  57         public void before() {
  58                 serviceInstance = setServiceInstance();
  59                 genericVnf = setGenericVnf();
  60                 vfModule = setVfModule();
  61                 volumeGroup = setVolumeGroup();
  62                 cloudRegion = setCloudRegion();
  63                 network = setL3Network();
  64                 configuration = setConfiguration();
  65         }
  66
  67         @Test
  68         public void updateOrchestrationStatusAssignedServiceTest() throws Exception {
  69                 doNothing().when(aaiServiceInstanceResources).updateOrchestrationStatusServiceInstance(serviceInstance, OrchestrationStatus.ASSIGNED);
  70
  71                 aaiUpdateTasks.updateOrchestrationStatusAssignedService(execution);
  72
  73                 verify(aaiServiceInstanceResources, times(1)).updateOrchestrationStatusServiceInstance(serviceInstance, OrchestrationStatus.ASSIGNED);
  74         }
  75
  76         @Test
  77         public void updateOrchestrationStatusAssignedServiceExceptionTest() throws Exception {
  78                 expectedException.expect(BpmnError.class);
  79
  80                 doThrow(Exception.class).when(aaiServiceInstanceResources).updateOrchestrationStatusServiceInstance(serviceInstance, OrchestrationStatus.ASSIGNED);
  81
  82                 aaiUpdateTasks.updateOrchestrationStatusAssignedService(execution);
  83         }
  84
  85         @Test
  86         public void updateOrchestrationStatusActiveServiceTest() throws Exception {
  87                 doNothing().when(aaiServiceInstanceResources).updateOrchestrationStatusServiceInstance(serviceInstance, OrchestrationStatus.ACTIVE);
  88
  89                 aaiUpdateTasks.updateOrchestrationStatusActiveService(execution);
  90
  91                 verify(aaiServiceInstanceResources, times(1)).updateOrchestrationStatusServiceInstance(serviceInstance, OrchestrationStatus.ACTIVE);
  92         }
  93
  94         @Test
  95         public void updateOrchestrationStatusActiveServiceExceptionTest() throws Exception {
  96                 expectedException.expect(BpmnError.class);
  97
  98                 doThrow(Exception.class).when(aaiServiceInstanceResources).updateOrchestrationStatusServiceInstance(serviceInstance, OrchestrationStatus.ACTIVE);
  99
 100                 aaiUpdateTasks.updateOrchestrationStatusActiveService(execution);
 101         }
 102
 103         @Test
 104         public void updateOrchestrationStatusAssignedVnfTest() throws Exception {
 105                 doNothing().when(aaiVnfResources).updateOrchestrationStatusVnf(genericVnf, OrchestrationStatus.ASSIGNED);
 106
 107                 aaiUpdateTasks.updateOrchestrationStatusAssignedVnf(execution);
 108
 109                 verify(aaiVnfResources, times(1)).updateOrchestrationStatusVnf(genericVnf, OrchestrationStatus.ASSIGNED);
 110         }
 111
 112         @Test
 113         public void updateOrchestrationStatusAssignedVnfExceptionTest() throws Exception {
 114                 expectedException.expect(BpmnError.class);
 115
 116                 doThrow(Exception.class).when(aaiVnfResources).updateOrchestrationStatusVnf(genericVnf, OrchestrationStatus.ASSIGNED);
 117
 118                 aaiUpdateTasks.updateOrchestrationStatusAssignedVnf(execution);
 119         }
 120
 121         @Test
 122         public void updateOrchestrationStatusActiveVnfTest() throws Exception {
 123                 doNothing().when(aaiVnfResources).updateOrchestrationStatusVnf(genericVnf, OrchestrationStatus.ACTIVE);
 124
 125                 aaiUpdateTasks.updateOrchestrationStatusActiveVnf(execution);
 126
 127                 verify(aaiVnfResources, times(1)).updateOrchestrationStatusVnf(genericVnf, OrchestrationStatus.ACTIVE);
 128         }
 129
 130         @Test
 131         public void updateOrchestrationStatusActiveVnfExceptionTest() throws Exception {
 132                 expectedException.expect(BpmnError.class);
 133
 134                 doThrow(Exception.class).when(aaiVnfResources).updateOrchestrationStatusVnf(genericVnf, OrchestrationStatus.ACTIVE);
 135
 136                 aaiUpdateTasks.updateOrchestrationStatusActiveVnf(execution);
 137         }
 138
 139         @Test
 140         public void updateOrchestrationStatusAssignVfModuleTest() throws Exception {
 141                 doNothing().when(aaiVfModuleResources).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.ASSIGNED);
 142                 aaiUpdateTasks.updateOrchestrationStatusAssignedVfModule(execution);
 143                 verify(aaiVfModuleResources, times(1)).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.ASSIGNED);
 144                 assertEquals("", vfModule.getHeatStackId());
 145         }
 146
 147         @Test
 148         public void updateOrchestrationStatusAssignVfModuleExceptionTest() throws Exception {
 149                 doThrow(Exception.class).when(aaiVfModuleResources).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.ASSIGNED);
 150
 151                 expectedException.expect(BpmnError.class);
 152
 153                 aaiUpdateTasks.updateOrchestrationStatusAssignedVfModule(execution);
 154         }
 155
 156         @Test
 157         public void updateOrchestrationStatusCreatedVfModuleTest() throws Exception {
 158                 doNothing().when(aaiVfModuleResources).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.CREATED);
 159                 aaiUpdateTasks.updateOrchestrationStatusCreatedVfModule(execution);
 160                 verify(aaiVfModuleResources, times(1)).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.CREATED);
 161         }
 162
 163         @Test
 164         public void updateOrchestrationStatusCreatedVfModuleExceptionTest() throws Exception {
 165                 doThrow(Exception.class).when(aaiVfModuleResources).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.CREATED);
 166
 167                 expectedException.expect(BpmnError.class);
 168
 169                 aaiUpdateTasks.updateOrchestrationStatusCreatedVfModule(execution);
 170         }
 171
 172         @Test
 173         public void updateOrchestrationStatusPendingActivatefModuleTest() throws Exception {
 174                 doNothing().when(aaiVfModuleResources).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.PENDING_ACTIVATION);
 175
 176                 aaiUpdateTasks.updateOrchestrationStatusPendingActivationVfModule(execution);
 177
 178                 verify(aaiVfModuleResources, times(1)).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.PENDING_ACTIVATION);
 179         }
 180
 181         @Test
 182         public void updateOrchestrationStatusPendingActivatefModuleExceptionTest() throws Exception {
 183                 doThrow(Exception.class).when(aaiVfModuleResources).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.PENDING_ACTIVATION);
 184
 185                 expectedException.expect(BpmnError.class);
 186
 187                 aaiUpdateTasks.updateOrchestrationStatusPendingActivationVfModule(execution);
 188         }
 189
 190         @Test
 191         public void updateOrchestrationStatusDectivateVfModuleTest() throws Exception {
 192                 doNothing().when(aaiVfModuleResources).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.CREATED);
 193
 194                 aaiUpdateTasks.updateOrchestrationStatusDeactivateVfModule(execution);
 195
 196                 verify(aaiVfModuleResources, times(1)).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.CREATED);
 197         }
 198
 199         @Test
 200         public void updateOrchestrationStatusDectivateVfModuleExceptionTest() throws Exception {
 201                 doThrow(Exception.class).when(aaiVfModuleResources).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.CREATED);
 202
 203                 expectedException.expect(BpmnError.class);
 204
 205                 aaiUpdateTasks.updateOrchestrationStatusDeactivateVfModule(execution);
 206         }
 207
 208         @Test
 209         public void updateHeatStackIdVfModuleTest() throws Exception {
 210                 execution.setVariable("heatStackId", "newHeatStackId");
 211                 doNothing().when(aaiVfModuleResources).updateHeatStackIdVfModule(vfModule, genericVnf);
 212
 213                 aaiUpdateTasks.updateHeatStackIdVfModule(execution);
 214
 215                 verify(aaiVfModuleResources, times(1)).updateHeatStackIdVfModule(vfModule, genericVnf);
 216                 assertEquals("newHeatStackId", vfModule.getHeatStackId());
 217         }
 218
 219         @Test
 220         public void updateHeatStackIdVfModuleExceptionTest() throws Exception {
 221                 doThrow(Exception.class).when(aaiVfModuleResources).updateHeatStackIdVfModule(vfModule, genericVnf);
 222
 223                 expectedException.expect(BpmnError.class);
 224
 225                 aaiUpdateTasks.updateHeatStackIdVfModule(execution);
 226         }
 227
 228         @Test
 229         public void updateOrchestrationStatusActiveVolumeGroupTest() throws Exception {
 230                 doNothing().when(aaiVolumeGroupResources).updateOrchestrationStatusVolumeGroup(volumeGroup, cloudRegion, OrchestrationStatus.ACTIVE);
 231
 232                 aaiUpdateTasks.updateOrchestrationStatusActiveVolumeGroup(execution);
 233
 234                 verify(aaiVolumeGroupResources, times(1)).updateOrchestrationStatusVolumeGroup(volumeGroup, cloudRegion, OrchestrationStatus.ACTIVE);
 235         }
 236
 237         @Test
 238         public void updateOrchestrationStatusActiveVolumeGroupExceptionTest() throws Exception {
 239                 expectedException.expect(BpmnError.class);
 240                 doThrow(Exception.class).when(aaiVolumeGroupResources).updateOrchestrationStatusVolumeGroup(volumeGroup, cloudRegion, OrchestrationStatus.ACTIVE);
 241                 aaiUpdateTasks.updateOrchestrationStatusActiveVolumeGroup(execution);
 242         }
 243
 244         @Test
 245         public void updateOrchestrationStatusCreatedVolumeGroupTest() throws Exception {
 246                 doNothing().when(aaiVolumeGroupResources).updateOrchestrationStatusVolumeGroup(volumeGroup, cloudRegion, OrchestrationStatus.CREATED);
 247
 248                 aaiUpdateTasks.updateOrchestrationStatusCreatedVolumeGroup(execution);
 249
 250                 verify(aaiVolumeGroupResources, times(1)).updateOrchestrationStatusVolumeGroup(volumeGroup, cloudRegion, OrchestrationStatus.CREATED);
 251         }
 252
 253         @Test
 254         public void updateOrchestrationStatusCreatedVolumeGroupExceptionTest() throws Exception {
 255                 expectedException.expect(BpmnError.class);
 256                 doThrow(Exception.class).when(aaiVolumeGroupResources).updateOrchestrationStatusVolumeGroup(volumeGroup, cloudRegion, OrchestrationStatus.CREATED);
 257                 aaiUpdateTasks.updateOrchestrationStatusCreatedVolumeGroup(execution);
 258         }
 259
 260         @Test
 261         public void test_updateOrchestrationStatusAssignedVolumeGroup() throws Exception {
 262                 doNothing().when(aaiVolumeGroupResources).updateOrchestrationStatusVolumeGroup(volumeGroup, cloudRegion, OrchestrationStatus.ASSIGNED);
 263
 264                 aaiUpdateTasks.updateOrchestrationStatusAssignedVolumeGroup(execution);
 265
 266                 verify(aaiVolumeGroupResources, times(1)).updateOrchestrationStatusVolumeGroup(volumeGroup, cloudRegion, OrchestrationStatus.ASSIGNED);
 267                 assertEquals("", volumeGroup.getHeatStackId());
 268         }
 269
 270         @Test
 271         public void test_updateOrchestrationStatusAssignedVolumeGroup_exception() throws Exception {
 272                 expectedException.expect(BpmnError.class);
 273                 doThrow(Exception.class).when(aaiVolumeGroupResources).updateOrchestrationStatusVolumeGroup(volumeGroup, cloudRegion, OrchestrationStatus.ASSIGNED);
 274                 aaiUpdateTasks.updateOrchestrationStatusAssignedVolumeGroup(execution);
 275         }
 276         @Test
 277         public void updateHeatStackIdVolumeGroupTest() throws Exception {
 278                 execution.setVariable("heatStackId", "newHeatStackId");
 279                 doNothing().when(aaiVolumeGroupResources).updateHeatStackIdVolumeGroup(volumeGroup, cloudRegion);
 280
 281                 aaiUpdateTasks.updateHeatStackIdVolumeGroup(execution);
 282
 283                 verify(aaiVolumeGroupResources, times(1)).updateHeatStackIdVolumeGroup(volumeGroup, cloudRegion);
 284                 assertEquals("newHeatStackId", volumeGroup.getHeatStackId());
 285         }
 286
 287         @Test
 288         public void updateHeatStackIdVolumeGroupExceptionTest() throws Exception {
 289                 expectedException.expect(BpmnError.class);
 290                 doThrow(Exception.class).when(aaiVolumeGroupResources).updateHeatStackIdVolumeGroup(volumeGroup, cloudRegion);
 291                 aaiUpdateTasks.updateHeatStackIdVolumeGroup(execution);
 292         }
 293
 294         @Test
 295         public void updateOstatusAssignedNetworkTest() throws Exception {
 296                 doNothing().when(aaiNetworkResources).updateNetwork(network);
 297
 298                 aaiUpdateTasks.updateOrchestrationStatusAssignedNetwork(execution);
 299
 300                 verify(aaiNetworkResources, times(1)).updateNetwork(network);
 301                 assertEquals("", network.getHeatStackId());
 302         }
 303
 304         @Test
 305         public void updateOstatusAssignedNetworkExceptionTest() throws Exception {
 306                 expectedException.expect(BpmnError.class);
 307
 308                 doThrow(Exception.class).when(aaiNetworkResources).updateNetwork(network);
 309
 310                 aaiUpdateTasks.updateOrchestrationStatusAssignedNetwork(execution);
 311         }
 312
 313         @Test
 314         public void updateOstatusActivedNetworkTest() throws Exception {
 315                 doNothing().when(aaiNetworkResources).updateNetwork(network);
 316
 317                 aaiUpdateTasks.updateOrchestrationStatusActiveNetwork(execution);
 318
 319                 verify(aaiNetworkResources, times(1)).updateNetwork(network);
 320         }
 321
 322         @Test
 323         public void updateOstatusCreatedNetworkTest() throws Exception {
 324                 doNothing().when(aaiNetworkResources).updateNetwork(network);
 325
 326                 aaiUpdateTasks.updateOrchestrationStatusActiveNetwork(execution);
 327
 328                 verify(aaiNetworkResources, times(1)).updateNetwork(network);
 329         }
 330
 331         @Test
 332         public void updateOstatusActiveNetworkExceptionTest() throws Exception {
 333                 expectedException.expect(BpmnError.class);
 334
 335                 doThrow(Exception.class).when(aaiNetworkResources).updateNetwork(network);
 336
 337                 aaiUpdateTasks.updateOrchestrationStatusActiveNetwork(execution);
 338         }
 339
 340         @Test
 341         public void updateOstatusActivedNetworkCollectionTest() throws Exception {
 342                 doNothing().when(aaiCollectionResources).updateCollection(serviceInstance.getCollection());
 343                 aaiUpdateTasks.updateOrchestrationStatusActiveNetworkCollection(execution);
 344                 verify(aaiCollectionResources, times(1)).updateCollection(serviceInstance.getCollection());
 345         }
 346
 347         @Test
 348         public void updateOstatusActiveNetworkColectionExceptionTest() throws Exception {
 349                 expectedException.expect(BpmnError.class);
 350                 doThrow(Exception.class).when(aaiCollectionResources).updateCollection(serviceInstance.getCollection());
 351                 aaiUpdateTasks.updateOrchestrationStatusActiveNetworkCollection(execution);
 352         }
 353
 354         @Test
 355         public void updateOrchestrationStatusActivateVfModuleTest() throws Exception {
 356                 doNothing().when(aaiVfModuleResources).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.ACTIVE);
 357
 358                 aaiUpdateTasks.updateOrchestrationStatusActivateVfModule(execution);
 359
 360                 verify(aaiVfModuleResources, times(1)).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.ACTIVE);
 361         }
 362
 363         @Test
 364         public void updateOrchestrationStatusActivateVfModuleExceptionTest() throws Exception {
 365                 doThrow(Exception.class).when(aaiVfModuleResources).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.ACTIVE);
 366
 367                 expectedException.expect(BpmnError.class);
 368
 369                 aaiUpdateTasks.updateOrchestrationStatusActivateVfModule(execution);
 370         }
 371
 372         @Test
 373         public void updateNetworkCreatedTest() throws Exception {
 374                 CreateNetworkResponse createNetworkResponse = new CreateNetworkResponse();
 375                 createNetworkResponse.setNetworkFqdn("testNetworkFqdn");
 376                 createNetworkResponse.setNetworkStackId("testNetworkStackId");
 377
 378                 execution.setVariable("createNetworkResponse", createNetworkResponse);
 379
 380                 doNothing().when(aaiNetworkResources).updateNetwork(network);
 381                 aaiUpdateTasks.updateNetworkCreated(execution);
 382                 verify(aaiNetworkResources, times(1)).updateNetwork(network);
 383
 384                 assertEquals(createNetworkResponse.getNetworkFqdn(), network.getContrailNetworkFqdn());
 385                 assertEquals(OrchestrationStatus.CREATED, network.getOrchestrationStatus());
 386                 assertEquals(createNetworkResponse.getNetworkStackId(), network.getHeatStackId());
 387                 assertEquals(createNetworkResponse.getNeutronNetworkId(), network.getNeutronNetworkId());
 388         }
 389
 390         @Test
 391         public void updateNetworkCreatedkExceptionTest() throws Exception {
 392                 expectedException.expect(BpmnError.class);
 393                 doThrow(Exception.class).when(aaiNetworkResources).updateNetwork(network);
 394                 aaiUpdateTasks.updateNetworkCreated(execution);
 395         }
 396
 397         @Test
 398         public void updateObjectNetworkTest() {
 399                 doNothing().when(aaiNetworkResources).updateNetwork(network);
 400
 401                 aaiUpdateTasks.updateObjectNetwork(execution);
 402
 403                 verify(aaiNetworkResources, times(1)).updateNetwork(network);
 404         }
 405
 406         @Test
 407         public void updateObjectNetworkExceptionText() {
 408                 expectedException.expect(BpmnError.class);
 409
 410                 doThrow(Exception.class).when(aaiNetworkResources).updateNetwork(network);
 411
 412                 aaiUpdateTasks.updateObjectNetwork(execution);
 413         }
 414
 415         @Test
 416         public void test_updateServiceInstance() {
 417                 doNothing().when(aaiServiceInstanceResources).updateServiceInstance(serviceInstance);
 418                 aaiUpdateTasks.updateServiceInstance(execution);
 419                 verify(aaiServiceInstanceResources, times(1)).updateServiceInstance(serviceInstance);
 420         }
 421
 422         @Test
 423         public void test_updateServiceInstance_exception() {
 424                 expectedException.expect(BpmnError.class);
 425                 doThrow(Exception.class).when(aaiServiceInstanceResources).updateServiceInstance(serviceInstance);
 426                 aaiUpdateTasks.updateServiceInstance(execution);
 427         }
 428
 429         @Test
 430         public void updateObjectVnfTest() {
 431                 doNothing().when(aaiVnfResources).updateObjectVnf(genericVnf);
 432
 433                 aaiUpdateTasks.updateObjectVnf(execution);
 434
 435                 verify(aaiVnfResources, times(1)).updateObjectVnf(genericVnf);
 436         }
 437
 438         @Test
 439         public void updateObjectVnfExceptionTest() {
 440                 expectedException.expect(BpmnError.class);
 441                 doThrow(Exception.class).when(aaiVnfResources).updateObjectVnf(genericVnf);
 442                 aaiUpdateTasks.updateObjectVnf(execution);
 443         }
 444
 445         @Test
 446         public void updateOrchestrationStatusDeleteVfModuleTest() throws Exception {
 447                 doNothing().when(aaiVfModuleResources).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.ASSIGNED);
 448
 449                 aaiUpdateTasks.updateOrchestrationStatusDeleteVfModule(execution);
 450
 451                 verify(aaiVfModuleResources, times(1)).updateOrchestrationStatusVfModule(vfModule, genericVnf, OrchestrationStatus.ASSIGNED);
 452                 assertEquals("", vfModule.getHeatStackId());
 453         }
 454
 455         @Test
 456         public void updateModelVfModuleTest() {
 457                 doNothing().when(aaiVfModuleResources).changeAssignVfModule(vfModule, genericVnf);
 458                 aaiUpdateTasks.updateModelVfModule(execution);
 459                 verify(aaiVfModuleResources, times(1)).changeAssignVfModule(vfModule, genericVnf);
 460         }
 461
 462         @Test
 463         public void updateModelVfModuleExceptionTest() {
 464                 expectedException.expect(BpmnError.class);
 465                 doThrow(Exception.class).when(aaiVfModuleResources).changeAssignVfModule(vfModule, genericVnf);
 466                 aaiUpdateTasks.updateModelVfModule(execution);
 467         }
 468
 469         @Test
 470         public void updateOrchestrationStatusDeactivateFabricConfigurationTest() throws Exception {
 471                 gBBInput = execution.getGeneralBuildingBlock();
 472                 doNothing().when(aaiConfigurationResources).updateOrchestrationStatusConfiguration(configuration, OrchestrationStatus.ASSIGNED);
 473
 474                 aaiUpdateTasks.updateOrchestrationStatusDeactivateFabricConfiguration(execution);
 475
 476                 verify(aaiConfigurationResources, times(1)).updateOrchestrationStatusConfiguration(configuration, OrchestrationStatus.ASSIGNED);
 477         }
 478         @Test
 479         public void updateOrchestrationStatusActivateFabricConfigurationTest() throws Exception {
 480                 gBBInput = execution.getGeneralBuildingBlock();
 481                 doNothing().when(aaiConfigurationResources).updateOrchestrationStatusConfiguration(configuration, OrchestrationStatus.ACTIVE);
 482
 483                 aaiUpdateTasks.updateOrchestrationStatusActivateFabricConfiguration(execution);
 484
 485                 verify(aaiConfigurationResources, times(1)).updateOrchestrationStatusConfiguration(configuration, OrchestrationStatus.ACTIVE);
 486         }
 487 }