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