bpmn/so-bpmn-tasks/src/test/java/org/onap/so/bpmn/infrastructure/aai/tasks/AAICreateTasksTest.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 package org.onap.so.bpmn.infrastructure.aai.tasks;
  21
  22 import static org.junit.Assert.assertEquals;
  23 import static org.mockito.ArgumentMatchers.any;
  24 import static org.mockito.ArgumentMatchers.eq;
  25 import static org.mockito.Mockito.doNothing;
  26 import static org.mockito.Mockito.doReturn;
  27 import static org.mockito.Mockito.doThrow;
  28 import static org.mockito.Mockito.never;
  29 import static org.mockito.Mockito.times;
  30 import static org.mockito.Mockito.verify;
  31 import static org.mockito.Mockito.when;
  32
  33 import java.util.Arrays;
  34 import java.util.Optional;
  35 import java.util.TreeSet;
  36
  37 import org.camunda.bpm.engine.delegate.BpmnError;
  38 import org.junit.Before;
  39 import org.junit.Rule;
  40 import org.junit.Test;
  41 import org.junit.rules.ExpectedException;
  42 import org.mockito.ArgumentCaptor;
  43 import org.mockito.ArgumentMatchers;
  44 import org.mockito.Captor;
  45 import org.mockito.InjectMocks;
  46 import org.onap.so.bpmn.BaseTaskTest;
  47 import org.onap.so.bpmn.common.BuildingBlockExecution;
  48 import org.onap.so.bpmn.servicedecomposition.bbobjects.CloudRegion;
  49 import org.onap.so.bpmn.servicedecomposition.bbobjects.Configuration;
  50 import org.onap.so.bpmn.servicedecomposition.bbobjects.Customer;
  51 import org.onap.so.bpmn.servicedecomposition.bbobjects.GenericVnf;
  52 import org.onap.so.bpmn.servicedecomposition.bbobjects.InstanceGroup;
  53 import org.onap.so.bpmn.servicedecomposition.bbobjects.L3Network;
  54 import org.onap.so.bpmn.servicedecomposition.bbobjects.NetworkPolicy;
  55 import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
  56 import org.onap.so.bpmn.servicedecomposition.bbobjects.VfModule;
  57 import org.onap.so.bpmn.servicedecomposition.bbobjects.VolumeGroup;
  58 import org.onap.so.bpmn.servicedecomposition.entities.ResourceKey;
  59 import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoGenericVnf;
  60 import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoVfModule;
  61 import org.onap.so.client.exception.BBObjectNotFoundException;
  62 import org.onap.so.db.catalog.beans.OrchestrationStatus;
  63 import org.onap.so.client.aai.entities.uri.AAIResourceUri;
  64
  65 public class AAICreateTasksTest extends BaseTaskTest{
  66
  67         @InjectMocks
  68         private AAICreateTasks aaiCreateTasks = new AAICreateTasks();
  69
  70
  71         private ServiceInstance serviceInstance;
  72         private L3Network network;
  73         private GenericVnf genericVnf;
  74         private VolumeGroup volumeGroup;
  75         private CloudRegion cloudRegion;
  76         private VfModule vfModule;
  77         private Customer customer;
  78         private Configuration configuration;
  79         private InstanceGroup instanceGroup;
  80
  81         @Captor
  82         ArgumentCaptor<NetworkPolicy> networkPolicyCaptor;
  83
  84         @Rule
  85         public final ExpectedException exception = ExpectedException.none();
  86
  87         @Before
  88         public void before() throws BBObjectNotFoundException {
  89                 customer = setCustomer();
  90                 serviceInstance = setServiceInstance();
  91                 network = setL3Network();
  92                 genericVnf = setGenericVnf();
  93                 volumeGroup = setVolumeGroup();
  94                 cloudRegion = setCloudRegion();
  95                 vfModule = setVfModule();
  96                 configuration = setConfiguration();
  97                 instanceGroup = setInstanceGroupVnf();
  98
  99                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.GENERIC_VNF_ID))).thenReturn(genericVnf);
 100                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.VF_MODULE_ID))).thenReturn(vfModule);
 101                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.NETWORK_ID))).thenReturn(network);
 102                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.VOLUME_GROUP_ID))).thenReturn(volumeGroup);
 103                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.SERVICE_INSTANCE_ID))).thenReturn(serviceInstance);
 104                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.CONFIGURATION_ID))).thenReturn(configuration);
 105                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.INSTANCE_GROUP_ID))).thenReturn(instanceGroup);
 106
 107
 108                 doThrow(new BpmnError("BPMN Error")).when(exceptionUtil).buildAndThrowWorkflowException(any(BuildingBlockExecution.class), eq(7000), any(Exception.class));
 109                 doThrow(new BpmnError("BPMN Error")).when(exceptionUtil).buildAndThrowWorkflowException(any(BuildingBlockExecution.class), eq(7000), any(String.class));
 110
 111         }
 112
 113         @Test
 114         public void createServiceInstanceTest() throws Exception {
 115                 doNothing().when(aaiServiceInstanceResources).createServiceInstance(serviceInstance, customer);
 116                 aaiCreateTasks.createServiceInstance(execution);
 117                 verify(aaiServiceInstanceResources, times(1)).createServiceInstance(serviceInstance, customer);
 118         }
 119
 120         @Test
 121         public void createServiceInstanceExceptionTest() throws Exception {
 122                 expectedException.expect(BpmnError.class);
 123
 124                 lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "notfound");
 125                 doThrow(RuntimeException.class).when(aaiServiceInstanceResources).createServiceInstance(serviceInstance, customer);
 126                 aaiCreateTasks.createServiceInstance(execution);
 127         }
 128
 129         @Test
 130         public void createVolumeGroupTest() throws Exception {
 131                 volumeGroup.setOrchestrationStatus(OrchestrationStatus.PRECREATED);
 132
 133                 doNothing().when(aaiVolumeGroupResources).createVolumeGroup(volumeGroup, cloudRegion);
 134                 doNothing().when(aaiVolumeGroupResources).connectVolumeGroupToVnf(genericVnf, volumeGroup, cloudRegion);
 135
 136                 aaiCreateTasks.createVolumeGroup(execution);
 137
 138                 verify(aaiVolumeGroupResources, times(1)).createVolumeGroup(volumeGroup, cloudRegion);
 139                 verify(aaiVolumeGroupResources, times(1)).connectVolumeGroupToVnf(genericVnf, volumeGroup, cloudRegion);
 140                 verify(aaiVolumeGroupResources, times(1)).connectVolumeGroupToTenant(volumeGroup, cloudRegion);
 141         }
 142
 143         @Test
 144         public void createVolumeGroupExceptionTest() throws Exception {
 145                 expectedException.expect(BpmnError.class);
 146
 147                 volumeGroup.setOrchestrationStatus(OrchestrationStatus.PRECREATED);
 148
 149                 doThrow(RuntimeException.class).when(aaiVolumeGroupResources).createVolumeGroup(volumeGroup, cloudRegion);
 150
 151                 aaiCreateTasks.createVolumeGroup(execution);
 152         }
 153
 154         @Test
 155         public void createProjectTest() throws Exception {
 156                 doNothing().when(aaiServiceInstanceResources).createProjectandConnectServiceInstance(serviceInstance.getProject(), serviceInstance);
 157                 aaiCreateTasks.createProject(execution);
 158                 verify(aaiServiceInstanceResources, times(1)).createProjectandConnectServiceInstance(serviceInstance.getProject(), serviceInstance);
 159         }
 160
 161         @Test
 162         public void createPlatformTest() throws Exception {
 163                 doNothing().when(aaiVnfResources).createPlatformandConnectVnf(genericVnf.getPlatform(), genericVnf);
 164                 aaiCreateTasks.createPlatform(execution);
 165                 verify(aaiVnfResources, times(1)).createPlatformandConnectVnf(genericVnf.getPlatform(), genericVnf);
 166         }
 167
 168         @Test
 169         public void createLineOfBusinessTest() throws Exception {
 170                 doNothing().when(aaiVnfResources).createLineOfBusinessandConnectVnf(genericVnf.getLineOfBusiness(), genericVnf);
 171                 aaiCreateTasks.createLineOfBusiness(execution);
 172                 verify(aaiVnfResources, times(1)).createLineOfBusinessandConnectVnf(genericVnf.getLineOfBusiness(), genericVnf);
 173         }
 174
 175         @Test
 176         public void createProjectExceptionTest() throws Exception {
 177                 expectedException.expect(BpmnError.class);
 178
 179                 lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "notfound");
 180                 doThrow(RuntimeException.class).when(aaiServiceInstanceResources).createProjectandConnectServiceInstance(serviceInstance.getProject(), serviceInstance);
 181                 aaiCreateTasks.createProject(execution);
 182         }
 183
 184         @Test
 185         public void createProjectNullProjectNameTest() throws Exception {
 186                 serviceInstance.getProject().setProjectName(null);
 187                 doNothing().when(aaiServiceInstanceResources).createProjectandConnectServiceInstance(serviceInstance.getProject(), serviceInstance);
 188                 aaiCreateTasks.createProject(execution);
 189                 verify(aaiServiceInstanceResources, times(0)).createProjectandConnectServiceInstance(serviceInstance.getProject(), serviceInstance);
 190         }
 191
 192         @Test
 193         public void createProjectEmptyProjectNameTest() throws Exception {
 194                 serviceInstance.getProject().setProjectName("");
 195                 doNothing().when(aaiServiceInstanceResources).createProjectandConnectServiceInstance(serviceInstance.getProject(), serviceInstance);
 196                 aaiCreateTasks.createProject(execution);
 197                 verify(aaiServiceInstanceResources, times(0)).createProjectandConnectServiceInstance(serviceInstance.getProject(), serviceInstance);
 198         }
 199
 200         @Test
 201         public void createOwningEntityTest() throws Exception {
 202                 doReturn(true).when(aaiServiceInstanceResources).existsOwningEntity(serviceInstance.getOwningEntity());
 203                 doNothing().when(aaiServiceInstanceResources).connectOwningEntityandServiceInstance(serviceInstance.getOwningEntity(),serviceInstance);
 204                 aaiCreateTasks.createOwningEntity(execution);
 205                 verify(aaiServiceInstanceResources, times(1)).existsOwningEntity(serviceInstance.getOwningEntity());
 206                 verify(aaiServiceInstanceResources, times(1)).connectOwningEntityandServiceInstance(serviceInstance.getOwningEntity(), serviceInstance);
 207         }
 208
 209         @Test
 210         public void createOwningEntityNotExistsOwningEntityTest() throws Exception {
 211                 doReturn(false).when(aaiServiceInstanceResources).existsOwningEntity(serviceInstance.getOwningEntity());
 212                 doNothing().when(aaiServiceInstanceResources).createOwningEntityandConnectServiceInstance(serviceInstance.getOwningEntity(),serviceInstance);
 213                 aaiCreateTasks.createOwningEntity(execution);
 214                 verify(aaiServiceInstanceResources, times(1)).existsOwningEntity(serviceInstance.getOwningEntity());
 215                 verify(aaiServiceInstanceResources, times(1)).createOwningEntityandConnectServiceInstance(serviceInstance.getOwningEntity(), serviceInstance);
 216         }
 217
 218         @Test
 219         public void createOwningEntityNullOwningEntityIdTest() throws Exception {
 220                 expectedException.expect(BpmnError.class);
 221
 222                 serviceInstance.getOwningEntity().setOwningEntityId(null);
 223
 224                 aaiCreateTasks.createOwningEntity(execution);
 225         }
 226
 227         @Test
 228         public void createOwningEntityEmptyOwningEntityIdTest() throws Exception {
 229                 expectedException.expect(BpmnError.class);
 230
 231                 serviceInstance.getOwningEntity().setOwningEntityId("");
 232
 233                 aaiCreateTasks.createOwningEntity(execution);
 234         }
 235
 236         @Test
 237         public void createOwningEntityNullOwningEntityNameTest() throws Exception {
 238                 expectedException.expect(BpmnError.class);
 239
 240                 serviceInstance.getOwningEntity().setOwningEntityName(null);
 241
 242                 doReturn(false).when(aaiServiceInstanceResources).existsOwningEntity(serviceInstance.getOwningEntity());
 243
 244                 aaiCreateTasks.createOwningEntity(execution);
 245         }
 246
 247         @Test
 248         public void createOwningEntityEmptyOwningEntityNameTest() throws Exception {
 249                 expectedException.expect(BpmnError.class);
 250
 251                 serviceInstance.getOwningEntity().setOwningEntityName("");
 252
 253                 doReturn(false).when(aaiServiceInstanceResources).existsOwningEntity(serviceInstance.getOwningEntity());
 254
 255                 aaiCreateTasks.createOwningEntity(execution);
 256         }
 257
 258         @Test
 259         public void createOwningEntityExceptionTest() throws Exception {
 260                 expectedException.expect(BpmnError.class);
 261
 262                 doReturn(true).when(aaiServiceInstanceResources).existsOwningEntity(serviceInstance.getOwningEntity());
 263
 264                 doThrow(RuntimeException.class).when(aaiServiceInstanceResources).connectOwningEntityandServiceInstance(serviceInstance.getOwningEntity(), serviceInstance);
 265
 266                 aaiCreateTasks.createOwningEntity(execution);
 267         }
 268
 269         @Test
 270         public void createVnfTest() throws Exception {
 271                 doNothing().when(aaiVnfResources).createVnfandConnectServiceInstance(genericVnf, serviceInstance);
 272                 aaiCreateTasks.createVnf(execution);
 273                 verify(aaiVnfResources, times(1)).createVnfandConnectServiceInstance(genericVnf, serviceInstance);
 274         }
 275
 276         @Test
 277         public void createVnfExceptionTest() throws Exception {
 278                 expectedException.expect(BpmnError.class);
 279                 lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "notfound");
 280                 doThrow(BBObjectNotFoundException.class).when(extractPojosForBB).extractByKey(any(),ArgumentMatchers.eq(ResourceKey.GENERIC_VNF_ID));
 281                 doNothing().when(aaiVnfResources).createVnfandConnectServiceInstance(genericVnf, serviceInstance);
 282                 aaiCreateTasks.createVnf(execution);
 283                 verify(aaiVnfResources, times(1)).createVnfandConnectServiceInstance(genericVnf, serviceInstance);
 284         }
 285
 286
 287         @Test
 288         public void createVfModuleTest() throws Exception {
 289
 290                 VfModule newVfModule = setVfModule(false);
 291                 newVfModule.setModuleIndex(null);
 292                 newVfModule.getModelInfoVfModule().setModelInvariantUUID("testModelInvariantUUID1");
 293                 doNothing().when(aaiVfModuleResources).createVfModule(newVfModule, genericVnf);
 294                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.VF_MODULE_ID))).thenReturn(newVfModule);
 295
 296                 assertEquals(null, newVfModule.getModuleIndex());
 297                 aaiCreateTasks.createVfModule(execution);
 298                 assertEquals(1, newVfModule.getModuleIndex().intValue());
 299                 verify(aaiVfModuleResources, times(1)).createVfModule(newVfModule, genericVnf);
 300         }
 301
 302         @Test
 303     public void createServiceSubscriptionTest(){
 304             doNothing().when(aaiServiceInstanceResources).createServiceSubscription(customer);
 305             aaiCreateTasks.createServiceSubscription(execution);
 306             verify(aaiServiceInstanceResources, times(1)).createServiceSubscription(customer);
 307     }
 308
 309     @Test
 310     public void createServiceSubscriptionTestExceptionHandling(){
 311         expectedException.expect(BpmnError.class);
 312         doThrow(RuntimeException.class).when(aaiServiceInstanceResources).createServiceSubscription(customer);
 313         aaiCreateTasks.createServiceSubscription(execution);
 314     }
 315
 316     @Test
 317     public void createServiceSubscriptionTestCustomerIsNull(){
 318         expectedException.expect(BpmnError.class);
 319         gBBInput.setCustomer(null);
 320         aaiCreateTasks.createServiceSubscription(execution);
 321     }
 322
 323         @Test
 324         public void createVfModuleExceptionTest() throws Exception {
 325                 expectedException.expect(BpmnError.class);
 326
 327                 doThrow(RuntimeException.class).when(aaiVfModuleResources).createVfModule(vfModule, genericVnf);
 328                 aaiCreateTasks.createVfModule(execution);
 329         }
 330
 331         @Test
 332         public void connectVfModuleToVolumeGroupTest() throws Exception {
 333                 doNothing().when(aaiVfModuleResources).connectVfModuleToVolumeGroup(genericVnf, vfModule, volumeGroup, cloudRegion);
 334                 aaiCreateTasks.connectVfModuleToVolumeGroup(execution);
 335                 verify(aaiVfModuleResources, times(1)).connectVfModuleToVolumeGroup(genericVnf, vfModule, volumeGroup, cloudRegion);
 336         }
 337
 338         @Test
 339         public void createNetworkTest() throws Exception {
 340                 network.getModelInfoNetwork().setNeutronNetworkType("PROVIDER");
 341
 342                 doNothing().when(aaiNetworkResources).createNetworkConnectToServiceInstance(network,serviceInstance);
 343                 aaiCreateTasks.createNetwork(execution);
 344                 verify(aaiNetworkResources, times(1)).createNetworkConnectToServiceInstance(network, serviceInstance);
 345         }
 346
 347         @Test
 348         public void createNetworkExceptionTest() throws Exception {
 349                 expectedException.expect(BpmnError.class);
 350
 351                 lookupKeyMap.put(ResourceKey.NETWORK_ID, "notfound");
 352                 doThrow(RuntimeException.class).when(aaiNetworkResources).createNetworkConnectToServiceInstance(network,serviceInstance);
 353                 aaiCreateTasks.createNetwork(execution);
 354         }
 355
 356         @Test
 357         public void createCustomerTest() throws Exception {
 358                 doNothing().when(aaiVpnBindingResources).createCustomer(customer);
 359
 360                 aaiCreateTasks.createCustomer(execution);
 361
 362                 verify(aaiVpnBindingResources, times(1)).createCustomer(customer);
 363         }
 364
 365         @Test
 366         public void createCustomerExceptionTest() throws Exception {
 367                 expectedException.expect(BpmnError.class);
 368
 369                 doThrow(RuntimeException.class).when(aaiVpnBindingResources).createCustomer(customer);
 370
 371                 aaiCreateTasks.createCustomer(execution);
 372         }
 373
 374         @Test
 375         public void createNetworkCollectionTest() throws Exception {
 376                 doNothing().when(aaiNetworkResources).createNetworkCollection(serviceInstance.getCollection());
 377                 execution.setVariable("networkCollectionName", "testNetworkCollectionName");
 378                 aaiCreateTasks.createNetworkCollection(execution);
 379                 verify(aaiNetworkResources, times(1)).createNetworkCollection(serviceInstance.getCollection());
 380         }
 381
 382         @Test
 383         public void createNetworkCollectionInstanceGroupTest() throws Exception {
 384                 doNothing().when(aaiNetworkResources).createNetworkInstanceGroup(serviceInstance.getCollection().getInstanceGroup());
 385                 aaiCreateTasks.createNetworkCollectionInstanceGroup(execution);
 386                 verify(aaiNetworkResources, times(1)).createNetworkInstanceGroup(serviceInstance.getCollection().getInstanceGroup());
 387         }
 388
 389         @Test
 390         public void connectNetworkToNetworkCollectionServiceInstanceTest() throws Exception {
 391                 doNothing().when(aaiNetworkResources).connectNetworkToNetworkCollectionServiceInstance(network, serviceInstance);
 392                 aaiCreateTasks.connectNetworkToNetworkCollectionServiceInstance(execution);
 393                 verify(aaiNetworkResources, times(1)).connectNetworkToNetworkCollectionServiceInstance(network, serviceInstance);
 394         }
 395
 396         @Test
 397         public void connectNetworkToNetworkCollectionInstanceGroupTest() throws Exception {
 398                 doNothing().when(aaiNetworkResources).connectNetworkToNetworkCollectionInstanceGroup(network, serviceInstance.getCollection().getInstanceGroup());
 399                 aaiCreateTasks.connectNetworkToNetworkCollectionInstanceGroup(execution);
 400                 verify(aaiNetworkResources, times(1)).connectNetworkToNetworkCollectionInstanceGroup(network, serviceInstance.getCollection().getInstanceGroup());
 401         }
 402
 403         @Test
 404         public void connectNetworkToNullNetworkCollectionInstanceGroupTest() throws Exception {
 405                 //reset test data to have no network collection instance group
 406                 ServiceInstance serviceInstance = new ServiceInstance();
 407                 serviceInstance.setServiceInstanceId("testServiceInstanceId");
 408                 L3Network network = new L3Network();
 409                 network.setNetworkId("testNetworkId");
 410                 serviceInstance.getNetworks().add(network);
 411                 lookupKeyMap.put(ResourceKey.NETWORK_ID, network.getNetworkId());
 412                 gBBInput.setServiceInstance(serviceInstance);
 413                 lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, serviceInstance.getServiceInstanceId());
 414
 415                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.SERVICE_INSTANCE_ID))).thenReturn(serviceInstance);
 416                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.NETWORK_ID))).thenReturn(serviceInstance);
 417                 //verify connection call was not executednetwork
 418                 exception.expect(BpmnError.class);
 419                 aaiCreateTasks.connectNetworkToNetworkCollectionInstanceGroup(execution);
 420                 verify(aaiNetworkResources, never()).connectNetworkToNetworkCollectionInstanceGroup(network, null);
 421         }
 422
 423         @Test
 424         public void connectNetworkToCloudRegionTest() throws Exception {
 425                 gBBInput = execution.getGeneralBuildingBlock();
 426                 doNothing().when(aaiNetworkResources).connectNetworkToCloudRegion(network, gBBInput.getCloudRegion());
 427                 aaiCreateTasks.connectNetworkToCloudRegion(execution);
 428                 verify(aaiNetworkResources, times(1)).connectNetworkToCloudRegion(network, gBBInput.getCloudRegion());
 429         }
 430
 431         @Test
 432         public void connectNetworkToTenantTest() throws Exception {
 433                 gBBInput = execution.getGeneralBuildingBlock();
 434                 doNothing().when(aaiNetworkResources).connectNetworkToTenant(network, gBBInput.getCloudRegion());
 435                 aaiCreateTasks.connectNetworkToTenant(execution);
 436                 verify(aaiNetworkResources, times(1)).connectNetworkToTenant(network, gBBInput.getCloudRegion());
 437         }
 438
 439         @Test
 440         public void createConfigurationTest() throws Exception {
 441                 gBBInput = execution.getGeneralBuildingBlock();
 442                 doNothing().when(aaiConfigurationResources).createConfiguration(configuration);
 443                 aaiCreateTasks.createConfiguration(execution);
 444                 verify(aaiConfigurationResources, times(1)).createConfiguration(configuration);
 445         }
 446
 447         @Test
 448         public void connectVnfToCloudRegionTest() throws Exception {
 449                 gBBInput = execution.getGeneralBuildingBlock();
 450                 doNothing().when(aaiVnfResources).connectVnfToCloudRegion(genericVnf, gBBInput.getCloudRegion());
 451                 aaiCreateTasks.connectVnfToCloudRegion(execution);
 452                 verify(aaiVnfResources, times(1)).connectVnfToCloudRegion(genericVnf, gBBInput.getCloudRegion());
 453         }
 454
 455         @Test
 456         public void connectNoneToVnfToCloudRegionTest() throws Exception {
 457                 String[] arr = new String[1];
 458                 arr[0] = "test25Region2";
 459                 doReturn(arr).when(env).getProperty("mso.bpmn.cloudRegionIdsToSkipAddingVnfEdgesTo", String[].class);
 460                 gBBInput = execution.getGeneralBuildingBlock();
 461                 gBBInput.getCloudRegion().setLcpCloudRegionId("test25Region2");
 462                 doNothing().when(aaiVnfResources).connectVnfToCloudRegion(genericVnf, gBBInput.getCloudRegion());
 463                 aaiCreateTasks.connectVnfToCloudRegion(execution);
 464                 verify(aaiVnfResources, times(0)).connectVnfToCloudRegion(genericVnf, gBBInput.getCloudRegion());
 465         }
 466
 467         @Test
 468         public void connectVnfTenantTest() throws Exception {
 469                 gBBInput = execution.getGeneralBuildingBlock();
 470                 doNothing().when(aaiVnfResources).connectVnfToTenant(genericVnf, gBBInput.getCloudRegion());
 471                 aaiCreateTasks.connectVnfToTenant(execution);
 472                 verify(aaiVnfResources, times(1)).connectVnfToTenant(genericVnf, gBBInput.getCloudRegion());
 473         }
 474
 475         @Test
 476         public void createInstanceGroupVnfTest() throws Exception {
 477                 doNothing().when(aaiInstanceGroupResources).createInstanceGroupandConnectServiceInstance(instanceGroup, serviceInstance);
 478                 aaiCreateTasks.createInstanceGroupVnf(execution);
 479                 verify(aaiInstanceGroupResources, times(1)).createInstanceGroupandConnectServiceInstance(instanceGroup, serviceInstance);
 480         }
 481
 482         @Test
 483         public void createInstanceGroupVnfExceptionTest() throws Exception {
 484                 expectedException.expect(BpmnError.class);
 485                 doThrow(RuntimeException.class).when(aaiInstanceGroupResources).createInstanceGroupandConnectServiceInstance(instanceGroup, serviceInstance);
 486                 aaiCreateTasks.createInstanceGroupVnf(execution);
 487         }
 488
 489         @Test
 490         public void createNetworkPolicyNeedToCreateAllTest() throws Exception {
 491                 execution.setVariable("heatStackId", "testHeatStackId");
 492                 execution.setVariable("contrailNetworkPolicyFqdnList", "ABC123,ED456");
 493                 Optional<NetworkPolicy> networkPolicy = Optional.empty();
 494                 doReturn(networkPolicy).when(aaiNetworkResources).getNetworkPolicy(any(AAIResourceUri.class));
 495                 doNothing().when(aaiNetworkResources).createNetworkPolicy(any(NetworkPolicy.class));
 496                 aaiCreateTasks.createNetworkPolicies(execution);
 497                 verify(aaiNetworkResources, times(2)).createNetworkPolicy(networkPolicyCaptor.capture());
 498                 assertEquals("ABC123", networkPolicyCaptor.getAllValues().get(0).getNetworkPolicyFqdn());
 499                 assertEquals("ED456", networkPolicyCaptor.getAllValues().get(1).getNetworkPolicyFqdn());
 500                 assertEquals("testHeatStackId", networkPolicyCaptor.getAllValues().get(0).getHeatStackId());
 501                 assertEquals("testHeatStackId", networkPolicyCaptor.getAllValues().get(1).getHeatStackId());
 502         }
 503
 504         @Test
 505         public void createNetworkPolicyNeedToCreateNoneTest() throws Exception {
 506                 execution.setVariable("heatStackId", "testHeatStackId");
 507                 execution.setVariable("contrailNetworkPolicyFqdnList", "ABC123");
 508                 NetworkPolicy networkPolicy = new NetworkPolicy();
 509                 doReturn(Optional.of(networkPolicy)).when(aaiNetworkResources).getNetworkPolicy(any(AAIResourceUri.class));
 510                 doNothing().when(aaiNetworkResources).createNetworkPolicy(any(NetworkPolicy.class));
 511                 aaiCreateTasks.createNetworkPolicies(execution);
 512                 verify(aaiNetworkResources, times(0)).createNetworkPolicy(any(NetworkPolicy.class));
 513         }
 514
 515         @Test
 516         public void createNetworkPolicyNoNetworkPoliciesTest() throws Exception {
 517                 execution.setVariable("heatStackId", "testHeatStackId");
 518                 aaiCreateTasks.createNetworkPolicies(execution);
 519                 verify(aaiNetworkResources, times(0)).createNetworkPolicy(any(NetworkPolicy.class));
 520         }
 521
 522         @Test
 523         public void createVfModuleGetLowestIndexTest() throws Exception {
 524                 GenericVnf vnf = new GenericVnf();
 525                 ModelInfoGenericVnf vnfInfo = new ModelInfoGenericVnf();
 526                 vnf.setModelInfoGenericVnf(vnfInfo);
 527                 vnfInfo.setModelInvariantUuid("my-uuid");
 528
 529                 ModelInfoVfModule infoA = new ModelInfoVfModule();
 530                 infoA.setIsBaseBoolean(false);
 531                 infoA.setModelInvariantUUID("A");
 532
 533                 ModelInfoVfModule infoB = new ModelInfoVfModule();
 534                 infoB.setIsBaseBoolean(false);
 535                 infoB.setModelInvariantUUID("B");
 536
 537                 ModelInfoVfModule infoC = new ModelInfoVfModule();
 538                 infoC.setIsBaseBoolean(false);
 539                 infoC.setModelInvariantUUID("C");
 540
 541                 VfModule newVfModuleA = new VfModule();
 542                 newVfModuleA.setVfModuleId("a");
 543                 VfModule newVfModuleB = new VfModule();
 544                 newVfModuleB.setVfModuleId("b");
 545                 VfModule newVfModuleC = new VfModule();
 546                 newVfModuleC.setVfModuleId("c");
 547
 548                 VfModule vfModule = new VfModule();
 549                 vnf.getVfModules().add(vfModule);
 550                 vfModule.setVfModuleId("1");
 551
 552                 VfModule vfModule2 = new VfModule();
 553                 vnf.getVfModules().add(vfModule2);
 554                 vfModule2.setVfModuleId("2");
 555
 556                 VfModule vfModule3 = new VfModule();
 557                 vnf.getVfModules().add(vfModule3);
 558                 vfModule3.setVfModuleId("3");
 559
 560                 VfModule vfModule4 = new VfModule();
 561                 vnf.getVfModules().add(vfModule4);
 562                 vfModule4.setVfModuleId("4");
 563
 564                 VfModule vfModule5 = new VfModule();
 565                 vnf.getVfModules().add(vfModule5);
 566                 vfModule5.setVfModuleId("5");
 567
 568                 //modules are included in the vnf already
 569                 vnf.getVfModules().add(newVfModuleA);
 570                 vnf.getVfModules().add(newVfModuleB);
 571                 vnf.getVfModules().add(newVfModuleC);
 572
 573                 //A
 574                 newVfModuleA.setModelInfoVfModule(infoA);
 575                 vfModule.setModelInfoVfModule(infoA);
 576                 vfModule2.setModelInfoVfModule(infoA);
 577                 vfModule3.setModelInfoVfModule(infoA);
 578
 579                 //B
 580
 581                 newVfModuleB.setModelInfoVfModule(infoB);
 582                 vfModule4.setModelInfoVfModule(infoB);
 583                 vfModule5.setModelInfoVfModule(infoB);
 584
 585                 //C
 586                 newVfModuleC.setModelInfoVfModule(infoC);
 587
 588
 589                 //A
 590                 vfModule.setModuleIndex(2);
 591                 vfModule2.setModuleIndex(0);
 592                 vfModule3.setModuleIndex(3);
 593
 594                 //B
 595                 vfModule4.setModuleIndex(null);
 596                 vfModule5.setModuleIndex(1);
 597
 598                 assertEquals(1, aaiCreateTasks.getLowestUnusedVfModuleIndexFromAAIVnfResponse(vnf, newVfModuleA));
 599
 600                 assertEquals(2, aaiCreateTasks.getLowestUnusedVfModuleIndexFromAAIVnfResponse(vnf, newVfModuleB));
 601
 602                 assertEquals(0, aaiCreateTasks.getLowestUnusedVfModuleIndexFromAAIVnfResponse(vnf, newVfModuleC));
 603
 604         }
 605
 606         @Test
 607         public void calculateUnusedIndexTest() {
 608
 609                 TreeSet<Integer> a = new TreeSet<>(Arrays.asList(0,1,3));
 610                 TreeSet<Integer> b = new TreeSet<>(Arrays.asList(0,1,8));
 611                 TreeSet<Integer> c = new TreeSet<>(Arrays.asList(0,2,4));
 612                 assertEquals(2, aaiCreateTasks.calculateUnusedIndex(a, 0));
 613                 assertEquals(5, aaiCreateTasks.calculateUnusedIndex(a, 2));
 614
 615                 assertEquals(4, aaiCreateTasks.calculateUnusedIndex(b, 2));
 616                 assertEquals(3, aaiCreateTasks.calculateUnusedIndex(b, 1));
 617
 618                 assertEquals(5, aaiCreateTasks.calculateUnusedIndex(c, 2));
 619                 assertEquals(9, aaiCreateTasks.calculateUnusedIndex(c, 6));
 620                 assertEquals(1, aaiCreateTasks.calculateUnusedIndex(c, 0));
 621
 622         }
 623 }