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