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