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