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