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  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.so.bpmn.servicedecomposition.tasks;
  22
  23 import static com.shazam.shazamcrest.MatcherAssert.assertThat;
  24 import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
  25 import static org.junit.Assert.assertEquals;
  26 import static org.junit.Assert.assertNull;
  27 import static org.mockito.ArgumentMatchers.any;
  28 import static org.mockito.ArgumentMatchers.eq;
  29 import static org.mockito.ArgumentMatchers.isA;
  30 import static org.mockito.Mockito.doReturn;
  31 import static org.mockito.Mockito.times;
  32 import static org.mockito.Mockito.verify;
  33 import java.io.File;
  34 import java.io.IOException;
  35 import java.util.Arrays;
  36 import java.util.List;
  37 import java.util.Optional;
  38 import org.junit.Before;
  39 import org.junit.Rule;
  40 import org.junit.Test;
  41 import org.junit.rules.ExpectedException;
  42 import org.junit.runner.RunWith;
  43 import org.mockito.InjectMocks;
  44 import org.mockito.Mock;
  45 import org.mockito.Mockito;
  46 import org.mockito.junit.MockitoJUnitRunner;
  47 import org.onap.aai.domain.yang.CloudRegion;
  48 import org.onap.aai.domain.yang.Configuration;
  49 import org.onap.aai.domain.yang.GenericVnf;
  50 import org.onap.aai.domain.yang.GenericVnfs;
  51 import org.onap.aai.domain.yang.L3Network;
  52 import org.onap.aai.domain.yang.L3Networks;
  53 import org.onap.aai.domain.yang.ServiceInstance;
  54 import org.onap.aai.domain.yang.ServiceInstances;
  55 import org.onap.aai.domain.yang.VolumeGroup;
  56 import org.onap.aai.domain.yang.VolumeGroups;
  57 import org.onap.so.bpmn.common.InjectionHelper;
  58 import org.onap.so.bpmn.servicedecomposition.bbobjects.Customer;
  59 import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceSubscription;
  60 import org.onap.so.bpmn.servicedecomposition.tasks.exceptions.MultipleObjectsFoundException;
  61 import org.onap.so.bpmn.servicedecomposition.tasks.exceptions.NoServiceInstanceFoundException;
  62 import org.onap.so.client.aai.AAIObjectPlurals;
  63 import org.onap.so.client.aai.AAIObjectType;
  64 import org.onap.so.client.aai.AAIResourcesClient;
  65 import org.onap.so.client.aai.entities.uri.AAIResourceUri;
  66 import org.onap.so.client.aai.entities.uri.AAIUriFactory;
  67 import org.onap.so.client.graphinventory.entities.uri.Depth;
  68 import org.onap.so.db.catalog.beans.CollectionResourceInstanceGroupCustomization;
  69 import org.onap.so.db.catalog.beans.Service;
  70 import org.onap.so.db.catalog.beans.VnfcInstanceGroupCustomization;
  71 import org.onap.so.db.catalog.client.CatalogDbClient;
  72 import org.onap.so.db.request.beans.InfraActiveRequests;
  73 import org.onap.so.db.request.client.RequestsDbClient;
  74 import org.onap.so.serviceinstancebeans.CloudConfiguration;
  75 import org.onap.so.serviceinstancebeans.ModelInfo;
  76 import org.onap.so.serviceinstancebeans.RequestDetails;
  77 import com.fasterxml.jackson.core.JsonParseException;
  78 import com.fasterxml.jackson.databind.JsonMappingException;
  79 import com.fasterxml.jackson.databind.ObjectMapper;
  80
  81 @RunWith(MockitoJUnitRunner.class)
  82 public class BBInputSetupUtilsTest {
  83     protected ObjectMapper mapper = new ObjectMapper();
  84     private static final String RESOURCE_PATH = "src/test/resources/__files/ExecuteBuildingBlock/";
  85
  86     @InjectMocks
  87     BBInputSetupUtils bbInputSetupUtils = new BBInputSetupUtils();
  88
  89     @Mock
  90     protected CatalogDbClient MOCK_catalogDbClient;
  91
  92     @Mock
  93     protected RequestsDbClient MOCK_requestsDbClient;
  94
  95     @Mock
  96     protected AAIResourcesClient MOCK_aaiResourcesClient;
  97
  98     @Mock
  99     protected InjectionHelper MOCK_injectionHelper;
 100
 101     @Rule
 102     public ExpectedException expectedException = ExpectedException.none();
 103
 104     @Before
 105     public void setup() {
 106         doReturn(MOCK_aaiResourcesClient).when(MOCK_injectionHelper).getAaiClient();
 107     }
 108
 109     @Test
 110     public void testGetCatalogServiceByModelUUID() throws JsonParseException, JsonMappingException, IOException {
 111         Service expected = mapper.readValue(new File(RESOURCE_PATH + "CatalogServiceExpected.json"), Service.class);
 112
 113         RequestDetails requestDetails = new RequestDetails();
 114         ModelInfo modelInfo = new ModelInfo();
 115         modelInfo.setModelVersionId("modelUUID");
 116         requestDetails.setModelInfo(modelInfo);
 117         doReturn(expected).when(MOCK_catalogDbClient).getServiceByID("modelUUID");
 118         Service actual = bbInputSetupUtils.getCatalogServiceByModelUUID(modelInfo.getModelVersionId());
 119
 120         assertThat(actual, sameBeanAs(expected));
 121     }
 122
 123     @Test
 124     public void testGetCatalogServiceByModelVersionAndModelInvariantUUID()
 125             throws JsonParseException, JsonMappingException, IOException {
 126         String modelVersion = "modelVersion";
 127         String modelInvariantUUID = "modelInvariantUUID";
 128         Service expectedService =
 129                 mapper.readValue(new File(RESOURCE_PATH + "CatalogServiceExpected.json"), Service.class);
 130
 131         doReturn(expectedService).when(MOCK_catalogDbClient)
 132                 .getServiceByModelVersionAndModelInvariantUUID(isA(String.class), isA(String.class));
 133
 134         Service actualService = bbInputSetupUtils.getCatalogServiceByModelVersionAndModelInvariantUUID(modelVersion,
 135                 modelInvariantUUID);
 136
 137         assertThat(actualService, sameBeanAs(expectedService));
 138     }
 139
 140     @Test
 141     public void testGetVnfcInstanceGroups() throws JsonParseException, JsonMappingException, IOException {
 142         VnfcInstanceGroupCustomization vnfc = mapper.readValue(
 143                 new File(RESOURCE_PATH + "VnfcInstanceGroupCustomization.json"), VnfcInstanceGroupCustomization.class);
 144         String modelCustomizationUUID = "modelCustomizationUUID";
 145
 146         doReturn(Arrays.asList(vnfc)).when(MOCK_catalogDbClient)
 147                 .getVnfcInstanceGroupsByVnfResourceCust(isA(String.class));
 148
 149         List<VnfcInstanceGroupCustomization> actualVnfcList =
 150                 bbInputSetupUtils.getVnfcInstanceGroups(modelCustomizationUUID);
 151
 152         assertThat(actualVnfcList, sameBeanAs(Arrays.asList(vnfc)));
 153     }
 154
 155     @Test
 156     public void testGetRequestDetails() throws JsonParseException, JsonMappingException, IOException {
 157         InfraActiveRequests infraActiveRequest = mapper
 158                 .readValue(new File(RESOURCE_PATH + "InfraActiveRequestExpected.json"), InfraActiveRequests.class);
 159
 160         RequestDetails expected =
 161                 mapper.readValue(new File(RESOURCE_PATH + "RequestDetailsExpected.json"), RequestDetails.class);
 162         String requestId = "requestId";
 163         doReturn(infraActiveRequest).when(MOCK_requestsDbClient).getInfraActiveRequestbyRequestId(requestId);
 164         RequestDetails actual = bbInputSetupUtils.getRequestDetails(requestId);
 165
 166         assertThat(actual, sameBeanAs(expected));
 167     }
 168
 169     @Test
 170     public void getRequestDetailsNullTest() throws IOException {
 171         RequestDetails requestDetails = bbInputSetupUtils.getRequestDetails("");
 172
 173         assertNull(requestDetails);
 174     }
 175
 176     @Test
 177     public void testGetCloudRegion() {
 178         CloudConfiguration cloudConfig = new CloudConfiguration();
 179         cloudConfig.setLcpCloudRegionId("lcpCloudRegionId");
 180         Optional<org.onap.aai.domain.yang.CloudRegion> expected =
 181                 Optional.of(new org.onap.aai.domain.yang.CloudRegion());
 182         expected.get().setCloudOwner("cloudOwner");
 183         expected.get().setCloudRegionId("lcpCloudRegionId");
 184         doReturn(expected).when(MOCK_aaiResourcesClient).get(org.onap.aai.domain.yang.CloudRegion.class,
 185                 AAIUriFactory.createResourceUri(AAIObjectType.CLOUD_REGION, cloudConfig.getCloudOwner(),
 186                         cloudConfig.getLcpCloudRegionId()).depth(Depth.TWO));
 187
 188         AAIResourceUri expectedUri = AAIUriFactory.createResourceUri(AAIObjectType.CLOUD_REGION,
 189                 cloudConfig.getCloudOwner(), cloudConfig.getLcpCloudRegionId()).depth(Depth.TWO);
 190         bbInputSetupUtils.getCloudRegion(cloudConfig);
 191
 192         verify(MOCK_aaiResourcesClient, times(1)).get(CloudRegion.class, expectedUri);
 193     }
 194
 195     @Test
 196     public void testGetCloudRegionExceptionTest() {
 197
 198         CloudConfiguration cloudConfig = new CloudConfiguration();
 199         cloudConfig.setLcpCloudRegionId("lcpCloudRegionId");
 200
 201         RequestDetails requestDetails = new RequestDetails();
 202         requestDetails.setCloudConfiguration(cloudConfig);
 203
 204         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(isA(Class.class), isA(AAIResourceUri.class));
 205
 206         CloudRegion cloudRegion = bbInputSetupUtils.getCloudRegion(cloudConfig);
 207
 208         assertNull(cloudRegion);
 209     }
 210
 211     @Test
 212     public void testGetCloudRegionEmptyId() {
 213         CloudConfiguration cloudConfig = new CloudConfiguration();
 214         cloudConfig.setLcpCloudRegionId("");
 215
 216         RequestDetails requestDetails = new RequestDetails();
 217         requestDetails.setCloudConfiguration(cloudConfig);
 218
 219         CloudRegion cloudRegion = bbInputSetupUtils.getCloudRegion(cloudConfig);
 220
 221         assertNull(cloudRegion);
 222     }
 223
 224     @Test
 225     public void testGetCloudRegionEmptyConfiguration() {
 226         RequestDetails requestDetails = new RequestDetails();
 227
 228         CloudRegion cloudRegion = bbInputSetupUtils.getCloudRegion(requestDetails.getCloudConfiguration());
 229
 230         assertNull(cloudRegion);
 231     }
 232
 233     @Test
 234     public void testGetAAIInstanceGroup() {
 235         Optional<org.onap.aai.domain.yang.InstanceGroup> expected =
 236                 Optional.of(new org.onap.aai.domain.yang.InstanceGroup());
 237         String instanceGroupId = "instanceGroupId";
 238         expected.get().setId(instanceGroupId);
 239         doReturn(expected).when(MOCK_aaiResourcesClient).get(org.onap.aai.domain.yang.InstanceGroup.class,
 240                 AAIUriFactory.createResourceUri(AAIObjectType.INSTANCE_GROUP, instanceGroupId));
 241         AAIResourceUri expectedUri = AAIUriFactory.createResourceUri(AAIObjectType.INSTANCE_GROUP, instanceGroupId);
 242
 243         bbInputSetupUtils.getAAIInstanceGroup(instanceGroupId);
 244         verify(MOCK_aaiResourcesClient, times(1)).get(org.onap.aai.domain.yang.InstanceGroup.class, expectedUri);
 245     }
 246
 247     @Test
 248     public void testGetAAIInstanceGroupThrowNotFound() {
 249         String instanceGroupId = "instanceGroupId";
 250         doReturn(MOCK_aaiResourcesClient).when(MOCK_injectionHelper).getAaiClient();
 251         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(org.onap.aai.domain.yang.InstanceGroup.class,
 252                 AAIUriFactory.createResourceUri(AAIObjectType.INSTANCE_GROUP, instanceGroupId));
 253
 254         org.onap.aai.domain.yang.InstanceGroup actual = bbInputSetupUtils.getAAIInstanceGroup(instanceGroupId);
 255
 256         assertNull(actual);
 257     }
 258
 259     @Test
 260     public void testGetAAICustomer() {
 261         Optional<org.onap.aai.domain.yang.Customer> expected = Optional.of(new org.onap.aai.domain.yang.Customer());
 262         String globalSubscriberId = "globalSubscriberId";
 263         expected.get().setGlobalCustomerId(globalSubscriberId);
 264         doReturn(expected).when(MOCK_aaiResourcesClient).get(org.onap.aai.domain.yang.Customer.class,
 265                 AAIUriFactory.createResourceUri(AAIObjectType.CUSTOMER, globalSubscriberId));
 266         AAIResourceUri expectedUri = AAIUriFactory.createResourceUri(AAIObjectType.CUSTOMER, globalSubscriberId);
 267
 268         bbInputSetupUtils.getAAICustomer(globalSubscriberId);
 269         verify(MOCK_aaiResourcesClient, times(1)).get(org.onap.aai.domain.yang.Customer.class, expectedUri);
 270     }
 271
 272     @Test
 273     public void testGetAAICustomerThrowNotFound() {
 274         String globalSubscriberId = "globalSubscriberId";
 275         doReturn(MOCK_aaiResourcesClient).when(MOCK_injectionHelper).getAaiClient();
 276         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(org.onap.aai.domain.yang.Customer.class,
 277                 AAIUriFactory.createResourceUri(AAIObjectType.CUSTOMER, globalSubscriberId));
 278
 279         org.onap.aai.domain.yang.Customer actual = bbInputSetupUtils.getAAICustomer(globalSubscriberId);
 280
 281         assertNull(actual);
 282     }
 283
 284     @Test
 285     public void testGetAAIServiceSubscription() {
 286         Optional<org.onap.aai.domain.yang.ServiceSubscription> expected =
 287                 Optional.of(new org.onap.aai.domain.yang.ServiceSubscription());
 288         String globalSubscriberId = "globalSubscriberId";
 289         String subscriptionServiceType = "subscriptionServiceType";
 290         expected.get().setServiceType(subscriptionServiceType);
 291         doReturn(expected).when(MOCK_aaiResourcesClient).get(org.onap.aai.domain.yang.ServiceSubscription.class,
 292                 AAIUriFactory.createResourceUri(AAIObjectType.SERVICE_SUBSCRIPTION, globalSubscriberId,
 293                         subscriptionServiceType));
 294         AAIResourceUri expectedUri = AAIUriFactory.createResourceUri(AAIObjectType.SERVICE_SUBSCRIPTION,
 295                 globalSubscriberId, subscriptionServiceType);
 296
 297         bbInputSetupUtils.getAAIServiceSubscription(globalSubscriberId, subscriptionServiceType);
 298         verify(MOCK_aaiResourcesClient, times(1)).get(org.onap.aai.domain.yang.ServiceSubscription.class, expectedUri);
 299     }
 300
 301     @Test
 302     public void testGetAAIServiceSubscriptionErrors() {
 303         String globalSubId = null;
 304         String subServiceType = null;
 305         org.onap.aai.domain.yang.ServiceSubscription actual =
 306                 bbInputSetupUtils.getAAIServiceSubscription(globalSubId, subServiceType);
 307         assertNull(actual);
 308
 309         String globalSubId2 = "";
 310         String subServiceType2 = "";
 311         org.onap.aai.domain.yang.ServiceSubscription actual2 =
 312                 bbInputSetupUtils.getAAIServiceSubscription(globalSubId2, subServiceType2);
 313         assertNull(actual2);
 314
 315         String globalSubId3 = "";
 316         String subServiceType3 = null;
 317         org.onap.aai.domain.yang.ServiceSubscription actual3 =
 318                 bbInputSetupUtils.getAAIServiceSubscription(globalSubId3, subServiceType3);
 319         assertNull(actual3);
 320
 321         String globalSubId4 = null;
 322         String subServiceType4 = "";
 323         org.onap.aai.domain.yang.ServiceSubscription actual4 =
 324                 bbInputSetupUtils.getAAIServiceSubscription(globalSubId4, subServiceType4);
 325         assertNull(actual4);
 326     }
 327
 328     @Test
 329     public void testGetAAIServiceSubscriptionThrowNotFound() {
 330         String globalSubscriberId = "globalSubscriberId";
 331         String subscriptionServiceType = "subscriptionServiceType";
 332         doReturn(MOCK_aaiResourcesClient).when(MOCK_injectionHelper).getAaiClient();
 333         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(org.onap.aai.domain.yang.ServiceSubscription.class,
 334                 AAIUriFactory.createResourceUri(AAIObjectType.SERVICE_SUBSCRIPTION, globalSubscriberId,
 335                         subscriptionServiceType));
 336         org.onap.aai.domain.yang.ServiceSubscription actual =
 337                 bbInputSetupUtils.getAAIServiceSubscription(globalSubscriberId, subscriptionServiceType);
 338         assertNull(actual);
 339     }
 340
 341     @Test
 342     public void testGetAAIServiceInstanceById() {
 343         String serviceInstanceId = "serviceInstanceId";
 344
 345         ServiceInstance expectedServiceInstance = new ServiceInstance();
 346
 347         doReturn(Optional.of(expectedServiceInstance)).when(MOCK_aaiResourcesClient).get(isA(Class.class),
 348                 isA(AAIResourceUri.class));
 349
 350         ServiceInstance actualServiceInstance = bbInputSetupUtils.getAAIServiceInstanceById(serviceInstanceId);
 351
 352         assertThat(actualServiceInstance, sameBeanAs(expectedServiceInstance));
 353     }
 354
 355     @Test
 356     public void testGetAAIServiceInstanceByIdThrowNotFound() {
 357         String serviceInstanceId = "serviceInstanceId";
 358
 359         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(isA(Class.class), isA(AAIResourceUri.class));
 360
 361         ServiceInstance actualServiceInstance = bbInputSetupUtils.getAAIServiceInstanceById(serviceInstanceId);
 362
 363         assertNull(actualServiceInstance);
 364     }
 365
 366     @Test
 367     public void testGetAAIServiceInstanceByIdAndCustomer() {
 368         String globalCustomerId = "globalCustomerId";
 369         String serviceType = "serviceType";
 370         String serviceInstanceId = "serviceInstanceId";
 371         ServiceInstance expected = new ServiceInstance();
 372         expected.setServiceInstanceId(serviceInstanceId);
 373         doReturn(Optional.of(expected)).when(MOCK_aaiResourcesClient).get(isA(Class.class), isA(AAIResourceUri.class));
 374         AAIResourceUri expectedUri = AAIUriFactory
 375                 .createResourceUri(AAIObjectType.SERVICE_INSTANCE, globalCustomerId, serviceType, serviceInstanceId)
 376                 .depth(Depth.TWO);
 377         this.bbInputSetupUtils.getAAIServiceInstanceByIdAndCustomer(globalCustomerId, serviceType, serviceInstanceId);
 378
 379         verify(MOCK_aaiResourcesClient, times(1)).get(org.onap.aai.domain.yang.ServiceInstance.class, expectedUri);
 380
 381     }
 382
 383     @Test
 384     public void testGetAAIServiceInstanceByIdAndCustomerThrowNotFound() {
 385         String globalCustomerId = "globalCustomerId";
 386         String serviceType = "serviceType";
 387         String serviceInstanceId = "serviceInstanceId";
 388
 389         doReturn(MOCK_aaiResourcesClient).when(MOCK_injectionHelper).getAaiClient();
 390         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(isA(Class.class), isA(AAIResourceUri.class));
 391         ServiceInstance actual = this.bbInputSetupUtils.getAAIServiceInstanceByIdAndCustomer(globalCustomerId,
 392                 serviceType, serviceInstanceId);
 393
 394         assertNull(actual);
 395     }
 396
 397     @Test
 398     public void testGetAAIServiceInstanceByName() throws Exception {
 399         String serviceInstanceName = "serviceInstanceName";
 400
 401         ServiceInstance expectedServiceInstance = new ServiceInstance();
 402         expectedServiceInstance.setServiceInstanceId("serviceInstanceId");
 403
 404         ServiceSubscription serviceSubscription = new ServiceSubscription();
 405         serviceSubscription.setServiceType("serviceType");
 406
 407         Customer customer = new Customer();
 408         customer.setGlobalCustomerId("globalCustomerId");
 409         customer.setServiceSubscription(serviceSubscription);
 410
 411         ServiceInstances serviceInstances = new ServiceInstances();
 412         serviceInstances.getServiceInstance().add(expectedServiceInstance);
 413
 414         doReturn(Optional.of(serviceInstances)).when(MOCK_aaiResourcesClient).get(isA(Class.class),
 415                 isA(AAIResourceUri.class));
 416         AAIResourceUri expectedUri = AAIUriFactory
 417                 .createResourceUri(AAIObjectPlurals.SERVICE_INSTANCE, customer.getGlobalCustomerId(),
 418                         customer.getServiceSubscription().getServiceType())
 419                 .queryParam("service-instance-name", serviceInstanceName).depth(Depth.TWO);
 420         bbInputSetupUtils.getAAIServiceInstanceByName(serviceInstanceName, customer);
 421
 422         verify(MOCK_aaiResourcesClient, times(1)).get(org.onap.aai.domain.yang.ServiceInstances.class, expectedUri);
 423     }
 424
 425     @Test
 426     public void testGetAAIServiceInstanceByNameException() throws Exception {
 427         expectedException.expect(Exception.class);
 428
 429         String serviceInstanceName = "serviceInstanceName";
 430
 431         ServiceInstance serviceInstance = new ServiceInstance();
 432         serviceInstance.setServiceInstanceId("serviceInstanceId");
 433
 434         ServiceSubscription serviceSubscription = new ServiceSubscription();
 435         serviceSubscription.setServiceType("serviceType");
 436
 437         Customer customer = new Customer();
 438         customer.setGlobalCustomerId("globalCustomerId");
 439         customer.setServiceSubscription(serviceSubscription);
 440
 441         ServiceInstances serviceInstances = new ServiceInstances();
 442         serviceInstances.getServiceInstance().add(serviceInstance);
 443         serviceInstances.getServiceInstance().add(serviceInstance);
 444
 445         doReturn(Optional.of(serviceInstances)).when(MOCK_aaiResourcesClient).get(isA(Class.class),
 446                 isA(AAIResourceUri.class));
 447
 448         bbInputSetupUtils.getAAIServiceInstanceByName(serviceInstanceName, customer);
 449     }
 450
 451     @Test
 452     public void testGetAAIServiceInstanceByNameNull() throws Exception {
 453         String serviceInstanceName = "serviceInstanceName";
 454
 455         ServiceInstance serviceInstance = new ServiceInstance();
 456         serviceInstance.setServiceInstanceId("serviceInstanceId");
 457
 458         ServiceSubscription serviceSubscription = new ServiceSubscription();
 459         serviceSubscription.setServiceType("serviceType");
 460
 461         Customer customer = new Customer();
 462         customer.setGlobalCustomerId("globalCustomerId");
 463         customer.setServiceSubscription(serviceSubscription);
 464
 465         ServiceInstances serviceInstances = new ServiceInstances();
 466         serviceInstances.getServiceInstance().add(serviceInstance);
 467         serviceInstances.getServiceInstance().add(serviceInstance);
 468
 469         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(isA(Class.class), isA(AAIResourceUri.class));
 470
 471         ServiceInstance actualServiceInstance =
 472                 bbInputSetupUtils.getAAIServiceInstanceByName(serviceInstanceName, customer);
 473
 474         assertNull(actualServiceInstance);
 475     }
 476
 477     @Test
 478     public void testGetOptionalAAIServiceInstanceByNameException() throws Exception {
 479         expectedException.expect(Exception.class);
 480
 481         String globalCustomerId = "globalCustomerId";
 482         String serviceType = "serviceType";
 483         String serviceInstanceId = "serviceInstanceId";
 484
 485         ServiceInstance serviceInstance = new ServiceInstance();
 486         serviceInstance.setServiceInstanceId("serviceInstanceId");
 487         serviceInstance.setServiceType(serviceType);
 488         serviceInstance.setServiceInstanceName("serviceInstanceName");
 489
 490         ServiceInstances serviceInstances = new ServiceInstances();
 491         serviceInstances.getServiceInstance().add(serviceInstance);
 492         serviceInstances.getServiceInstance().add(serviceInstance);
 493
 494         doReturn(Optional.of(serviceInstances)).when(MOCK_aaiResourcesClient).get(isA(Class.class),
 495                 isA(AAIResourceUri.class));
 496
 497         bbInputSetupUtils.getAAIServiceInstanceByName(globalCustomerId, serviceType, serviceInstanceId);
 498     }
 499
 500     @Test
 501     public void testGetOptionalAAIServiceInstanceByNameNull() throws Exception {
 502         String globalCustomerId = "globalCustomerId";
 503         String serviceType = "serviceType";
 504         String serviceInstanceId = "serviceInstanceId";
 505
 506         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(isA(Class.class), isA(AAIResourceUri.class));
 507         Optional<ServiceInstance> actual =
 508                 this.bbInputSetupUtils.getAAIServiceInstanceByName(globalCustomerId, serviceType, serviceInstanceId);
 509
 510         assertThat(actual, sameBeanAs(Optional.empty()));
 511     }
 512
 513     @Test
 514     public void testGetCatalogInstanceGroup() throws JsonParseException, JsonMappingException, IOException {
 515         String modelUUID = "modelUUID";
 516
 517         org.onap.so.db.catalog.beans.InstanceGroup expectedInstanceGroup = mapper.readValue(
 518                 new File(RESOURCE_PATH + "InstanceGroup.json"), org.onap.so.db.catalog.beans.InstanceGroup.class);
 519
 520         doReturn(expectedInstanceGroup).when(MOCK_catalogDbClient).getInstanceGroupByModelUUID(isA(String.class));
 521
 522         org.onap.so.db.catalog.beans.InstanceGroup actualInstanceGroup =
 523                 bbInputSetupUtils.getCatalogInstanceGroup(modelUUID);
 524
 525         assertThat(actualInstanceGroup, sameBeanAs(expectedInstanceGroup));
 526     }
 527
 528     @Test
 529     public void testGetCollectionResourceInstanceGroupCustomization() {
 530         String modelCustomizationUUID = "modelCustomizationUUID";
 531
 532         CollectionResourceInstanceGroupCustomization expectedCollection =
 533                 new CollectionResourceInstanceGroupCustomization();
 534
 535         doReturn(Arrays.asList(expectedCollection)).when(MOCK_catalogDbClient)
 536                 .getCollectionResourceInstanceGroupCustomizationByModelCustUUID(modelCustomizationUUID);
 537
 538         List<CollectionResourceInstanceGroupCustomization> actualCollection =
 539                 bbInputSetupUtils.getCollectionResourceInstanceGroupCustomization(modelCustomizationUUID);
 540
 541         assertThat(actualCollection, sameBeanAs(Arrays.asList(expectedCollection)));
 542     }
 543
 544     @Test
 545     public void testGetAAIGenericVnf() throws JsonParseException, JsonMappingException, IOException {
 546         String vnfId = "vnfId";
 547
 548         GenericVnf expectedAaiVnf =
 549                 mapper.readValue(new File(RESOURCE_PATH + "aaiGenericVnfInput.json"), GenericVnf.class);
 550
 551         doReturn(Optional.of(expectedAaiVnf)).when(MOCK_aaiResourcesClient).get(isA(Class.class),
 552                 isA(AAIResourceUri.class));
 553         AAIResourceUri expectedUri = AAIUriFactory.createResourceUri(AAIObjectType.GENERIC_VNF, vnfId).depth(Depth.ONE);
 554         GenericVnf actualAaiVnf = bbInputSetupUtils.getAAIGenericVnf(vnfId);
 555
 556         assertThat(actualAaiVnf, sameBeanAs(expectedAaiVnf));
 557
 558         verify(MOCK_aaiResourcesClient, times(1)).get(org.onap.aai.domain.yang.GenericVnf.class, expectedUri);
 559     }
 560
 561     @Test
 562     public void testGetAAIConfiguration() throws JsonParseException, JsonMappingException, IOException {
 563         String configurationId = "configurationId";
 564
 565         Configuration expectedAaiConfiguration =
 566                 mapper.readValue(new File(RESOURCE_PATH + "ConfigurationInput.json"), Configuration.class);
 567
 568         doReturn(Optional.of(expectedAaiConfiguration)).when(MOCK_aaiResourcesClient).get(isA(Class.class),
 569                 isA(AAIResourceUri.class));
 570         AAIResourceUri expectedUri =
 571                 AAIUriFactory.createResourceUri(AAIObjectType.CONFIGURATION, configurationId).depth(Depth.ONE);
 572         bbInputSetupUtils.getAAIConfiguration(configurationId);
 573
 574         verify(MOCK_aaiResourcesClient, times(1)).get(org.onap.aai.domain.yang.Configuration.class, expectedUri);
 575     }
 576
 577     @Test
 578     public void testGetAAIGenericVnfThrowNotFound() throws JsonParseException, JsonMappingException, IOException {
 579         String vnfId = "vnfId";
 580
 581         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(isA(Class.class), isA(AAIResourceUri.class));
 582
 583         GenericVnf actualAaiVnf = bbInputSetupUtils.getAAIGenericVnf(vnfId);
 584
 585         assertNull(actualAaiVnf);
 586     }
 587
 588     @Test
 589     public void testGetAAIResourceDepthOne() {
 590         String vnfId = "vnfId";
 591         AAIResourceUri aaiResourceUri = AAIUriFactory.createResourceUri(AAIObjectType.GENERIC_VNF, vnfId);
 592         AAIResourceUri expectedUri = aaiResourceUri.clone().depth(Depth.ONE);
 593         AAIResourceUri aaiResourceUriClone = aaiResourceUri.clone();
 594         bbInputSetupUtils.getAAIResourceDepthOne(aaiResourceUri);
 595
 596         verify(MOCK_aaiResourcesClient, times(1)).get(expectedUri);
 597         assertEquals("Uri should not have changed", aaiResourceUriClone.build(), aaiResourceUri.build());
 598     }
 599
 600     @Test
 601     public void testGetAAIResourceDepthTwo() {
 602         String vnfId = "vnfId";
 603         AAIResourceUri aaiResourceUri = AAIUriFactory.createResourceUri(AAIObjectType.GENERIC_VNF, vnfId);
 604         AAIResourceUri expectedUri = aaiResourceUri.clone().depth(Depth.TWO);
 605         AAIResourceUri aaiResourceUriClone = aaiResourceUri.clone();
 606         bbInputSetupUtils.getAAIResourceDepthTwo(aaiResourceUri);
 607
 608         verify(MOCK_aaiResourcesClient, times(1)).get(expectedUri);
 609         assertEquals("Uri should not have changed", aaiResourceUriClone.build(), aaiResourceUri.build());
 610     }
 611
 612     @Test
 613     public void getRelatedNetworkByNameFromServiceInstanceTest() throws Exception {
 614         Optional<L3Networks> expected = Optional.of(new L3Networks());
 615         L3Network network = new L3Network();
 616         network.setNetworkId("id123");
 617         network.setNetworkName("name123");
 618         expected.get().getL3Network().add(network);
 619         doReturn(expected).when(MOCK_aaiResourcesClient).get(eq(L3Networks.class), any(AAIResourceUri.class));
 620         Optional<L3Network> actual =
 621                 this.bbInputSetupUtils.getRelatedNetworkByNameFromServiceInstance("id123", "name123");
 622         assertEquals(actual.get().getNetworkId(), expected.get().getL3Network().get(0).getNetworkId());
 623     }
 624
 625     @Test
 626     public void getRelatedNetworkByNameFromServiceInstanceMultipleNetworksExceptionTest() throws Exception {
 627         expectedException.expect(Exception.class);
 628
 629         String serviceInstanceId = "serviceInstanceId";
 630         String networkName = "networkName";
 631
 632         L3Network network = new L3Network();
 633         network.setNetworkId("id123");
 634         network.setNetworkName("name123");
 635
 636         L3Networks expected = new L3Networks();
 637         expected.getL3Network().add(network);
 638         expected.getL3Network().add(network);
 639
 640         doReturn(expected).when(MOCK_aaiResourcesClient).get(eq(L3Networks.class), any(AAIResourceUri.class));
 641
 642         bbInputSetupUtils.getRelatedNetworkByNameFromServiceInstance(serviceInstanceId, networkName);
 643     }
 644
 645     @Test
 646     public void getRelatedNetworkByNameFromServiceInstanceNotFoundTest() throws Exception {
 647         String serviceInstanceId = "serviceInstanceId";
 648         String networkName = "networkName";
 649
 650         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(eq(L3Networks.class), any(AAIResourceUri.class));
 651
 652         Optional<L3Network> actualNetwork =
 653                 bbInputSetupUtils.getRelatedNetworkByNameFromServiceInstance(serviceInstanceId, networkName);
 654
 655         assertEquals(Optional.empty(), actualNetwork);
 656     }
 657
 658     @Test
 659     public void getRelatedServiceInstanceFromInstanceGroupTest() throws Exception {
 660         Optional<ServiceInstances> expected = Optional.of(new ServiceInstances());
 661         ServiceInstance serviceInstance = new ServiceInstance();
 662         serviceInstance.setServiceInstanceId("serviceInstanceId");
 663         serviceInstance.setServiceInstanceName("serviceInstanceName");
 664         expected.get().getServiceInstance().add(serviceInstance);
 665
 666         doReturn(expected).when(MOCK_aaiResourcesClient).get(eq(ServiceInstances.class), any(AAIResourceUri.class));
 667         Optional<ServiceInstance> actual = this.bbInputSetupUtils.getRelatedServiceInstanceFromInstanceGroup("ig-001");
 668         assertEquals(actual.get().getServiceInstanceId(),
 669                 expected.get().getServiceInstance().get(0).getServiceInstanceId());
 670     }
 671
 672     @Test
 673     public void getRelatedServiceInstanceFromInstanceGroupMultipleTest() throws Exception {
 674         expectedException.expect(MultipleObjectsFoundException.class);
 675         Optional<ServiceInstances> serviceInstances = Optional.of(new ServiceInstances());
 676         ServiceInstance si1 = Mockito.mock(ServiceInstance.class);
 677         ServiceInstance si2 = Mockito.mock(ServiceInstance.class);
 678         serviceInstances.get().getServiceInstance().add(si1);
 679         serviceInstances.get().getServiceInstance().add(si2);
 680
 681         doReturn(serviceInstances).when(MOCK_aaiResourcesClient).get(eq(ServiceInstances.class),
 682                 any(AAIResourceUri.class));
 683         this.bbInputSetupUtils.getRelatedServiceInstanceFromInstanceGroup("ig-001");
 684     }
 685
 686     @Test
 687     public void getRelatedServiceInstanceFromInstanceGroupNotFoundTest() throws Exception {
 688         expectedException.expect(NoServiceInstanceFoundException.class);
 689         Optional<ServiceInstances> serviceInstances = Optional.of(new ServiceInstances());
 690
 691         doReturn(serviceInstances).when(MOCK_aaiResourcesClient).get(eq(ServiceInstances.class),
 692                 any(AAIResourceUri.class));
 693         this.bbInputSetupUtils.getRelatedServiceInstanceFromInstanceGroup("ig-001");
 694     }
 695
 696     @Test
 697     public void getRelatedVnfByNameFromServiceInstanceTest() throws Exception {
 698         Optional<GenericVnfs> expected = Optional.of(new GenericVnfs());
 699         GenericVnf vnf = new GenericVnf();
 700         vnf.setVnfId("id123");
 701         vnf.setVnfName("name123");
 702         expected.get().getGenericVnf().add(vnf);
 703         doReturn(expected).when(MOCK_aaiResourcesClient).get(eq(GenericVnfs.class), any(AAIResourceUri.class));
 704         Optional<GenericVnf> actual = this.bbInputSetupUtils.getRelatedVnfByNameFromServiceInstance("id123", "name123");
 705         assertEquals(actual.get().getVnfId(), expected.get().getGenericVnf().get(0).getVnfId());
 706     }
 707
 708     @Test
 709     public void getRelatedVnfByNameFromServiceInstanceMultipleVnfsExceptionTest() throws Exception {
 710         expectedException.expect(Exception.class);
 711
 712         String serviceInstanceId = "serviceInstanceId";
 713         String vnfName = "vnfName";
 714
 715         GenericVnf vnf = new GenericVnf();
 716         vnf.setVnfId("id123");
 717         vnf.setVnfName("name123");
 718
 719         GenericVnfs expectedVnf = new GenericVnfs();
 720         expectedVnf.getGenericVnf().add(vnf);
 721         expectedVnf.getGenericVnf().add(vnf);
 722
 723         doReturn(expectedVnf).when(MOCK_aaiResourcesClient).get(eq(GenericVnfs.class), any(AAIResourceUri.class));
 724
 725         bbInputSetupUtils.getRelatedVnfByNameFromServiceInstance(serviceInstanceId, vnfName);
 726     }
 727
 728     @Test
 729     public void getRelatedVnfByNameFromServiceInstanceNotFoundTest() throws Exception {
 730         String serviceInstanceId = "serviceInstanceId";
 731         String vnfName = "vnfName";
 732
 733         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(eq(GenericVnfs.class), any(AAIResourceUri.class));
 734
 735         Optional<GenericVnf> actualVnf =
 736                 this.bbInputSetupUtils.getRelatedVnfByNameFromServiceInstance(serviceInstanceId, vnfName);
 737
 738         assertEquals(actualVnf, Optional.empty());
 739     }
 740
 741     @Test
 742     public void getRelatedVolumeGroupByNameFromVnfTest() throws Exception {
 743         Optional<VolumeGroups> expected = Optional.of(new VolumeGroups());
 744         VolumeGroup volumeGroup = new VolumeGroup();
 745         volumeGroup.setVolumeGroupId("id123");
 746         volumeGroup.setVolumeGroupName("name123");
 747         expected.get().getVolumeGroup().add(volumeGroup);
 748         doReturn(expected).when(MOCK_aaiResourcesClient).get(eq(VolumeGroups.class), any(AAIResourceUri.class));
 749         Optional<VolumeGroup> actual = this.bbInputSetupUtils.getRelatedVolumeGroupByNameFromVnf("id123", "name123");
 750         assertEquals(actual.get().getVolumeGroupId(), expected.get().getVolumeGroup().get(0).getVolumeGroupId());
 751     }
 752
 753     @Test
 754     public void getRelatedVolumeGroupByNameFromVnfMultipleVolumeGroupsExceptionTest() throws Exception {
 755         expectedException.expect(Exception.class);
 756
 757         String vnfId = "vnfId";
 758         String volumeGroupName = "volumeGroupName";
 759
 760         VolumeGroup volumeGroup = new VolumeGroup();
 761         volumeGroup.setVolumeGroupId("id123");
 762         volumeGroup.setVolumeGroupName("name123");
 763
 764         VolumeGroups expectedVolumeGroup = new VolumeGroups();
 765         expectedVolumeGroup.getVolumeGroup().add(volumeGroup);
 766         expectedVolumeGroup.getVolumeGroup().add(volumeGroup);
 767
 768         doReturn(expectedVolumeGroup).when(MOCK_aaiResourcesClient).get(eq(VolumeGroups.class),
 769                 any(AAIResourceUri.class));
 770
 771         bbInputSetupUtils.getRelatedVolumeGroupByNameFromVnf(vnfId, volumeGroupName);
 772     }
 773
 774     @Test
 775     public void getRelatedVolumeGroupByNameFromVnfNotFoundTest() throws Exception {
 776         String vnfId = "vnfId";
 777         String volumeGroupName = "volumeGroupName";
 778
 779         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(eq(VolumeGroups.class), any(AAIResourceUri.class));
 780
 781         Optional<VolumeGroup> actualVolumeGroup =
 782                 bbInputSetupUtils.getRelatedVolumeGroupByNameFromVnf(vnfId, volumeGroupName);
 783
 784         assertEquals(actualVolumeGroup, Optional.empty());
 785     }
 786
 787     @Test
 788     public void getRelatedVolumeGroupByNameFromVfModuleTest() throws Exception {
 789         Optional<VolumeGroups> expected = Optional.of(new VolumeGroups());
 790         VolumeGroup volumeGroup = new VolumeGroup();
 791         volumeGroup.setVolumeGroupId("id123");
 792         volumeGroup.setVolumeGroupName("name123");
 793         expected.get().getVolumeGroup().add(volumeGroup);
 794         doReturn(expected).when(MOCK_aaiResourcesClient).get(eq(VolumeGroups.class), any(AAIResourceUri.class));
 795         Optional<VolumeGroup> actual =
 796                 this.bbInputSetupUtils.getRelatedVolumeGroupByNameFromVfModule("id123", "id123", "name123");
 797         assertEquals(actual.get().getVolumeGroupId(), expected.get().getVolumeGroup().get(0).getVolumeGroupId());
 798     }
 799
 800     @Test
 801     public void getRelatedVolumeGroupByNameFromVfModuleMultipleVolumeGroupsExceptionTest() throws Exception {
 802         expectedException.expect(Exception.class);
 803
 804         String vnfId = "vnfId";
 805         String volumeGroupId = "volumeGroupId";
 806         String volumeGroupName = "volumeGroupName";
 807
 808         VolumeGroup volumeGroup = new VolumeGroup();
 809         volumeGroup.setVolumeGroupId("id123");
 810         volumeGroup.setVolumeGroupName("name123");
 811
 812         VolumeGroups expectedVolumeGroup = new VolumeGroups();
 813         expectedVolumeGroup.getVolumeGroup().add(volumeGroup);
 814         expectedVolumeGroup.getVolumeGroup().add(volumeGroup);
 815
 816         doReturn(expectedVolumeGroup).when(MOCK_aaiResourcesClient).get(eq(VolumeGroups.class),
 817                 any(AAIResourceUri.class));
 818
 819         bbInputSetupUtils.getRelatedVolumeGroupByNameFromVfModule(vnfId, volumeGroupId, volumeGroupName);
 820     }
 821
 822     @Test
 823     public void getRelatedVolumeGroupByNameFromVfModuleNotFoundTest() throws Exception {
 824         String vnfId = "vnfId";
 825         String volumeGroupId = "volumeGroupId";
 826         String volumeGroupName = "volumeGroupName";
 827
 828         doReturn(Optional.empty()).when(MOCK_aaiResourcesClient).get(eq(VolumeGroups.class), any(AAIResourceUri.class));
 829
 830         Optional<VolumeGroup> actualVolumeGroup =
 831                 bbInputSetupUtils.getRelatedVolumeGroupByNameFromVfModule(vnfId, volumeGroupId, volumeGroupName);
 832
 833         assertEquals(actualVolumeGroup, Optional.empty());
 834     }
 835 }