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