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