bpmn/MSOCommonBPMN/src/test/java/org/onap/so/bpmn/servicedecomposition/tasks/BBInputSetupUtilsTest.java

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