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.mockito.ArgumentMatchers.any;
  23 import static org.mockito.ArgumentMatchers.eq;
  24 import static org.mockito.Mockito.doNothing;
  25 import static org.mockito.Mockito.doReturn;
  26 import static org.mockito.Mockito.doThrow;
  27 import static org.mockito.Mockito.never;
  28 import static org.mockito.Mockito.times;
  29 import static org.mockito.Mockito.verify;
  30 import static org.mockito.Mockito.when;
  31
  32 import org.camunda.bpm.engine.delegate.BpmnError;
  33 import org.junit.Before;
  34 import org.junit.Rule;
  35 import org.junit.Test;
  36 import org.junit.rules.ExpectedException;
  37 import org.mockito.ArgumentMatchers;
  38 import org.mockito.InjectMocks;
  39 import org.onap.so.bpmn.BaseTaskTest;
  40 import org.onap.so.bpmn.common.BuildingBlockExecution;
  41 import org.onap.so.bpmn.servicedecomposition.bbobjects.CloudRegion;
  42 import org.onap.so.bpmn.servicedecomposition.bbobjects.Configuration;
  43 import org.onap.so.bpmn.servicedecomposition.bbobjects.Customer;
  44 import org.onap.so.bpmn.servicedecomposition.bbobjects.GenericVnf;
  45 import org.onap.so.bpmn.servicedecomposition.bbobjects.L3Network;
  46 import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
  47 import org.onap.so.bpmn.servicedecomposition.bbobjects.VfModule;
  48 import org.onap.so.bpmn.servicedecomposition.bbobjects.VolumeGroup;
  49 import org.onap.so.bpmn.servicedecomposition.entities.ResourceKey;
  50 import org.onap.so.client.exception.BBObjectNotFoundException;
  51 import org.onap.so.db.catalog.beans.OrchestrationStatus;
  52
  53 public class AAICreateTasksTest extends BaseTaskTest{
  54
  55         @InjectMocks
  56         private AAICreateTasks aaiCreateTasks = new AAICreateTasks();
  57
  58
  59         private ServiceInstance serviceInstance;
  60         private L3Network network;
  61         private GenericVnf genericVnf;
  62         private VolumeGroup volumeGroup;
  63         private CloudRegion cloudRegion;
  64         private VfModule vfModule;
  65         private Customer customer;
  66         private Configuration configuration;
  67
  68         @Rule
  69         public final ExpectedException exception = ExpectedException.none();
  70
  71         @Before
  72         public void before() throws BBObjectNotFoundException {
  73                 customer = setCustomer();
  74                 serviceInstance = setServiceInstance();
  75                 network = setL3Network();
  76                 genericVnf = setGenericVnf();
  77                 volumeGroup = setVolumeGroup();
  78                 cloudRegion = setCloudRegion();
  79                 vfModule = setVfModule();
  80                 configuration = setConfiguration();
  81
  82                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.GENERIC_VNF_ID), any())).thenReturn(genericVnf);
  83                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.VF_MODULE_ID), any())).thenReturn(vfModule);
  84                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.NETWORK_ID), any())).thenReturn(network);
  85                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.VOLUME_GROUP_ID), any())).thenReturn(volumeGroup);
  86                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.SERVICE_INSTANCE_ID), any())).thenReturn(serviceInstance);
  87                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.CONFIGURATION_ID), any())).thenReturn(configuration);
  88
  89
  90                 doThrow(new BpmnError("BPMN Error")).when(exceptionUtil).buildAndThrowWorkflowException(any(BuildingBlockExecution.class), eq(7000), any(Exception.class));
  91                 doThrow(new BpmnError("BPMN Error")).when(exceptionUtil).buildAndThrowWorkflowException(any(BuildingBlockExecution.class), eq(7000), any(String.class));
  92
  93         }
  94
  95         @Test
  96         public void createServiceInstanceTest() throws Exception {
  97                 doNothing().when(aaiServiceInstanceResources).createServiceInstance(serviceInstance, customer);
  98                 aaiCreateTasks.createServiceInstance(execution);
  99                 verify(aaiServiceInstanceResources, times(1)).createServiceInstance(serviceInstance, customer);
 100         }
 101
 102         @Test
 103         public void createServiceInstanceExceptionTest() throws Exception {
 104                 expectedException.expect(BpmnError.class);
 105
 106                 lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "notfound");
 107                 doThrow(RuntimeException.class).when(aaiServiceInstanceResources).createServiceInstance(serviceInstance, customer);
 108                 aaiCreateTasks.createServiceInstance(execution);
 109         }
 110
 111         @Test
 112         public void createVolumeGroupTest() throws Exception {
 113                 volumeGroup.setOrchestrationStatus(OrchestrationStatus.PRECREATED);
 114
 115                 doNothing().when(aaiVolumeGroupResources).createVolumeGroup(volumeGroup, cloudRegion);
 116                 doNothing().when(aaiVolumeGroupResources).connectVolumeGroupToVnf(genericVnf, volumeGroup, cloudRegion);
 117
 118                 aaiCreateTasks.createVolumeGroup(execution);
 119
 120                 verify(aaiVolumeGroupResources, times(1)).createVolumeGroup(volumeGroup, cloudRegion);
 121                 verify(aaiVolumeGroupResources, times(1)).connectVolumeGroupToVnf(genericVnf, volumeGroup, cloudRegion);
 122                 verify(aaiVolumeGroupResources, times(1)).connectVolumeGroupToTenant(volumeGroup, cloudRegion);
 123         }
 124
 125         @Test
 126         public void createVolumeGroupExceptionTest() throws Exception {
 127                 expectedException.expect(BpmnError.class);
 128
 129                 volumeGroup.setOrchestrationStatus(OrchestrationStatus.PRECREATED);
 130
 131                 doThrow(RuntimeException.class).when(aaiVolumeGroupResources).createVolumeGroup(volumeGroup, cloudRegion);
 132
 133                 aaiCreateTasks.createVolumeGroup(execution);
 134         }
 135
 136         @Test
 137         public void createProjectTest() throws Exception {
 138                 doNothing().when(aaiServiceInstanceResources).createProjectandConnectServiceInstance(serviceInstance.getProject(), serviceInstance);
 139                 aaiCreateTasks.createProject(execution);
 140                 verify(aaiServiceInstanceResources, times(1)).createProjectandConnectServiceInstance(serviceInstance.getProject(), serviceInstance);
 141         }
 142
 143         @Test
 144         public void createPlatformTest() throws Exception {
 145                 doNothing().when(aaiVnfResources).createPlatformandConnectVnf(genericVnf.getPlatform(), genericVnf);
 146                 aaiCreateTasks.createPlatform(execution);
 147                 verify(aaiVnfResources, times(1)).createPlatformandConnectVnf(genericVnf.getPlatform(), genericVnf);
 148         }
 149
 150         @Test
 151         public void createLineOfBusinessTest() throws Exception {
 152                 doNothing().when(aaiVnfResources).createLineOfBusinessandConnectVnf(genericVnf.getLineOfBusiness(), genericVnf);
 153                 aaiCreateTasks.createLineOfBusiness(execution);
 154                 verify(aaiVnfResources, times(1)).createLineOfBusinessandConnectVnf(genericVnf.getLineOfBusiness(), genericVnf);
 155         }
 156
 157         @Test
 158         public void createProjectExceptionTest() throws Exception {
 159                 expectedException.expect(BpmnError.class);
 160
 161                 lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "notfound");
 162                 doThrow(RuntimeException.class).when(aaiServiceInstanceResources).createProjectandConnectServiceInstance(serviceInstance.getProject(), serviceInstance);
 163                 aaiCreateTasks.createProject(execution);
 164         }
 165
 166         @Test
 167         public void createProjectNullProjectNameTest() throws Exception {
 168                 serviceInstance.getProject().setProjectName(null);
 169                 doNothing().when(aaiServiceInstanceResources).createProjectandConnectServiceInstance(serviceInstance.getProject(), serviceInstance);
 170                 aaiCreateTasks.createProject(execution);
 171                 verify(aaiServiceInstanceResources, times(0)).createProjectandConnectServiceInstance(serviceInstance.getProject(), serviceInstance);
 172         }
 173
 174         @Test
 175         public void createProjectEmptyProjectNameTest() throws Exception {
 176                 serviceInstance.getProject().setProjectName("");
 177                 doNothing().when(aaiServiceInstanceResources).createProjectandConnectServiceInstance(serviceInstance.getProject(), serviceInstance);
 178                 aaiCreateTasks.createProject(execution);
 179                 verify(aaiServiceInstanceResources, times(0)).createProjectandConnectServiceInstance(serviceInstance.getProject(), serviceInstance);
 180         }
 181
 182         @Test
 183         public void createOwningEntityTest() throws Exception {
 184                 doReturn(true).when(aaiServiceInstanceResources).existsOwningEntity(serviceInstance.getOwningEntity());
 185                 doNothing().when(aaiServiceInstanceResources).connectOwningEntityandServiceInstance(serviceInstance.getOwningEntity(),serviceInstance);
 186                 aaiCreateTasks.createOwningEntity(execution);
 187                 verify(aaiServiceInstanceResources, times(1)).existsOwningEntity(serviceInstance.getOwningEntity());
 188                 verify(aaiServiceInstanceResources, times(1)).connectOwningEntityandServiceInstance(serviceInstance.getOwningEntity(), serviceInstance);
 189         }
 190
 191         @Test
 192         public void createOwningEntityNotExistsOwningEntityTest() throws Exception {
 193                 doReturn(false).when(aaiServiceInstanceResources).existsOwningEntity(serviceInstance.getOwningEntity());
 194                 doNothing().when(aaiServiceInstanceResources).createOwningEntityandConnectServiceInstance(serviceInstance.getOwningEntity(),serviceInstance);
 195                 aaiCreateTasks.createOwningEntity(execution);
 196                 verify(aaiServiceInstanceResources, times(1)).existsOwningEntity(serviceInstance.getOwningEntity());
 197                 verify(aaiServiceInstanceResources, times(1)).createOwningEntityandConnectServiceInstance(serviceInstance.getOwningEntity(), serviceInstance);
 198         }
 199
 200         @Test
 201         public void createOwningEntityNullOwningEntityIdTest() throws Exception {
 202                 expectedException.expect(BpmnError.class);
 203
 204                 serviceInstance.getOwningEntity().setOwningEntityId(null);
 205
 206                 aaiCreateTasks.createOwningEntity(execution);
 207         }
 208
 209         @Test
 210         public void createOwningEntityEmptyOwningEntityIdTest() throws Exception {
 211                 expectedException.expect(BpmnError.class);
 212
 213                 serviceInstance.getOwningEntity().setOwningEntityId("");
 214
 215                 aaiCreateTasks.createOwningEntity(execution);
 216         }
 217
 218         @Test
 219         public void createOwningEntityNullOwningEntityNameTest() throws Exception {
 220                 expectedException.expect(BpmnError.class);
 221
 222                 serviceInstance.getOwningEntity().setOwningEntityName(null);
 223
 224                 doReturn(false).when(aaiServiceInstanceResources).existsOwningEntity(serviceInstance.getOwningEntity());
 225
 226                 aaiCreateTasks.createOwningEntity(execution);
 227         }
 228
 229         @Test
 230         public void createOwningEntityEmptyOwningEntityNameTest() throws Exception {
 231                 expectedException.expect(BpmnError.class);
 232
 233                 serviceInstance.getOwningEntity().setOwningEntityName("");
 234
 235                 doReturn(false).when(aaiServiceInstanceResources).existsOwningEntity(serviceInstance.getOwningEntity());
 236
 237                 aaiCreateTasks.createOwningEntity(execution);
 238         }
 239
 240         @Test
 241         public void createOwningEntityExceptionTest() throws Exception {
 242                 expectedException.expect(BpmnError.class);
 243
 244                 doReturn(true).when(aaiServiceInstanceResources).existsOwningEntity(serviceInstance.getOwningEntity());
 245
 246                 doThrow(RuntimeException.class).when(aaiServiceInstanceResources).connectOwningEntityandServiceInstance(serviceInstance.getOwningEntity(), serviceInstance);
 247
 248                 aaiCreateTasks.createOwningEntity(execution);
 249         }
 250
 251         @Test
 252         public void createVnfTest() throws Exception {
 253                 doNothing().when(aaiVnfResources).createVnfandConnectServiceInstance(genericVnf, serviceInstance);
 254                 aaiCreateTasks.createVnf(execution);
 255                 verify(aaiVnfResources, times(1)).createVnfandConnectServiceInstance(genericVnf, serviceInstance);
 256         }
 257
 258         @Test
 259         public void createVnfExceptionTest() throws Exception {
 260                 expectedException.expect(BpmnError.class);
 261                 lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "notfound");
 262                 doThrow(BBObjectNotFoundException.class).when(extractPojosForBB).extractByKey(any(),ArgumentMatchers.eq(ResourceKey.GENERIC_VNF_ID),eq("notfound"));
 263                 doNothing().when(aaiVnfResources).createVnfandConnectServiceInstance(genericVnf, serviceInstance);
 264                 aaiCreateTasks.createVnf(execution);
 265                 verify(aaiVnfResources, times(1)).createVnfandConnectServiceInstance(genericVnf, serviceInstance);
 266         }
 267
 268
 269         @Test
 270         public void createVfModuleTest() throws Exception {
 271                 doNothing().when(aaiVfModuleResources).createVfModule(vfModule, genericVnf);
 272                 aaiCreateTasks.createVfModule(execution);
 273                 verify(aaiVfModuleResources, times(1)).createVfModule(vfModule, genericVnf);
 274         }
 275
 276         @Test
 277     public void createServiceSubscriptionTest(){
 278             doNothing().when(aaiServiceInstanceResources).createServiceSubscription(customer);
 279             aaiCreateTasks.createServiceSubscription(execution);
 280             verify(aaiServiceInstanceResources, times(1)).createServiceSubscription(customer);
 281     }
 282
 283     @Test
 284     public void createServiceSubscriptionTestExceptionHandling(){
 285         expectedException.expect(BpmnError.class);
 286         doThrow(RuntimeException.class).when(aaiServiceInstanceResources).createServiceSubscription(customer);
 287         aaiCreateTasks.createServiceSubscription(execution);
 288     }
 289
 290     @Test
 291     public void createServiceSubscriptionTestCustomerIsNull(){
 292         expectedException.expect(BpmnError.class);
 293         gBBInput.setCustomer(null);
 294         aaiCreateTasks.createServiceSubscription(execution);
 295     }
 296
 297         @Test
 298         public void createVfModuleExceptionTest() throws Exception {
 299                 expectedException.expect(BpmnError.class);
 300
 301                 doThrow(RuntimeException.class).when(aaiVfModuleResources).createVfModule(vfModule, genericVnf);
 302                 aaiCreateTasks.createVfModule(execution);
 303         }
 304
 305         @Test
 306         public void connectVfModuleToVolumeGroupTest() throws Exception {
 307                 doNothing().when(aaiVfModuleResources).connectVfModuleToVolumeGroup(genericVnf, vfModule, volumeGroup, cloudRegion);
 308                 aaiCreateTasks.connectVfModuleToVolumeGroup(execution);
 309                 verify(aaiVfModuleResources, times(1)).connectVfModuleToVolumeGroup(genericVnf, vfModule, volumeGroup, cloudRegion);
 310         }
 311
 312         @Test
 313         public void createNetworkTest() throws Exception {
 314                 network.getModelInfoNetwork().setNeutronNetworkType("PROVIDER");
 315
 316                 doNothing().when(aaiNetworkResources).createNetworkConnectToServiceInstance(network,serviceInstance);
 317                 aaiCreateTasks.createNetwork(execution);
 318                 verify(aaiNetworkResources, times(1)).createNetworkConnectToServiceInstance(network, serviceInstance);
 319         }
 320
 321         @Test
 322         public void createNetworkExceptionTest() throws Exception {
 323                 expectedException.expect(BpmnError.class);
 324
 325                 lookupKeyMap.put(ResourceKey.NETWORK_ID, "notfound");
 326                 doThrow(RuntimeException.class).when(aaiNetworkResources).createNetworkConnectToServiceInstance(network,serviceInstance);
 327                 aaiCreateTasks.createNetwork(execution);
 328         }
 329
 330         @Test
 331         public void createCustomerTest() throws Exception {
 332                 doNothing().when(aaiVpnBindingResources).createCustomer(customer);
 333
 334                 aaiCreateTasks.createCustomer(execution);
 335
 336                 verify(aaiVpnBindingResources, times(1)).createCustomer(customer);
 337         }
 338
 339         @Test
 340         public void createCustomerExceptionTest() throws Exception {
 341                 expectedException.expect(BpmnError.class);
 342
 343                 doThrow(RuntimeException.class).when(aaiVpnBindingResources).createCustomer(customer);
 344
 345                 aaiCreateTasks.createCustomer(execution);
 346         }
 347
 348         @Test
 349         public void createNetworkCollectionTest() throws Exception {
 350                 doNothing().when(aaiNetworkResources).createNetworkCollection(serviceInstance.getCollection());
 351                 execution.setVariable("networkCollectionName", "testNetworkCollectionName");
 352                 aaiCreateTasks.createNetworkCollection(execution);
 353                 verify(aaiNetworkResources, times(1)).createNetworkCollection(serviceInstance.getCollection());
 354         }
 355
 356         @Test
 357         public void createNetworkCollectionInstanceGroupTest() throws Exception {
 358                 doNothing().when(aaiNetworkResources).createNetworkInstanceGroup(serviceInstance.getCollection().getInstanceGroup());
 359                 aaiCreateTasks.createNetworkCollectionInstanceGroup(execution);
 360                 verify(aaiNetworkResources, times(1)).createNetworkInstanceGroup(serviceInstance.getCollection().getInstanceGroup());
 361         }
 362
 363         @Test
 364         public void connectNetworkToNetworkCollectionServiceInstanceTest() throws Exception {
 365                 doNothing().when(aaiNetworkResources).connectNetworkToNetworkCollectionServiceInstance(network, serviceInstance);
 366                 aaiCreateTasks.connectNetworkToNetworkCollectionServiceInstance(execution);
 367                 verify(aaiNetworkResources, times(1)).connectNetworkToNetworkCollectionServiceInstance(network, serviceInstance);
 368         }
 369
 370         @Test
 371         public void connectNetworkToNetworkCollectionInstanceGroupTest() throws Exception {
 372                 doNothing().when(aaiNetworkResources).connectNetworkToNetworkCollectionInstanceGroup(network, serviceInstance.getCollection().getInstanceGroup());
 373                 aaiCreateTasks.connectNetworkToNetworkCollectionInstanceGroup(execution);
 374                 verify(aaiNetworkResources, times(1)).connectNetworkToNetworkCollectionInstanceGroup(network, serviceInstance.getCollection().getInstanceGroup());
 375         }
 376
 377         @Test
 378         public void connectNetworkToNullNetworkCollectionInstanceGroupTest() throws Exception {
 379                 //reset test data to have no network collection instance group
 380                 ServiceInstance serviceInstance = new ServiceInstance();
 381                 serviceInstance.setServiceInstanceId("testServiceInstanceId");
 382                 L3Network network = new L3Network();
 383                 network.setNetworkId("testNetworkId");
 384                 serviceInstance.getNetworks().add(network);
 385                 lookupKeyMap.put(ResourceKey.NETWORK_ID, network.getNetworkId());
 386                 gBBInput.setServiceInstance(serviceInstance);
 387                 lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, serviceInstance.getServiceInstanceId());
 388
 389                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.SERVICE_INSTANCE_ID), eq("testServiceInstanceId"))).thenReturn(serviceInstance);
 390                 when(extractPojosForBB.extractByKey(any(),ArgumentMatchers.eq(ResourceKey.NETWORK_ID),eq("testNetworkId"))).thenReturn(serviceInstance);
 391                 //verify connection call was not executednetwork
 392                 exception.expect(BpmnError.class);
 393                 aaiCreateTasks.connectNetworkToNetworkCollectionInstanceGroup(execution);
 394                 verify(aaiNetworkResources, never()).connectNetworkToNetworkCollectionInstanceGroup(network, null);
 395         }
 396
 397         @Test
 398         public void connectNetworkToCloudRegionTest() throws Exception {
 399                 gBBInput = execution.getGeneralBuildingBlock();
 400                 doNothing().when(aaiNetworkResources).connectNetworkToCloudRegion(network, gBBInput.getCloudRegion());
 401                 aaiCreateTasks.connectNetworkToCloudRegion(execution);
 402                 verify(aaiNetworkResources, times(1)).connectNetworkToCloudRegion(network, gBBInput.getCloudRegion());
 403         }
 404
 405         @Test
 406         public void connectNetworkToTenantTest() throws Exception {
 407                 gBBInput = execution.getGeneralBuildingBlock();
 408                 doNothing().when(aaiNetworkResources).connectNetworkToTenant(network, gBBInput.getCloudRegion());
 409                 aaiCreateTasks.connectNetworkToTenant(execution);
 410                 verify(aaiNetworkResources, times(1)).connectNetworkToTenant(network, gBBInput.getCloudRegion());
 411         }
 412
 413         @Test
 414         public void createConfigurationTest() throws Exception {
 415                 gBBInput = execution.getGeneralBuildingBlock();
 416                 doNothing().when(aaiConfigurationResources).createConfiguration(configuration);
 417                 aaiCreateTasks.createConfiguration(execution);
 418                 verify(aaiConfigurationResources, times(1)).createConfiguration(configuration);
 419         }
 420 }