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