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