gerrit.onap Code Review - so.git/blob

   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
  23 package org.onap.so.bpmn.servicedecomposition.tasks;
  24
  25 import static com.shazam.shazamcrest.MatcherAssert.assertThat;
  26 import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
  27 import static org.hamcrest.CoreMatchers.containsString;
  28 import static org.junit.Assert.assertEquals;
  29 import static org.junit.Assert.assertNull;
  30 import static org.junit.Assert.assertTrue;
  31 import static org.mockito.ArgumentMatchers.any;
  32 import static org.mockito.ArgumentMatchers.anyString;
  33 import static org.mockito.ArgumentMatchers.eq;
  34 import static org.mockito.ArgumentMatchers.isA;
  35 import static org.mockito.Mockito.doReturn;
  36 import static org.mockito.Mockito.times;
  37 import static org.mockito.Mockito.verify;
  38 import java.io.File;
  39 import java.io.IOException;
  40 import java.nio.charset.StandardCharsets;
  41 import java.nio.file.Files;
  42 import java.nio.file.Paths;
  43 import java.util.Arrays;
  44 import java.util.List;
  45 import java.util.Optional;
  46 import org.junit.Before;
  47 import org.junit.Rule;
  48 import org.junit.Test;
  49 import org.junit.rules.ExpectedException;
  50 import org.junit.runner.RunWith;
  51 import org.mockito.InjectMocks;
  52 import org.mockito.Mock;
  53 import org.mockito.Mockito;
  54 import org.mockito.junit.MockitoJUnitRunner;
  55 import org.onap.aai.domain.yang.CloudRegion;
  56 import org.onap.aai.domain.yang.Configuration;
  57 import org.onap.aai.domain.yang.Configurations;
  58 import org.onap.aai.domain.yang.GenericVnf;
  59 import org.onap.aai.domain.yang.GenericVnfs;
  60 import org.onap.aai.domain.yang.InstanceGroup;
  61 import org.onap.aai.domain.yang.L3Network;
  62 import org.onap.aai.domain.yang.L3Networks;
  63 import org.onap.aai.domain.yang.ServiceInstance;
  64 import org.onap.aai.domain.yang.ServiceInstances;
  65 import org.onap.aai.domain.yang.VolumeGroup;
  66 import org.onap.aai.domain.yang.VolumeGroups;
  67 import org.onap.aai.domain.yang.VpnBinding;
  68 import org.onap.so.bpmn.common.InjectionHelper;
  69 import org.onap.so.bpmn.servicedecomposition.bbobjects.Customer;
  70 import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceSubscription;
  71 import org.onap.so.bpmn.servicedecomposition.entities.ExecuteBuildingBlock;
  72 import org.onap.so.bpmn.servicedecomposition.tasks.exceptions.MultipleObjectsFoundException;
  73 import org.onap.so.bpmn.servicedecomposition.tasks.exceptions.NoServiceInstanceFoundException;
  74 import org.onap.so.client.aai.AAIObjectPlurals;
  75 import org.onap.so.client.aai.AAIObjectType;
  76 import org.onap.so.client.aai.AAIResourcesClient;
  77 import org.onap.so.client.aai.entities.uri.AAIResourceUri;
  78 import org.onap.so.client.aai.entities.uri.AAIUriFactory;
  79 import org.onap.so.client.graphinventory.entities.uri.Depth;
  80 import org.onap.so.db.catalog.beans.VnfcInstanceGroupCustomization;
  81 import org.onap.so.db.catalog.beans.CollectionResourceInstanceGroupCustomization;
  82 import org.onap.so.db.catalog.beans.Service;
  83 import org.onap.so.db.catalog.client.CatalogDbClient;
  84 import org.onap.so.db.request.beans.InfraActiveRequests;
  85 import org.onap.so.db.request.beans.RequestProcessingData;
  86 import org.onap.so.db.request.client.RequestsDbClient;
  87 import org.onap.so.serviceinstancebeans.CloudConfiguration;
  88 import org.onap.so.serviceinstancebeans.RequestDetails;
  89 import com.fasterxml.jackson.databind.ObjectMapper;
  90
  91 @RunWith(MockitoJUnitRunner.class)
  92 public class BBInputSetupUtilsTest {
  93     protected ObjectMapper mapper = new ObjectMapper();
  94     private static final String RESOURCE_PATH = "src/test/resources/__files/ExecuteBuildingBlock/";
  95
  96     @InjectMocks
  97     BBInputSetupUtils bbInputSetupUtils = new BBInputSetupUtils();
  98
  99     @Mock
 100     protected CatalogDbClient MOCK_catalogDbClient;
 101
 102     @Mock
 103     protected RequestsDbClient MOCK_requestsDbClient;
 104
 105     @Mock
 106     protected AAIResourcesClient MOCK_aaiResourcesClient;
 107
 108     @Mock
 109     protected InjectionHelper MOCK_injectionHelper;
 110
 111     @Rule
 112     public ExpectedException expectedException = ExpectedException.none();
 113
 114     @Before
 115     public void setup() {
 116         doReturn(MOCK_aaiResourcesClient).when(MOCK_injectionHelper).getAaiClient();
 117     }
 118
 119     @Test
 120     public void getCatalogServiceByModelUUIDTest() throws IOException {
 121         Service expected = mapper.readValue(new File(RESOURCE_PATH + "CatalogServiceExpected.json"), Service.class);
 122         final String modelUUID = "modelUUIDTest";
 123
 124         doReturn(expected).when(MOCK_catalogDbClient).getServiceByID(modelUUID);
 125
 126         assertThat(bbInputSetupUtils.getCatalogServiceByModelUUID(modelUUID), sameBeanAs(expected));
 127     }
 128
 129     @Test
 130     public void getCatalogServiceByModelVersionAndModelInvariantUUIDTest() throws IOException {
 131         final String modelVersion = "modelVersionTest";
 132         final String modelInvariantUUID = "modelInvariantUUIDTest";
 133         Service expectedService =
 134                 mapper.readValue(new File(RESOURCE_PATH + "CatalogServiceExpected.json"), Service.class);
 135
 136         doReturn(expectedService).when(MOCK_catalogDbClient).getServiceByModelVersionAndModelInvariantUUID(modelVersion,
 137                 modelInvariantUUID);
 138
 139         assertThat(bbInputSetupUtils.getCatalogServiceByModelVersionAndModelInvariantUUID(modelVersion,
 140                 modelInvariantUUID), sameBeanAs(expectedService));
 141     }
 142
 143     @Test
 144     public void getVnfcInstanceGroupsTest() throws IOException {
 145         final String modelCustomizationUUID = "modelCustomizationUUIDTest";
 146         VnfcInstanceGroupCustomization vnfc = mapper.readValue(
 147                 new File(RESOURCE_PATH + "VnfcInstanceGroupCustomization.json"), VnfcInstanceGroupCustomization.class);
 148
 149         doReturn(Arrays.asList(vnfc)).when(MOCK_catalogDbClient)
 150                 .getVnfcInstanceGroupsByVnfResourceCust(modelCustomizationUUID);
 151
 152         assertThat(bbInputSetupUtils.getVnfcInstanceGroups(modelCustomizationUUID), sameBeanAs(Arrays.asList(vnfc)));
 153     }
 154
 155     @Test
 156     public void getRequestDetailsTest() throws IOException {
 157         final String requestId = "requestId";
 158         InfraActiveRequests infraActiveRequest = mapper
 159                 .readValue(new File(RESOURCE_PATH + "InfraActiveRequestExpected.json"), InfraActiveRequests.class);
 160         RequestDetails expected =
 161                 mapper.readValue(new File(RESOURCE_PATH + "RequestDetailsExpected.json"), RequestDetails.class);
 162
 163         doReturn(infraActiveRequest).when(MOCK_requestsDbClient).getInfraActiveRequestbyRequestId(requestId);
 164
 165         assertThat(bbInputSetupUtils.getRequestDetails(requestId), sameBeanAs(expected));
 166     }
 167
 168     @Test
 169     public void getRequestDetailsNullTest() throws IOException {
 170         assertNull(bbInputSetupUtils.getRequestDetails(""));
 171     }
 172
 173     @Test
 174     public void getCloudRegionTest() {
 175         CloudConfiguration cloudConfig = new CloudConfiguration();
 176         cloudConfig.setLcpCloudRegionId("lcpCloudRegionId");
 177         Optional<CloudRegion> expected = Optional.of(new CloudRegion());
 178
 179         doReturn(expected).when(MOCK_aaiResourcesClient).get(CloudRegion.class,
 180                 AAIUriFactory.createResourceUri(AAIObjectType.CLOUD_REGION, cloudConfig.getCloudOwner(),
 181                         cloudConfig.getLcpCloudRegionId()).depth(Depth.TWO));
 182
 183         assertThat(bbInputSetupUtils.getCloudRegion(cloudConfig), sameBeanAs(expected.get()));
 184     }
 185
 186     @Test
 187     public void getCloudRegionNullTest() {
 188         CloudConfiguration cloudConfig = new CloudConfiguration();
 189         cloudConfig.setLcpCloudRegionId("lcpCloudRegionId");
 190
 191         assertNull(bbInputSetupUtils.getCloudRegion(cloudConfig));
 192     }
 193
 194     @Test
 195     public void getCloudRegionEmptyIdTest() {
 196         CloudConfiguration cloudConfig = new CloudConfiguration();
 197         cloudConfig.setLcpCloudRegionId("");
 198
 199         assertNull(bbInputSetupUtils.getCloudRegion(cloudConfig));
 200     }
 201
 202     @Test
 203     public void getAAIInstanceGroupTest() {
 204         final String instanceGroupId = "instanceGroupId";
 205         Optional<InstanceGroup> expected = Optional.of(new InstanceGroup());
 206         expected.get().setId(instanceGroupId);
 207
 208         doReturn(expected).when(MOCK_aaiResourcesClient).get(InstanceGroup.class,
 209                 AAIUriFactory.createResourceUri(AAIObjectType.INSTANCE_GROUP, instanceGroupId));
 210
 211         assertThat(bbInputSetupUtils.getAAIInstanceGroup(instanceGroupId), sameBeanAs(expected.get()));
 212     }
 213
 214     @Test
 215     public void getAAIInstanceGroupNullTest() {
 216         assertNull(bbInputSetupUtils.getAAIInstanceGroup(""));
 217     }
 218
 219     @Test
 220     public void getAAICustomerTest() {
 221         final String globalSubscriberId = "globalSubscriberId";
 222         Optional<org.onap.aai.domain.yang.Customer> expected = Optional.of(new org.onap.aai.domain.yang.Customer());
 223         expected.get().setGlobalCustomerId(globalSubscriberId);
 224
 225         doReturn(expected).when(MOCK_aaiResourcesClient).get(org.onap.aai.domain.yang.Customer.class,
 226                 AAIUriFactory.createResourceUri(AAIObjectType.CUSTOMER, globalSubscriberId));
 227
 228         assertThat(bbInputSetupUtils.getAAICustomer(globalSubscriberId), sameBeanAs(expected.get()));
 229     }
 230
 231     @Test
 232     public void getAAICustomerNullTest() {
 233         assertNull(bbInputSetupUtils.getAAICustomer(""));
 234     }
 235
 236     @Test
 237     public void getAAIServiceSubscriptionTest() {
 238         final String globalSubscriberId = "globalSubscriberId";
 239         final String subscriptionServiceType = "subscriptionServiceType";
 240         Optional<org.onap.aai.domain.yang.ServiceSubscription> expected =
 241                 Optional.of(new org.onap.aai.domain.yang.ServiceSubscription());
 242
 243         expected.get().setServiceType(subscriptionServiceType);
 244         doReturn(expected).when(MOCK_aaiResourcesClient).get(org.onap.aai.domain.yang.ServiceSubscription.class,
 245                 AAIUriFactory.createResourceUri(AAIObjectType.SERVICE_SUBSCRIPTION, globalSubscriberId,
 246                         subscriptionServiceType));
 247
 248         assertThat(bbInputSetupUtils.getAAIServiceSubscription(globalSubscriberId, subscriptionServiceType),
 249                 sameBeanAs(expected.get()));
 250     }
 251
 252     @Test
 253     public void getAAIServiceSubscriptionErrorsTest() {
 254         assertNull(bbInputSetupUtils.getAAIServiceSubscription(null, null));
 255         assertNull(bbInputSetupUtils.getAAIServiceSubscription("", ""));
 256         assertNull(bbInputSetupUtils.getAAIServiceSubscription("", null));
 257         assertNull(bbInputSetupUtils.getAAIServiceSubscription(null, ""));
 258     }
 259
 260     @Test
 261     public void getAAIServiceInstanceByIdTest() {
 262         final String serviceInstanceId = "serviceInstanceId";
 263         ServiceInstance expectedServiceInstance = new ServiceInstance();
 264
 265         doReturn(Optional.of(expectedServiceInstance)).when(MOCK_aaiResourcesClient).get(isA(Class.class),
 266                 isA(AAIResourceUri.class));
 267
 268         assertThat(bbInputSetupUtils.getAAIServiceInstanceById(serviceInstanceId), sameBeanAs(expectedServiceInstance));
 269     }
 270
 271     @Test
 272     public void getAAIServiceInstanceById_ifEmptyReturnNull() {
 273         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(eq(ServiceInstance.class),
 274                 any(AAIResourceUri.class));
 275
 276         assertNull(bbInputSetupUtils.getAAIServiceInstanceById("any"));
 277     }
 278
 279     @Test
 280     public void getAAIServiceInstanceByIdAndCustomerTest() {
 281         final String globalCustomerId = "globalCustomerId";
 282         final String serviceType = "serviceType";
 283         final String serviceInstanceId = "serviceInstanceId";
 284         ServiceInstance expected = new ServiceInstance();
 285         expected.setServiceInstanceId(serviceInstanceId);
 286
 287         doReturn(Optional.of(expected)).when(MOCK_aaiResourcesClient).get(ServiceInstance.class, AAIUriFactory
 288                 .createResourceUri(AAIObjectType.SERVICE_INSTANCE, globalCustomerId, serviceType, serviceInstanceId)
 289                 .depth(Depth.TWO));
 290
 291         assertThat(bbInputSetupUtils.getAAIServiceInstanceByIdAndCustomer(globalCustomerId, serviceType,
 292                 serviceInstanceId), sameBeanAs(expected));
 293     }
 294
 295     @Test
 296     public void getAAIServiceInstanceByIdAndCustomerNullTest() {
 297         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(eq(ServiceInstance.class),
 298                 any(AAIResourceUri.class));
 299
 300         assertNull(bbInputSetupUtils.getAAIServiceInstanceByIdAndCustomer("", "", ""));
 301     }
 302
 303     @Test
 304     public void getAAIServiceInstanceByNameTest() throws Exception {
 305         final String serviceInstanceName = "serviceInstanceName";
 306
 307         ServiceInstance expectedServiceInstance = new ServiceInstance();
 308         expectedServiceInstance.setServiceInstanceId("serviceInstanceId");
 309
 310         ServiceSubscription serviceSubscription = new ServiceSubscription();
 311         serviceSubscription.setServiceType("serviceType");
 312
 313         Customer customer = new Customer();
 314         customer.setGlobalCustomerId("globalCustomerId");
 315         customer.setServiceSubscription(serviceSubscription);
 316
 317         ServiceInstances serviceInstances = new ServiceInstances();
 318         serviceInstances.getServiceInstance().add(expectedServiceInstance);
 319
 320         doReturn(Optional.of(serviceInstances)).when(MOCK_aaiResourcesClient).get(isA(Class.class),
 321                 isA(AAIResourceUri.class));
 322
 323         assertThat(bbInputSetupUtils.getAAIServiceInstanceByName(serviceInstanceName, customer),
 324                 sameBeanAs(serviceInstances.getServiceInstance().get(0)));
 325     }
 326
 327     @Test
 328     public void getAAIServiceInstanceByNameExceptionTest() throws Exception {
 329         final String serviceInstanceName = "serviceInstanceName";
 330
 331         expectedException.expect(Exception.class);
 332         expectedException.expectMessage("Multiple Service Instances Returned");
 333
 334         ServiceInstance serviceInstance = new ServiceInstance();
 335         serviceInstance.setServiceInstanceId("serviceInstanceId");
 336
 337         ServiceSubscription serviceSubscription = new ServiceSubscription();
 338         serviceSubscription.setServiceType("serviceType");
 339
 340         Customer customer = new Customer();
 341         customer.setGlobalCustomerId("globalCustomerId");
 342         customer.setServiceSubscription(serviceSubscription);
 343
 344         ServiceInstances serviceInstances = new ServiceInstances();
 345         serviceInstances.getServiceInstance().add(serviceInstance);
 346         serviceInstances.getServiceInstance().add(serviceInstance);
 347
 348         doReturn(Optional.of(serviceInstances)).when(MOCK_aaiResourcesClient).get(isA(Class.class),
 349                 isA(AAIResourceUri.class));
 350
 351         bbInputSetupUtils.getAAIServiceInstanceByName(serviceInstanceName, customer);
 352     }
 353
 354     @Test
 355     public void getAAIServiceInstanceByNameNullTest() throws Exception {
 356         Customer customer = new Customer();
 357         customer.setServiceSubscription(new ServiceSubscription());
 358
 359         assertNull(bbInputSetupUtils.getAAIServiceInstanceByName("", customer));
 360     }
 361
 362     @Test
 363     public void getOptionalAAIServiceInstanceByNameExceptionTest() throws Exception {
 364         expectedException.expect(MultipleObjectsFoundException.class);
 365         expectedException.expectMessage(containsString(
 366                 "Multiple service instances found for customer-id: globalCustomerId, service-type: serviceType and service-instance-name: serviceInstanceId."));
 367
 368         final String globalCustomerId = "globalCustomerId";
 369         final String serviceType = "serviceType";
 370         final String serviceInstanceId = "serviceInstanceId";
 371
 372         ServiceInstance serviceInstance = new ServiceInstance();
 373         serviceInstance.setServiceInstanceId(serviceInstanceId);
 374         serviceInstance.setServiceType(serviceType);
 375
 376         ServiceInstances serviceInstances = new ServiceInstances();
 377         serviceInstances.getServiceInstance().add(serviceInstance);
 378         serviceInstances.getServiceInstance().add(serviceInstance);
 379
 380         doReturn(Optional.of(serviceInstances)).when(MOCK_aaiResourcesClient).get(isA(Class.class),
 381                 isA(AAIResourceUri.class));
 382
 383         bbInputSetupUtils.getAAIServiceInstanceByName(globalCustomerId, serviceType, serviceInstanceId);
 384     }
 385
 386     @Test
 387     public void getOptionalAAIServiceInstanceByNameNullTest() throws Exception {
 388         Optional<ServiceInstance> actual = bbInputSetupUtils.getAAIServiceInstanceByName("", "", "");
 389
 390         assertThat(actual, sameBeanAs(Optional.empty()));
 391     }
 392
 393     @Test
 394     public void getCatalogInstanceGroupNullTest() {
 395         assertNull(bbInputSetupUtils.getCatalogInstanceGroup(""));
 396     }
 397
 398     @Test
 399     public void getCatalogInstanceGroupTest() throws IOException {
 400         final String modelUUID = "modelUUIDTest";
 401         org.onap.so.db.catalog.beans.InstanceGroup expectedInstanceGroup = mapper.readValue(
 402                 new File(RESOURCE_PATH + "InstanceGroup.json"), org.onap.so.db.catalog.beans.InstanceGroup.class);
 403
 404         doReturn(expectedInstanceGroup).when(MOCK_catalogDbClient).getInstanceGroupByModelUUID(modelUUID);
 405
 406         assertThat(bbInputSetupUtils.getCatalogInstanceGroup(modelUUID), sameBeanAs(expectedInstanceGroup));
 407     }
 408
 409     @Test
 410     public void getCollectionResourceInstanceGroupCustomizationTest() {
 411         final String modelCustomizationUUID = "modelCustomizationUUID";
 412         CollectionResourceInstanceGroupCustomization expectedCollection =
 413                 new CollectionResourceInstanceGroupCustomization();
 414
 415         doReturn(Arrays.asList(expectedCollection)).when(MOCK_catalogDbClient)
 416                 .getCollectionResourceInstanceGroupCustomizationByModelCustUUID(modelCustomizationUUID);
 417
 418         assertThat(bbInputSetupUtils.getCollectionResourceInstanceGroupCustomization(modelCustomizationUUID),
 419                 sameBeanAs(Arrays.asList(expectedCollection)));
 420     }
 421
 422     @Test
 423     public void getAAIConfigurationNullTest() {
 424         assertNull(bbInputSetupUtils.getAAIConfiguration(""));
 425     }
 426
 427     @Test
 428     public void getAAIConfigurationTest() throws IOException {
 429         final String configurationId = "configurationId";
 430         Configuration expectedAaiConfiguration =
 431                 mapper.readValue(new File(RESOURCE_PATH + "ConfigurationInput.json"), Configuration.class);
 432
 433         doReturn(Optional.of(expectedAaiConfiguration)).when(MOCK_aaiResourcesClient).get(isA(Class.class),
 434                 isA(AAIResourceUri.class));
 435
 436         assertThat(bbInputSetupUtils.getAAIConfiguration(configurationId), sameBeanAs(expectedAaiConfiguration));
 437     }
 438
 439     @Test
 440     public void getAAIGenericVnfNullTest() {
 441         assertNull(bbInputSetupUtils.getAAIGenericVnf(""));
 442     }
 443
 444     @Test
 445     public void getAAIGenericVnfTest() throws IOException {
 446         final String vnfId = "vnfId";
 447         GenericVnf expectedAaiVnf =
 448                 mapper.readValue(new File(RESOURCE_PATH + "aaiGenericVnfInput.json"), GenericVnf.class);
 449
 450         doReturn(Optional.of(expectedAaiVnf)).when(MOCK_aaiResourcesClient).get(isA(Class.class),
 451                 eq(AAIUriFactory.createResourceUri(AAIObjectType.GENERIC_VNF, vnfId).depth(Depth.ONE)));
 452
 453         assertThat(bbInputSetupUtils.getAAIGenericVnf(vnfId), sameBeanAs(expectedAaiVnf));
 454     }
 455
 456     @Test
 457     public void getAAIResourceDepthOneTest() {
 458         AAIResourceUri aaiResourceUri = AAIUriFactory.createResourceUri(AAIObjectType.GENERIC_VNF, "anyVnfId");
 459         AAIResourceUri expectedUri = aaiResourceUri.clone().depth(Depth.ONE);
 460         AAIResourceUri aaiResourceUriClone = aaiResourceUri.clone();
 461
 462         bbInputSetupUtils.getAAIResourceDepthOne(aaiResourceUri);
 463
 464         verify(MOCK_aaiResourcesClient, times(1)).get(expectedUri);
 465         assertEquals("Uri should not have changed", aaiResourceUriClone.build(), aaiResourceUri.build());
 466     }
 467
 468     @Test
 469     public void getAAIResourceDepthTwoTest() {
 470         AAIResourceUri aaiResourceUri = AAIUriFactory.createResourceUri(AAIObjectType.GENERIC_VNF, "anyVnfId");
 471         AAIResourceUri expectedUri = aaiResourceUri.clone().depth(Depth.TWO);
 472         AAIResourceUri aaiResourceUriClone = aaiResourceUri.clone();
 473
 474         bbInputSetupUtils.getAAIResourceDepthTwo(aaiResourceUri);
 475
 476         verify(MOCK_aaiResourcesClient, times(1)).get(expectedUri);
 477         assertEquals("Uri should not have changed", aaiResourceUriClone.build(), aaiResourceUri.build());
 478     }
 479
 480     @Test
 481     public void getRelatedNetworkByNameFromServiceInstanceTest() throws Exception {
 482         final String networkId = "id123";
 483         final String networkName = "name123";
 484
 485         Optional<L3Networks> expected = Optional.of(new L3Networks());
 486         L3Network network = new L3Network();
 487         network.setNetworkId(networkId);
 488         network.setNetworkName(networkName);
 489         expected.get().getL3Network().add(network);
 490
 491         doReturn(expected).when(MOCK_aaiResourcesClient).get(eq(L3Networks.class), any(AAIResourceUri.class));
 492         Optional<L3Network> actual =
 493                 bbInputSetupUtils.getRelatedNetworkByNameFromServiceInstance(networkId, networkName);
 494
 495         assertTrue(actual.isPresent());
 496         assertEquals(networkId, actual.get().getNetworkId());
 497         assertEquals(networkName, actual.get().getNetworkName());
 498         assertEquals(expected.get().getL3Network().get(0).getNetworkId(), actual.get().getNetworkId());
 499     }
 500
 501     @Test
 502     public void getRelatedNetworkByNameFromServiceInstanceMultipleNetworksExceptionTest() throws Exception {
 503         final String serviceInstanceId = "serviceInstanceId";
 504         final String networkName = "networkName";
 505         expectedException.expect(MultipleObjectsFoundException.class);
 506         expectedException.expectMessage(
 507                 String.format("Multiple networks found for service-instance-id: %s and network-name: %s.",
 508                         serviceInstanceId, networkName));
 509
 510         L3Network network = new L3Network();
 511         network.setNetworkId("id123");
 512         network.setNetworkName("name123");
 513
 514         L3Networks l3Networks = new L3Networks();
 515         l3Networks.getL3Network().add(network);
 516         l3Networks.getL3Network().add(network);
 517         Optional<L3Networks> optNetworks = Optional.of(l3Networks);
 518
 519         doReturn(optNetworks).when(MOCK_aaiResourcesClient).get(eq(L3Networks.class), any(AAIResourceUri.class));
 520
 521         bbInputSetupUtils.getRelatedNetworkByNameFromServiceInstance(serviceInstanceId, networkName);
 522     }
 523
 524     @Test
 525     public void getRelatedNetworkByNameFromServiceInstanceNotFoundTest() throws Exception {
 526         assertEquals(Optional.empty(), bbInputSetupUtils.getRelatedNetworkByNameFromServiceInstance("", ""));
 527     }
 528
 529     @Test
 530     public void getRelatedServiceInstanceFromInstanceGroupTest() throws Exception {
 531         Optional<ServiceInstances> expected = Optional.of(new ServiceInstances());
 532         ServiceInstance serviceInstance = new ServiceInstance();
 533         serviceInstance.setServiceInstanceId("serviceInstanceId");
 534         serviceInstance.setServiceInstanceName("serviceInstanceName");
 535         expected.get().getServiceInstance().add(serviceInstance);
 536
 537         doReturn(expected).when(MOCK_aaiResourcesClient).get(eq(ServiceInstances.class), any(AAIResourceUri.class));
 538         Optional<ServiceInstance> actual = this.bbInputSetupUtils.getRelatedServiceInstanceFromInstanceGroup("ig-001");
 539
 540         assertTrue(actual.isPresent());
 541         assertEquals(expected.get().getServiceInstance().get(0).getServiceInstanceId(),
 542                 actual.get().getServiceInstanceId());
 543     }
 544
 545     @Test
 546     public void getRelatedServiceInstanceFromInstanceGroupMultipleExceptionTest() throws Exception {
 547         final String instanceGroupId = "ig-001";
 548         expectedException.expect(MultipleObjectsFoundException.class);
 549         expectedException.expectMessage(
 550                 String.format("Mulitple service instances were found for instance-group-id: %s.", instanceGroupId));
 551
 552         Optional<ServiceInstances> serviceInstances = Optional.of(new ServiceInstances());
 553         ServiceInstance si1 = Mockito.mock(ServiceInstance.class);
 554         ServiceInstance si2 = Mockito.mock(ServiceInstance.class);
 555         serviceInstances.get().getServiceInstance().add(si1);
 556         serviceInstances.get().getServiceInstance().add(si2);
 557
 558         doReturn(serviceInstances).when(MOCK_aaiResourcesClient).get(eq(ServiceInstances.class),
 559                 any(AAIResourceUri.class));
 560         bbInputSetupUtils.getRelatedServiceInstanceFromInstanceGroup(instanceGroupId);
 561     }
 562
 563     @Test
 564     public void getRelatedServiceInstanceFromInstanceGroupNotFoundExceptionTest() throws Exception {
 565         expectedException.expect(NoServiceInstanceFoundException.class);
 566         expectedException.expectMessage("No ServiceInstances Returned");
 567
 568         Optional<ServiceInstances> serviceInstances = Optional.of(new ServiceInstances());
 569
 570         doReturn(serviceInstances).when(MOCK_aaiResourcesClient).get(eq(ServiceInstances.class),
 571                 any(AAIResourceUri.class));
 572         bbInputSetupUtils.getRelatedServiceInstanceFromInstanceGroup("ig-001");
 573     }
 574
 575     @Test
 576     public void getRelatedVnfByNameFromServiceInstanceTest() throws Exception {
 577         final String vnfId = "id123";
 578         final String vnfName = "name123";
 579
 580         Optional<GenericVnfs> expected = Optional.of(new GenericVnfs());
 581         GenericVnf vnf = new GenericVnf();
 582         vnf.setVnfId(vnfId);
 583         vnf.setVnfName(vnfName);
 584         expected.get().getGenericVnf().add(vnf);
 585
 586         doReturn(expected).when(MOCK_aaiResourcesClient).get(eq(GenericVnfs.class), any(AAIResourceUri.class));
 587         Optional<GenericVnf> actual = this.bbInputSetupUtils.getRelatedVnfByNameFromServiceInstance(vnfId, vnfName);
 588
 589         assertTrue(actual.isPresent());
 590         assertEquals(expected.get().getGenericVnf().get(0).getVnfId(), actual.get().getVnfId());
 591     }
 592
 593     @Test
 594     public void getRelatedVnfByNameFromServiceInstanceMultipleVnfsExceptionTest() throws Exception {
 595         final String serviceInstanceId = "serviceInstanceId";
 596         final String vnfName = "vnfName";
 597         expectedException.expect(MultipleObjectsFoundException.class);
 598         expectedException.expectMessage(String.format(
 599                 "Multiple vnfs found for service-instance-id: %s and vnf-name: %s.", serviceInstanceId, vnfName));
 600
 601         GenericVnf vnf = new GenericVnf();
 602         vnf.setVnfId("id123");
 603         vnf.setVnfName("name123");
 604
 605         GenericVnfs vnfs = new GenericVnfs();
 606         vnfs.getGenericVnf().add(vnf);
 607         vnfs.getGenericVnf().add(vnf);
 608
 609         Optional<GenericVnfs> optVnfs = Optional.of(vnfs);
 610         doReturn(optVnfs).when(MOCK_aaiResourcesClient).get(eq(GenericVnfs.class), any(AAIResourceUri.class));
 611
 612         bbInputSetupUtils.getRelatedVnfByNameFromServiceInstance(serviceInstanceId, vnfName);
 613     }
 614
 615     @Test
 616     public void getRelatedVnfByNameFromServiceInstanceNotFoundTest() throws Exception {
 617         final String serviceInstanceId = "serviceInstanceId";
 618         final String vnfName = "vnfName";
 619
 620         assertEquals(Optional.empty(),
 621                 bbInputSetupUtils.getRelatedVnfByNameFromServiceInstance(serviceInstanceId, vnfName));
 622     }
 623
 624     @Test
 625     public void getRelatedVolumeGroupByNameFromVnfTest() throws Exception {
 626         final String vnfId = "id123";
 627         final String vnfName = "name123";
 628
 629         Optional<VolumeGroups> expected = Optional.of(new VolumeGroups());
 630         VolumeGroup volumeGroup = new VolumeGroup();
 631         volumeGroup.setVolumeGroupId(vnfId);
 632         volumeGroup.setVolumeGroupName(vnfName);
 633         expected.get().getVolumeGroup().add(volumeGroup);
 634
 635         doReturn(expected).when(MOCK_aaiResourcesClient).get(eq(VolumeGroups.class), any(AAIResourceUri.class));
 636         Optional<VolumeGroup> actual = this.bbInputSetupUtils.getRelatedVolumeGroupByNameFromVnf(vnfId, vnfName);
 637
 638         assertTrue(actual.isPresent());
 639         assertEquals(expected.get().getVolumeGroup().get(0).getVolumeGroupId(), actual.get().getVolumeGroupId());
 640     }
 641
 642     @Test
 643     public void getRelatedVolumeGroupByNameFromVnfMultipleVolumeGroupsExceptionTest() throws Exception {
 644         final String vnfId = "vnfId";
 645         final String volumeGroupName = "volumeGroupName";
 646         expectedException.expect(MultipleObjectsFoundException.class);
 647         expectedException.expectMessage(String.format(
 648                 "Multiple volume-groups found for vnf-id: %s and volume-group-name: %s.", vnfId, volumeGroupName));
 649
 650         VolumeGroup volumeGroup = new VolumeGroup();
 651         volumeGroup.setVolumeGroupId("id123");
 652         volumeGroup.setVolumeGroupName("name123");
 653
 654         VolumeGroups volumeGroups = new VolumeGroups();
 655         volumeGroups.getVolumeGroup().add(volumeGroup);
 656         volumeGroups.getVolumeGroup().add(volumeGroup);
 657         Optional<VolumeGroups> optVolumeGroups = Optional.of(volumeGroups);
 658
 659         doReturn(optVolumeGroups).when(MOCK_aaiResourcesClient).get(eq(VolumeGroups.class), any(AAIResourceUri.class));
 660
 661         bbInputSetupUtils.getRelatedVolumeGroupByNameFromVnf(vnfId, volumeGroupName);
 662     }
 663
 664     @Test
 665     public void getRelatedVolumeGroupByNameFromVnfNotFoundTest() throws Exception {
 666         assertEquals(Optional.empty(), bbInputSetupUtils.getRelatedVolumeGroupByNameFromVnf("", ""));
 667     }
 668
 669     @Test
 670     public void getRelatedVolumeGroupByNameFromVfModuleTest() throws Exception {
 671         Optional<VolumeGroups> expected = Optional.of(new VolumeGroups());
 672         VolumeGroup volumeGroup = new VolumeGroup();
 673         volumeGroup.setVolumeGroupId("id123");
 674         volumeGroup.setVolumeGroupName("name123");
 675         expected.get().getVolumeGroup().add(volumeGroup);
 676
 677         doReturn(expected).when(MOCK_aaiResourcesClient).get(eq(VolumeGroups.class), any(AAIResourceUri.class));
 678         Optional<VolumeGroup> actual =
 679                 this.bbInputSetupUtils.getRelatedVolumeGroupByNameFromVfModule("id123", "id123", "name123");
 680
 681         assertTrue(actual.isPresent());
 682         assertEquals(expected.get().getVolumeGroup().get(0).getVolumeGroupId(), actual.get().getVolumeGroupId());
 683     }
 684
 685     @Test
 686     public void getRelatedVolumeGroupFromVfModuleMultipleVolumeGroupsExceptionTest() throws Exception {
 687         expectedException.expect(Exception.class);
 688         final String vnfId = "vnfId";
 689         final String volumeGroupId = "volumeGroupId";
 690
 691         VolumeGroup volumeGroup = new VolumeGroup();
 692         volumeGroup.setVolumeGroupId("id123");
 693         volumeGroup.setVolumeGroupName("name123");
 694
 695         VolumeGroups expectedVolumeGroup = new VolumeGroups();
 696         expectedVolumeGroup.getVolumeGroup().add(volumeGroup);
 697         expectedVolumeGroup.getVolumeGroup().add(volumeGroup);
 698
 699         doReturn(expectedVolumeGroup).when(MOCK_aaiResourcesClient).get(eq(VolumeGroups.class),
 700                 any(AAIResourceUri.class));
 701
 702         bbInputSetupUtils.getRelatedVolumeGroupFromVfModule(vnfId, volumeGroupId);
 703     }
 704
 705     @Test
 706     public void getRelatedVolumeGroupFromVfModuleNotFoundTest() throws Exception {
 707         final String vnfId = "vnfId";
 708         final String volumeGroupId = "volumeGroupId";
 709
 710         assertEquals(Optional.empty(), bbInputSetupUtils.getRelatedVolumeGroupFromVfModule(vnfId, volumeGroupId));
 711     }
 712
 713     @Test
 714     public void getRelatedVolumeGroupFromVfModuleTest() throws Exception {
 715         Optional<VolumeGroups> expected = Optional.of(new VolumeGroups());
 716         VolumeGroup volumeGroup = new VolumeGroup();
 717         volumeGroup.setVolumeGroupId("id123");
 718         expected.get().getVolumeGroup().add(volumeGroup);
 719
 720         doReturn(expected).when(MOCK_aaiResourcesClient).get(eq(VolumeGroups.class), any(AAIResourceUri.class));
 721         Optional<VolumeGroup> actual = bbInputSetupUtils.getRelatedVolumeGroupFromVfModule("id123", "id123");
 722
 723         assertTrue(actual.isPresent());
 724         assertEquals(expected.get().getVolumeGroup().get(0).getVolumeGroupId(), actual.get().getVolumeGroupId());
 725     }
 726
 727     @Test
 728     public void getRelatedVolumeGroupByNameFromVfModuleMultipleVolumeGroupsExceptionTest() throws Exception {
 729         final String vnfId = "vnfId";
 730         final String vfModuleId = "vfModuleId";
 731         final String volumeGroupName = "volumeGroupName";
 732
 733         expectedException.expect(MultipleObjectsFoundException.class);
 734         expectedException.expectMessage(String.format(
 735                 "Multiple voulme-groups found for vnf-id: %s, vf-module-id: %s and volume-group-name: %s.", vnfId,
 736                 vfModuleId, volumeGroupName));
 737
 738         VolumeGroup volumeGroup = new VolumeGroup();
 739         volumeGroup.setVolumeGroupId("id123");
 740         volumeGroup.setVolumeGroupName("name123");
 741
 742         VolumeGroups volumeGroups = new VolumeGroups();
 743         volumeGroups.getVolumeGroup().add(volumeGroup);
 744         volumeGroups.getVolumeGroup().add(volumeGroup);
 745
 746         Optional<VolumeGroups> optVolumeGroups = Optional.of(volumeGroups);
 747         doReturn(optVolumeGroups).when(MOCK_aaiResourcesClient).get(eq(VolumeGroups.class), any(AAIResourceUri.class));
 748
 749         bbInputSetupUtils.getRelatedVolumeGroupByNameFromVfModule(vnfId, vfModuleId, volumeGroupName);
 750     }
 751
 752     @Test
 753     public void getRelatedVolumeGroupByNameFromVfModuleNotFoundTest() throws Exception {
 754         assertEquals(Optional.empty(), bbInputSetupUtils.getRelatedVolumeGroupByNameFromVfModule("", "", ""));
 755     }
 756
 757     @Test
 758     public void loadOriginalFlowExecutionPathTest() throws IOException {
 759         final String requestId = "123";
 760         final String originalRequestId = "originalRequestId";
 761         final String flowsToExecuteString = new String(
 762                 Files.readAllBytes(Paths.get(RESOURCE_PATH + "FlowsToExecute.json")), StandardCharsets.UTF_8);
 763
 764         InfraActiveRequests request = new InfraActiveRequests();
 765         ExecuteBuildingBlock[] expectedFlowsToExecute =
 766                 mapper.readValue(flowsToExecuteString, ExecuteBuildingBlock[].class);
 767
 768         request.setRequestId(requestId);
 769         request.setOriginalRequestId(originalRequestId);
 770         doReturn(request).when(MOCK_requestsDbClient).getInfraActiveRequestbyRequestId(requestId);
 771
 772         RequestProcessingData requestProcessingData = new RequestProcessingData();
 773         requestProcessingData.setValue(flowsToExecuteString);
 774         doReturn(requestProcessingData).when(MOCK_requestsDbClient)
 775                 .getRequestProcessingDataBySoRequestIdAndName(anyString(), anyString());
 776
 777         List<ExecuteBuildingBlock> flowsToExecute = bbInputSetupUtils.loadOriginalFlowExecutionPath(requestId);
 778
 779         assertEquals(mapper.writeValueAsString(expectedFlowsToExecute), mapper.writeValueAsString(flowsToExecute));
 780     }
 781
 782     @Test
 783     public void getRelatedConfigurationByNameFromServiceInstanceExceptionTest() throws Exception {
 784         Configuration configuration = new Configuration();
 785         configuration.setConfigurationId("id123");
 786
 787         Configurations configurations = new Configurations();
 788         configurations.getConfiguration().add(configuration);
 789         configurations.getConfiguration().add(configuration);
 790
 791         Optional<Configurations> optConfigurations = Optional.of(configurations);
 792
 793         doReturn(optConfigurations).when(MOCK_aaiResourcesClient).get(eq(Configurations.class),
 794                 any(AAIResourceUri.class));
 795
 796         expectedException.expect(MultipleObjectsFoundException.class);
 797         this.bbInputSetupUtils.getRelatedConfigurationByNameFromServiceInstance("id123", "name123");
 798     }
 799
 800     @Test
 801     public void getRelatedConfigurationByNameFromServiceInstanceNotFoundTest() throws Exception {
 802         assertEquals(Optional.empty(), bbInputSetupUtils.getRelatedConfigurationByNameFromServiceInstance("", ""));
 803     }
 804
 805     @Test
 806     public void getRelatedConfigurationByNameFromServiceInstanceTest() throws Exception {
 807         Optional<Configurations> expected = Optional.of(new Configurations());
 808         Configuration configuration = new Configuration();
 809         configuration.setConfigurationId("id123");
 810         expected.get().getConfiguration().add(configuration);
 811
 812         doReturn(expected).when(MOCK_aaiResourcesClient).get(eq(Configurations.class), any(AAIResourceUri.class));
 813         Optional<Configuration> actual =
 814                 this.bbInputSetupUtils.getRelatedConfigurationByNameFromServiceInstance("id123", "name123");
 815
 816         assertTrue(actual.isPresent());
 817         assertEquals(expected.get().getConfiguration().get(0).getConfigurationId(), actual.get().getConfigurationId());
 818     }
 819
 820     @Test
 821     public void existsAAIVfModuleGloballyByNameTest() {
 822         AAIResourceUri expectedUri =
 823                 AAIUriFactory.createNodesUri(AAIObjectPlurals.VF_MODULE).queryParam("vf-module-name", "testVfModule");
 824         bbInputSetupUtils.existsAAIVfModuleGloballyByName("testVfModule");
 825
 826         verify(MOCK_aaiResourcesClient, times(1)).exists(expectedUri);
 827     }
 828
 829     @Test
 830     public void existsAAIConfigurationGloballyByNameTest() {
 831         AAIResourceUri expectedUri = AAIUriFactory.createResourceUri(AAIObjectPlurals.CONFIGURATION)
 832                 .queryParam("configuration-name", "testConfig");
 833         bbInputSetupUtils.existsAAIConfigurationGloballyByName("testConfig");
 834
 835         verify(MOCK_aaiResourcesClient, times(1)).exists(expectedUri);
 836     }
 837
 838     @Test
 839     public void existsAAINetworksGloballyByNameTest() {
 840         AAIResourceUri expectedUri =
 841                 AAIUriFactory.createResourceUri(AAIObjectPlurals.L3_NETWORK).queryParam("network-name", "testNetwork");
 842         bbInputSetupUtils.existsAAINetworksGloballyByName("testNetwork");
 843
 844         verify(MOCK_aaiResourcesClient, times(1)).exists(expectedUri);
 845     }
 846
 847     @Test
 848     public void existsAAIVolumeGroupGloballyByNameTest() {
 849         AAIResourceUri expectedUri = AAIUriFactory.createNodesUri(AAIObjectPlurals.VOLUME_GROUP)
 850                 .queryParam("volume-group-name", "testVoumeGroup");
 851
 852         bbInputSetupUtils.existsAAIVolumeGroupGloballyByName("testVoumeGroup");
 853         verify(MOCK_aaiResourcesClient, times(1)).exists(expectedUri);
 854     }
 855
 856     @Test
 857     public void shouldChangeInfraActiveRequestVnfId() throws IOException {
 858         final String vnfId = "vnfId";
 859         InfraActiveRequests infraActiveRequests = loadExpectedInfraActiveRequest();
 860
 861         bbInputSetupUtils.updateInfraActiveRequestVnfId(infraActiveRequests, vnfId);
 862
 863         assertEquals(infraActiveRequests.getVnfId(), vnfId);
 864     }
 865
 866     @Test
 867     public void shouldChangeInfraActiveRequestVfModuleId() throws IOException {
 868         final String vfModuleId = "vfModuleId";
 869         InfraActiveRequests infraActiveRequests = loadExpectedInfraActiveRequest();
 870
 871         bbInputSetupUtils.updateInfraActiveRequestVfModuleId(infraActiveRequests, vfModuleId);
 872
 873         assertEquals(infraActiveRequests.getVfModuleId(), vfModuleId);
 874     }
 875
 876     @Test
 877     public void shouldChangeInfraActiveRequestVolumeGroupId() throws IOException {
 878         final String volumeGroupId = "volumeGroupId";
 879         InfraActiveRequests infraActiveRequests = loadExpectedInfraActiveRequest();
 880
 881         bbInputSetupUtils.updateInfraActiveRequestVolumeGroupId(infraActiveRequests, volumeGroupId);
 882
 883         assertEquals(infraActiveRequests.getVolumeGroupId(), volumeGroupId);
 884     }
 885
 886     @Test
 887     public void shouldChangeInfraActiveRequestNetworkId() throws IOException {
 888         final String networkId = "activeRequestNetworkId";
 889         InfraActiveRequests infraActiveRequests = loadExpectedInfraActiveRequest();
 890
 891         bbInputSetupUtils.updateInfraActiveRequestNetworkId(infraActiveRequests, networkId);
 892
 893         assertEquals(infraActiveRequests.getNetworkId(), networkId);
 894     }
 895
 896     @Test
 897     public void getAAIVpnBindingNullTest() {
 898         assertNull(bbInputSetupUtils.getAAIVpnBinding("vpnBindingId"));
 899     }
 900
 901     @Test
 902     public void getAAIVolumeGroupNullTest() {
 903         VolumeGroup actualAaiVnf =
 904                 bbInputSetupUtils.getAAIVolumeGroup("cloudOwnerId", "cloudRegionId", "volumeGroupId");
 905         assertNull(actualAaiVnf);
 906     }
 907
 908     @Test
 909     public void getAAIVfModuleNullTest() {
 910         assertNull(bbInputSetupUtils.getAAIVfModule("vnfId", "vfModuleId"));
 911     }
 912
 913     @Test
 914     public void getAAIL3NetworkNullTest() {
 915         assertNull(bbInputSetupUtils.getAAIL3Network("networkId"));
 916     }
 917
 918     @Test
 919     public void getAICVpnBindingFromNetwork_noVpnBindingTest() throws IOException {
 920         L3Network l3Network =
 921                 mapper.readValue(new File(RESOURCE_PATH + "aaiL3NetworkInputWithSubnets.json"), L3Network.class);
 922
 923         Optional<VpnBinding> actual = bbInputSetupUtils.getAICVpnBindingFromNetwork(l3Network);
 924         assertEquals(actual, Optional.empty());
 925     }
 926
 927     @Test
 928     public void getAAIServiceInstancesGloballyByName_noAAIResourceTest() {
 929         final String serviceInstanceName = "serviceInstanceName";
 930
 931         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(isA(Class.class), isA(AAIResourceUri.class));
 932         ServiceInstances actualServiceInstances =
 933                 bbInputSetupUtils.getAAIServiceInstancesGloballyByName(serviceInstanceName);
 934
 935         assertNull(actualServiceInstances);
 936     }
 937
 938     @Test
 939     public void getAAIVnfsGloballyByName_noAAIResourceTest() {
 940         final String vnfName = "vnfName";
 941
 942         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(isA(Class.class), isA(AAIResourceUri.class));
 943         GenericVnfs actualGenericVnfs = bbInputSetupUtils.getAAIVnfsGloballyByName(vnfName);
 944
 945         assertNull(actualGenericVnfs);
 946     }
 947
 948     private InfraActiveRequests loadExpectedInfraActiveRequest() throws IOException {
 949         return mapper.readValue(new File(RESOURCE_PATH + "InfraActiveRequestExpected.json"), InfraActiveRequests.class);
 950     }
 951 }