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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Modifications Copyright (c) 2019 Samsung
   8  * ================================================================================
   9  * Modifications Copyright (c) 2020 Nokia
  10  * ================================================================================
  11  * Licensed under the Apache License, Version 2.0 (the "License");
  12  * you may not use this file except in compliance with the License.
  13  * You may obtain a copy of the License at
  14  *
  15  *      http://www.apache.org/licenses/LICENSE-2.0
  16  *
  17  * Unless required by applicable law or agreed to in writing, software
  18  * distributed under the License is distributed on an "AS IS" BASIS,
  19  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  20  * See the License for the specific language governing permissions and
  21  * limitations under the License.
  22  * ============LICENSE_END=========================================================
  23  */
  24
  25 package org.onap.so.bpmn.servicedecomposition.tasks;
  26
  27 import static com.shazam.shazamcrest.MatcherAssert.assertThat;
  28 import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
  29 import static org.junit.Assert.assertEquals;
  30 import static org.junit.Assert.assertNotNull;
  31 import static org.junit.Assert.assertNull;
  32 import static org.mockito.ArgumentMatchers.any;
  33 import static org.mockito.ArgumentMatchers.eq;
  34 import static org.mockito.ArgumentMatchers.isA;
  35 import static org.mockito.Mockito.doNothing;
  36 import static org.mockito.Mockito.doReturn;
  37 import static org.mockito.Mockito.times;
  38 import static org.mockito.Mockito.verify;
  39 import static org.onap.so.bpmn.servicedecomposition.tasks.BaseBBInputSetupTestHelper.prepareConfigurationResourceKeys;
  40 import static org.onap.so.bpmn.servicedecomposition.tasks.BaseBBInputSetupTestHelper.prepareLookupKeyMap;
  41 import java.io.File;
  42 import java.io.IOException;
  43 import java.util.ArrayList;
  44 import java.util.Arrays;
  45 import java.util.HashMap;
  46 import java.util.List;
  47 import java.util.Map;
  48 import java.util.Optional;
  49 import org.camunda.bpm.engine.delegate.DelegateExecution;
  50 import org.junit.Assert;
  51 import org.junit.Rule;
  52 import org.junit.Test;
  53 import org.junit.rules.ExpectedException;
  54 import org.junit.runner.RunWith;
  55 import org.mockito.ArgumentMatchers;
  56 import org.mockito.InjectMocks;
  57 import org.mockito.Mock;
  58 import org.mockito.Mockito;
  59 import org.mockito.Spy;
  60 import org.mockito.junit.MockitoJUnitRunner;
  61 import org.onap.aaiclient.client.aai.AAICommonObjectMapperProvider;
  62 import org.onap.aaiclient.client.aai.AAIObjectType;
  63 import org.onap.aaiclient.client.aai.entities.AAIResultWrapper;
  64 import org.onap.aaiclient.client.aai.entities.uri.AAIResourceUri;
  65 import org.onap.aaiclient.client.aai.entities.uri.AAIUriFactory;
  66 import org.onap.aaiclient.client.generated.fluentbuilders.AAIFluentTypeBuilder;
  67 import org.onap.so.bpmn.servicedecomposition.bbobjects.CloudRegion;
  68 import org.onap.so.bpmn.servicedecomposition.bbobjects.Collection;
  69 import org.onap.so.bpmn.servicedecomposition.bbobjects.Configuration;
  70 import org.onap.so.bpmn.servicedecomposition.bbobjects.Customer;
  71 import org.onap.so.bpmn.servicedecomposition.bbobjects.GenericVnf;
  72 import org.onap.so.bpmn.servicedecomposition.bbobjects.InstanceGroup;
  73 import org.onap.so.bpmn.servicedecomposition.bbobjects.L3Network;
  74 import org.onap.so.bpmn.servicedecomposition.bbobjects.LineOfBusiness;
  75 import org.onap.so.bpmn.servicedecomposition.bbobjects.OwningEntity;
  76 import org.onap.so.bpmn.servicedecomposition.bbobjects.Platform;
  77 import org.onap.so.bpmn.servicedecomposition.bbobjects.Project;
  78 import org.onap.so.bpmn.servicedecomposition.bbobjects.RouteTableReference;
  79 import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
  80 import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceProxy;
  81 import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceSubscription;
  82 import org.onap.so.bpmn.servicedecomposition.bbobjects.VfModule;
  83 import org.onap.so.bpmn.servicedecomposition.bbobjects.Vnfc;
  84 import org.onap.so.bpmn.servicedecomposition.bbobjects.VolumeGroup;
  85 import org.onap.so.bpmn.servicedecomposition.entities.BuildingBlock;
  86 import org.onap.so.bpmn.servicedecomposition.entities.ConfigurationResourceKeys;
  87 import org.onap.so.bpmn.servicedecomposition.entities.ExecuteBuildingBlock;
  88 import org.onap.so.bpmn.servicedecomposition.entities.GeneralBuildingBlock;
  89 import org.onap.so.bpmn.servicedecomposition.entities.ResourceKey;
  90 import org.onap.so.bpmn.servicedecomposition.entities.ServiceModel;
  91 import org.onap.so.bpmn.servicedecomposition.entities.WorkflowResourceIds;
  92 import org.onap.so.bpmn.servicedecomposition.generalobjects.OrchestrationContext;
  93 import org.onap.so.bpmn.servicedecomposition.generalobjects.RequestContext;
  94 import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoCollection;
  95 import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoGenericVnf;
  96 import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoInstanceGroup;
  97 import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoNetwork;
  98 import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoServiceInstance;
  99 import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoServiceProxy;
 100 import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoVfModule;
 101 import org.onap.so.bpmn.servicedecomposition.tasks.exceptions.NoServiceInstanceFoundException;
 102 import org.onap.so.bpmn.servicedecomposition.tasks.exceptions.ServiceModelNotFoundException;
 103 import org.onap.so.db.catalog.beans.CollectionNetworkResourceCustomization;
 104 import org.onap.so.db.catalog.beans.CollectionResource;
 105 import org.onap.so.db.catalog.beans.CollectionResourceCustomization;
 106 import org.onap.so.db.catalog.beans.CollectionResourceInstanceGroupCustomization;
 107 import org.onap.so.db.catalog.beans.ConfigurationResource;
 108 import org.onap.so.db.catalog.beans.ConfigurationResourceCustomization;
 109 import org.onap.so.db.catalog.beans.CvnfcConfigurationCustomization;
 110 import org.onap.so.db.catalog.beans.InstanceGroupType;
 111 import org.onap.so.db.catalog.beans.NetworkCollectionResourceCustomization;
 112 import org.onap.so.db.catalog.beans.NetworkResourceCustomization;
 113 import org.onap.so.db.catalog.beans.OrchestrationStatus;
 114 import org.onap.so.db.catalog.beans.Service;
 115 import org.onap.so.db.catalog.beans.ServiceProxyResourceCustomization;
 116 import org.onap.so.db.catalog.beans.VfModuleCustomization;
 117 import org.onap.so.db.catalog.beans.VnfResourceCustomization;
 118 import org.onap.so.db.catalog.beans.VnfcInstanceGroupCustomization;
 119 import org.onap.so.db.request.beans.InfraActiveRequests;
 120 import org.onap.so.serviceinstancebeans.CloudConfiguration;
 121 import org.onap.so.serviceinstancebeans.ModelInfo;
 122 import org.onap.so.serviceinstancebeans.ModelType;
 123 import org.onap.so.serviceinstancebeans.RelatedInstance;
 124 import org.onap.so.serviceinstancebeans.RelatedInstanceList;
 125 import org.onap.so.serviceinstancebeans.RequestDetails;
 126 import org.onap.so.serviceinstancebeans.RequestInfo;
 127 import org.onap.so.serviceinstancebeans.RequestParameters;
 128 import org.onap.so.serviceinstancebeans.Resources;
 129 import org.onap.so.serviceinstancebeans.SubscriberInfo;
 130 import com.fasterxml.jackson.core.JsonParseException;
 131 import com.fasterxml.jackson.core.JsonProcessingException;
 132 import com.fasterxml.jackson.databind.JsonMappingException;
 133 import com.fasterxml.jackson.databind.ObjectMapper;
 134
 135 @RunWith(MockitoJUnitRunner.class)
 136 public class BBInputSetupTest {
 137     private static final String RESOURCE_PATH = "src/test/resources/__files/ExecuteBuildingBlock/";
 138
 139     protected ObjectMapper mapper = new ObjectMapper();
 140     private static final String CLOUD_OWNER = "CloudOwner";
 141     private static final String REQUEST_ID = "b20bbd26-af25-4a50-a9fe-222a3c0f9771";
 142
 143     @Spy
 144     @InjectMocks
 145     private BBInputSetup SPY_bbInputSetup = new BBInputSetup();
 146
 147     @Mock
 148     private BBInputSetupUtils SPY_bbInputSetupUtils;
 149
 150     @Mock
 151     private CloudInfoFromAAI SPY_cloudInfoFromAAI;
 152
 153     @Spy
 154     private BBInputSetupMapperLayer bbInputSetupMapperLayer;
 155
 156     @Rule
 157     public ExpectedException expectedException = ExpectedException.none();
 158
 159     @Test
 160     public void testGetVolumeGroupIdRelatedToVfModule() {
 161         String expected = "volumeGroupId";
 162         String modelCustomizationId = "modelCustomizationId";
 163         ModelInfo modelInfo = new ModelInfo();
 164         modelInfo.setModelCustomizationId(modelCustomizationId);
 165         String cloudOwner = "cloudOwner";
 166         String cloudRegionId = "cloudRegionId";
 167         String volumeGroupId = "volumeGroupId";
 168         GenericVnf vnf = new GenericVnf();
 169         VolumeGroup volumeGroup = new VolumeGroup();
 170         volumeGroup.setVolumeGroupId(expected);
 171         vnf.getVolumeGroups().add(volumeGroup);
 172         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 173         lookupKeyMap.put(ResourceKey.VOLUME_GROUP_ID, null);
 174         org.onap.aai.domain.yang.VolumeGroup aaiVolumeGroup = new org.onap.aai.domain.yang.VolumeGroup();
 175         aaiVolumeGroup.setModelCustomizationId(modelCustomizationId);
 176         doReturn(aaiVolumeGroup).when(SPY_bbInputSetupUtils).getAAIVolumeGroup(cloudOwner, cloudRegionId,
 177                 volumeGroupId);
 178
 179         Optional<String> actual = SPY_bbInputSetup.getVolumeGroupIdRelatedToVfModule(vnf, modelInfo, cloudOwner,
 180                 cloudRegionId, lookupKeyMap);
 181
 182         assertEquals(expected, actual.get());
 183     }
 184
 185     @Test
 186     public void testGetAlaCarteServiceInstance() throws Exception {
 187         ServiceInstance expected =
 188                 mapper.readValue(new File(RESOURCE_PATH + "ServiceInstance_getServiceInstanceNOAAIExpected.json"),
 189                         ServiceInstance.class);
 190         RequestDetails requestDetails = new RequestDetails();
 191         RequestInfo requestInfo = new RequestInfo();
 192         requestInfo.setInstanceName("SharansInstanceName");
 193         requestDetails.setRequestInfo(requestInfo);
 194         Customer customer = new Customer();
 195         String serviceInstanceId = "SharansInstanceId";
 196         boolean aLaCarte = true;
 197         Service service = new Service();
 198         service.setModelUUID("modelUUID");
 199         ModelInfoServiceInstance modelInfoServiceInstance = new ModelInfoServiceInstance();
 200         modelInfoServiceInstance.setModelUuid("modelUUID");
 201         expected.setModelInfoServiceInstance(modelInfoServiceInstance);
 202         org.onap.aai.domain.yang.ServiceInstance serviceInstanceAAI = new org.onap.aai.domain.yang.ServiceInstance();
 203         serviceInstanceAAI.setModelVersionId("modelUUIDDifferent");
 204         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 205         String bbName = AssignFlows.SERVICE_INSTANCE.toString();
 206         Service differentService = new Service();
 207         differentService.setModelUUID("modelUUIDDifferent");
 208
 209         doReturn(expected).when(SPY_bbInputSetup).getServiceInstanceHelper(requestDetails, customer, null, null,
 210                 lookupKeyMap, serviceInstanceId, aLaCarte, service, bbName);
 211         doReturn(serviceInstanceAAI).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById(serviceInstanceId);
 212         doReturn(differentService).when(SPY_bbInputSetupUtils)
 213                 .getCatalogServiceByModelUUID(serviceInstanceAAI.getModelVersionId());
 214         doReturn(expected.getModelInfoServiceInstance()).when(bbInputSetupMapperLayer)
 215                 .mapCatalogServiceIntoServiceInstance(differentService);
 216
 217         ServiceInstance actual = SPY_bbInputSetup.getALaCarteServiceInstance(service, requestDetails, customer, null,
 218                 null, lookupKeyMap, serviceInstanceId, aLaCarte, bbName);
 219         assertThat(actual, sameBeanAs(expected));
 220     }
 221
 222     @Test(expected = Exception.class)
 223     public void testGetAlaCarteServiceInstanceException() throws Exception {
 224         ServiceInstance expected =
 225                 mapper.readValue(new File(RESOURCE_PATH + "ServiceInstance_getServiceInstanceNOAAIExpected.json"),
 226                         ServiceInstance.class);
 227         RequestDetails requestDetails = new RequestDetails();
 228         RequestInfo requestInfo = new RequestInfo();
 229         requestInfo.setInstanceName("SharansInstanceName");
 230         requestDetails.setRequestInfo(requestInfo);
 231         Customer customer = new Customer();
 232         String serviceInstanceId = "SharansInstanceId";
 233         boolean aLaCarte = true;
 234         Service service = new Service();
 235         service.setModelUUID("modelUUID");
 236         ModelInfoServiceInstance modelInfoServiceInstance = new ModelInfoServiceInstance();
 237         modelInfoServiceInstance.setModelUuid("modelUUID");
 238         expected.setModelInfoServiceInstance(modelInfoServiceInstance);
 239         org.onap.aai.domain.yang.ServiceInstance serviceInstanceAAI = new org.onap.aai.domain.yang.ServiceInstance();
 240         serviceInstanceAAI.setModelVersionId("modelUUIDDifferent");
 241         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 242         String bbName = AssignFlows.SERVICE_INSTANCE.toString();
 243         Service differentService = new Service();
 244         differentService.setModelUUID("modelUUIDDifferent");
 245
 246         doReturn(expected).when(SPY_bbInputSetup).getServiceInstanceHelper(requestDetails, customer, null, null,
 247                 lookupKeyMap, serviceInstanceId, aLaCarte, service, bbName);
 248         doReturn(serviceInstanceAAI).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById(serviceInstanceId);
 249         doReturn(null).when(SPY_bbInputSetupUtils).getCatalogServiceByModelUUID(serviceInstanceAAI.getModelVersionId());
 250
 251         ServiceInstance actual = SPY_bbInputSetup.getALaCarteServiceInstance(service, requestDetails, customer, null,
 252                 null, lookupKeyMap, serviceInstanceId, aLaCarte, bbName);
 253         assertThat(actual, sameBeanAs(expected));
 254     }
 255
 256     @Test
 257     public void testGetCustomerAndServiceSubscription() throws JsonParseException, JsonMappingException, IOException {
 258         RequestDetails requestDetails = mapper.readValue(
 259                 new File(RESOURCE_PATH + "RequestDetailsInput_withRelatedInstanceList.json"), RequestDetails.class);
 260         SubscriberInfo subscriberInfo = new SubscriberInfo();
 261         subscriberInfo.setGlobalSubscriberId("globalSubscriberId");
 262         RequestParameters requestParams = new RequestParameters();
 263         requestParams.setSubscriptionServiceType("subscriptionServiceType");
 264         requestDetails.setRequestParameters(requestParams);
 265         requestDetails.setSubscriberInfo(subscriberInfo);
 266         String resourceId = "resourceId";
 267         Customer expected = new Customer();
 268         expected.setGlobalCustomerId("globalCustomerId");
 269         ServiceSubscription serviceSubscription = new ServiceSubscription();
 270         serviceSubscription.setServiceType("subscriptionServiceType");
 271
 272         doReturn(expected).when(this.SPY_bbInputSetup).getCustomerFromRequest(requestDetails);
 273         doReturn(serviceSubscription).when(this.SPY_bbInputSetup).getServiceSubscription(requestDetails, expected);
 274
 275         Customer actual = this.SPY_bbInputSetup.getCustomerAndServiceSubscription(requestDetails, resourceId);
 276
 277         assertThat(actual, sameBeanAs(expected));
 278
 279         requestDetails.setSubscriberInfo(null);
 280
 281
 282         assertThat(actual, sameBeanAs(expected));
 283
 284     }
 285
 286     @Test
 287     public void testSetHomingFlag() throws IOException {
 288         GeneralBuildingBlock expected = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
 289                 GeneralBuildingBlock.class);
 290         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 291         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "vnfId");
 292         GenericVnf genericVnfExpected = new GenericVnf();
 293         genericVnfExpected.setVnfId("vnfId");
 294         genericVnfExpected.setCallHoming(true);
 295         expected.getCustomer().getServiceSubscription().getServiceInstances().get(0).getVnfs().add(genericVnfExpected);
 296         boolean homing = true;
 297         GenericVnf genericVnfActual = new GenericVnf();
 298         genericVnfActual.setVnfId("vnfId");
 299         genericVnfActual.setCallHoming(false);
 300         GeneralBuildingBlock actual = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
 301                 GeneralBuildingBlock.class);
 302         actual.getCustomer().getServiceSubscription().getServiceInstances().get(0).getVnfs().add(genericVnfActual);
 303
 304         SPY_bbInputSetup.setHomingFlag(actual, homing, lookupKeyMap);
 305         assertThat(actual, sameBeanAs(expected));
 306     }
 307
 308     @Test
 309     public void testGetExecuteBBFromExecution() throws IOException {
 310         BuildingBlock bb = new BuildingBlock().setBpmnFlowName("AssignServiceInstanceBB");
 311         ExecuteBuildingBlock expected =
 312                 new ExecuteBuildingBlock().setBuildingBlock(bb).setRequestId("00032ab7-3fb3-42e5-965d-8ea592502017");
 313         DelegateExecution execution = Mockito.mock(DelegateExecution.class);
 314         doReturn(expected).when(execution).getVariable(any(String.class));
 315         ExecuteBuildingBlock actual = SPY_bbInputSetup.getExecuteBBFromExecution(execution);
 316         assertThat(actual, sameBeanAs(expected));
 317     }
 318
 319     @Test
 320     public void testGetGBB() throws Exception {
 321         GeneralBuildingBlock expected = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
 322                 GeneralBuildingBlock.class);
 323
 324         ExecuteBuildingBlock executeBB = new ExecuteBuildingBlock().setRequestId("requestId");
 325         RequestDetails requestDetails = new RequestDetails();
 326         ModelInfo modelInfo = new ModelInfo();
 327         modelInfo.setModelType(ModelType.service);
 328         requestDetails.setModelInfo(modelInfo);
 329         RequestParameters requestParams = new RequestParameters();
 330         requestParams.setaLaCarte(true);
 331         requestDetails.setRequestParameters(requestParams);
 332         doReturn(requestDetails).when(SPY_bbInputSetupUtils).getRequestDetails(executeBB.getRequestId());
 333         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 334         String resourceId = "123";
 335         String requestAction = "createInstance";
 336         doReturn(expected).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
 337                 requestAction, resourceId);
 338         doNothing().when(SPY_bbInputSetup).populateLookupKeyMapWithIds(executeBB.getWorkflowResourceIds(),
 339                 lookupKeyMap);
 340         boolean aLaCarte = true;
 341         GeneralBuildingBlock actual =
 342                 SPY_bbInputSetup.getGBB(executeBB, lookupKeyMap, requestAction, aLaCarte, resourceId, null);
 343
 344         assertThat(actual, sameBeanAs(expected));
 345     }
 346
 347     @Test
 348     public void testGetGBBCM() throws Exception {
 349         GeneralBuildingBlock expected = mapper
 350                 .readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockCMExpected.json"), GeneralBuildingBlock.class);
 351
 352         ExecuteBuildingBlock executeBB = new ExecuteBuildingBlock().setRequestId("requestId");
 353         RequestDetails requestDetails = new RequestDetails();
 354         requestDetails.setModelInfo(null);
 355         RequestParameters requestParams = new RequestParameters();
 356         requestParams.setaLaCarte(true);
 357         requestDetails.setRequestParameters(requestParams);
 358         RequestInfo requestInfo = new RequestInfo();
 359         requestInfo.setSuppressRollback(true);
 360         requestInfo.setSource("VID");
 361         requestDetails.setRequestInfo(requestInfo);
 362         CloudConfiguration cloudConfiguration = new CloudConfiguration();
 363         cloudConfiguration.setLcpCloudRegionId("myRegionId");
 364         requestDetails.setCloudConfiguration(cloudConfiguration);
 365         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 366         String resourceId = "123";
 367         String requestAction = "createInstance";
 368
 369         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "vnf-001");
 370
 371         doReturn(new org.onap.aai.domain.yang.GenericVnf()).when(SPY_bbInputSetupUtils)
 372                 .getAAIGenericVnf(ArgumentMatchers.isA(String.class));
 373         doReturn(null).when(bbInputSetupMapperLayer)
 374                 .mapAAIGenericVnfIntoGenericVnf(ArgumentMatchers.isA(org.onap.aai.domain.yang.GenericVnf.class));
 375         GeneralBuildingBlock actual =
 376                 SPY_bbInputSetup.getGBBCM(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId);
 377         assertThat(actual, sameBeanAs(expected));
 378     }
 379
 380     @Test
 381     public void testGetGBBCMAddMembersAction() throws Exception {
 382         GeneralBuildingBlock expected = mapper.readValue(
 383                 new File(RESOURCE_PATH + "GeneralBuildingBlockInstanceGroupExpected.json"), GeneralBuildingBlock.class);
 384         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
 385                 ExecuteBuildingBlock.class);
 386         RequestDetails requestDetails = mapper.readValue(
 387                 new File(RESOURCE_PATH + "RequestDetailsInput_instanceGroupAddMembers.json"), RequestDetails.class);
 388         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 389         String requestAction = "addMembers";
 390         String instanceGroupId = "instance-group-001";
 391
 392         WorkflowResourceIds workflowResourceIds = new WorkflowResourceIds();
 393         workflowResourceIds.setInstanceGroupId(instanceGroupId);
 394         executeBB.setWorkflowResourceIds(workflowResourceIds);
 395
 396         lookupKeyMap.put(ResourceKey.INSTANCE_GROUP_ID, instanceGroupId);
 397
 398         org.onap.aai.domain.yang.InstanceGroup aaiInstanceGroup = new org.onap.aai.domain.yang.InstanceGroup();
 399         aaiInstanceGroup.setId(instanceGroupId);
 400         aaiInstanceGroup.setInstanceGroupName("test instance group 1");
 401
 402         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
 403         aaiServiceInstance.setServiceInstanceId("service-instance-001");
 404         aaiServiceInstance.setServiceInstanceName("test service instance 1");
 405         Optional<org.onap.aai.domain.yang.ServiceInstance> optSI = Optional.of(aaiServiceInstance);
 406
 407         org.onap.aai.domain.yang.GenericVnf vnf1 = new org.onap.aai.domain.yang.GenericVnf();
 408         vnf1.setVnfId("vnf-001");
 409         vnf1.setVnfName("test vnf 1");
 410
 411         org.onap.aai.domain.yang.GenericVnf vnf2 = new org.onap.aai.domain.yang.GenericVnf();
 412         vnf2.setVnfId("vnf-002");
 413         vnf2.setVnfName("test vnf 2");
 414
 415         doReturn(aaiInstanceGroup).when(SPY_bbInputSetupUtils).getAAIInstanceGroup(instanceGroupId);
 416         doReturn(optSI).when(SPY_bbInputSetupUtils).getRelatedServiceInstanceFromInstanceGroup(instanceGroupId);
 417         doReturn(vnf1).when(SPY_bbInputSetupUtils).getAAIGenericVnf("vnf-001");
 418         doReturn(vnf2).when(SPY_bbInputSetupUtils).getAAIGenericVnf("vnf-002");
 419
 420         GeneralBuildingBlock actual =
 421                 SPY_bbInputSetup.getGBBCM(executeBB, requestDetails, lookupKeyMap, requestAction, instanceGroupId);
 422
 423         assertThat(actual, sameBeanAs(expected));
 424     }
 425
 426     @Test
 427     public void testGetGBBALaCarteNonService() throws Exception {
 428         GeneralBuildingBlock expected = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
 429                 GeneralBuildingBlock.class);
 430         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
 431                 ExecuteBuildingBlock.class);
 432         RequestDetails requestDetails = mapper.readValue(
 433                 new File(RESOURCE_PATH + "RequestDetailsInput_withRelatedInstanceList.json"), RequestDetails.class);
 434         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 435         String requestAction = "createInstance";
 436         Service service = Mockito.mock(Service.class);
 437         ServiceModel serviceModel = new ServiceModel();
 438         serviceModel.setCurrentService(service);
 439         ServiceInstance serviceInstance = Mockito.mock(ServiceInstance.class);
 440         String resourceId = "123";
 441         String vnfType = "vnfType";
 442         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
 443         aaiServiceInstance.setModelVersionId("modelVersionId");
 444         org.onap.aai.domain.yang.CloudRegion aaiCloudRegion = Mockito.mock(org.onap.aai.domain.yang.CloudRegion.class);
 445         lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "instanceId");
 446         doReturn(service).when(SPY_bbInputSetupUtils)
 447                 .getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
 448         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById("instanceId");
 449         doNothing().when(SPY_bbInputSetup).populateObjectsOnAssignAndCreateFlows(any(BBInputSetupParameter.class));
 450         doReturn(serviceInstance).when(SPY_bbInputSetup).getExistingServiceInstance(aaiServiceInstance);
 451         doReturn(expected).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
 452
 453         GeneralBuildingBlock actual = SPY_bbInputSetup.getGBBALaCarteNonService(executeBB, requestDetails, lookupKeyMap,
 454                 requestAction, resourceId, vnfType);
 455
 456         assertThat(actual, sameBeanAs(expected));
 457     }
 458
 459     @Test
 460     public void testGetGBBALaCarteNonServiceIsReplace() throws Exception {
 461         GeneralBuildingBlock expected = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
 462                 GeneralBuildingBlock.class);
 463         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
 464                 ExecuteBuildingBlock.class);
 465         RequestDetails requestDetails = mapper.readValue(
 466                 new File(RESOURCE_PATH + "RequestDetailsInput_withRelatedInstanceList.json"), RequestDetails.class);
 467         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 468         String requestAction = "replaceInstance";
 469         Service service = Mockito.mock(Service.class);
 470         ServiceModel serviceModel = new ServiceModel();
 471         serviceModel.setCurrentService(service);
 472         ServiceInstance serviceInstance = Mockito.mock(ServiceInstance.class);
 473         String resourceId = "123";
 474         String vnfType = "vnfType";
 475         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
 476         aaiServiceInstance.setModelVersionId("modelVersionId");
 477         org.onap.aai.domain.yang.CloudRegion aaiCloudRegion = Mockito.mock(org.onap.aai.domain.yang.CloudRegion.class);
 478         lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "instanceId");
 479         doReturn(service).when(SPY_bbInputSetupUtils)
 480                 .getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
 481         doReturn(service).when(SPY_bbInputSetupUtils).getCatalogServiceByModelUUID("modelUUID");
 482         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById("instanceId");
 483
 484         doNothing().when(SPY_bbInputSetup).populateObjectsOnAssignAndCreateFlows(any(BBInputSetupParameter.class));
 485         doReturn(serviceInstance).when(SPY_bbInputSetup).getExistingServiceInstance(aaiServiceInstance);
 486         doReturn(expected).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
 487
 488         GeneralBuildingBlock actual = SPY_bbInputSetup.getGBBALaCarteNonService(executeBB, requestDetails, lookupKeyMap,
 489                 requestAction, resourceId, vnfType);
 490
 491         verify(SPY_bbInputSetup, times(1)).populateObjectsOnAssignAndCreateFlows(any(BBInputSetupParameter.class));
 492
 493         verify(SPY_bbInputSetupUtils, times(1)).getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
 494         verify(SPY_bbInputSetupUtils, times(1)).getCatalogServiceByModelUUID("modelUUID");
 495
 496         assertThat(actual, sameBeanAs(expected));
 497     }
 498
 499     @Test
 500     public void testGetGBBALaCarteNonServiceWithoutServiceModelInfo() throws Exception {
 501         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
 502                 ExecuteBuildingBlock.class);
 503         RequestDetails requestDetails = mapper.readValue(
 504                 new File(RESOURCE_PATH + "RequestDetailsInput_withRelatedInstanceList.json"), RequestDetails.class);
 505         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 506         lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "si123");
 507         String requestAction = "createInstance";
 508         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
 509         aaiServiceInstance.setModelVersionId("modelVersionId");
 510         String resourceId = "123";
 511         String vnfType = "vnfType";
 512
 513         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById("si123");
 514         doReturn(null).when(SPY_bbInputSetupUtils).getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
 515
 516         expectedException.expect(ServiceModelNotFoundException.class);
 517         expectedException.expectMessage(
 518                 "Related service instance model not found in MSO CatalogDB: model-version-id=modelVersionId");
 519
 520         SPY_bbInputSetup.getGBBALaCarteNonService(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId,
 521                 vnfType);
 522     }
 523
 524     @Test
 525     public void testGetGBBALaCarteNonServiceServiceInstanceNotFoundInAAI() throws Exception {
 526         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
 527                 ExecuteBuildingBlock.class);
 528         RequestDetails requestDetails = mapper.readValue(
 529                 new File(RESOURCE_PATH + "RequestDetailsInput_withRelatedInstanceList.json"), RequestDetails.class);
 530         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 531         lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "si123");
 532         String requestAction = "createInstance";
 533         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
 534         aaiServiceInstance.setModelVersionId("modelVersionId");
 535         String resourceId = "123";
 536         String vnfType = "vnfType";
 537
 538         doReturn(null).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById("si123");
 539
 540         expectedException.expect(NoServiceInstanceFoundException.class);
 541         expectedException.expectMessage("Related service instance from AAI not found: service-instance-id=si123");
 542
 543         SPY_bbInputSetup.getGBBALaCarteNonService(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId,
 544                 vnfType);
 545     }
 546
 547     @Test
 548     public void testGetGBBALaCarteNonServiceWithoutRelatedInstances() throws Exception {
 549         GeneralBuildingBlock expected = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
 550                 GeneralBuildingBlock.class);
 551         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
 552                 ExecuteBuildingBlock.class);
 553         RequestDetails requestDetails = mapper.readValue(
 554                 new File(RESOURCE_PATH + "RequestDetailsInput_withoutRelatedInstanceList.json"), RequestDetails.class);
 555         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 556         String requestAction = "createInstance";
 557         Service service = Mockito.mock(Service.class);
 558         ServiceModel serviceModel = new ServiceModel();
 559         serviceModel.setCurrentService(service);
 560         String resourceId = "123";
 561         ServiceInstance serviceInstance = Mockito.mock(ServiceInstance.class);
 562         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
 563         aaiServiceInstance.setModelVersionId("modelVersionId");
 564         org.onap.aai.domain.yang.CloudRegion aaiCloudRegion = Mockito.mock(org.onap.aai.domain.yang.CloudRegion.class);
 565         String vnfType = "vnfType";
 566         lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "instanceId");
 567         doReturn(service).when(SPY_bbInputSetupUtils)
 568                 .getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
 569         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById("instanceId");
 570
 571         doNothing().when(SPY_bbInputSetup).populateObjectsOnAssignAndCreateFlows(any(BBInputSetupParameter.class));
 572
 573         doReturn(serviceInstance).when(SPY_bbInputSetup).getExistingServiceInstance(aaiServiceInstance);
 574         doReturn(expected).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
 575
 576         GeneralBuildingBlock actual = SPY_bbInputSetup.getGBBALaCarteNonService(executeBB, requestDetails, lookupKeyMap,
 577                 requestAction, resourceId, vnfType);
 578
 579         assertThat(actual, sameBeanAs(expected));
 580     }
 581
 582     @Test
 583     public void testGetGBBALaCarteService() throws Exception {
 584         GeneralBuildingBlock expected = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
 585                 GeneralBuildingBlock.class);
 586         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
 587                 ExecuteBuildingBlock.class);
 588         RequestDetails requestDetails = mapper.readValue(
 589                 new File(RESOURCE_PATH + "RequestDetailsInput_withRelatedInstanceList.json"), RequestDetails.class);
 590         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 591
 592         org.onap.so.serviceinstancebeans.Project requestProject = new org.onap.so.serviceinstancebeans.Project();
 593         org.onap.so.serviceinstancebeans.OwningEntity requestOwningEntity =
 594                 new org.onap.so.serviceinstancebeans.OwningEntity();
 595         requestDetails.setProject(requestProject);
 596         requestDetails.setOwningEntity(requestOwningEntity);
 597
 598         Service service = Mockito.mock(Service.class);
 599         Customer customer = Mockito.mock(Customer.class);
 600         ServiceSubscription serviceSubscription = Mockito.mock(ServiceSubscription.class);
 601         Project project = Mockito.mock(Project.class);
 602         OwningEntity owningEntity = Mockito.mock(OwningEntity.class);
 603         ServiceInstance serviceInstance = Mockito.mock(ServiceInstance.class);
 604         String resourceId = "123";
 605         String requestAction = "createInstance";
 606         executeBB.setaLaCarte(true);
 607         executeBB.getBuildingBlock().setBpmnFlowName(AssignFlows.SERVICE_INSTANCE.toString());
 608         org.onap.aai.domain.yang.CloudRegion aaiCloudRegion = Mockito.mock(org.onap.aai.domain.yang.CloudRegion.class);
 609
 610         doReturn(service).when(SPY_bbInputSetupUtils)
 611                 .getCatalogServiceByModelUUID(requestDetails.getModelInfo().getModelVersionId());
 612         doReturn(project).when(bbInputSetupMapperLayer).mapRequestProject(requestDetails.getProject());
 613         doReturn(owningEntity).when(bbInputSetupMapperLayer).mapRequestOwningEntity(requestDetails.getOwningEntity());
 614
 615         doReturn(customer).when(SPY_bbInputSetup).getCustomerAndServiceSubscription(requestDetails, resourceId);
 616         doReturn(serviceInstance).when(SPY_bbInputSetup).getALaCarteServiceInstance(service, requestDetails, customer,
 617                 project, owningEntity, lookupKeyMap, resourceId, Boolean.TRUE.equals(executeBB.isaLaCarte()),
 618                 executeBB.getBuildingBlock().getBpmnFlowName());
 619         doReturn(expected).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
 620
 621         GeneralBuildingBlock actual = SPY_bbInputSetup.getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
 622                 requestAction, resourceId);
 623
 624         assertThat(actual, sameBeanAs(expected));
 625     }
 626
 627     @Test
 628     public void testGetGBBALaCarteServiceFindServiceByModelVersionId() throws Exception {
 629         GeneralBuildingBlock expected = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
 630                 GeneralBuildingBlock.class);
 631         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
 632                 ExecuteBuildingBlock.class);
 633         RequestDetails requestDetails = mapper.readValue(
 634                 new File(RESOURCE_PATH + "RequestDetailsInput_withRelatedInstanceList.json"), RequestDetails.class);
 635         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 636
 637         org.onap.so.serviceinstancebeans.Project requestProject = new org.onap.so.serviceinstancebeans.Project();
 638         org.onap.so.serviceinstancebeans.OwningEntity requestOwningEntity =
 639                 new org.onap.so.serviceinstancebeans.OwningEntity();
 640         requestDetails.setProject(requestProject);
 641         requestDetails.setOwningEntity(requestOwningEntity);
 642
 643         Service service = Mockito.mock(Service.class);
 644         Customer customer = Mockito.mock(Customer.class);
 645         ServiceSubscription serviceSubscription = Mockito.mock(ServiceSubscription.class);
 646         Project project = Mockito.mock(Project.class);
 647         OwningEntity owningEntity = Mockito.mock(OwningEntity.class);
 648         ServiceInstance serviceInstance = Mockito.mock(ServiceInstance.class);
 649         String resourceId = "123";
 650         String requestAction = "createInstance";
 651         executeBB.setaLaCarte(true);
 652         executeBB.getBuildingBlock().setBpmnFlowName(AssignFlows.SERVICE_INSTANCE.toString());
 653         org.onap.aai.domain.yang.CloudRegion aaiCloudRegion = Mockito.mock(org.onap.aai.domain.yang.CloudRegion.class);
 654
 655         doReturn(null).when(SPY_bbInputSetupUtils)
 656                 .getCatalogServiceByModelUUID(requestDetails.getModelInfo().getModelVersionId());
 657         doReturn(service).when(SPY_bbInputSetupUtils).getCatalogServiceByModelVersionAndModelInvariantUUID(
 658                 requestDetails.getModelInfo().getModelVersion(), requestDetails.getModelInfo().getModelInvariantId());
 659         doReturn(project).when(bbInputSetupMapperLayer).mapRequestProject(requestDetails.getProject());
 660         doReturn(owningEntity).when(bbInputSetupMapperLayer).mapRequestOwningEntity(requestDetails.getOwningEntity());
 661
 662         doReturn(customer).when(SPY_bbInputSetup).getCustomerAndServiceSubscription(requestDetails, resourceId);
 663         doReturn(serviceInstance).when(SPY_bbInputSetup).getALaCarteServiceInstance(service, requestDetails, customer,
 664                 project, owningEntity, lookupKeyMap, resourceId, Boolean.TRUE.equals(executeBB.isaLaCarte()),
 665                 executeBB.getBuildingBlock().getBpmnFlowName());
 666         doReturn(expected).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
 667
 668         GeneralBuildingBlock actual = SPY_bbInputSetup.getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
 669                 requestAction, resourceId);
 670
 671         assertThat(actual, sameBeanAs(expected));
 672     }
 673
 674     @Test
 675     public void testGetGBBALaCarteServiceNoProjectNoOE() throws Exception {
 676         GeneralBuildingBlock expected = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
 677                 GeneralBuildingBlock.class);
 678         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
 679                 ExecuteBuildingBlock.class);
 680         RequestDetails requestDetails = mapper.readValue(
 681                 new File(RESOURCE_PATH + "RequestDetailsInput_withRelatedInstanceList.json"), RequestDetails.class);
 682         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 683
 684         Service service = Mockito.mock(Service.class);
 685         Customer customer = Mockito.mock(Customer.class);
 686         ServiceSubscription serviceSubscription = Mockito.mock(ServiceSubscription.class);
 687         ServiceInstance serviceInstance = Mockito.mock(ServiceInstance.class);
 688         String resourceId = "123";
 689         String requestAction = "createInstance";
 690         executeBB.setaLaCarte(true);
 691         executeBB.getBuildingBlock().setBpmnFlowName(AssignFlows.SERVICE_INSTANCE.toString());
 692         org.onap.aai.domain.yang.CloudRegion aaiCloudRegion = Mockito.mock(org.onap.aai.domain.yang.CloudRegion.class);
 693
 694         Map<String, String> uriKeys = new HashMap<>();
 695         uriKeys.put("global-customer-id", "globalCustomerId");
 696         uriKeys.put("service-type", "serviceType");
 697
 698         doReturn(service).when(SPY_bbInputSetupUtils)
 699                 .getCatalogServiceByModelUUID(requestDetails.getModelInfo().getModelVersionId());
 700
 701         doReturn(customer).when(SPY_bbInputSetup).getCustomerAndServiceSubscription(requestDetails, resourceId);
 702
 703         doReturn(serviceInstance).when(SPY_bbInputSetup).getALaCarteServiceInstance(service, requestDetails, customer,
 704                 null, null, lookupKeyMap, resourceId, Boolean.TRUE.equals(executeBB.isaLaCarte()),
 705                 executeBB.getBuildingBlock().getBpmnFlowName());
 706         doReturn(expected).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
 707
 708         GeneralBuildingBlock actual = SPY_bbInputSetup.getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
 709                 requestAction, resourceId);
 710
 711         assertThat(actual, sameBeanAs(expected));
 712     }
 713
 714     @Test
 715     public void testGetServiceInstanceHelperCreateScenario() throws Exception {
 716         RequestDetails requestDetails = new RequestDetails();
 717         RequestInfo requestInfo = new RequestInfo();
 718         requestInfo.setInstanceName("SharansInstanceName");
 719         requestDetails.setRequestInfo(requestInfo);
 720         Customer customer = new Customer();
 721         String serviceInstanceId = "SharansInstanceId";
 722         boolean aLaCarte = true;
 723         ServiceInstance expected = new ServiceInstance();
 724         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 725         Service service = new Service();
 726         service.setModelUUID("modelUUID");
 727         String bbName = AssignFlows.SERVICE_INSTANCE.toString();
 728
 729         doReturn(null).when(SPY_bbInputSetupUtils).getAAIServiceInstanceByName(requestInfo.getInstanceName(), customer);
 730         doReturn(null).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById(serviceInstanceId);
 731
 732
 733         doReturn(expected).when(SPY_bbInputSetup).createServiceInstance(requestDetails, null, null, lookupKeyMap,
 734                 serviceInstanceId);
 735
 736         ServiceInstance actual = SPY_bbInputSetup.getServiceInstanceHelper(requestDetails, customer, null, null,
 737                 lookupKeyMap, serviceInstanceId, aLaCarte, service, bbName);
 738         assertThat(actual, sameBeanAs(expected));
 739     }
 740
 741     @Test
 742     public void testGetServiceInstanceHelperCreateScenarioExisting() throws Exception {
 743         RequestDetails requestDetails = new RequestDetails();
 744         RequestInfo requestInfo = new RequestInfo();
 745         requestInfo.setInstanceName("SharansInstanceName");
 746         requestDetails.setRequestInfo(requestInfo);
 747         Customer customer = new Customer();
 748         String serviceInstanceId = "SharansInstanceId";
 749         boolean aLaCarte = true;
 750         Service service = new Service();
 751         service.setModelUUID("modelUUID");
 752         ServiceInstance expected = new ServiceInstance();
 753         org.onap.aai.domain.yang.ServiceInstance serviceInstanceAAI = new org.onap.aai.domain.yang.ServiceInstance();
 754         serviceInstanceAAI.setModelVersionId("modelUUID");
 755         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 756         String bbName = AssignFlows.SERVICE_INSTANCE.toString();
 757
 758         doReturn(serviceInstanceAAI).when(SPY_bbInputSetupUtils)
 759                 .getAAIServiceInstanceByName(requestInfo.getInstanceName(), customer);
 760         doReturn(expected).when(SPY_bbInputSetup).getExistingServiceInstance(serviceInstanceAAI);
 761
 762         ServiceInstance actual = SPY_bbInputSetup.getServiceInstanceHelper(requestDetails, customer, null, null,
 763                 lookupKeyMap, serviceInstanceId, aLaCarte, service, bbName);
 764         assertThat(actual, sameBeanAs(expected));
 765     }
 766
 767     @Test
 768     public void testGetServiceInstanceHelperCreateScenarioExistingNoNameButWithId() throws Exception {
 769         RequestDetails requestDetails = new RequestDetails();
 770         RequestInfo requestInfo = new RequestInfo();
 771         requestInfo.setInstanceName("SharansInstanceName");
 772         requestDetails.setRequestInfo(requestInfo);
 773         Customer customer = new Customer();
 774         String serviceInstanceId = "SharansInstanceId";
 775         boolean aLaCarte = true;
 776         Service service = new Service();
 777         service.setModelUUID("modelUUID");
 778         ServiceInstance expected = new ServiceInstance();
 779         org.onap.aai.domain.yang.ServiceInstance serviceInstanceAAI = new org.onap.aai.domain.yang.ServiceInstance();
 780         serviceInstanceAAI.setModelVersionId("modelUUID");
 781         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 782         String bbName = "ActivateServiceInstanceBB";
 783
 784         doReturn(serviceInstanceAAI).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById(serviceInstanceId);
 785         doReturn(expected).when(SPY_bbInputSetup).getExistingServiceInstance(serviceInstanceAAI);
 786
 787         ServiceInstance actual = SPY_bbInputSetup.getServiceInstanceHelper(requestDetails, customer, null, null,
 788                 lookupKeyMap, serviceInstanceId, aLaCarte, service, bbName);
 789         assertThat(actual, sameBeanAs(expected));
 790     }
 791
 792     @Test
 793     public void testGetServiceInstanceHelperCreateScenarioExistingNoNameButWithIdDifferentModel() throws Exception {
 794         RequestDetails requestDetails = new RequestDetails();
 795         RequestInfo requestInfo = new RequestInfo();
 796         requestDetails.setRequestInfo(requestInfo);
 797         Customer customer = new Customer();
 798         String serviceInstanceId = "SharansInstanceId";
 799         boolean aLaCarte = true;
 800         Service service = new Service();
 801         service.setModelUUID("modelUUID");
 802         ServiceInstance expected = new ServiceInstance();
 803         org.onap.aai.domain.yang.ServiceInstance serviceInstanceAAI = new org.onap.aai.domain.yang.ServiceInstance();
 804         serviceInstanceAAI.setModelVersionId("modelUUIDDifferent");
 805         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 806         String bbName = "ActivateServiceInstanceBB";
 807         Service differentService = new Service();
 808         differentService.setModelUUID("modelUUIDDifferent");
 809
 810         doReturn(serviceInstanceAAI).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById(serviceInstanceId);
 811
 812
 813         ServiceInstance actual = SPY_bbInputSetup.getServiceInstanceHelper(requestDetails, customer, null, null,
 814                 lookupKeyMap, serviceInstanceId, aLaCarte, service, bbName);
 815         assertThat(actual, sameBeanAs(expected));
 816     }
 817
 818     @Test(expected = Exception.class)
 819     public void testGetServiceInstanceHelperCreateScenarioExistingNoNameButWithIdExceptionThrown() throws Exception {
 820         RequestDetails requestDetails = new RequestDetails();
 821         RequestInfo requestInfo = new RequestInfo();
 822         requestDetails.setRequestInfo(requestInfo);
 823         Customer customer = new Customer();
 824         String serviceInstanceId = "SharansInstanceId";
 825         boolean aLaCarte = true;
 826         Service service = new Service();
 827         service.setModelUUID("modelUUID");
 828         org.onap.aai.domain.yang.ServiceInstance serviceInstanceAAI = new org.onap.aai.domain.yang.ServiceInstance();
 829         serviceInstanceAAI.setModelVersionId("modelUUIDDifferent");
 830         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 831         String bbName = AssignFlows.SERVICE_INSTANCE.toString();
 832
 833         ServiceInstance actual = SPY_bbInputSetup.getServiceInstanceHelper(requestDetails, customer, null, null,
 834                 lookupKeyMap, serviceInstanceId, aLaCarte, service, bbName);
 835     }
 836
 837     @Test
 838     public void testPopulateObjectsOnAssignAndCreateFlows() throws Exception {
 839         String bbName = AssignFlows.SERVICE_INSTANCE.toString();
 840         String instanceName = "instanceName";
 841         String vnfType = "vnfType";
 842         String resourceId = "networkId";
 843         String productFamilyId = "productFamilyId";
 844         String applicationId = "applicationId";
 845         Service service = Mockito.mock(Service.class);
 846         ServiceModel serviceModel = new ServiceModel();
 847         serviceModel.setCurrentService(service);
 848         ServiceInstance serviceInstance = Mockito.mock(ServiceInstance.class);
 849         RequestDetails requestDetails = Mockito.mock(RequestDetails.class);
 850         ModelInfo modelInfo = Mockito.mock(ModelInfo.class);
 851         RequestInfo requestInfo = Mockito.mock(RequestInfo.class);
 852         RelatedInstanceList[] relatedInstanceList = new RelatedInstanceList[] {};
 853         CloudConfiguration cloudConfiguration = new CloudConfiguration();
 854         org.onap.so.serviceinstancebeans.Platform platform =
 855                 Mockito.mock(org.onap.so.serviceinstancebeans.Platform.class);
 856         org.onap.so.serviceinstancebeans.LineOfBusiness lineOfBusiness =
 857                 Mockito.mock(org.onap.so.serviceinstancebeans.LineOfBusiness.class);
 858         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
 859
 860         doReturn(modelInfo).when(requestDetails).getModelInfo();
 861         doReturn(productFamilyId).when(requestInfo).getProductFamilyId();
 862         doReturn(requestInfo).when(requestDetails).getRequestInfo();
 863         doReturn(instanceName).when(requestInfo).getInstanceName();
 864         doReturn(platform).when(requestDetails).getPlatform();
 865         doReturn(lineOfBusiness).when(requestDetails).getLineOfBusiness();
 866         doReturn(relatedInstanceList).when(requestDetails).getRelatedInstanceList();
 867         doReturn(cloudConfiguration).when(requestDetails).getCloudConfiguration();
 868         doReturn(applicationId).when(requestInfo).getApplicationId();
 869
 870         doReturn(ModelType.network).when(modelInfo).getModelType();
 871         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
 872                 .setRequestDetails(requestDetails).setService(service).setBbName(bbName)
 873                 .setServiceInstance(serviceInstance).setLookupKeyMap(lookupKeyMap).setResourceId(resourceId)
 874                 .setVnfType(vnfType).setIsReplace(false).setApplicationId(applicationId).build();
 875
 876         doNothing().when(SPY_bbInputSetup).populateL3Network(parameter);
 877         SPY_bbInputSetup.populateObjectsOnAssignAndCreateFlows(parameter);
 878         parameter.setInstanceName(instanceName);
 879         parameter.setModelInfo(modelInfo);
 880         verify(SPY_bbInputSetup, times(1)).populateL3Network(parameter);
 881         assertEquals("NetworkId populated", true,
 882                 lookupKeyMap.get(ResourceKey.NETWORK_ID).equalsIgnoreCase(resourceId));
 883
 884         doReturn(ModelType.vnf).when(modelInfo).getModelType();
 885         resourceId = "vnfId";
 886         doNothing().when(SPY_bbInputSetup).populateGenericVnf(parameter);
 887         parameter.setResourceId(resourceId);
 888         SPY_bbInputSetup.populateObjectsOnAssignAndCreateFlows(parameter);
 889         verify(SPY_bbInputSetup, times(1)).populateGenericVnf(parameter);
 890         assertEquals("VnfId populated", true,
 891                 lookupKeyMap.get(ResourceKey.GENERIC_VNF_ID).equalsIgnoreCase(resourceId));
 892         doReturn(ModelType.volumeGroup).when(modelInfo).getModelType();
 893         resourceId = "volumeGroupId";
 894         parameter.setResourceId(resourceId);
 895         doNothing().when(SPY_bbInputSetup).populateVolumeGroup(parameter);
 896         SPY_bbInputSetup.populateObjectsOnAssignAndCreateFlows(parameter);
 897         verify(SPY_bbInputSetup, times(1)).populateVolumeGroup(parameter);
 898         assertEquals("VolumeGroupId populated", true,
 899                 lookupKeyMap.get(ResourceKey.VOLUME_GROUP_ID).equalsIgnoreCase(resourceId));
 900
 901         doReturn(ModelType.vfModule).when(modelInfo).getModelType();
 902         resourceId = "vfModuleId";
 903         parameter.setResourceId(resourceId);
 904         doNothing().when(SPY_bbInputSetup).populateVfModule(parameter);
 905         SPY_bbInputSetup.populateObjectsOnAssignAndCreateFlows(parameter);
 906         verify(SPY_bbInputSetup, times(1)).populateVfModule(parameter);
 907         assertEquals("VfModuleId populated", true,
 908                 lookupKeyMap.get(ResourceKey.VF_MODULE_ID).equalsIgnoreCase(resourceId));
 909
 910         String bbNameAssignVolume = AssignFlows.VOLUME_GROUP.toString();
 911         doReturn(ModelType.vfModule).when(modelInfo).getModelType();
 912         resourceId = "vfModuleId";
 913         parameter.setResourceId(resourceId);
 914         parameter.setBbName(bbNameAssignVolume);
 915         doNothing().when(SPY_bbInputSetup).populateVolumeGroup(parameter);
 916         SPY_bbInputSetup.populateObjectsOnAssignAndCreateFlows(parameter);
 917         verify(SPY_bbInputSetup, times(2)).populateVolumeGroup(parameter);
 918         assertEquals(resourceId, lookupKeyMap.get(ResourceKey.VOLUME_GROUP_ID));
 919     }
 920
 921     @Test
 922     public void testPopulateGBBWithSIAndAdditionalInfo() throws Exception {
 923         GeneralBuildingBlock expected =
 924                 mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpectedWUserParamsInfo.json"),
 925                         GeneralBuildingBlock.class);
 926         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
 927                 ExecuteBuildingBlock.class);
 928         RequestDetails requestDetails = mapper.readValue(
 929                 new File(RESOURCE_PATH + "RequestDetailsInput_withRelatedInstanceList.json"), RequestDetails.class);
 930         RequestContext requestContext =
 931                 mapper.readValue(new File(RESOURCE_PATH + "RequestContextExpected.json"), RequestContext.class);
 932         ServiceInstance serviceInstance =
 933                 mapper.readValue(new File(RESOURCE_PATH + "ServiceInstance_getServiceInstanceNOAAIExpected.json"),
 934                         ServiceInstance.class);
 935         CloudConfiguration cloudConfiguration = new CloudConfiguration();
 936         cloudConfiguration.setTenantId("tenantId");
 937         requestDetails.setCloudConfiguration(cloudConfiguration);
 938         OrchestrationContext orchestrationContext = new OrchestrationContext();
 939         orchestrationContext.setIsRollbackEnabled(false);
 940
 941         CloudRegion cloudRegion = new CloudRegion();
 942         cloudRegion.setCloudOwner("test-owner-name");
 943         cloudRegion.setLcpCloudRegionId("lcpCloudRegionId");
 944         cloudRegion.setComplex("complexName");
 945         cloudRegion.setTenantId("tenantId");
 946
 947         Map<String, String> uriKeys = new HashMap<>();
 948         uriKeys.put(AAIFluentTypeBuilder.Types.CUSTOMER.getUriParams().globalCustomerId, "global-customer-id");
 949         uriKeys.put(AAIFluentTypeBuilder.Types.SERVICE_SUBSCRIPTION.getUriParams().serviceType, "service-type");
 950
 951         Customer customer = new Customer();
 952         ServiceSubscription serviceSubscription = new ServiceSubscription();
 953         serviceSubscription.setServiceType("subscriptionServiceType");
 954         customer.setGlobalCustomerId("globalCustomerId");
 955         customer.setSubscriberName("subscriberName");
 956         customer.setSubscriberType("subscriberType");
 957         customer.setServiceSubscription(serviceSubscription);
 958
 959         org.onap.so.bpmn.servicedecomposition.bbobjects.Tenant tenant =
 960                 new org.onap.so.bpmn.servicedecomposition.bbobjects.Tenant();
 961         tenant.setTenantContext("tenantContext");
 962         tenant.setTenantId("tenantId");
 963         tenant.setTenantName("tenantName");
 964
 965         org.onap.aai.domain.yang.CloudRegion aaiCloudRegion = Mockito.mock(org.onap.aai.domain.yang.CloudRegion.class);
 966         org.onap.aai.domain.yang.Tenants aaiTenants = Mockito.mock(org.onap.aai.domain.yang.Tenants.class);
 967         org.onap.aai.domain.yang.Tenant aaiTenant = new org.onap.aai.domain.yang.Tenant();
 968         aaiTenant.setTenantId("tenantId");
 969         List<org.onap.aai.domain.yang.Tenant> tenants = new ArrayList<>();
 970         tenants.add(aaiTenant);
 971
 972         String requestAction = "createInstance";
 973
 974         doReturn(uriKeys).when(SPY_bbInputSetupUtils)
 975                 .getURIKeysFromServiceInstance(serviceInstance.getServiceInstanceId());
 976         doReturn(customer).when(SPY_bbInputSetup).mapCustomer(uriKeys.get("global-customer-id"),
 977                 uriKeys.get("service-type"));
 978         doReturn(aaiCloudRegion).when(SPY_bbInputSetupUtils).getCloudRegion(requestDetails.getCloudConfiguration());
 979         doReturn(orchestrationContext).when(bbInputSetupMapperLayer).mapOrchestrationContext(requestDetails);
 980         doReturn(requestContext).when(bbInputSetupMapperLayer).mapRequestContext(requestDetails);
 981         doReturn(cloudRegion).when(bbInputSetupMapperLayer).mapCloudRegion(requestDetails.getCloudConfiguration(),
 982                 aaiCloudRegion);
 983         doReturn(tenant).when(bbInputSetupMapperLayer).mapTenant(aaiTenant);
 984         doReturn(aaiTenants).when(aaiCloudRegion).getTenants();
 985         doReturn(tenants).when(aaiTenants).getTenant();
 986         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setServiceInstance(serviceInstance)
 987                 .setRequestDetails(requestDetails).setExecuteBB(executeBB).setRequestAction(requestAction).build();
 988         GeneralBuildingBlock actual = SPY_bbInputSetup.populateGBBWithSIAndAdditionalInfo(parameter);
 989
 990         assertThat(actual, sameBeanAs(expected));
 991     }
 992
 993     @Test
 994     public void testGetServiceInstanceNOAAI() throws Exception {
 995         ServiceInstance expected =
 996                 mapper.readValue(new File(RESOURCE_PATH + "ServiceInstance_getServiceInstanceNOAAIExpected.json"),
 997                         ServiceInstance.class);
 998         Service service = mapper.readValue(
 999                 new File(RESOURCE_PATH + "CatalogDBService_getServiceInstanceNOAAIInput.json"), Service.class);
1000         Customer customer = mapper.readValue(new File(RESOURCE_PATH + "Customer.json"), Customer.class);
1001         Project project = mapper.readValue(new File(RESOURCE_PATH + "Project.json"), Project.class);
1002         OwningEntity owningEntity = mapper.readValue(new File(RESOURCE_PATH + "OwningEntity.json"), OwningEntity.class);
1003         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
1004
1005         BuildingBlock buildingBlock = new BuildingBlock().setBpmnFlowName(AssignFlows.SERVICE_INSTANCE.toString());
1006         ExecuteBuildingBlock executeBB = new ExecuteBuildingBlock().setaLaCarte(true).setBuildingBlock(buildingBlock);
1007         RequestDetails requestDetails = new RequestDetails();
1008         RequestInfo reqInfo = new RequestInfo();
1009         reqInfo.setInstanceName("serviceInstanceName");
1010         requestDetails.setRequestInfo(reqInfo);
1011         ModelInfo modelInfo = new ModelInfo();
1012         modelInfo.setModelType(ModelType.service);
1013         requestDetails.setModelInfo(modelInfo);
1014         doReturn(null).when(SPY_bbInputSetupUtils)
1015                 .getAAIServiceInstanceByName(requestDetails.getRequestInfo().getInstanceName(), customer);
1016         doReturn(expected.getModelInfoServiceInstance()).when(bbInputSetupMapperLayer)
1017                 .mapCatalogServiceIntoServiceInstance(service);
1018         doReturn(null).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById(any(String.class));
1019         String serviceInstanceId = "3655a595-05d1-433c-93c0-3afd6b572545";
1020         boolean aLaCarte = true;
1021
1022         ServiceInstance actual =
1023                 SPY_bbInputSetup.getALaCarteServiceInstance(service, requestDetails, customer, project, owningEntity,
1024                         lookupKeyMap, serviceInstanceId, aLaCarte, executeBB.getBuildingBlock().getBpmnFlowName());
1025
1026         assertThat(actual, sameBeanAs(expected));
1027     }
1028
1029     @Test
1030     public void testGetServiceSubscription() throws IOException {
1031         ServiceSubscription expected = new ServiceSubscription();
1032         RequestDetails requestDetails = new RequestDetails();
1033         RequestParameters params = new RequestParameters();
1034         params.setSubscriptionServiceType("subscriptionServiceType");
1035         requestDetails.setRequestParameters(params);
1036         org.onap.aai.domain.yang.ServiceSubscription aaiServiceSubscription =
1037                 new org.onap.aai.domain.yang.ServiceSubscription();
1038         Customer customer = new Customer();
1039         customer.setGlobalCustomerId("globalCustomerId");
1040         doReturn(aaiServiceSubscription).when(SPY_bbInputSetupUtils).getAAIServiceSubscription(
1041                 customer.getGlobalCustomerId(), requestDetails.getRequestParameters().getSubscriptionServiceType());
1042         doReturn(expected).when(bbInputSetupMapperLayer).mapAAIServiceSubscription(aaiServiceSubscription);
1043
1044         ServiceSubscription actual = SPY_bbInputSetup.getServiceSubscription(requestDetails, customer);
1045         assertThat(actual, sameBeanAs(expected));
1046     }
1047
1048     @Test
1049     public void testGetCustomer() throws IOException {
1050         Customer expected = new Customer();
1051         RequestDetails requestDetails = new RequestDetails();
1052         SubscriberInfo subscriberInfo = new SubscriberInfo();
1053         subscriberInfo.setGlobalSubscriberId("globalSubscriberId");
1054         requestDetails.setSubscriberInfo(subscriberInfo);
1055         org.onap.aai.domain.yang.Customer aaiCustomer = new org.onap.aai.domain.yang.Customer();
1056         doReturn(aaiCustomer).when(SPY_bbInputSetupUtils)
1057                 .getAAICustomer(requestDetails.getSubscriberInfo().getGlobalSubscriberId());
1058         doReturn(expected).when(bbInputSetupMapperLayer).mapAAICustomer(aaiCustomer);
1059
1060         Customer actual = SPY_bbInputSetup.getCustomerFromRequest(requestDetails);
1061         assertThat(actual, sameBeanAs(expected));
1062     }
1063
1064     @Test
1065     public void testGetExistingServiceInstance() throws Exception {
1066         org.onap.aai.domain.yang.ServiceInstance serviceInstanceAAI = new org.onap.aai.domain.yang.ServiceInstance();
1067         ServiceInstance expected = new ServiceInstance();
1068
1069         doReturn(expected).when(bbInputSetupMapperLayer).mapAAIServiceInstanceIntoServiceInstance(serviceInstanceAAI);
1070
1071
1072         ServiceInstance actual = SPY_bbInputSetup.getExistingServiceInstance(serviceInstanceAAI);
1073         assertThat(actual, sameBeanAs(expected));
1074     }
1075
1076     @Test
1077     public void testPopulateNetworkCollectionAndInstanceGroupAssign() throws Exception {
1078         Service service = Mockito.mock(Service.class);
1079         String key = "collectionCustId";
1080         ServiceInstance serviceInstance =
1081                 mapper.readValue(new File(RESOURCE_PATH + "ServiceInstance_getServiceInstanceNOAAIExpected.json"),
1082                         ServiceInstance.class);
1083         String resourceId = "123";
1084         Collection collection = SPY_bbInputSetup.createCollection(resourceId);
1085         InstanceGroup instanceGroup = SPY_bbInputSetup.createInstanceGroup();
1086         assertNull(serviceInstance.getCollection());
1087         doReturn(true).when(SPY_bbInputSetup).isVlanTagging(service, key);
1088
1089         doReturn(collection).when(SPY_bbInputSetup).createCollection(resourceId);
1090         doReturn(instanceGroup).when(SPY_bbInputSetup).createInstanceGroup();
1091         doNothing().when(SPY_bbInputSetup).mapCatalogCollection(service, collection, key);
1092
1093         NetworkCollectionResourceCustomization networkCollection = new NetworkCollectionResourceCustomization();
1094         networkCollection.setModelCustomizationUUID(key);
1095         networkCollection.setCollectionResource(new CollectionResource());
1096         networkCollection.getCollectionResource().setInstanceGroup(new org.onap.so.db.catalog.beans.InstanceGroup());
1097         networkCollection.getCollectionResource().getInstanceGroup().setToscaNodeType("NetworkCollectionResource");
1098         networkCollection.getCollectionResource().getInstanceGroup().setType(InstanceGroupType.L3_NETWORK);
1099         networkCollection.getCollectionResource().getInstanceGroup()
1100                 .setCollectionInstanceGroupCustomizations(new ArrayList<>());
1101         List<CollectionResourceCustomization> customizations = new ArrayList<>();
1102         customizations.add(networkCollection);
1103         doReturn(customizations).when(service).getCollectionResourceCustomizations();
1104         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setService(service)
1105                 .setServiceInstance(serviceInstance).setResourceId(resourceId).setKey(key)
1106                 .setBbName(AssignFlows.NETWORK_COLLECTION.toString()).build();
1107
1108         SPY_bbInputSetup.populateNetworkCollectionAndInstanceGroupAssign(parameter);
1109         assertNotNull(serviceInstance.getCollection());
1110         assertNotNull(serviceInstance.getCollection().getInstanceGroup());
1111
1112         verify(SPY_bbInputSetup, times(1)).mapCatalogCollection(service, serviceInstance.getCollection(), key);
1113         verify(SPY_bbInputSetup, times(1)).mapCatalogNetworkCollectionInstanceGroup(service,
1114                 serviceInstance.getCollection().getInstanceGroup(), key);
1115     }
1116
1117     @Test
1118     public void testPopulateInstanceGroup() throws Exception {
1119         ModelInfo modelInfo = Mockito.mock(ModelInfo.class);
1120         Service service = Mockito.mock(Service.class);
1121         List<InstanceGroup> instanceGroups = Mockito.spy(new ArrayList<>());
1122         ServiceInstance serviceInstance = Mockito.spy(new ServiceInstance());
1123         serviceInstance.setServiceInstanceId("si-001");
1124         serviceInstance.setServiceInstanceName("test service instance");
1125         serviceInstance.setInstanceGroups(instanceGroups);
1126
1127         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setModelInfo(modelInfo)
1128                 .setService(service).setServiceInstance(serviceInstance).setResourceId("instance-group-001")
1129                 .setInstanceName("test instance group").build();
1130         SPY_bbInputSetup.populateInstanceGroup(parameter);
1131         verify(SPY_bbInputSetup, times(1)).mapCatalogInstanceGroup(isA(InstanceGroup.class), isA(ModelInfo.class),
1132                 isA(Service.class));
1133         verify(instanceGroups, times(1)).add(isA(InstanceGroup.class));
1134     }
1135
1136     @Test
1137     public void testIsVlanTagging() throws Exception {
1138         boolean expected = true;
1139         Service service = Mockito.mock(Service.class);
1140         String key = "collectionCustId";
1141         NetworkCollectionResourceCustomization networkCollection = new NetworkCollectionResourceCustomization();
1142         networkCollection.setModelCustomizationUUID(key);
1143         networkCollection.setCollectionResource(new CollectionResource());
1144         networkCollection.getCollectionResource().setInstanceGroup(new org.onap.so.db.catalog.beans.InstanceGroup());
1145         networkCollection.getCollectionResource().getInstanceGroup()
1146                 .setToscaNodeType("org.openecomp.resource.cr.NetworkCollectionResource1806");
1147         List<CollectionResourceCustomization> customizations = new ArrayList<>();
1148         customizations.add(networkCollection);
1149         doReturn(customizations).when(service).getCollectionResourceCustomizations();
1150         boolean actual = SPY_bbInputSetup.isVlanTagging(service, key);
1151         assertEquals("Is Vlan Tagging check.", expected, actual);
1152     }
1153
1154     @Test
1155     public void testPopulateVolumeGroup() throws Exception {
1156         RequestDetails requestDetails = new RequestDetails();
1157         RelatedInstanceList ril = new RelatedInstanceList();
1158         RelatedInstance ri = new RelatedInstance();
1159         ModelInfo mi = new ModelInfo();
1160         mi.setModelType(ModelType.vnf);
1161         mi.setModelCustomizationUuid("vnfModelCustomizationUUID");
1162         mi.setModelCustomizationId("vnfModelCustomizationUUID");
1163         ri.setModelInfo(mi);
1164         ril.setRelatedInstance(ri);
1165         requestDetails.setRelatedInstanceList(new RelatedInstanceList[] {ril});
1166
1167         ModelInfo modelInfo = new ModelInfo();
1168         modelInfo.setModelCustomizationId("volumeGroupCustId");
1169
1170         RequestInfo reqInfo = new RequestInfo();
1171         reqInfo.setInstanceName("volumeGroupName");
1172         requestDetails.setModelInfo(modelInfo);
1173         requestDetails.setRequestInfo(reqInfo);
1174
1175         ServiceInstance serviceInstance = new ServiceInstance();
1176         GenericVnf vnf = new GenericVnf();
1177         vnf.setVnfId("genericVnfId");
1178
1179         VolumeGroup vg = new VolumeGroup();
1180         vg.setVolumeGroupName("volumeGroupName");
1181         vg.setVolumeGroupId("volumeGroupId");
1182         vg.setModelInfoVfModule(new ModelInfoVfModule());
1183         vg.getModelInfoVfModule().setModelCustomizationUUID("volumeGroupCustId");
1184         vnf.getVolumeGroups().add(vg);
1185         serviceInstance.getVnfs().add(vnf);
1186
1187         Service service = mapper.readValue(
1188                 new File(RESOURCE_PATH + "CatalogDBService_getServiceInstanceNOAAIInput.json"), Service.class);
1189         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
1190         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "genericVnfId");
1191
1192         ServiceModel serviceModel = new ServiceModel();
1193         serviceModel.setCurrentService(service);
1194         String bbName = AssignFlows.VOLUME_GROUP.toString();
1195         String resourceId = "123";
1196         doNothing().when(SPY_bbInputSetup).mapCatalogVolumeGroup(isA(VolumeGroup.class), eq(modelInfo), eq(service),
1197                 eq("vnfModelCustomizationUUID"));
1198         org.onap.aai.domain.yang.GenericVnf aaiGenericVnf = new org.onap.aai.domain.yang.GenericVnf();
1199         aaiGenericVnf.setModelCustomizationId("vnfModelCustomizationUUID");
1200         doReturn(aaiGenericVnf).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
1201
1202         lookupKeyMap.put(ResourceKey.VOLUME_GROUP_ID, "volumeGroupId");
1203         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
1204                 .setModelInfo(modelInfo).setService(service).setBbName(bbName).setServiceInstance(serviceInstance)
1205                 .setLookupKeyMap(lookupKeyMap).setResourceId(resourceId).setRequestDetails(requestDetails)
1206                 .setInstanceName(reqInfo.getInstanceName()).setServiceModel(serviceModel).build();
1207         SPY_bbInputSetup.populateVolumeGroup(parameter);
1208         verify(SPY_bbInputSetup, times(1)).mapCatalogVolumeGroup(eq(vg), isA(ModelInfo.class), eq(service),
1209                 eq("vnfModelCustomizationUUID"));
1210         vnf.getVolumeGroups().clear();
1211         SPY_bbInputSetup.populateVolumeGroup(parameter);
1212         verify(SPY_bbInputSetup, times(1)).mapCatalogVolumeGroup(vnf.getVolumeGroups().get(0), modelInfo, service,
1213                 "vnfModelCustomizationUUID");
1214     }
1215
1216     @Test
1217     public void testMapCatalogVolumeGroup() {
1218         VolumeGroup volumeGroup = new VolumeGroup();
1219         RequestDetails requestDetails = new RequestDetails();
1220         ModelInfo modelInfo = new ModelInfo();
1221         modelInfo.setModelCustomizationUuid("modelCustomizationUUID");
1222         requestDetails.setModelInfo(modelInfo);
1223         Service service = new Service();
1224         VnfResourceCustomization resourceCust = new VnfResourceCustomization();
1225         resourceCust.setModelCustomizationUUID("vnfModelCustomizationUUID");
1226         service.getVnfCustomizations().add(resourceCust);
1227         VfModuleCustomization vfResourceCust = new VfModuleCustomization();
1228         vfResourceCust.setModelCustomizationUUID("modelCustomizationUUID");
1229         ModelInfoVfModule modelInfoVfModule = new ModelInfoVfModule();
1230         resourceCust.getVfModuleCustomizations().add(vfResourceCust);
1231
1232         doReturn(modelInfoVfModule).when(bbInputSetupMapperLayer).mapCatalogVfModuleToVfModule(vfResourceCust);
1233
1234         SPY_bbInputSetup.mapCatalogVolumeGroup(volumeGroup, modelInfo, service, "vnfModelCustomizationUUID");
1235
1236         assertEquals(modelInfoVfModule, volumeGroup.getModelInfoVfModule());
1237     }
1238
1239     @Test
1240     public void testPopulateL3Network() throws JsonParseException, JsonMappingException, IOException {
1241         String instanceName = "networkName";
1242         ModelInfo modelInfo = new ModelInfo();
1243         modelInfo.setModelType(ModelType.network);
1244
1245         ServiceInstance serviceInstance = new ServiceInstance();
1246         L3Network network = new L3Network();
1247         network.setNetworkId("networkId");
1248         network.setNetworkName("networkName");
1249         serviceInstance.getNetworks().add(network);
1250         String resourceId = "123";
1251         // Mock service
1252         Service service = mapper.readValue(
1253                 new File(RESOURCE_PATH + "CatalogDBService_getServiceInstanceNOAAIInput.json"), Service.class);
1254         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
1255         lookupKeyMap.put(ResourceKey.NETWORK_ID, "networkId");
1256         String bbName = AssignFlows.NETWORK_A_LA_CARTE.toString();
1257
1258         doNothing().when(SPY_bbInputSetup).mapCatalogNetwork(network, modelInfo, service);
1259
1260         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
1261                 .setInstanceName(instanceName).setModelInfo(modelInfo).setService(service).setBbName(bbName)
1262                 .setServiceInstance(serviceInstance).setLookupKeyMap(lookupKeyMap).setResourceId(resourceId).build();
1263         SPY_bbInputSetup.populateL3Network(parameter);
1264
1265         lookupKeyMap.put(ResourceKey.NETWORK_ID, null);
1266
1267         SPY_bbInputSetup.populateL3Network(parameter);
1268         verify(SPY_bbInputSetup, times(1)).mapCatalogNetwork(network, modelInfo, service);
1269
1270         instanceName = "networkName2";
1271         L3Network network2 = SPY_bbInputSetup.createNetwork(lookupKeyMap, instanceName, resourceId, null, parameter);
1272         SPY_bbInputSetup.populateL3Network(parameter);
1273         verify(SPY_bbInputSetup, times(2)).mapCatalogNetwork(network2, modelInfo, service);
1274     }
1275
1276     @Test
1277     public void testMapCatalogNetwork() {
1278         ModelInfoNetwork modelInfoNetwork = new ModelInfoNetwork();
1279         L3Network network = new L3Network();
1280
1281         RequestDetails requestDetails = new RequestDetails();
1282         ModelInfo modelInfo = new ModelInfo();
1283         modelInfo.setModelCustomizationUuid("modelCustomizationUUID");
1284         requestDetails.setModelInfo(modelInfo);
1285         Service service = new Service();
1286         NetworkResourceCustomization resourceCust = new NetworkResourceCustomization();
1287         resourceCust.setModelCustomizationUUID("modelCustomizationUUID");
1288         service.setNetworkCustomizations(Arrays.asList(new NetworkResourceCustomization[] {resourceCust}));
1289
1290         doReturn(modelInfoNetwork).when(bbInputSetupMapperLayer).mapCatalogNetworkToNetwork(resourceCust);
1291
1292         SPY_bbInputSetup.mapCatalogNetwork(network, modelInfo, service);
1293
1294         assertEquals(modelInfoNetwork, network.getModelInfoNetwork());
1295     }
1296
1297     @Test
1298     public void testPopulateConfiguration() throws JsonParseException, JsonMappingException, IOException {
1299         String instanceName = "configurationName";
1300         ModelInfo modelInfo = new ModelInfo();
1301         modelInfo.setModelCustomizationUuid("72d9d1cd-f46d-447a-abdb-451d6fb05fa9");
1302
1303         ServiceInstance serviceInstance = new ServiceInstance();
1304         Configuration configuration = new Configuration();
1305         configuration.setConfigurationId("configurationId");
1306         configuration.setConfigurationName("configurationName");
1307         serviceInstance.getConfigurations().add(configuration);
1308         String resourceId = "configurationId";
1309         String vnfcName = "vnfcName";
1310         // Mock service
1311         Service service = mapper.readValue(
1312                 new File(RESOURCE_PATH + "CatalogDBService_getServiceInstanceNOAAIInput.json"), Service.class);
1313         ConfigurationResourceCustomization configurationCust = new ConfigurationResourceCustomization();
1314         configurationCust.setModelCustomizationUUID("72d9d1cd-f46d-447a-abdb-451d6fb05fa9");
1315         service.getConfigurationCustomizations().add(configurationCust);
1316         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
1317         lookupKeyMap.put(ResourceKey.CONFIGURATION_ID, "configurationId");
1318         String bbName = AssignFlows.FABRIC_CONFIGURATION.toString();
1319         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
1320         configResourceKeys.setVnfcName(vnfcName);
1321         Vnfc vnfc = new Vnfc();
1322         vnfc.setVnfcName(vnfcName);
1323         RequestDetails requestDetails = new RequestDetails();
1324         doNothing().when(SPY_bbInputSetup).mapCatalogConfiguration(configuration, modelInfo, service,
1325                 configResourceKeys);
1326         doReturn(vnfc).when(SPY_bbInputSetup).getVnfcToConfiguration(vnfcName);
1327         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
1328                 .setModelInfo(modelInfo).setService(service).setBbName(bbName).setServiceInstance(serviceInstance)
1329                 .setLookupKeyMap(lookupKeyMap).setResourceId(resourceId).setInstanceName(instanceName)
1330                 .setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails).build();
1331         SPY_bbInputSetup.populateConfiguration(parameter);
1332         verify(SPY_bbInputSetup, times(1)).mapCatalogConfiguration(configuration, modelInfo, service,
1333                 configResourceKeys);
1334
1335         lookupKeyMap.put(ResourceKey.CONFIGURATION_ID, null);
1336
1337         SPY_bbInputSetup.populateConfiguration(parameter);
1338         verify(SPY_bbInputSetup, times(2)).mapCatalogConfiguration(configuration, modelInfo, service,
1339                 configResourceKeys);
1340
1341         instanceName = "configurationName2";
1342         resourceId = "resourceId2";
1343         lookupKeyMap.put(ResourceKey.CONFIGURATION_ID, "configurationId2");
1344         parameter.setInstanceName(instanceName);
1345         parameter.setResourceId(resourceId);
1346         Configuration configuration2 = SPY_bbInputSetup.createConfiguration(lookupKeyMap, instanceName, resourceId);
1347         doReturn(configuration2).when(SPY_bbInputSetup).createConfiguration(lookupKeyMap, instanceName, resourceId);
1348         doNothing().when(SPY_bbInputSetup).mapCatalogConfiguration(configuration2, modelInfo, service,
1349                 configResourceKeys);
1350         SPY_bbInputSetup.populateConfiguration(parameter);
1351         verify(SPY_bbInputSetup, times(1)).mapCatalogConfiguration(configuration2, modelInfo, service,
1352                 configResourceKeys);
1353     }
1354
1355     @Test
1356     public void testMapCatalogConfiguration() {
1357         ModelInfoNetwork modelInfoNetwork = new ModelInfoNetwork();
1358         L3Network network = new L3Network();
1359
1360         RequestDetails requestDetails = new RequestDetails();
1361         ModelInfo modelInfo = new ModelInfo();
1362         modelInfo.setModelCustomizationUuid("modelCustomizationUUID");
1363         requestDetails.setModelInfo(modelInfo);
1364         Service service = new Service();
1365         NetworkResourceCustomization resourceCust = new NetworkResourceCustomization();
1366         resourceCust.setModelCustomizationUUID("modelCustomizationUUID");
1367         service.setNetworkCustomizations(Arrays.asList(new NetworkResourceCustomization[] {resourceCust}));
1368
1369         doReturn(modelInfoNetwork).when(bbInputSetupMapperLayer).mapCatalogNetworkToNetwork(resourceCust);
1370
1371         SPY_bbInputSetup.mapCatalogNetwork(network, modelInfo, service);
1372
1373         assertEquals(modelInfoNetwork, network.getModelInfoNetwork());
1374     }
1375
1376     @Test
1377     public void testPopulateFabricConfiguration() throws JsonParseException, JsonMappingException, IOException {
1378         String instanceName = "configurationName";
1379         ModelInfo modelInfo = new ModelInfo();
1380         modelInfo.setModelCustomizationUuid("72d9d1cd-f46d-447a-abdb-451d6fb05fa9");
1381
1382         ServiceInstance serviceInstance = new ServiceInstance();
1383         Configuration configuration = new Configuration();
1384         configuration.setConfigurationId("configurationId");
1385         configuration.setConfigurationName("configurationName");
1386         configuration.setConfigurationSubType("Fabric Config");
1387         serviceInstance.getConfigurations().add(configuration);
1388         String resourceId = "configurationId";
1389         String vnfcName = "vnfcName";
1390         // Mock service
1391         Service service = mapper.readValue(
1392                 new File(RESOURCE_PATH + "CatalogDBService_getServiceInstanceNOAAIInput.json"), Service.class);
1393         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
1394         lookupKeyMap.put(ResourceKey.CONFIGURATION_ID, "configurationId");
1395         String bbName = AssignFlows.FABRIC_CONFIGURATION.toString();
1396         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
1397         configResourceKeys.setVnfcName(vnfcName);
1398         Vnfc vnfc = new Vnfc();
1399         vnfc.setVnfcName(vnfcName);
1400         RequestDetails requestDetails = new RequestDetails();
1401
1402         CvnfcConfigurationCustomization vnfVfmoduleCvnfcConfigurationCustomization =
1403                 new CvnfcConfigurationCustomization();
1404         ConfigurationResource configurationResource = new ConfigurationResource();
1405         configurationResource.setModelUUID("modelUUID");
1406         configurationResource.setModelInvariantUUID("modelInvariantUUID");
1407         vnfVfmoduleCvnfcConfigurationCustomization.setConfigurationResource(configurationResource);
1408
1409         doReturn(null).when(SPY_bbInputSetup).findConfigurationResourceCustomization(modelInfo, service);
1410         doReturn(vnfc).when(SPY_bbInputSetup).getVnfcToConfiguration(vnfcName);
1411         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
1412                 .setModelInfo(modelInfo).setService(service).setBbName(bbName).setServiceInstance(serviceInstance)
1413                 .setLookupKeyMap(lookupKeyMap).setResourceId(resourceId).setInstanceName(instanceName)
1414                 .setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails).build();
1415         SPY_bbInputSetup.populateConfiguration(parameter);
1416         verify(SPY_bbInputSetup, times(1)).mapCatalogConfiguration(configuration, modelInfo, service,
1417                 configResourceKeys);
1418     }
1419
1420     @Test
1421     public void testPopulateGenericVnf() throws JsonParseException, JsonMappingException, IOException {
1422         org.onap.so.serviceinstancebeans.Platform platform = new org.onap.so.serviceinstancebeans.Platform();
1423         org.onap.so.serviceinstancebeans.LineOfBusiness lineOfBusiness =
1424                 new org.onap.so.serviceinstancebeans.LineOfBusiness();
1425         String instanceName = "vnfName";
1426         ModelInfo modelInfo = new ModelInfo();
1427         modelInfo.setModelType(ModelType.vnf);
1428         ServiceInstance serviceInstance = new ServiceInstance();
1429         GenericVnf vnf = new GenericVnf();
1430         vnf.setVnfId("genericVnfId");
1431         vnf.setVnfName("vnfName");
1432         serviceInstance.getVnfs().add(vnf);
1433         String vnfType = "vnfType";
1434         String applicationId = "applicationId";
1435         RequestDetails requestDetails =
1436                 mapper.readValue(new File(RESOURCE_PATH + "RequestDetails_CreateVnf.json"), RequestDetails.class);
1437
1438         Service service = mapper.readValue(
1439                 new File(RESOURCE_PATH + "CatalogDBService_getServiceInstanceNOAAIInput.json"), Service.class);
1440         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
1441         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "genericVnfId");
1442         String bbName = AssignFlows.VNF.toString();
1443
1444         Platform expectedPlatform = new Platform();
1445         LineOfBusiness expectedLineOfBusiness = new LineOfBusiness();
1446         String resourceId = "123";
1447         doReturn(expectedPlatform).when(bbInputSetupMapperLayer).mapRequestPlatform(platform);
1448         doReturn(expectedLineOfBusiness).when(bbInputSetupMapperLayer).mapRequestLineOfBusiness(lineOfBusiness);
1449         org.onap.aai.domain.yang.GenericVnf vnfAAI = new org.onap.aai.domain.yang.GenericVnf();
1450         vnfAAI.setModelCustomizationId("modelCustId");
1451         doReturn(vnfAAI).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
1452         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(vnf, modelInfo, service);
1453         org.onap.aai.domain.yang.InstanceGroup instanceGroupAAI = new org.onap.aai.domain.yang.InstanceGroup();
1454         doReturn(instanceGroupAAI).when(SPY_bbInputSetupUtils).getAAIInstanceGroup(any());
1455         org.onap.so.db.catalog.beans.InstanceGroup catalogInstanceGroup =
1456                 new org.onap.so.db.catalog.beans.InstanceGroup();
1457         doReturn(catalogInstanceGroup).when(SPY_bbInputSetupUtils).getCatalogInstanceGroup(any());
1458         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
1459                 .setModelInfo(modelInfo).setInstanceName(instanceName).setPlatform(platform)
1460                 .setLineOfBusiness(lineOfBusiness).setService(service).setBbName(bbName)
1461                 .setServiceInstance(serviceInstance).setLookupKeyMap(lookupKeyMap)
1462                 .setRelatedInstanceList(requestDetails.getRelatedInstanceList()).setResourceId(resourceId)
1463                 .setVnfType(vnfType).setProductFamilyId(requestDetails.getRequestInfo().getProductFamilyId()).build();
1464         SPY_bbInputSetup.populateGenericVnf(parameter);
1465
1466         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, null);
1467
1468         SPY_bbInputSetup.populateGenericVnf(parameter);
1469         verify(SPY_bbInputSetup, times(1)).mapCatalogVnf(vnf, modelInfo, service);
1470
1471         instanceName = "vnfName2";
1472         GenericVnf vnf2 = SPY_bbInputSetup.createGenericVnf(lookupKeyMap, instanceName, platform, lineOfBusiness,
1473                 resourceId, vnfType, null, requestDetails.getRequestInfo().getProductFamilyId(), applicationId);
1474
1475         doNothing().when(SPY_bbInputSetup).mapNetworkCollectionInstanceGroup(vnf2, "{instanceGroupId}");
1476         doNothing().when(SPY_bbInputSetup).mapVnfcCollectionInstanceGroup(vnf2, modelInfo, service);
1477
1478         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "genericVnfId2");
1479
1480         SPY_bbInputSetup.populateGenericVnf(parameter);
1481         verify(SPY_bbInputSetup, times(2)).mapCatalogVnf(vnf2, modelInfo, service);
1482         verify(SPY_bbInputSetup, times(2)).mapNetworkCollectionInstanceGroup(vnf2, "{instanceGroupId}");
1483         verify(SPY_bbInputSetup, times(2)).mapVnfcCollectionInstanceGroup(vnf2, modelInfo, service);
1484
1485         assertEquals("modelCustId", modelInfo.getModelCustomizationUuid());
1486
1487     }
1488
1489     @Test
1490     public void testPopulateGenericVnfReplace() throws JsonParseException, JsonMappingException, IOException {
1491         org.onap.so.serviceinstancebeans.Platform platform = new org.onap.so.serviceinstancebeans.Platform();
1492         org.onap.so.serviceinstancebeans.LineOfBusiness lineOfBusiness =
1493                 new org.onap.so.serviceinstancebeans.LineOfBusiness();
1494         String instanceName = "vnfName";
1495         ModelInfo modelInfo = new ModelInfo();
1496         modelInfo.setModelType(ModelType.vnf);
1497         ServiceInstance serviceInstance = new ServiceInstance();
1498         GenericVnf vnf = new GenericVnf();
1499         vnf.setVnfId("genericVnfId");
1500         vnf.setVnfName("vnfName");
1501         serviceInstance.getVnfs().add(vnf);
1502         String vnfType = "vnfType";
1503         String applicationId = "applicationId";
1504         RequestDetails requestDetails =
1505                 mapper.readValue(new File(RESOURCE_PATH + "RequestDetails_CreateVnf.json"), RequestDetails.class);
1506
1507         Service service = mapper.readValue(
1508                 new File(RESOURCE_PATH + "CatalogDBService_getServiceInstanceNOAAIInput.json"), Service.class);
1509         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
1510         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "genericVnfId");
1511         String bbName = AssignFlows.VNF.toString();
1512
1513         String resourceId = "123";
1514         org.onap.aai.domain.yang.GenericVnf vnfAAI = new org.onap.aai.domain.yang.GenericVnf();
1515         vnfAAI.setModelCustomizationId("modelCustId");
1516         doReturn(vnfAAI).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
1517         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(vnf, modelInfo, service);
1518         org.onap.aai.domain.yang.InstanceGroup instanceGroupAAI = new org.onap.aai.domain.yang.InstanceGroup();
1519         doReturn(instanceGroupAAI).when(SPY_bbInputSetupUtils).getAAIInstanceGroup(any());
1520         org.onap.so.db.catalog.beans.InstanceGroup catalogInstanceGroup =
1521                 new org.onap.so.db.catalog.beans.InstanceGroup();
1522         doReturn(catalogInstanceGroup).when(SPY_bbInputSetupUtils).getCatalogInstanceGroup(any());
1523
1524         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setModelInfo(modelInfo)
1525                 .setInstanceName(instanceName).setPlatform(platform).setLineOfBusiness(lineOfBusiness)
1526                 .setService(service).setBbName(bbName).setServiceInstance(serviceInstance).setLookupKeyMap(lookupKeyMap)
1527                 .setRelatedInstanceList(requestDetails.getRelatedInstanceList()).setResourceId(resourceId)
1528                 .setVnfType(vnfType).setProductFamilyId(requestDetails.getRequestInfo().getProductFamilyId())
1529                 .setApplicationId(applicationId).setIsReplace(true).build();
1530
1531         SPY_bbInputSetup.populateGenericVnf(parameter);
1532
1533         assertEquals("my-test-uuid", modelInfo.getModelCustomizationUuid());
1534
1535     }
1536
1537     @Test
1538     public void testMapVnfcCollectionInstanceGroup() {
1539         VnfResourceCustomization vnfResourceCust = Mockito.mock(VnfResourceCustomization.class);
1540         GenericVnf genericVnf = new GenericVnf();
1541         ModelInfo modelInfo = Mockito.mock(ModelInfo.class);
1542         Service service = Mockito.mock(Service.class);
1543         org.onap.so.db.catalog.beans.InstanceGroup instanceGroup = new org.onap.so.db.catalog.beans.InstanceGroup();
1544         instanceGroup.setModelUUID("modelUUID");
1545         List<VnfcInstanceGroupCustomization> vnfcInstanceGroups = new ArrayList<>();
1546         VnfcInstanceGroupCustomization vnfcInstanceGroupCust = new VnfcInstanceGroupCustomization();
1547         vnfcInstanceGroupCust.setInstanceGroup(instanceGroup);
1548         vnfcInstanceGroupCust.setFunction("function");
1549         vnfcInstanceGroupCust.setDescription("description");
1550         vnfcInstanceGroups.add(vnfcInstanceGroupCust);
1551
1552         ModelInfoInstanceGroup modelInfoInstanceGroup = new ModelInfoInstanceGroup();
1553         modelInfoInstanceGroup.setModelUUID("modelUUID");
1554         doReturn(vnfResourceCust).when(SPY_bbInputSetup).getVnfResourceCustomizationFromService(modelInfo, service);
1555         doReturn(vnfcInstanceGroups).when(vnfResourceCust).getVnfcInstanceGroupCustomizations();
1556         doReturn(instanceGroup).when(SPY_bbInputSetupUtils).getCatalogInstanceGroup("modelUUID");
1557         doReturn(modelInfoInstanceGroup).when(bbInputSetupMapperLayer).mapCatalogInstanceGroupToInstanceGroup(null,
1558                 instanceGroup);
1559
1560         SPY_bbInputSetup.mapVnfcCollectionInstanceGroup(genericVnf, modelInfo, service);
1561
1562         assertEquals("Instance Group was created", true, genericVnf.getInstanceGroups().size() == 1);
1563     }
1564
1565     @Test
1566     public void testPopulateGenericVnfWhereVnfTypeIsNull()
1567             throws JsonParseException, JsonMappingException, IOException {
1568         org.onap.so.serviceinstancebeans.Platform platform = new org.onap.so.serviceinstancebeans.Platform();
1569         org.onap.so.serviceinstancebeans.LineOfBusiness lineOfBusiness =
1570                 new org.onap.so.serviceinstancebeans.LineOfBusiness();
1571         String instanceName = "vnfName";
1572         ModelInfo modelInfo = new ModelInfo();
1573         modelInfo.setModelType(ModelType.vnf);
1574
1575         ServiceInstance serviceInstance = new ServiceInstance();
1576         GenericVnf vnf = new GenericVnf();
1577         vnf.setVnfId("genericVnfId");
1578         vnf.setVnfName("vnfName");
1579         serviceInstance.getVnfs().add(vnf);
1580         String vnfType = null;
1581         RequestDetails requestDetails =
1582                 mapper.readValue(new File(RESOURCE_PATH + "RequestDetails_CreateVnf.json"), RequestDetails.class);
1583
1584         Service service = mapper.readValue(
1585                 new File(RESOURCE_PATH + "CatalogDBService_getServiceInstanceNOAAIInput.json"), Service.class);
1586         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
1587         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "genericVnfId");
1588         String bbName = AssignFlows.VNF.toString();
1589
1590         Platform expectedPlatform = new Platform();
1591         LineOfBusiness expectedLineOfBusiness = new LineOfBusiness();
1592         String resourceId = "123";
1593         String applicationId = "applicationId";
1594         doReturn(expectedPlatform).when(bbInputSetupMapperLayer).mapRequestPlatform(platform);
1595         doReturn(expectedLineOfBusiness).when(bbInputSetupMapperLayer).mapRequestLineOfBusiness(lineOfBusiness);
1596         org.onap.aai.domain.yang.GenericVnf vnfAAI = new org.onap.aai.domain.yang.GenericVnf();
1597         vnfAAI.setModelCustomizationId("modelCustId");
1598         doReturn(vnfAAI).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
1599         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(vnf, modelInfo, service);
1600         org.onap.aai.domain.yang.InstanceGroup instanceGroupAAI = new org.onap.aai.domain.yang.InstanceGroup();
1601         doReturn(instanceGroupAAI).when(SPY_bbInputSetupUtils).getAAIInstanceGroup(any());
1602         org.onap.so.db.catalog.beans.InstanceGroup catalogInstanceGroup =
1603                 new org.onap.so.db.catalog.beans.InstanceGroup();
1604         doReturn(catalogInstanceGroup).when(SPY_bbInputSetupUtils).getCatalogInstanceGroup(any());
1605         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
1606                 .setModelInfo(modelInfo).setInstanceName(instanceName).setPlatform(platform)
1607                 .setLineOfBusiness(lineOfBusiness).setService(service).setBbName(bbName)
1608                 .setServiceInstance(serviceInstance).setLookupKeyMap(lookupKeyMap)
1609                 .setRelatedInstanceList(requestDetails.getRelatedInstanceList()).setResourceId(resourceId)
1610                 .setVnfType(vnfType).setProductFamilyId(requestDetails.getRequestInfo().getProductFamilyId()).build();
1611         SPY_bbInputSetup.populateGenericVnf(parameter);
1612
1613         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, null);
1614
1615         SPY_bbInputSetup.populateGenericVnf(parameter);
1616         verify(SPY_bbInputSetup, times(1)).mapCatalogVnf(vnf, modelInfo, service);
1617
1618         instanceName = "vnfName2";
1619         GenericVnf vnf2 = SPY_bbInputSetup.createGenericVnf(lookupKeyMap, instanceName, platform, lineOfBusiness,
1620                 resourceId, vnfType, null, requestDetails.getRequestInfo().getProductFamilyId(), applicationId);
1621
1622         org.onap.aai.domain.yang.GenericVnf vnf2AAI = new org.onap.aai.domain.yang.GenericVnf();
1623         vnfAAI.setModelCustomizationId("modelCustId2");
1624         doReturn(vnf2AAI).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf2.getVnfId());
1625         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(vnf2, modelInfo, service);
1626         doNothing().when(SPY_bbInputSetup).mapNetworkCollectionInstanceGroup(vnf2, "{instanceGroupId}");
1627         SPY_bbInputSetup.populateGenericVnf(parameter);
1628         verify(SPY_bbInputSetup, times(2)).mapCatalogVnf(vnf2, modelInfo, service);
1629         verify(SPY_bbInputSetup, times(2)).mapNetworkCollectionInstanceGroup(vnf2, "{instanceGroupId}");
1630         verify(SPY_bbInputSetup, times(1)).mapVnfcCollectionInstanceGroup(vnf2, modelInfo, service);
1631     }
1632
1633     @Test
1634     public void testMapCatalogVnf() {
1635         ModelInfoGenericVnf modelInfoGenericVnf = new ModelInfoGenericVnf();
1636         GenericVnf genericVnf = new GenericVnf();
1637         RequestDetails requestDetails = new RequestDetails();
1638         ModelInfo modelInfo = new ModelInfo();
1639         modelInfo.setModelCustomizationUuid("modelCustomizationUUID");
1640         requestDetails.setModelInfo(modelInfo);
1641         Service service = new Service();
1642         VnfResourceCustomization resourceCust = new VnfResourceCustomization();
1643         resourceCust.setModelCustomizationUUID("vnfModelCustomizationUUID");
1644         service.getVnfCustomizations().add(resourceCust);
1645         resourceCust.setModelCustomizationUUID("modelCustomizationUUID");
1646
1647         doReturn(modelInfoGenericVnf).when(bbInputSetupMapperLayer).mapCatalogVnfToVnf(resourceCust);
1648
1649         SPY_bbInputSetup.mapCatalogVnf(genericVnf, modelInfo, service);
1650
1651         assertEquals(modelInfoGenericVnf, genericVnf.getModelInfoGenericVnf());
1652     }
1653
1654     @Test
1655     public void testMapCatalogCollectionAndInstanceGroup() {
1656         ModelInfoCollection modelInfoCollection = new ModelInfoCollection();
1657         modelInfoCollection.setCollectionFunction("collectionFunction");
1658         modelInfoCollection.setCollectionRole("collectionRole");
1659         modelInfoCollection.setCollectionType("collectionType");
1660         modelInfoCollection.setDescription("description");
1661         modelInfoCollection.setModelInvariantUUID("modelInvariantUUID");
1662         modelInfoCollection.setQuantity(0);
1663
1664         ModelInfoInstanceGroup modelInfoInstanceGroup = new ModelInfoInstanceGroup();
1665         modelInfoInstanceGroup.setFunction("function");
1666         modelInfoInstanceGroup.setInstanceGroupRole("instanceGroupRole");
1667         modelInfoInstanceGroup.setModelInvariantUUID("modelInvariantUUID");
1668         modelInfoInstanceGroup.setModelUUID("modelUUID");
1669         modelInfoInstanceGroup.setType("VNFC");
1670         modelInfoInstanceGroup.setDescription("description");
1671
1672         InstanceGroup instanceGroup = new InstanceGroup();
1673         Collection collection = new Collection();
1674         collection.setInstanceGroup(instanceGroup);
1675
1676         CollectionResource collectionResource = new CollectionResource();
1677         org.onap.so.db.catalog.beans.InstanceGroup catalogInstanceGroup =
1678                 new org.onap.so.db.catalog.beans.InstanceGroup();
1679         collectionResource.setToscaNodeType("NetworkCollection");
1680         collectionResource.setInstanceGroup(catalogInstanceGroup);
1681
1682         CollectionResourceCustomization collectionCust = new NetworkCollectionResourceCustomization();
1683         collectionCust.setModelCustomizationUUID("modelCustomizationUUID");
1684         collectionCust.setCollectionResource(collectionResource);
1685
1686         Service service = new Service();
1687         service.getCollectionResourceCustomizations().add(collectionCust);
1688         ServiceInstance serviceInstance = new ServiceInstance();
1689         serviceInstance.setCollection(collection);
1690
1691         List<CollectionResourceInstanceGroupCustomization> instanceGroupCustList = new ArrayList<>();
1692         CollectionResourceInstanceGroupCustomization instanceGroupCust =
1693                 new CollectionResourceInstanceGroupCustomization();
1694         instanceGroupCust.setFunction("function");
1695         instanceGroupCust.setDescription("description");
1696
1697         doReturn(modelInfoCollection).when(bbInputSetupMapperLayer).mapCatalogCollectionToCollection(collectionCust,
1698                 collectionResource);
1699
1700         doReturn(modelInfoInstanceGroup).when(bbInputSetupMapperLayer)
1701                 .mapCatalogInstanceGroupToInstanceGroup(collectionCust, catalogInstanceGroup);
1702
1703         SPY_bbInputSetup.mapCatalogCollection(service, serviceInstance.getCollection(), "modelCustomizationUUID");
1704         SPY_bbInputSetup.mapCatalogNetworkCollectionInstanceGroup(service,
1705                 serviceInstance.getCollection().getInstanceGroup(), collectionCust.getModelCustomizationUUID());
1706
1707         assertThat(collection.getModelInfoCollection(), sameBeanAs(modelInfoCollection));
1708         assertThat(instanceGroup.getModelInfoInstanceGroup(), sameBeanAs(modelInfoInstanceGroup));
1709     }
1710
1711     @Test
1712     public void testAddRelationshipsToSI() throws Exception {
1713         ServiceInstance serviceInstance = new ServiceInstance();
1714         org.onap.aai.domain.yang.ServiceInstance serviceInstanceAAI = new org.onap.aai.domain.yang.ServiceInstance();
1715         serviceInstanceAAI.setServiceInstanceId("serviceInstanceId");
1716
1717         org.onap.aai.domain.yang.RelationshipList relationshipList = new org.onap.aai.domain.yang.RelationshipList();
1718         org.onap.aai.domain.yang.Relationship relationship = new org.onap.aai.domain.yang.Relationship();
1719         relationshipList.getRelationship().add(relationship);
1720         serviceInstanceAAI.setRelationshipList(relationshipList);
1721
1722         Map<String, String> uriKeys = new HashMap<>();
1723         uriKeys.put("global-customer-id", "globalCustomerId");
1724         uriKeys.put("service-type", "serviceType");
1725
1726
1727         doNothing().when(SPY_bbInputSetup).mapProject(any(), eq(serviceInstance));
1728         doNothing().when(SPY_bbInputSetup).mapOwningEntity(any(), eq(serviceInstance));
1729         doNothing().when(SPY_bbInputSetup).mapL3Networks(any(), eq(serviceInstance.getNetworks()));
1730         doNothing().when(SPY_bbInputSetup).mapGenericVnfs(any(), eq(serviceInstance.getVnfs()));
1731         doNothing().when(SPY_bbInputSetup).mapCollection(any(), eq(serviceInstance));
1732
1733         SPY_bbInputSetup.addRelationshipsToSI(serviceInstanceAAI, serviceInstance);
1734
1735         verify(SPY_bbInputSetup, times(1)).mapProject(any(), eq(serviceInstance));
1736         verify(SPY_bbInputSetup, times(1)).mapOwningEntity(any(), eq(serviceInstance));
1737         verify(SPY_bbInputSetup, times(1)).mapL3Networks(any(), eq(serviceInstance.getNetworks()));
1738         verify(SPY_bbInputSetup, times(1)).mapGenericVnfs(any(), eq(serviceInstance.getVnfs()));
1739         verify(SPY_bbInputSetup, times(1)).mapCollection(any(), eq(serviceInstance));
1740         verify(SPY_bbInputSetup, times(1)).mapConfigurations(any(), eq(serviceInstance.getConfigurations()));
1741     }
1742
1743     @Test
1744     public void testMapConfigurations() throws JsonProcessingException {
1745         org.onap.aai.domain.yang.Configuration expectedAAI = new org.onap.aai.domain.yang.Configuration();
1746         org.onap.aai.domain.yang.RelationshipList relationshipList = new org.onap.aai.domain.yang.RelationshipList();
1747         org.onap.aai.domain.yang.Relationship relationship = new org.onap.aai.domain.yang.Relationship();
1748         relationshipList.getRelationship().add(relationship);
1749         expectedAAI.setRelationshipList(relationshipList);
1750
1751         Configuration expected = new Configuration();
1752         AAIResourceUri aaiResourceUri = AAIUriFactory.createResourceUri(AAIObjectType.CONFIGURATION, "configurationId");
1753         AAIResultWrapper configurationWrapper =
1754                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1755
1756         doReturn(configurationWrapper).when(SPY_bbInputSetupUtils).getAAIResourceDepthOne(aaiResourceUri);
1757         doReturn(expected).when(bbInputSetupMapperLayer)
1758                 .mapAAIConfiguration(isA(org.onap.aai.domain.yang.Configuration.class));
1759
1760         List<Configuration> configurations = new ArrayList<>();
1761
1762         SPY_bbInputSetup.mapConfigurations(Arrays.asList(new AAIResourceUri[] {aaiResourceUri}), configurations);
1763
1764         assertEquals(expected, configurations.get(0));
1765     }
1766
1767     @Test
1768     public void testMapGenericVnfs() throws JsonProcessingException {
1769         org.onap.aai.domain.yang.GenericVnf expectedAAI = new org.onap.aai.domain.yang.GenericVnf();
1770         org.onap.aai.domain.yang.RelationshipList relationshipList = new org.onap.aai.domain.yang.RelationshipList();
1771         org.onap.aai.domain.yang.Relationship relationship = new org.onap.aai.domain.yang.Relationship();
1772         relationshipList.getRelationship().add(relationship);
1773         expectedAAI.setRelationshipList(relationshipList);
1774
1775         GenericVnf expected = new GenericVnf();
1776         AAIResourceUri aaiResourceUri = AAIUriFactory.createResourceUri(AAIObjectType.GENERIC_VNF, "vnfId");
1777         AAIResultWrapper vnfWrapper =
1778                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1779
1780         doReturn(vnfWrapper).when(SPY_bbInputSetupUtils).getAAIResourceDepthOne(aaiResourceUri);
1781         doReturn(expected).when(bbInputSetupMapperLayer)
1782                 .mapAAIGenericVnfIntoGenericVnf(isA(org.onap.aai.domain.yang.GenericVnf.class));
1783         doNothing().when(SPY_bbInputSetup).mapPlatform(any(), eq(expected));
1784         doNothing().when(SPY_bbInputSetup).mapLineOfBusiness(any(), eq(expected));
1785         doReturn(new ArrayList<>()).when(SPY_bbInputSetup).mapVolumeGroups(any());
1786
1787         List<GenericVnf> genericVnfs = new ArrayList<>();
1788
1789         SPY_bbInputSetup.mapGenericVnfs(Arrays.asList(new AAIResourceUri[] {aaiResourceUri}), genericVnfs);
1790
1791         assertEquals(expected, genericVnfs.get(0));
1792         verify(SPY_bbInputSetup, times(1)).mapPlatform(any(), eq(expected));
1793         verify(SPY_bbInputSetup, times(1)).mapLineOfBusiness(any(), eq(expected));
1794         verify(SPY_bbInputSetup, times(1)).mapVolumeGroups(any());
1795     }
1796
1797     @Test
1798     public void testMapVolumeGroups() throws JsonProcessingException {
1799         org.onap.aai.domain.yang.VolumeGroup expectedAAI = new org.onap.aai.domain.yang.VolumeGroup();
1800
1801         VolumeGroup expected = new VolumeGroup();
1802         AAIResultWrapper vnfWrapper =
1803                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1804
1805         doReturn(expected).when(bbInputSetupMapperLayer)
1806                 .mapAAIVolumeGroup(isA(org.onap.aai.domain.yang.VolumeGroup.class));
1807
1808         List<VolumeGroup> volumeGroupsList =
1809                 SPY_bbInputSetup.mapVolumeGroups(Arrays.asList(new AAIResultWrapper[] {vnfWrapper}));
1810
1811         assertEquals(expected, volumeGroupsList.get(0));
1812     }
1813
1814     @Test
1815     public void testMapLineOfBusiness() throws JsonProcessingException {
1816         org.onap.aai.domain.yang.LineOfBusiness expectedAAI = new org.onap.aai.domain.yang.LineOfBusiness();
1817
1818         LineOfBusiness expected = new LineOfBusiness();
1819         AAIResultWrapper vnfWrapper =
1820                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1821
1822         doReturn(expected).when(bbInputSetupMapperLayer)
1823                 .mapAAILineOfBusiness(isA(org.onap.aai.domain.yang.LineOfBusiness.class));
1824
1825         GenericVnf vnf = new GenericVnf();
1826
1827         SPY_bbInputSetup.mapLineOfBusiness(Arrays.asList(new AAIResultWrapper[] {vnfWrapper}), vnf);
1828
1829         assertEquals(expected, vnf.getLineOfBusiness());
1830     }
1831
1832     @Test
1833     public void testMapPlatform() throws JsonProcessingException {
1834         org.onap.aai.domain.yang.Platform expectedAAI = new org.onap.aai.domain.yang.Platform();
1835
1836         Platform expected = new Platform();
1837         AAIResultWrapper vnfWrapper =
1838                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1839
1840         doReturn(expected).when(bbInputSetupMapperLayer).mapAAIPlatform(isA(org.onap.aai.domain.yang.Platform.class));
1841
1842         GenericVnf vnf = new GenericVnf();
1843
1844         SPY_bbInputSetup.mapPlatform(Arrays.asList(new AAIResultWrapper[] {vnfWrapper}), vnf);
1845
1846         assertEquals(expected, vnf.getPlatform());
1847     }
1848
1849     @Test
1850     public void testMapCollection() throws JsonProcessingException {
1851         List<AAIResultWrapper> collections = new ArrayList<>();
1852         ServiceInstance serviceInstance = new ServiceInstance();
1853
1854         org.onap.aai.domain.yang.Collection aaiCollection = new org.onap.aai.domain.yang.Collection();
1855         org.onap.aai.domain.yang.RelationshipList collectionRelationshipList =
1856                 new org.onap.aai.domain.yang.RelationshipList();
1857         org.onap.aai.domain.yang.Relationship collectionInstanceGroupRelationship =
1858                 new org.onap.aai.domain.yang.Relationship();
1859         collectionRelationshipList.getRelationship().add(collectionInstanceGroupRelationship);
1860         aaiCollection.setRelationshipList(collectionRelationshipList);
1861
1862         collections.add(new AAIResultWrapper(
1863                 new AAICommonObjectMapperProvider().getMapper().writeValueAsString(aaiCollection)));
1864
1865         Collection collection = new Collection();
1866         ModelInfoCollection modelInfoCollection = new ModelInfoCollection();
1867         List<InstanceGroup> instanceGroupsList = new ArrayList<>();
1868         InstanceGroup instanceGroup = new InstanceGroup();
1869         instanceGroupsList.add(instanceGroup);
1870         NetworkCollectionResourceCustomization networkCollectionCust =
1871                 Mockito.mock(NetworkCollectionResourceCustomization.class);
1872         CollectionResource collectionResource = new CollectionResource();
1873         doReturn(collection).when(bbInputSetupMapperLayer)
1874                 .mapAAICollectionIntoCollection(isA(org.onap.aai.domain.yang.Collection.class));
1875         doReturn(instanceGroupsList).when(SPY_bbInputSetup).mapInstanceGroups(any());
1876         doReturn(networkCollectionCust).when(SPY_bbInputSetupUtils)
1877                 .getCatalogNetworkCollectionResourceCustByID(aaiCollection.getCollectionCustomizationId());
1878         doReturn(collectionResource).when(networkCollectionCust).getCollectionResource();
1879         doReturn(modelInfoCollection).when(bbInputSetupMapperLayer)
1880                 .mapCatalogCollectionToCollection(networkCollectionCust, collectionResource);
1881
1882         SPY_bbInputSetup.mapCollection(collections, serviceInstance);
1883
1884         assertEquals(collection, serviceInstance.getCollection());
1885         assertEquals(instanceGroup, collection.getInstanceGroup());
1886
1887         instanceGroupsList.clear();
1888         collection = new Collection();
1889
1890         SPY_bbInputSetup.mapCollection(collections, serviceInstance);
1891         assertEquals(collection, serviceInstance.getCollection());
1892         assertNull(collection.getInstanceGroup());
1893     }
1894
1895     @Test
1896     public void testMapL3Networks() throws JsonProcessingException {
1897         org.onap.aai.domain.yang.L3Network expectedAAI = new org.onap.aai.domain.yang.L3Network();
1898         org.onap.aai.domain.yang.RelationshipList relationshipList = new org.onap.aai.domain.yang.RelationshipList();
1899         org.onap.aai.domain.yang.Relationship relationship = new org.onap.aai.domain.yang.Relationship();
1900         relationshipList.getRelationship().add(relationship);
1901         expectedAAI.setRelationshipList(relationshipList);
1902
1903         L3Network expected = new L3Network();
1904         List<L3Network> l3Networks = new ArrayList<>();
1905         AAIResultWrapper l3NetworksWrapper =
1906                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1907         AAIResourceUri aaiResourceUri = AAIUriFactory.createResourceUri(AAIObjectType.L3_NETWORK, "networkId");
1908
1909         doReturn(l3NetworksWrapper).when(SPY_bbInputSetupUtils).getAAIResourceDepthTwo(aaiResourceUri);
1910         doReturn(expected).when(bbInputSetupMapperLayer).mapAAIL3Network(isA(org.onap.aai.domain.yang.L3Network.class));
1911         doNothing().when(SPY_bbInputSetup).mapNetworkPolicies(any(), eq(expected.getNetworkPolicies()));
1912         doNothing().when(SPY_bbInputSetup).mapRouteTableReferences(any(),
1913                 eq(expected.getContrailNetworkRouteTableReferences()));
1914
1915         SPY_bbInputSetup.mapL3Networks(Arrays.asList(new AAIResourceUri[] {aaiResourceUri}), l3Networks);
1916
1917         assertEquals(expected, l3Networks.get(0));
1918         verify(SPY_bbInputSetup, times(1)).mapNetworkPolicies(any(), eq(expected.getNetworkPolicies()));
1919         verify(SPY_bbInputSetup, times(1)).mapRouteTableReferences(any(),
1920                 eq(expected.getContrailNetworkRouteTableReferences()));
1921     }
1922
1923     @Test
1924     public void testMapRouteTableReferences() throws JsonProcessingException {
1925         org.onap.aai.domain.yang.RouteTableReference expectedAAI = new org.onap.aai.domain.yang.RouteTableReference();
1926
1927         RouteTableReference expected = new RouteTableReference();
1928         List<RouteTableReference> contrailNetworkRouteTableReferences = new ArrayList<>();
1929         AAIResultWrapper vnfWrapper =
1930                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1931
1932         doReturn(expected).when(bbInputSetupMapperLayer).mapAAIRouteTableReferenceIntoRouteTableReference(
1933                 isA(org.onap.aai.domain.yang.RouteTableReference.class));
1934
1935         SPY_bbInputSetup.mapRouteTableReferences(Arrays.asList(new AAIResultWrapper[] {vnfWrapper}),
1936                 contrailNetworkRouteTableReferences);
1937
1938         assertEquals(expected, contrailNetworkRouteTableReferences.get(0));
1939     }
1940
1941     @Test
1942     public void testMapOwningEntity() throws JsonProcessingException {
1943         org.onap.aai.domain.yang.OwningEntity expectedAAI = new org.onap.aai.domain.yang.OwningEntity();
1944
1945         OwningEntity expected = new OwningEntity();
1946         AAIResultWrapper vnfWrapper =
1947                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1948
1949         doReturn(expected).when(bbInputSetupMapperLayer)
1950                 .mapAAIOwningEntity(isA(org.onap.aai.domain.yang.OwningEntity.class));
1951
1952         ServiceInstance serviceInstance = new ServiceInstance();
1953
1954         SPY_bbInputSetup.mapOwningEntity(Arrays.asList(new AAIResultWrapper[] {vnfWrapper}), serviceInstance);
1955
1956         assertEquals(expected, serviceInstance.getOwningEntity());
1957     }
1958
1959     @Test
1960     public void testMapProject() throws JsonProcessingException {
1961         org.onap.aai.domain.yang.Project expectedAAI = new org.onap.aai.domain.yang.Project();
1962
1963         Project expected = new Project();
1964         AAIResultWrapper vnfWrapper =
1965                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1966
1967         doReturn(expected).when(bbInputSetupMapperLayer).mapAAIProject(isA(org.onap.aai.domain.yang.Project.class));
1968
1969         ServiceInstance serviceInstance = new ServiceInstance();
1970
1971         SPY_bbInputSetup.mapProject(Arrays.asList(new AAIResultWrapper[] {vnfWrapper}), serviceInstance);
1972
1973         assertEquals(expected, serviceInstance.getProject());
1974     }
1975
1976     @Test
1977     public void testMapCustomer() throws Exception {
1978         org.onap.aai.domain.yang.Customer customerAAI = new org.onap.aai.domain.yang.Customer();
1979         org.onap.aai.domain.yang.ServiceSubscription serviceSubscriptionAAI =
1980                 new org.onap.aai.domain.yang.ServiceSubscription();
1981
1982         Customer expected = new Customer();
1983         ServiceSubscription serviceSubscription = new ServiceSubscription();
1984
1985         String globalCustomerId = "globalCustomerId";
1986         String subscriptionServiceType = "subscriptionServiceType";
1987
1988         doReturn(customerAAI).when(SPY_bbInputSetupUtils).getAAICustomer(globalCustomerId);
1989         doReturn(serviceSubscriptionAAI).when(SPY_bbInputSetupUtils).getAAIServiceSubscription(globalCustomerId,
1990                 subscriptionServiceType);
1991         doReturn(expected).when(bbInputSetupMapperLayer).mapAAICustomer(isA(org.onap.aai.domain.yang.Customer.class));
1992         doReturn(serviceSubscription).when(bbInputSetupMapperLayer)
1993                 .mapAAIServiceSubscription(isA(org.onap.aai.domain.yang.ServiceSubscription.class));
1994
1995         Customer actual = SPY_bbInputSetup.mapCustomer(globalCustomerId, subscriptionServiceType);
1996
1997         assertEquals(expected, actual);
1998         assertEquals(serviceSubscription, expected.getServiceSubscription());
1999     }
2000
2001     @Test
2002     public void testPopulateLookupKeyMapWithIds() {
2003         Map<ResourceKey, String> expected = new HashMap<>();
2004         Map<ResourceKey, String> actual = new HashMap<>();
2005         String serviceInstanceId = "serviceInstanceId";
2006         String networkId = "networkId";
2007         String vnfId = "vnfId";
2008         String pnfId = "pnfId";
2009         String vfModuleId = "vfModuleId";
2010         String volumeGroupId = "volumeGroupId";
2011         String configurationId = "configurationId";
2012         String instanceGroupId = "instancegroupId";
2013
2014         expected.put(ResourceKey.SERVICE_INSTANCE_ID, serviceInstanceId);
2015         expected.put(ResourceKey.NETWORK_ID, networkId);
2016         expected.put(ResourceKey.GENERIC_VNF_ID, vnfId);
2017         expected.put(ResourceKey.PNF, pnfId);
2018         expected.put(ResourceKey.VF_MODULE_ID, vfModuleId);
2019         expected.put(ResourceKey.VOLUME_GROUP_ID, volumeGroupId);
2020         expected.put(ResourceKey.CONFIGURATION_ID, configurationId);
2021         expected.put(ResourceKey.INSTANCE_GROUP_ID, instanceGroupId);
2022
2023         WorkflowResourceIds workflowResourceIds = new WorkflowResourceIds();
2024         workflowResourceIds.setServiceInstanceId(serviceInstanceId);
2025         workflowResourceIds.setNetworkId(networkId);
2026         workflowResourceIds.setVnfId(vnfId);
2027         workflowResourceIds.setPnfId(pnfId);
2028         workflowResourceIds.setVfModuleId(vfModuleId);
2029         workflowResourceIds.setVolumeGroupId(volumeGroupId);
2030         workflowResourceIds.setConfigurationId(configurationId);
2031         workflowResourceIds.setInstanceGroupId(instanceGroupId);
2032
2033         SPY_bbInputSetup.populateLookupKeyMapWithIds(workflowResourceIds, actual);
2034
2035         assertThat(actual, sameBeanAs(expected));
2036     }
2037
2038     @Test
2039     public void testGBBMacroNoUserParamsVrfConfiguration() throws Exception {
2040         String resourceId = "123";
2041         String vnfType = "vnfType";
2042         String requestAction = "createInstance";
2043         Service service = Mockito.mock(Service.class);
2044         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2045                 GeneralBuildingBlock.class);
2046         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2047                 ExecuteBuildingBlock.class);
2048         RequestDetails requestDetails = mapper
2049                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacroVrf.json"), RequestDetails.class);
2050         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2051
2052         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2053         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2054         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2055         buildingBlock.setBpmnFlowName("AssignVrfConfigurationBB");
2056         buildingBlock.setKey("72d9d1cd-f46d-447a-abdb-451d6fb05fa9");
2057
2058         doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
2059                 requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2060         doReturn(service).when(SPY_bbInputSetupUtils)
2061                 .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
2062
2063         RelatedInstance relatedVpnBinding = new RelatedInstance();
2064         relatedVpnBinding.setInstanceId("vpnBindingInstanceId");
2065         RelatedInstance relatedLocalNetwork = new RelatedInstance();
2066         relatedLocalNetwork.setInstanceId("localNetworkInstanceId");
2067         org.onap.aai.domain.yang.VpnBinding aaiVpnBinding = new org.onap.aai.domain.yang.VpnBinding();
2068         aaiVpnBinding.setVpnId("vpnBindingId");
2069         org.onap.aai.domain.yang.L3Network aaiLocalNetwork = new org.onap.aai.domain.yang.L3Network();
2070         aaiLocalNetwork.setNetworkId("localNetworkId");
2071         Optional<org.onap.aai.domain.yang.VpnBinding> aaiAICVpnBindingOp =
2072                 Optional.of(new org.onap.aai.domain.yang.VpnBinding());
2073         aaiAICVpnBindingOp.get().setVpnId("AICVpnBindingId");
2074         ServiceProxy proxy = new ServiceProxy();
2075         proxy.setType("transport");
2076         proxy.setServiceInstance(new ServiceInstance());
2077         proxy.getServiceInstance().setModelInfoServiceInstance(new ModelInfoServiceInstance());
2078         proxy.getServiceInstance().getModelInfoServiceInstance().setModelUuid("sourceServiceModelUUID");
2079         doReturn(relatedVpnBinding).when(SPY_bbInputSetupUtils).getRelatedInstanceByType(requestDetails,
2080                 ModelType.vpnBinding);
2081         doReturn(relatedLocalNetwork).when(SPY_bbInputSetupUtils).getRelatedInstanceByType(requestDetails,
2082                 ModelType.network);
2083         doReturn(aaiVpnBinding).when(SPY_bbInputSetupUtils).getAAIVpnBinding(relatedVpnBinding.getInstanceId());
2084         doReturn(aaiLocalNetwork).when(SPY_bbInputSetupUtils).getAAIL3Network(relatedLocalNetwork.getInstanceId());
2085         doReturn(aaiAICVpnBindingOp).when(SPY_bbInputSetupUtils).getAICVpnBindingFromNetwork(aaiLocalNetwork);
2086         doReturn(proxy).when(SPY_bbInputSetup).getServiceProxy(service);
2087
2088         Configuration configuration = new Configuration();
2089         configuration.setConfigurationId("configurationId");
2090         gBB.getServiceInstance().getConfigurations().add(configuration);
2091         List<ConfigurationResourceCustomization> configurationCustList = new ArrayList<>();
2092         ConfigurationResourceCustomization configurationCust = new ConfigurationResourceCustomization();
2093         configurationCust.setModelCustomizationUUID("72d9d1cd-f46d-447a-abdb-451d6fb05fa9");
2094         configurationCustList.add(configurationCust);
2095         doNothing().when(SPY_bbInputSetup).populateConfiguration(any(BBInputSetupParameter.class));
2096
2097         gBB = SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
2098         verify(SPY_bbInputSetup, times(1)).populateConfiguration(any(BBInputSetupParameter.class));
2099         assertEquals(gBB.getCustomer().getVpnBindings().get(0).getVpnId(), "vpnBindingId");
2100         assertEquals(gBB.getServiceInstance().getNetworks().get(0).getNetworkId(), "localNetworkId");
2101         assertEquals(gBB.getServiceInstance().getNetworks().get(0).getVpnBindings().get(0).getVpnId(),
2102                 "AICVpnBindingId");
2103         assertEquals(gBB.getServiceInstance().getServiceProxies().get(0).getType(), "transport");
2104     }
2105
2106     @Test
2107     public void testGetServiceProxy() {
2108         ServiceProxy expected = new ServiceProxy();
2109         expected.setType("TRANSPORT");
2110         expected.setModelInfoServiceProxy(new ModelInfoServiceProxy());
2111         expected.getModelInfoServiceProxy().setModelUuid("modelUUID");
2112         expected.getModelInfoServiceProxy().setModelInstanceName("modelInstanceName");
2113         expected.setServiceInstance(new ServiceInstance());
2114         expected.getServiceInstance().setModelInfoServiceInstance(new ModelInfoServiceInstance());
2115         expected.getServiceInstance().getModelInfoServiceInstance().setModelUuid("modelUUID");
2116         expected.getServiceInstance().getModelInfoServiceInstance().setServiceType("TRANSPORT");
2117         Service service = new Service();
2118         ServiceProxyResourceCustomization serviceProxyCatalog = new ServiceProxyResourceCustomization();
2119         serviceProxyCatalog.setModelCustomizationUUID("modelCustomizationUUID");
2120         serviceProxyCatalog.setModelInstanceName("modelInstanceName");
2121         Service sourceService = new Service();
2122         sourceService.setModelUUID("modelUUID");
2123         sourceService.setServiceType("TRANSPORT");
2124         serviceProxyCatalog.setSourceService(sourceService);
2125         service.setServiceProxyCustomizations(new ArrayList<ServiceProxyResourceCustomization>());
2126         service.getServiceProxyCustomizations().add(serviceProxyCatalog);
2127         ServiceProxy actual = SPY_bbInputSetup.getServiceProxy(service);
2128         assertThat(actual, sameBeanAs(expected));
2129     }
2130
2131     @Test
2132     public void testgetGBBMacroCloudConfiguration() throws Exception {
2133         org.onap.so.serviceinstancebeans.Service serviceMacro = mapper.readValue(
2134                 new File(RESOURCE_PATH + "ServiceMacroVfModules.json"), org.onap.so.serviceinstancebeans.Service.class);
2135         CloudConfiguration cloudConfig = null;
2136         org.onap.aai.domain.yang.CloudRegion aaiCloudRegion = new org.onap.aai.domain.yang.CloudRegion();
2137         aaiCloudRegion.setCloudOwner("test-owner-name");
2138         Resources resources = serviceMacro.getResources();
2139         doReturn(aaiCloudRegion).when(SPY_bbInputSetupUtils).getCloudRegion(any(CloudConfiguration.class));
2140         CloudRegion expected = new CloudRegion();
2141         expected.setLcpCloudRegionId("mdt1");
2142         expected.setCloudOwner("test-owner-name");
2143         expected.setTenantId("88a6ca3ee0394ade9403f075db23167e");
2144
2145         CloudRegion actual = SPY_bbInputSetup.getCloudRegionFromMacroRequest(cloudConfig, resources);
2146         assertThat(actual, sameBeanAs(expected));
2147
2148         serviceMacro = mapper.readValue(new File(RESOURCE_PATH + "ServiceMacroVnfs.json"),
2149                 org.onap.so.serviceinstancebeans.Service.class);
2150         resources = serviceMacro.getResources();
2151
2152         actual = SPY_bbInputSetup.getCloudRegionFromMacroRequest(cloudConfig, resources);
2153         assertThat(actual, sameBeanAs(expected));
2154
2155         serviceMacro = mapper.readValue(new File(RESOURCE_PATH + "ServiceMacroNetworks.json"),
2156                 org.onap.so.serviceinstancebeans.Service.class);
2157         resources = serviceMacro.getResources();
2158
2159         actual = SPY_bbInputSetup.getCloudRegionFromMacroRequest(cloudConfig, resources);
2160         assertThat(actual, sameBeanAs(expected));
2161
2162         serviceMacro = mapper.readValue(new File(RESOURCE_PATH + "ServiceMacroNoCloudConfig.json"),
2163                 org.onap.so.serviceinstancebeans.Service.class);
2164         resources = serviceMacro.getResources();
2165
2166         actual = SPY_bbInputSetup.getCloudRegionFromMacroRequest(cloudConfig, resources);
2167         assertNull(actual);
2168     }
2169
2170     @Test
2171     public void testgetGBBMacroWithEmptyUserParams() throws Exception {
2172         String resourceId = "123";
2173         String vnfType = "vnfType";
2174         String requestAction = "createInstance";
2175         Service service = Mockito.mock(Service.class);
2176         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2177                 GeneralBuildingBlock.class);
2178         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2179                 ExecuteBuildingBlock.class);
2180         RequestDetails requestDetails = mapper
2181                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2182         requestDetails.getRequestParameters().getUserParams().clear();
2183         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2184         aaiVnf.setModelCustomizationId("modelCustId");
2185         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2186         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2187         buildingBlock.setBpmnFlowName(AssignFlows.NETWORK_MACRO.toString())
2188                 .setKey("ab153b6e-c364-44c0-bef6-1f2982117f04").setIsVirtualLink(false);
2189
2190         doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
2191                 requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2192         doReturn(service).when(SPY_bbInputSetupUtils)
2193                 .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
2194
2195         SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
2196         verify(SPY_bbInputSetup, times(1)).getGBBMacroNoUserParamsCreate(any(ExecuteBuildingBlock.class), any(),
2197                 any(String.class), any(String.class), any(GeneralBuildingBlock.class), any(Service.class));
2198     }
2199
2200     @Test(expected = Exception.class)
2201     public void testgetGBBMacroException() throws Exception {
2202         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2203                 ExecuteBuildingBlock.class);
2204         RequestDetails requestDetails = mapper
2205                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2206         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2207         String resourceId = "123";
2208         String vnfType = "vnfType";
2209         String requestAction = "createInstance";
2210
2211         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2212         buildingBlock.setBpmnFlowName("Network").setKey("ab153b6e-c364-44c0-bef6-1f2982117f04");
2213
2214         SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
2215     }
2216
2217     @Test
2218     public void test_getGBBMacroForVnfTypeNull_populateL3Network_shouldBeCalled() throws Exception {
2219         // given
2220         String resourceId = "123";
2221         String vnfType = "null";
2222         String requestAction = "createInstance";
2223         Service service = Mockito.mock(Service.class);
2224         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2225                 GeneralBuildingBlock.class);
2226         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2227
2228         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2229         RequestDetails requestDetails = mapper
2230                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2231         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2232                 ExecuteBuildingBlock.class);
2233         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2234         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2235         buildingBlock.setBpmnFlowName(AssignFlows.NETWORK_MACRO.toString())
2236                 .setKey("ab153b6e-c364-44c0-bef6-1f2982117f04");
2237
2238         doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
2239                 requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2240         doReturn(service).when(SPY_bbInputSetupUtils)
2241                 .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
2242         // when
2243         SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
2244         // then
2245         verify(SPY_bbInputSetup, times(1)).populateL3Network(any(BBInputSetupParameter.class));
2246     }
2247
2248     @Test
2249     public void testgetGBBMacroNoUserParamsDeactivateInstnace() throws Exception {
2250         String resourceId = "123";
2251         String vnfType = "vnfType";
2252         String requestAction = "deactivateInstance";
2253         Service service = Mockito.mock(Service.class);
2254         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2255                 GeneralBuildingBlock.class);
2256         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2257                 ExecuteBuildingBlock.class);
2258         RequestDetails requestDetails = mapper
2259                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2260         requestDetails.getRequestParameters().setUserParams(null);
2261         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2262         aaiVnf.setModelCustomizationId("modelCustId");
2263         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2264         lookupKeyMap.put(ResourceKey.NETWORK_ID, "networkId");
2265         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "vnfId");
2266         lookupKeyMap.put(ResourceKey.VF_MODULE_ID, "vfModuleId");
2267         lookupKeyMap.put(ResourceKey.VOLUME_GROUP_ID, "volumeGroupId");
2268         lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "serviceInstanceId");
2269         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2270         buildingBlock.setBpmnFlowName("DeactivateServiceInstanceBB").setKey("3c40d244-808e-42ca-b09a-256d83d19d0a");
2271
2272         doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
2273                 requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2274         doReturn(service).when(SPY_bbInputSetupUtils)
2275                 .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
2276
2277         GeneralBuildingBlock actual = SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap,
2278                 requestAction, resourceId, vnfType);
2279         assertThat(actual, sameBeanAs(gBB));
2280     }
2281
2282     @Test
2283     public void test_getGBBMacroNoUserParamsCreate_shouldBeCalled() throws Exception {
2284         // given
2285         String resourceId = "123";
2286         String vnfType = "vnfType";
2287         String requestAction = "createInstance";
2288         Service service = Mockito.mock(Service.class);
2289         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2290                 GeneralBuildingBlock.class);
2291         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2292         List<NetworkResourceCustomization> networkCustList = new ArrayList<>();
2293         NetworkResourceCustomization networkCust = Mockito.mock(NetworkResourceCustomization.class);
2294         networkCustList.add(networkCust);
2295
2296         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2297         RequestDetails requestDetails = mapper
2298                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2299         requestDetails.getRequestParameters().setUserParams(null);
2300         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2301                 ExecuteBuildingBlock.class);
2302         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2303         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2304         buildingBlock.setBpmnFlowName(AssignFlows.NETWORK_MACRO.toString())
2305                 .setKey("ab153b6e-c364-44c0-bef6-1f2982117f04").setIsVirtualLink(false);
2306
2307         doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
2308                 requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2309         doReturn(service).when(SPY_bbInputSetupUtils)
2310                 .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
2311         doReturn(networkCustList).when(service).getNetworkCustomizations();
2312         doReturn("ab153b6e-c364-44c0-bef6-1f2982117f04").when(networkCust).getModelCustomizationUUID();
2313         doNothing().when(SPY_bbInputSetup).populateL3Network(any(BBInputSetupParameter.class));
2314         // when
2315         SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
2316         // then
2317         verify(SPY_bbInputSetup, times(1)).getGBBMacroNoUserParamsCreate(executeBB, lookupKeyMap,
2318                 executeBB.getBuildingBlock().getBpmnFlowName(), "ab153b6e-c364-44c0-bef6-1f2982117f04", gBB, service);
2319     }
2320
2321     @Test
2322     public void test_getGBBMacroNoUserParamsCreate_shouldBeCalled_whenBBhasVirtualLink() throws Exception {
2323         // given
2324         String resourceId = "123";
2325         String vnfType = "vnfType";
2326         String requestAction = "createInstance";
2327         Service service = Mockito.mock(Service.class);
2328         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2329                 GeneralBuildingBlock.class);
2330         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2331         List<NetworkResourceCustomization> networkCustList = new ArrayList<>();
2332         NetworkResourceCustomization networkCust = Mockito.mock(NetworkResourceCustomization.class);
2333         networkCustList.add(networkCust);
2334         CollectionNetworkResourceCustomization collectionNetworkResourceCust =
2335                 Mockito.mock(CollectionNetworkResourceCustomization.class);
2336         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2337         aaiVnf.setModelCustomizationId("modelCustId");
2338         ModelInfoNetwork modelInfoNetwork = Mockito.mock(ModelInfoNetwork.class);
2339         NetworkResourceCustomization networkResourceCustomization = Mockito.mock(NetworkResourceCustomization.class);
2340
2341         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2342         RequestDetails requestDetails = mapper
2343                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2344         requestDetails.getRequestParameters().setUserParams(null);
2345         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2346                 ExecuteBuildingBlock.class);
2347         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2348         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2349         buildingBlock.setBpmnFlowName(AssignFlows.NETWORK_MACRO.toString())
2350                 .setKey("ab153b6e-c364-44c0-bef6-1f2982117f04").setIsVirtualLink(true);
2351
2352         doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
2353                 requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2354         doReturn(service).when(SPY_bbInputSetupUtils)
2355                 .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
2356         doReturn(collectionNetworkResourceCust).when(SPY_bbInputSetupUtils)
2357                 .getCatalogCollectionNetworkResourceCustByID(any(String.class));
2358         doReturn(networkResourceCustomization).when(bbInputSetupMapperLayer)
2359                 .mapCollectionNetworkResourceCustToNetworkResourceCust(collectionNetworkResourceCust);
2360         doReturn(modelInfoNetwork).when(bbInputSetupMapperLayer)
2361                 .mapCatalogNetworkToNetwork(networkResourceCustomization);
2362         // when
2363         SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
2364         // then
2365         verify(SPY_bbInputSetup, times(1)).getGBBMacroNoUserParamsCreate(executeBB, lookupKeyMap,
2366                 executeBB.getBuildingBlock().getBpmnFlowName(), "ab153b6e-c364-44c0-bef6-1f2982117f04", gBB, service);
2367     }
2368
2369     @Test
2370     public void test_getGBBMacroNoUserParamsCreate_shouldBeCalled_whenBBhasVirtualLinkAndOtherFlowName()
2371             throws Exception {
2372         // given
2373         String otherFlowName = "CreateNetworkBB";
2374         String resourceId = "123";
2375         String vnfType = "vnfType";
2376         String requestAction = "createInstance";
2377         Service service = Mockito.mock(Service.class);
2378         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2379                 GeneralBuildingBlock.class);
2380         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2381         List<NetworkResourceCustomization> networkCustList = new ArrayList<>();
2382         NetworkResourceCustomization networkCust = Mockito.mock(NetworkResourceCustomization.class);
2383         networkCustList.add(networkCust);
2384         CollectionNetworkResourceCustomization collectionNetworkResourceCust =
2385                 Mockito.mock(CollectionNetworkResourceCustomization.class);
2386
2387         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2388         RequestDetails requestDetails = mapper
2389                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2390         requestDetails.getRequestParameters().setUserParams(null);
2391         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2392                 ExecuteBuildingBlock.class);
2393         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2394         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2395         buildingBlock.setBpmnFlowName(otherFlowName).setKey("ab153b6e-c364-44c0-bef6-1f2982117f04")
2396                 .setIsVirtualLink(true);
2397
2398         doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
2399                 requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2400         doReturn(service).when(SPY_bbInputSetupUtils)
2401                 .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
2402         doReturn(collectionNetworkResourceCust).when(SPY_bbInputSetupUtils)
2403                 .getCatalogCollectionNetworkResourceCustByID(any(String.class));
2404         // when
2405         SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
2406         // then
2407         verify(SPY_bbInputSetup, times(1)).getGBBMacroNoUserParamsCreate(executeBB, lookupKeyMap,
2408                 executeBB.getBuildingBlock().getBpmnFlowName(), "ab153b6e-c364-44c0-bef6-1f2982117f04", gBB, service);
2409     }
2410
2411     @Test(expected = IllegalArgumentException.class)
2412     public void testgetGBBMacroNoUserParamsOtherException() throws Exception {
2413         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2414                 GeneralBuildingBlock.class);
2415         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2416                 ExecuteBuildingBlock.class);
2417         RequestDetails requestDetails = mapper
2418                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2419         requestDetails.getRequestParameters().setUserParams(null);
2420         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2421         aaiVnf.setModelCustomizationId("modelCustId");
2422         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2423         lookupKeyMap.put(ResourceKey.NETWORK_ID, "networkId");
2424         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "vnfId");
2425         lookupKeyMap.put(ResourceKey.VF_MODULE_ID, "vfModuleId");
2426         lookupKeyMap.put(ResourceKey.VOLUME_GROUP_ID, "volumeGroupId");
2427         lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "serviceInstanceId");
2428         String resourceId = "123";
2429         String vnfType = "vnfType";
2430         Service service = Mockito.mock(Service.class);
2431         String requestAction = "assignInstance";
2432         doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
2433                 requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2434         doReturn(service).when(SPY_bbInputSetupUtils)
2435                 .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
2436         String generatedId = "12131";
2437
2438         SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
2439     }
2440
2441     @Test
2442     public void test_getGBBMacroNoUserParamsExistingService_forCatalogNetwork() throws Exception {
2443         // given
2444         String requestAction = "unassignInstance";
2445         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2446                 GeneralBuildingBlock.class);
2447         L3Network network = new L3Network();
2448         network.setNetworkId("networkId");
2449         gBB.getServiceInstance().getNetworks().add(network);
2450         ServiceInstance serviceInstance = gBB.getServiceInstance();
2451         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2452                 ExecuteBuildingBlock.class);
2453         RequestDetails requestDetails = mapper
2454                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2455         requestDetails.getRequestParameters().setUserParams(null);
2456         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2457         Service service = Mockito.mock(Service.class);
2458         CloudConfiguration cloudConfiguration = new CloudConfiguration();
2459         cloudConfiguration.setLcpCloudRegionId("cloudRegionId");
2460         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
2461         org.onap.aai.domain.yang.L3Network aaiNetwork = new org.onap.aai.domain.yang.L3Network();
2462         aaiNetwork.setModelCustomizationId("modelCustId");
2463
2464         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2465         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2466         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2467         buildingBlock.setBpmnFlowName("DeleteNetworkBB").setKey("ab153b6e-c364-44c0-bef6-1f2982117f04");
2468
2469         aaiServiceInstance.setModelVersionId("modelVersionId");
2470         doReturn(service).when(SPY_bbInputSetupUtils)
2471                 .getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
2472         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils)
2473                 .getAAIServiceInstanceById(lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2474         doReturn(serviceInstance).when(SPY_bbInputSetup).getExistingServiceInstance(aaiServiceInstance);
2475         doReturn(gBB).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
2476         doReturn(aaiNetwork).when(SPY_bbInputSetupUtils).getAAIL3Network(network.getNetworkId());
2477         doNothing().when(SPY_bbInputSetup).mapCatalogNetwork(any(L3Network.class), any(ModelInfo.class),
2478                 any(Service.class));
2479         // when
2480         SPY_bbInputSetup.getGBBMacroExistingService(executeBB, lookupKeyMap,
2481                 executeBB.getBuildingBlock().getBpmnFlowName(), requestAction, null);
2482         // then
2483         verify(SPY_bbInputSetup, times(1)).mapCatalogNetwork(any(L3Network.class), any(ModelInfo.class),
2484                 any(Service.class));
2485     }
2486
2487     @Test
2488     public void test_getGBBMacroNoUserParamsExistingService_forControllerExecutionBB() throws Exception {
2489         // given
2490         String requestAction = "unassignInstance";
2491         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2492                 GeneralBuildingBlock.class);
2493         L3Network network = new L3Network();
2494         network.setNetworkId("networkId");
2495         gBB.getServiceInstance().getNetworks().add(network);
2496         ServiceInstance serviceInstance = gBB.getServiceInstance();
2497         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2498                 ExecuteBuildingBlock.class);
2499         RequestDetails requestDetails = mapper
2500                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2501         requestDetails.getRequestParameters().setUserParams(null);
2502         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2503         Service service = Mockito.mock(Service.class);
2504         CloudConfiguration cloudConfiguration = new CloudConfiguration();
2505         cloudConfiguration.setLcpCloudRegionId("cloudRegionId");
2506         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
2507         org.onap.aai.domain.yang.L3Network aaiNetwork = new org.onap.aai.domain.yang.L3Network();
2508         aaiNetwork.setModelCustomizationId("modelCustId");
2509         GenericVnf vnf = new GenericVnf();
2510         vnf.setVnfId("vnfId");
2511         gBB.getServiceInstance().getVnfs().add(vnf);
2512         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2513         aaiVnf.setModelCustomizationId("modelCustId");
2514
2515         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2516         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2517         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2518         buildingBlock.setBpmnFlowName("ControllerExecutionBB").setKey("ab153b6e-c364-44c0-bef6-1f2982117f04");
2519         buildingBlock.setBpmnScope("VNF");
2520
2521         aaiServiceInstance.setModelVersionId("modelVersionId");
2522         doReturn(service).when(SPY_bbInputSetupUtils)
2523                 .getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
2524         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils)
2525                 .getAAIServiceInstanceById(lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2526         doReturn(serviceInstance).when(SPY_bbInputSetup).getExistingServiceInstance(aaiServiceInstance);
2527         doReturn(gBB).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
2528         doReturn(aaiVnf).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
2529         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(any(GenericVnf.class), any(ModelInfo.class),
2530                 any(Service.class));
2531         // when
2532         SPY_bbInputSetup.getGBBMacroExistingService(executeBB, lookupKeyMap,
2533                 executeBB.getBuildingBlock().getBpmnFlowName(), requestAction, cloudConfiguration);
2534         // then
2535         verify(SPY_bbInputSetup, times(1)).mapCatalogVnf(any(GenericVnf.class), any(ModelInfo.class),
2536                 any(Service.class));
2537     }
2538
2539     @Test
2540     public void test_getGBBMacroNoUserParamsExistingService_forActivateVnfBB() throws Exception {
2541         // given
2542         String requestAction = "unassignInstance";
2543         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2544                 GeneralBuildingBlock.class);
2545         L3Network network = new L3Network();
2546         network.setNetworkId("networkId");
2547         gBB.getServiceInstance().getNetworks().add(network);
2548         ServiceInstance serviceInstance = gBB.getServiceInstance();
2549         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2550                 ExecuteBuildingBlock.class);
2551         RequestDetails requestDetails = mapper
2552                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2553         requestDetails.getRequestParameters().setUserParams(null);
2554         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2555         Service service = Mockito.mock(Service.class);
2556         CloudConfiguration cloudConfiguration = new CloudConfiguration();
2557         cloudConfiguration.setLcpCloudRegionId("cloudRegionId");
2558         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
2559         org.onap.aai.domain.yang.L3Network aaiNetwork = new org.onap.aai.domain.yang.L3Network();
2560         aaiNetwork.setModelCustomizationId("modelCustId");
2561         GenericVnf vnf = new GenericVnf();
2562         vnf.setVnfId("vnfId");
2563         gBB.getServiceInstance().getVnfs().add(vnf);
2564         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2565         aaiVnf.setModelCustomizationId("modelCustId");
2566
2567         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2568         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2569         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2570         buildingBlock.setBpmnFlowName("ActivateVnfBB").setKey("ab153b6e-c364-44c0-bef6-1f2982117f04");
2571
2572         aaiServiceInstance.setModelVersionId("modelVersionId");
2573         doReturn(service).when(SPY_bbInputSetupUtils)
2574                 .getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
2575         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils)
2576                 .getAAIServiceInstanceById(lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2577         doReturn(serviceInstance).when(SPY_bbInputSetup).getExistingServiceInstance(aaiServiceInstance);
2578         doReturn(gBB).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
2579         doReturn(aaiVnf).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
2580         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(any(GenericVnf.class), any(ModelInfo.class),
2581                 any(Service.class));
2582         // when
2583         SPY_bbInputSetup.getGBBMacroExistingService(executeBB, lookupKeyMap,
2584                 executeBB.getBuildingBlock().getBpmnFlowName(), requestAction, cloudConfiguration);
2585         // then
2586         verify(SPY_bbInputSetup, times(1)).mapCatalogVnf(any(GenericVnf.class), any(ModelInfo.class),
2587                 any(Service.class));
2588     }
2589
2590     @Test
2591     public void test_getGBBMacroNoUserParamsExistingService_forControllerExecutionBB_VFModule() throws Exception {
2592         // given
2593         String requestAction = "unassignInstance";
2594         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2595                 GeneralBuildingBlock.class);
2596         L3Network network = new L3Network();
2597         network.setNetworkId("networkId");
2598         gBB.getServiceInstance().getNetworks().add(network);
2599         ServiceInstance serviceInstance = gBB.getServiceInstance();
2600         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2601                 ExecuteBuildingBlock.class);
2602         RequestDetails requestDetails = mapper
2603                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2604         requestDetails.getRequestParameters().setUserParams(null);
2605         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2606         Service service = Mockito.mock(Service.class);
2607         CloudConfiguration cloudConfiguration = new CloudConfiguration();
2608         cloudConfiguration.setLcpCloudRegionId("cloudRegionId");
2609         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
2610         org.onap.aai.domain.yang.L3Network aaiNetwork = new org.onap.aai.domain.yang.L3Network();
2611         aaiNetwork.setModelCustomizationId("modelCustId");
2612         GenericVnf vnf = new GenericVnf();
2613         vnf.setVnfId("vnfId");
2614         gBB.getServiceInstance().getVnfs().add(vnf);
2615         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2616         aaiVnf.setModelCustomizationId("modelCustId");
2617         VfModule vfModule = new VfModule();
2618         vfModule.setVfModuleId("vfModuleId");
2619         gBB.getServiceInstance().getVnfs().get(0).getVfModules().add(vfModule);
2620         org.onap.aai.domain.yang.VfModule aaiVfModule = new org.onap.aai.domain.yang.VfModule();
2621         aaiVfModule.setModelCustomizationId("modelCustId");
2622
2623         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2624         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2625         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2626         buildingBlock.setBpmnFlowName("ControllerExecutionBB").setKey("a25e8e8c-58b8-4eec-810c-97dcc1f5cb7f");
2627         buildingBlock.setBpmnScope("VfModule");
2628
2629         aaiServiceInstance.setModelVersionId("modelVersionId");
2630         doReturn(service).when(SPY_bbInputSetupUtils)
2631                 .getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
2632         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils)
2633                 .getAAIServiceInstanceById(lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2634         doReturn(serviceInstance).when(SPY_bbInputSetup).getExistingServiceInstance(aaiServiceInstance);
2635         doReturn(gBB).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
2636         doReturn(aaiVnf).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
2637         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(any(GenericVnf.class), any(ModelInfo.class),
2638                 any(Service.class));
2639         doReturn(aaiVfModule).when(SPY_bbInputSetupUtils).getAAIVfModule(vnf.getVnfId(), vfModule.getVfModuleId());
2640         // when
2641         SPY_bbInputSetup.getGBBMacroExistingService(executeBB, lookupKeyMap,
2642                 executeBB.getBuildingBlock().getBpmnFlowName(), requestAction, cloudConfiguration);
2643         // then
2644         verify(SPY_bbInputSetup, times(1)).mapCatalogVnf(any(GenericVnf.class), any(ModelInfo.class),
2645                 any(Service.class));
2646         verify(SPY_bbInputSetup, times(1)).mapCatalogVfModule(any(VfModule.class), any(ModelInfo.class),
2647                 any(Service.class), any(String.class));
2648     }
2649
2650     @Test
2651     public void test_getGBBMacroNoUserParamsExistingService_forUnassignVfModuleBB() throws Exception {
2652         // given
2653         String requestAction = "unassignInstance";
2654         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2655                 GeneralBuildingBlock.class);
2656         L3Network network = new L3Network();
2657         network.setNetworkId("networkId");
2658         gBB.getServiceInstance().getNetworks().add(network);
2659         ServiceInstance serviceInstance = gBB.getServiceInstance();
2660         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2661                 ExecuteBuildingBlock.class);
2662         RequestDetails requestDetails = mapper
2663                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2664         requestDetails.getRequestParameters().setUserParams(null);
2665         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2666         Service service = Mockito.mock(Service.class);
2667         CloudConfiguration cloudConfiguration = new CloudConfiguration();
2668         cloudConfiguration.setLcpCloudRegionId("cloudRegionId");
2669         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
2670         org.onap.aai.domain.yang.L3Network aaiNetwork = new org.onap.aai.domain.yang.L3Network();
2671         aaiNetwork.setModelCustomizationId("modelCustId");
2672         GenericVnf vnf = new GenericVnf();
2673         vnf.setVnfId("vnfId");
2674         gBB.getServiceInstance().getVnfs().add(vnf);
2675         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2676         aaiVnf.setModelCustomizationId("modelCustId");
2677         VfModule vfModule = new VfModule();
2678         vfModule.setVfModuleId("vfModuleId");
2679         gBB.getServiceInstance().getVnfs().get(0).getVfModules().add(vfModule);
2680         org.onap.aai.domain.yang.VfModule aaiVfModule = new org.onap.aai.domain.yang.VfModule();
2681         aaiVfModule.setModelCustomizationId("modelCustId");
2682
2683         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2684         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2685         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2686         buildingBlock.setBpmnFlowName("UnassignVfModuleBB").setKey("a25e8e8c-58b8-4eec-810c-97dcc1f5cb7f");
2687
2688         aaiServiceInstance.setModelVersionId("modelVersionId");
2689         doReturn(service).when(SPY_bbInputSetupUtils)
2690                 .getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
2691         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils)
2692                 .getAAIServiceInstanceById(lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2693         doReturn(serviceInstance).when(SPY_bbInputSetup).getExistingServiceInstance(aaiServiceInstance);
2694         doReturn(gBB).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
2695         doReturn(aaiVnf).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
2696         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(any(GenericVnf.class), any(ModelInfo.class),
2697                 any(Service.class));
2698         doReturn(aaiVfModule).when(SPY_bbInputSetupUtils).getAAIVfModule(vnf.getVnfId(), vfModule.getVfModuleId());
2699         // when
2700         SPY_bbInputSetup.getGBBMacroExistingService(executeBB, lookupKeyMap,
2701                 executeBB.getBuildingBlock().getBpmnFlowName(), requestAction, cloudConfiguration);
2702         // then
2703         verify(SPY_bbInputSetup, times(1)).mapCatalogVnf(any(GenericVnf.class), any(ModelInfo.class),
2704                 any(Service.class));
2705         verify(SPY_bbInputSetup, times(1)).mapCatalogVfModule(any(VfModule.class), any(ModelInfo.class),
2706                 any(Service.class), any(String.class));
2707     }
2708
2709     @Test
2710     public void test_getGBBMacroNoUserParamsExistingService_forUnassignVolumeGroupBB() throws Exception {
2711         // given
2712         String requestAction = "unassignInstance";
2713         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2714                 GeneralBuildingBlock.class);
2715         L3Network network = new L3Network();
2716         network.setNetworkId("networkId");
2717         gBB.getServiceInstance().getNetworks().add(network);
2718         ServiceInstance serviceInstance = gBB.getServiceInstance();
2719         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2720                 ExecuteBuildingBlock.class);
2721         RequestDetails requestDetails = mapper
2722                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2723         requestDetails.getRequestParameters().setUserParams(null);
2724         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2725         Service service = Mockito.mock(Service.class);
2726         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
2727         GenericVnf vnf = new GenericVnf();
2728         vnf.setVnfId("vnfId");
2729         gBB.getServiceInstance().getVnfs().add(vnf);
2730         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2731         aaiVnf.setModelCustomizationId("modelCustId");
2732         VfModule vfModule = new VfModule();
2733         vfModule.setVfModuleId("vfModuleId");
2734         gBB.getServiceInstance().getVnfs().get(0).getVfModules().add(vfModule);
2735         CloudRegion cloudRegion = new CloudRegion();
2736         cloudRegion.setLcpCloudRegionId("cloudRegionId");
2737         cloudRegion.setCloudOwner("CloudOwner");
2738         VolumeGroup volumeGroup = new VolumeGroup();
2739         volumeGroup.setVolumeGroupId("volumeGroupId");
2740         gBB.getServiceInstance().getVnfs().get(0).getVolumeGroups().add(volumeGroup);
2741         org.onap.aai.domain.yang.VolumeGroup aaiVolumeGroup = new org.onap.aai.domain.yang.VolumeGroup();
2742         aaiVolumeGroup.setModelCustomizationId("modelCustId");
2743
2744         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2745         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2746         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2747         buildingBlock.setBpmnFlowName("UnassignVolumeGroupBB").setKey("72d9d1cd-f46d-447a-abdb-451d6fb05fa8");
2748
2749         aaiServiceInstance.setModelVersionId("modelVersionId");
2750         doReturn(service).when(SPY_bbInputSetupUtils)
2751                 .getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
2752         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils)
2753                 .getAAIServiceInstanceById(lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2754         doReturn(serviceInstance).when(SPY_bbInputSetup).getExistingServiceInstance(aaiServiceInstance);
2755         doReturn(gBB).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
2756         doReturn(aaiVnf).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
2757         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(any(GenericVnf.class), any(ModelInfo.class),
2758                 any(Service.class));
2759         doReturn(aaiVolumeGroup).when(SPY_bbInputSetupUtils).getAAIVolumeGroup(cloudRegion.getCloudOwner(),
2760                 cloudRegion.getLcpCloudRegionId(), volumeGroup.getVolumeGroupId());
2761         doReturn(Optional.of(cloudRegion)).when(SPY_cloudInfoFromAAI).getCloudInfoFromAAI(gBB.getServiceInstance());
2762
2763         // when
2764         SPY_bbInputSetup.getGBBMacroExistingService(executeBB, lookupKeyMap,
2765                 executeBB.getBuildingBlock().getBpmnFlowName(), requestAction, null);
2766         // then
2767         verify(SPY_bbInputSetup, times(1)).mapCatalogVnf(any(GenericVnf.class), any(ModelInfo.class),
2768                 any(Service.class));
2769         verify(SPY_bbInputSetup, times(1)).mapCatalogVolumeGroup(isA(VolumeGroup.class), isA(ModelInfo.class),
2770                 isA(Service.class), isA(String.class));
2771     }
2772
2773     @Test
2774     public void test_getGBBMacroNoUserParamsExistingService_forActivateFabricConfigurationBB() throws Exception {
2775         // given
2776         String requestAction = "unassignInstance";
2777         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2778                 GeneralBuildingBlock.class);
2779         L3Network network = new L3Network();
2780         network.setNetworkId("networkId");
2781         gBB.getServiceInstance().getNetworks().add(network);
2782         ServiceInstance serviceInstance = gBB.getServiceInstance();
2783         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2784                 ExecuteBuildingBlock.class);
2785         RequestDetails requestDetails = mapper
2786                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2787         requestDetails.getRequestParameters().setUserParams(null);
2788         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2789         Service service = Mockito.mock(Service.class);
2790         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
2791         GenericVnf vnf = new GenericVnf();
2792         vnf.setVnfId("vnfId");
2793         gBB.getServiceInstance().getVnfs().add(vnf);
2794         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2795         aaiVnf.setModelCustomizationId("modelCustId");
2796         VfModule vfModule = new VfModule();
2797         vfModule.setVfModuleId("vfModuleId");
2798         gBB.getServiceInstance().getVnfs().get(0).getVfModules().add(vfModule);
2799         VolumeGroup volumeGroup = new VolumeGroup();
2800         volumeGroup.setVolumeGroupId("volumeGroupId");
2801         gBB.getServiceInstance().getVnfs().get(0).getVolumeGroups().add(volumeGroup);
2802         CloudConfiguration cloudConfiguration = new CloudConfiguration();
2803         cloudConfiguration.setLcpCloudRegionId("cloudRegionId");
2804         Configuration configuration = new Configuration();
2805         configuration.setConfigurationId("configurationId");
2806         gBB.getServiceInstance().getConfigurations().add(configuration);
2807         org.onap.aai.domain.yang.Configuration aaiConfiguration = new org.onap.aai.domain.yang.Configuration();
2808         aaiConfiguration.setModelCustomizationId("modelCustId");
2809
2810         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2811         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2812         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2813         buildingBlock.setBpmnFlowName("ActivateFabricConfigurationBB").setKey("72d9d1cd-f46d-447a-abdb-451d6fb05fa9");
2814
2815         aaiServiceInstance.setModelVersionId("modelVersionId");
2816         doReturn(service).when(SPY_bbInputSetupUtils)
2817                 .getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
2818         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils)
2819                 .getAAIServiceInstanceById(lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2820         doReturn(serviceInstance).when(SPY_bbInputSetup).getExistingServiceInstance(aaiServiceInstance);
2821         doReturn(gBB).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
2822         doReturn(aaiConfiguration).when(SPY_bbInputSetupUtils).getAAIConfiguration(configuration.getConfigurationId());
2823         doNothing().when(SPY_bbInputSetup).mapCatalogConfiguration(isA(Configuration.class), isA(ModelInfo.class),
2824                 isA(Service.class), isA(ConfigurationResourceKeys.class));
2825
2826         // when
2827         SPY_bbInputSetup.getGBBMacroExistingService(executeBB, lookupKeyMap,
2828                 executeBB.getBuildingBlock().getBpmnFlowName(), requestAction, cloudConfiguration);
2829         // then
2830         verify(SPY_bbInputSetup, times(1)).mapCatalogConfiguration(any(Configuration.class), any(ModelInfo.class),
2831                 any(Service.class), isA(ConfigurationResourceKeys.class));
2832     }
2833
2834     @Test
2835     public void testGetGBBMacroExistingServiceServiceinstancenotFoundInAai() throws Exception {
2836         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2837                 ExecuteBuildingBlock.class);
2838         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2839         lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "si123");
2840
2841         CloudConfiguration cloudConfiguration = new CloudConfiguration();
2842         cloudConfiguration.setLcpCloudRegionId("cloudRegionId");
2843
2844         doReturn(null).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById("si123");
2845
2846         expectedException.expect(NoServiceInstanceFoundException.class);
2847         expectedException.expectMessage("Related service instance from AAI not found: service-instance-id=si123");
2848
2849         SPY_bbInputSetup.getGBBMacroExistingService(executeBB, lookupKeyMap, "AssignVnfBB", "assign",
2850                 cloudConfiguration);
2851     }
2852
2853     @Test
2854     public void testGetGBBMacroExistingServiceServiceModelNotFound() throws Exception {
2855         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2856                 ExecuteBuildingBlock.class);
2857         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2858         lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "si123");
2859         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
2860         aaiServiceInstance.setModelVersionId("modelVersionId");
2861
2862         CloudConfiguration cloudConfiguration = new CloudConfiguration();
2863         cloudConfiguration.setLcpCloudRegionId("cloudRegionId");
2864
2865         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById("si123");
2866         doReturn(null).when(SPY_bbInputSetupUtils).getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
2867
2868         expectedException.expect(ServiceModelNotFoundException.class);
2869         expectedException.expectMessage(
2870                 "Related service instance model not found in MSO CatalogDB: model-version-id=modelVersionId");
2871
2872         SPY_bbInputSetup.getGBBMacroExistingService(executeBB, lookupKeyMap, "AssignVnfBB", "assign",
2873                 cloudConfiguration);
2874     }
2875
2876     @Test
2877     public void testGetVnfId() {
2878         String expected = "vnfId";
2879         ExecuteBuildingBlock executeBB = new ExecuteBuildingBlock().setRequestId("requestId");
2880         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2881         InfraActiveRequests request = new InfraActiveRequests();
2882         request.setVnfId(expected);
2883         doReturn(request).when(SPY_bbInputSetupUtils).getInfraActiveRequest(executeBB.getRequestId());
2884
2885         String actual = SPY_bbInputSetup.getVnfId(executeBB, lookupKeyMap);
2886
2887         assertEquals("VnfId is set correctly", expected, actual);
2888     }
2889
2890     @Test
2891     public void testCreateVfModule() {
2892         String vfModuleId = "vfModuleId";
2893         String instanceName = "vfModuleName";
2894         Map<String, String> cloudParams = new HashMap<>();
2895         cloudParams.put("param1", "param1Value");
2896         VfModule expected = new VfModule();
2897         expected.setVfModuleId(vfModuleId);
2898         expected.setVfModuleName(instanceName);
2899         expected.setCloudParams(cloudParams);
2900         expected.setOrchestrationStatus(OrchestrationStatus.PRECREATED);
2901         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2902         List<Map<String, String>> instanceParams = new ArrayList<>();
2903         instanceParams.add(cloudParams);
2904
2905         VfModule actual = SPY_bbInputSetup.createVfModule(lookupKeyMap, vfModuleId, instanceName, instanceParams);
2906
2907         assertThat(actual, sameBeanAs(expected));
2908         assertEquals("LookupKeyMap is populated", vfModuleId, lookupKeyMap.get(ResourceKey.VF_MODULE_ID));
2909
2910         expected.getCloudParams().clear();
2911         actual = SPY_bbInputSetup.createVfModule(lookupKeyMap, vfModuleId, instanceName, null);
2912         assertThat(actual, sameBeanAs(expected));
2913     }
2914
2915     @Test
2916     public void testCreateVolumeGroup() {
2917         String volumeGroupId = "volumeGroupId";
2918         String instanceName = "vfModuleName";
2919         String vnfType = "vnfType";
2920         Map<String, String> cloudParams = new HashMap<>();
2921         cloudParams.put("param1", "param1Value");
2922         VolumeGroup expected = new VolumeGroup();
2923         expected.setVolumeGroupId(volumeGroupId);
2924         expected.setVolumeGroupName(instanceName);
2925         expected.setCloudParams(cloudParams);
2926         expected.setVnfType(vnfType);
2927         expected.setOrchestrationStatus(OrchestrationStatus.PRECREATED);
2928         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2929         List<Map<String, String>> instanceParams = new ArrayList<>();
2930         instanceParams.add(cloudParams);
2931
2932         VolumeGroup actual =
2933                 SPY_bbInputSetup.createVolumeGroup(lookupKeyMap, volumeGroupId, instanceName, vnfType, instanceParams);
2934
2935         assertThat(actual, sameBeanAs(expected));
2936         assertEquals("LookupKeyMap is populated", volumeGroupId, lookupKeyMap.get(ResourceKey.VOLUME_GROUP_ID));
2937
2938         expected.getCloudParams().clear();
2939         actual = SPY_bbInputSetup.createVolumeGroup(lookupKeyMap, volumeGroupId, instanceName, vnfType, null);
2940         assertThat(actual, sameBeanAs(expected));
2941     }
2942
2943     @Test
2944     public void testCreateNetwork() {
2945         String networkId = "networkId";
2946         String instanceName = "networkName";
2947         Map<String, String> cloudParams = new HashMap<>();
2948         cloudParams.put("param1", "param1Value");
2949         L3Network expected = new L3Network();
2950         expected.setNetworkId(networkId);
2951         expected.setNetworkName(instanceName);
2952         expected.setCloudParams(cloudParams);
2953         Platform platform = new Platform();
2954         platform.setPlatformName("platformName");
2955         expected.setPlatform(platform);
2956         LineOfBusiness lineOfBusiness = new LineOfBusiness();
2957         lineOfBusiness.setLineOfBusinessName("lineOfBusiness");
2958         expected.setLineOfBusiness(lineOfBusiness);
2959         expected.setOrchestrationStatus(OrchestrationStatus.PRECREATED);
2960         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2961         List<Map<String, String>> instanceParams = new ArrayList<>();
2962         instanceParams.add(cloudParams);
2963         org.onap.so.serviceinstancebeans.Platform platformRequest = new org.onap.so.serviceinstancebeans.Platform();
2964         org.onap.so.serviceinstancebeans.LineOfBusiness lineOfBusinessRequest =
2965                 new org.onap.so.serviceinstancebeans.LineOfBusiness();
2966         lineOfBusinessRequest.setLineOfBusinessName("lineOfBusiness");
2967         platformRequest.setPlatformName("platformName");
2968         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
2969                 .setPlatform(platformRequest).setLineOfBusiness(lineOfBusinessRequest).build();
2970         L3Network actual =
2971                 SPY_bbInputSetup.createNetwork(lookupKeyMap, instanceName, networkId, instanceParams, parameter);
2972
2973         assertThat(actual, sameBeanAs(expected));
2974         assertEquals("LookupKeyMap is populated", networkId, lookupKeyMap.get(ResourceKey.NETWORK_ID));
2975
2976         expected.getCloudParams().clear();
2977
2978         actual = SPY_bbInputSetup.createNetwork(lookupKeyMap, instanceName, networkId, null, parameter);
2979         assertThat(actual, sameBeanAs(expected));
2980     }
2981
2982     @Test
2983     public void testCreateGenericVnf() {
2984         String vnfId = "vnfId";
2985         String instanceName = "vnfName";
2986         String vnfType = "vnfType";
2987         String platformName = "platformName";
2988         String lineOfBusinessName = "lineOfBusinessName";
2989         String productFamilyId = "productFamilyId";
2990         String applicationId = "applicationId";
2991         Platform platform = new Platform();
2992         platform.setPlatformName(platformName);
2993         LineOfBusiness lineOfBusiness = new LineOfBusiness();
2994         lineOfBusiness.setLineOfBusinessName(lineOfBusinessName);
2995         Map<String, String> cloudParams = new HashMap<>();
2996         cloudParams.put("param1", "param1Value");
2997         GenericVnf expected = new GenericVnf();
2998         expected.setVnfId(vnfId);
2999         expected.setVnfName(instanceName);
3000         expected.setVnfType(vnfType);
3001         expected.setCloudParams(cloudParams);
3002         expected.setOrchestrationStatus(OrchestrationStatus.PRECREATED);
3003         expected.setPlatform(platform);
3004         expected.setLineOfBusiness(lineOfBusiness);
3005         expected.setProvStatus("PREPROV");
3006         expected.setServiceId(productFamilyId);
3007         expected.setApplicationId(applicationId);
3008         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
3009         List<Map<String, String>> instanceParams = new ArrayList<>();
3010         instanceParams.add(cloudParams);
3011         org.onap.so.serviceinstancebeans.Platform requestPlatform = new org.onap.so.serviceinstancebeans.Platform();
3012         platform.setPlatformName(platformName);
3013         org.onap.so.serviceinstancebeans.LineOfBusiness requestLineOfBusiness =
3014                 new org.onap.so.serviceinstancebeans.LineOfBusiness();
3015         lineOfBusiness.setLineOfBusinessName(lineOfBusinessName);
3016
3017         doReturn(platform).when(bbInputSetupMapperLayer).mapRequestPlatform(requestPlatform);
3018         doReturn(lineOfBusiness).when(bbInputSetupMapperLayer).mapRequestLineOfBusiness(requestLineOfBusiness);
3019
3020         GenericVnf actual = SPY_bbInputSetup.createGenericVnf(lookupKeyMap, instanceName, requestPlatform,
3021                 requestLineOfBusiness, vnfId, vnfType, instanceParams, productFamilyId, applicationId);
3022
3023         assertThat(actual, sameBeanAs(expected));
3024         assertEquals("LookupKeyMap is populated", vnfId, lookupKeyMap.get(ResourceKey.GENERIC_VNF_ID));
3025
3026         expected.getCloudParams().clear();
3027         actual = SPY_bbInputSetup.createGenericVnf(lookupKeyMap, instanceName, requestPlatform, requestLineOfBusiness,
3028                 vnfId, vnfType, null, productFamilyId, applicationId);
3029         assertThat(actual, sameBeanAs(expected));
3030     }
3031
3032     @Test
3033     public void testMapCatalogVfModule() {
3034         String vnfModelCustomizationUUID = "vnfResourceCustUUID";
3035         String vfModuleCustomizationUUID = "vfModelCustomizationUUID";
3036         VfModule vfModule = new VfModule();
3037         ModelInfo modelInfo = new ModelInfo();
3038         modelInfo.setModelCustomizationUuid(vfModuleCustomizationUUID);
3039         Service service = new Service();
3040         VnfResourceCustomization vnfResourceCust = new VnfResourceCustomization();
3041         vnfResourceCust.setModelCustomizationUUID(vnfModelCustomizationUUID);
3042         VfModuleCustomization vfModuleCust = new VfModuleCustomization();
3043         vfModuleCust.setModelCustomizationUUID(vfModuleCustomizationUUID);
3044         vnfResourceCust.getVfModuleCustomizations().add(vfModuleCust);
3045         service.getVnfCustomizations().add(vnfResourceCust);
3046         ModelInfoVfModule modelInfoVfModule = new ModelInfoVfModule();
3047
3048         doReturn(modelInfoVfModule).when(bbInputSetupMapperLayer).mapCatalogVfModuleToVfModule(vfModuleCust);
3049
3050         SPY_bbInputSetup.mapCatalogVfModule(vfModule, modelInfo, service, vnfModelCustomizationUUID);
3051
3052         assertThat(vfModule.getModelInfoVfModule(), sameBeanAs(modelInfoVfModule));
3053
3054         modelInfo.setModelCustomizationUuid(null);
3055         modelInfo.setModelCustomizationId(vfModuleCustomizationUUID);
3056
3057         SPY_bbInputSetup.mapCatalogVfModule(vfModule, modelInfo, service, vnfModelCustomizationUUID);
3058
3059         assertThat(vfModule.getModelInfoVfModule(), sameBeanAs(modelInfoVfModule));
3060     }
3061
3062     @Test
3063     public void testMapCatalogVfModuleIfNoVfUnderVnf() {
3064         String vnfModelCustomizationUUID = "vnfResourceCustUUID";
3065         String vfModuleCustomizationUUID = "vfModelCustomizationUUID";
3066         VfModule vfModule = new VfModule();
3067         ModelInfo modelInfo = new ModelInfo();
3068         modelInfo.setModelCustomizationUuid(vfModuleCustomizationUUID);
3069         Service service = new Service();
3070         VnfResourceCustomization vnfResourceCust = new VnfResourceCustomization();
3071         vnfResourceCust.setModelCustomizationUUID(vnfModelCustomizationUUID);
3072         VfModuleCustomization vfModuleCust = new VfModuleCustomization();
3073         vfModuleCust.setModelCustomizationUUID(vfModuleCustomizationUUID);
3074         ModelInfoVfModule modelInfoVfModule = new ModelInfoVfModule();
3075         doReturn(vfModuleCust).when(SPY_bbInputSetupUtils)
3076                 .getVfModuleCustomizationByModelCuztomizationUUID(vfModuleCustomizationUUID);
3077         doReturn(modelInfoVfModule).when(bbInputSetupMapperLayer).mapCatalogVfModuleToVfModule(vfModuleCust);
3078
3079         SPY_bbInputSetup.mapCatalogVfModule(vfModule, modelInfo, service, vnfModelCustomizationUUID);
3080
3081         assertThat(vfModule.getModelInfoVfModule(), sameBeanAs(modelInfoVfModule));
3082
3083         verify(SPY_bbInputSetupUtils, times(1))
3084                 .getVfModuleCustomizationByModelCuztomizationUUID(modelInfo.getModelCustomizationId());
3085     }
3086
3087     @Test
3088     public void testPopulateVfModule() throws Exception {
3089         String vnfId = "vnfId";
3090         String vfModuleId = "vfModuleId";
3091         String volumeGroupId = "volumeGroupId";
3092         String vfModuleCustomizationId = "vfModuleCustomizationId";
3093         ModelInfo modelInfo = new ModelInfo();
3094         modelInfo.setModelCustomizationId(vfModuleCustomizationId);
3095         Service service = new Service();
3096         ServiceModel serviceModel = new ServiceModel();
3097         serviceModel.setCurrentService(service);
3098         String bbName = AssignFlows.VF_MODULE.toString();
3099         ServiceInstance serviceInstance = new ServiceInstance();
3100         GenericVnf vnf = new GenericVnf();
3101         vnf.setVnfId(vnfId);
3102         VolumeGroup volumeGroup = new VolumeGroup();
3103         volumeGroup.setVolumeGroupId(volumeGroupId);
3104         vnf.getVolumeGroups().add(volumeGroup);
3105         serviceInstance.getVnfs().add(vnf);
3106         VfModule vfModule1 = new VfModule();
3107         vfModule1.setVfModuleId("vfModuleId1");
3108         VfModule vfModule2 = new VfModule();
3109         vfModule2.setVfModuleId("vfModuleId2");
3110         vnf.getVfModules().add(vfModule1);
3111         vnf.getVfModules().add(vfModule2);
3112         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
3113         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, vnfId);
3114         String resourceId = vfModuleId;
3115         RelatedInstanceList[] relatedInstanceList = null;
3116         String instanceName = "vfModuleName";
3117         List<Map<String, String>> instanceParams = null;
3118         CloudConfiguration cloudConfiguration = new CloudConfiguration();
3119
3120         org.onap.aai.domain.yang.GenericVnf vnfAAI = new org.onap.aai.domain.yang.GenericVnf();
3121         vnfAAI.setModelCustomizationId("vnfModelCustId");
3122         org.onap.aai.domain.yang.VolumeGroup volumeGroupAAI = new org.onap.aai.domain.yang.VolumeGroup();
3123         volumeGroupAAI.setModelCustomizationId(vfModuleCustomizationId);
3124         org.onap.aai.domain.yang.VfModule vfModuleAAI = new org.onap.aai.domain.yang.VfModule();
3125         vfModuleAAI.setModelCustomizationId(vfModuleCustomizationId);
3126
3127         doReturn(vnfAAI).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
3128         doReturn(volumeGroupAAI).when(SPY_bbInputSetupUtils).getAAIVolumeGroup(CLOUD_OWNER,
3129                 cloudConfiguration.getLcpCloudRegionId(), volumeGroup.getVolumeGroupId());
3130         doReturn(vfModuleAAI).when(SPY_bbInputSetupUtils).getAAIVfModule(isA(String.class), isA(String.class));
3131         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(isA(GenericVnf.class), isA(ModelInfo.class),
3132                 isA(Service.class));
3133         doNothing().when(SPY_bbInputSetup).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class),
3134                 isA(Service.class), isA(String.class));
3135
3136         SPY_bbInputSetup.populateVfModule(new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
3137                 .setModelInfo(modelInfo).setService(service).setBbName(bbName).setServiceInstance(serviceInstance)
3138                 .setLookupKeyMap(lookupKeyMap).setResourceId(resourceId).setRelatedInstanceList(relatedInstanceList)
3139                 .setInstanceName(instanceName).setInstanceParams(instanceParams)
3140                 .setCloudConfiguration(cloudConfiguration).setServiceModel(serviceModel).build());
3141
3142         verify(SPY_bbInputSetup, times(3)).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class),
3143                 isA(Service.class), isA(String.class));
3144         assertEquals("Lookup Key Map populated with VfModule Id", vfModuleId,
3145                 lookupKeyMap.get(ResourceKey.VF_MODULE_ID));
3146         assertEquals("Lookup Key Map populated with VolumeGroup Id", volumeGroupId,
3147                 lookupKeyMap.get(ResourceKey.VOLUME_GROUP_ID));
3148     }
3149
3150     @Test
3151     public void testPopulateVfModuleIsReplaceCorrectPopulationOfVfs() throws Exception {
3152         String vnfId = "vnfId";
3153         String vfModuleId = "vfModuleId";
3154         String volumeGroupId = "volumeGroupId";
3155         String vfModuleCustomizationId = "vfModuleCustomizationId";
3156         ModelInfo modelInfo = new ModelInfo();
3157         modelInfo.setModelCustomizationId(vfModuleCustomizationId);
3158         Service currentService = new Service();
3159         currentService.setModelUUID("currentUUID");
3160         Service newService = new Service();
3161         newService.setModelUUID("newUUID");
3162         ServiceModel serviceModel = new ServiceModel();
3163         serviceModel.setCurrentService(currentService);
3164         serviceModel.setNewService(newService);
3165         String bbName = "ActivateVfModuleBB";
3166         ServiceInstance serviceInstance = new ServiceInstance();
3167         GenericVnf vnf = new GenericVnf();
3168         vnf.setVnfId(vnfId);
3169         VolumeGroup volumeGroup = new VolumeGroup();
3170         volumeGroup.setVolumeGroupId(volumeGroupId);
3171         vnf.getVolumeGroups().add(volumeGroup);
3172         serviceInstance.getVnfs().add(vnf);
3173         VfModule vfModule1 = new VfModule();
3174         vfModule1.setVfModuleId("vfModuleId1");
3175         VfModule vfModule2 = new VfModule();
3176         vfModule2.setVfModuleId("vfModuleId2");
3177         vnf.getVfModules().add(vfModule1);
3178         vnf.getVfModules().add(vfModule2);
3179         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
3180         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, vnfId);
3181         lookupKeyMap.put(ResourceKey.VF_MODULE_ID, "vfModuleId1");
3182         String resourceId = vfModuleId;
3183         RelatedInstanceList[] relatedInstanceList = new RelatedInstanceList[1];
3184         RelatedInstanceList relatedInstanceListObj = new RelatedInstanceList();
3185         RelatedInstance relatedInstance = new RelatedInstance();
3186         relatedInstance.setInstanceId(vnfId);
3187
3188         ModelInfo vnfModelInfo = new ModelInfo();
3189         vnfModelInfo.setModelCustomizationId("vnfCustomizationId");
3190         vnfModelInfo.setModelType(ModelType.vnf);
3191         relatedInstance.setModelInfo(vnfModelInfo);
3192         relatedInstanceListObj.setRelatedInstance(relatedInstance);
3193         relatedInstanceList[0] = relatedInstanceListObj;
3194
3195         String instanceName = "vfModuleName";
3196         List<Map<String, String>> instanceParams = null;
3197         CloudConfiguration cloudConfiguration = new CloudConfiguration();
3198
3199         org.onap.aai.domain.yang.GenericVnf vnfAAI = new org.onap.aai.domain.yang.GenericVnf();
3200         vnfAAI.setModelCustomizationId("vnfModelCustId");
3201         org.onap.aai.domain.yang.VolumeGroup volumeGroupAAI = new org.onap.aai.domain.yang.VolumeGroup();
3202         volumeGroupAAI.setModelCustomizationId(vfModuleCustomizationId);
3203         org.onap.aai.domain.yang.VfModule vfModuleAAI = new org.onap.aai.domain.yang.VfModule();
3204         vfModuleAAI.setModelCustomizationId(vfModuleCustomizationId);
3205
3206         doReturn(vnfAAI).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
3207         doReturn(volumeGroupAAI).when(SPY_bbInputSetupUtils).getAAIVolumeGroup(CLOUD_OWNER,
3208                 cloudConfiguration.getLcpCloudRegionId(), volumeGroup.getVolumeGroupId());
3209         doReturn(vfModuleAAI).when(SPY_bbInputSetupUtils).getAAIVfModule(isA(String.class), isA(String.class));
3210         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(isA(GenericVnf.class), isA(ModelInfo.class),
3211                 isA(Service.class));
3212         doNothing().when(SPY_bbInputSetup).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class),
3213                 isA(Service.class), isA(String.class));
3214
3215         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setModelInfo(modelInfo)
3216                 .setService(newService).setBbName(bbName).setServiceInstance(serviceInstance)
3217                 .setLookupKeyMap(lookupKeyMap).setResourceId(resourceId).setRelatedInstanceList(relatedInstanceList)
3218                 .setInstanceName(instanceName).setInstanceParams(instanceParams)
3219                 .setCloudConfiguration(cloudConfiguration).setIsReplace(true).setServiceModel(serviceModel).build();
3220         SPY_bbInputSetup.populateVfModule(parameter);
3221
3222         verify(SPY_bbInputSetup, times(1)).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class),
3223                 eq(currentService), eq("vnfModelCustId"));
3224         verify(SPY_bbInputSetup, times(1)).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class), eq(newService),
3225                 eq("vnfCustomizationId"));
3226         assertEquals("Lookup Key Map populated with VfModule Id", "vfModuleId1",
3227                 lookupKeyMap.get(ResourceKey.VF_MODULE_ID));
3228         assertEquals("Lookup Key Map populated with VolumeGroup Id", volumeGroupId,
3229                 lookupKeyMap.get(ResourceKey.VOLUME_GROUP_ID));
3230     }
3231
3232     @Test
3233     public void testPopulateVfModuleIsReplace() throws Exception {
3234         String vnfId = "vnfId";
3235         String vfModuleId = "vfModuleId";
3236         String volumeGroupId = "volumeGroupId";
3237         String vfModuleCustomizationId = "vfModuleCustomizationId";
3238         ModelInfo modelInfo = new ModelInfo();
3239         modelInfo.setModelCustomizationId(vfModuleCustomizationId);
3240         Service currentService = new Service();
3241         Service newService = new Service();
3242         ServiceModel serviceModel = new ServiceModel();
3243         serviceModel.setCurrentService(currentService);
3244         currentService.setModelUUID("currentUUID");
3245         serviceModel.setNewService(newService);
3246         currentService.setModelUUID("newUUID");
3247         String bbName = AssignFlows.VF_MODULE.toString();
3248         ServiceInstance serviceInstance = new ServiceInstance();
3249         GenericVnf vnf = new GenericVnf();
3250         vnf.setVnfId(vnfId);
3251         VolumeGroup volumeGroup = new VolumeGroup();
3252         volumeGroup.setVolumeGroupId(volumeGroupId);
3253         vnf.getVolumeGroups().add(volumeGroup);
3254         serviceInstance.getVnfs().add(vnf);
3255         VfModule vfModule1 = new VfModule();
3256         vfModule1.setVfModuleId("vfModuleId1");
3257         VfModule vfModule2 = new VfModule();
3258         vfModule2.setVfModuleId("vfModuleId2");
3259         vnf.getVfModules().add(vfModule1);
3260         vnf.getVfModules().add(vfModule2);
3261         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
3262         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, vnfId);
3263         lookupKeyMap.put(ResourceKey.VF_MODULE_ID, vfModuleId);
3264         String resourceId = vfModuleId;
3265         RelatedInstanceList[] relatedInstanceList = new RelatedInstanceList[1];
3266         RelatedInstanceList relatedInstanceListObj = new RelatedInstanceList();
3267         RelatedInstance relatedInstance = new RelatedInstance();
3268         relatedInstance.setInstanceId(vnfId);
3269
3270         ModelInfo vnfModelInfo = new ModelInfo();
3271         vnfModelInfo.setModelCustomizationId("vnfCustomizationId");
3272         vnfModelInfo.setModelType(ModelType.vnf);
3273         relatedInstance.setModelInfo(vnfModelInfo);
3274         relatedInstanceListObj.setRelatedInstance(relatedInstance);
3275         relatedInstanceList[0] = relatedInstanceListObj;
3276
3277         String instanceName = "vfModuleName";
3278         List<Map<String, String>> instanceParams = null;
3279         CloudConfiguration cloudConfiguration = new CloudConfiguration();
3280
3281         org.onap.aai.domain.yang.GenericVnf vnfAAI = new org.onap.aai.domain.yang.GenericVnf();
3282         vnfAAI.setModelCustomizationId("vnfModelCustId");
3283         org.onap.aai.domain.yang.VolumeGroup volumeGroupAAI = new org.onap.aai.domain.yang.VolumeGroup();
3284         volumeGroupAAI.setModelCustomizationId(vfModuleCustomizationId);
3285         org.onap.aai.domain.yang.VfModule vfModuleAAI = new org.onap.aai.domain.yang.VfModule();
3286         vfModuleAAI.setModelCustomizationId(vfModuleCustomizationId);
3287
3288         doReturn(vnfAAI).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
3289         doReturn(volumeGroupAAI).when(SPY_bbInputSetupUtils).getAAIVolumeGroup(CLOUD_OWNER,
3290                 cloudConfiguration.getLcpCloudRegionId(), volumeGroup.getVolumeGroupId());
3291         doReturn(vfModuleAAI).when(SPY_bbInputSetupUtils).getAAIVfModule(isA(String.class), isA(String.class));
3292         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(isA(GenericVnf.class), isA(ModelInfo.class),
3293                 isA(Service.class));
3294         doNothing().when(SPY_bbInputSetup).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class),
3295                 isA(Service.class), isA(String.class));
3296
3297         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setModelInfo(modelInfo)
3298                 .setService(newService).setServiceInstance(serviceInstance).setBbName(bbName)
3299                 .setLookupKeyMap(lookupKeyMap).setResourceId(resourceId).setRelatedInstanceList(relatedInstanceList)
3300                 .setInstanceName(instanceName).setInstanceParams(instanceParams)
3301                 .setCloudConfiguration(cloudConfiguration).setIsReplace(true).setServiceModel(serviceModel).build();
3302
3303
3304         SPY_bbInputSetup.populateVfModule(parameter);
3305
3306         verify(SPY_bbInputSetup, times(2)).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class),
3307                 eq(serviceModel.getCurrentService()), isA(String.class));
3308         verify(SPY_bbInputSetup, times(1)).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class),
3309                 eq(serviceModel.getNewService()), isA(String.class));
3310         assertEquals("Lookup Key Map populated with VfModule Id", vfModuleId,
3311                 lookupKeyMap.get(ResourceKey.VF_MODULE_ID));
3312         assertEquals("Lookup Key Map populated with VolumeGroup Id", volumeGroupId,
3313                 lookupKeyMap.get(ResourceKey.VOLUME_GROUP_ID));
3314     }
3315
3316     @Test
3317     public void testGettingVnfcToConfiguration() throws Exception {
3318
3319         String vnfcName = "vnfcName";
3320         org.onap.aai.domain.yang.Configuration expectedAAI = new org.onap.aai.domain.yang.Configuration();
3321         AAIResourceUri aaiResourceUri = AAIUriFactory.createResourceUri(AAIObjectType.VNFC, vnfcName);
3322         AAIResultWrapper configurationWrapper =
3323                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
3324
3325         doReturn(new AAIResultWrapper(null)).when(SPY_bbInputSetupUtils).getAAIResourceDepthOne(aaiResourceUri);
3326         Vnfc vnfc = SPY_bbInputSetup.getVnfcToConfiguration(vnfcName);
3327         Assert.assertNull(vnfc);
3328
3329         doReturn(configurationWrapper).when(SPY_bbInputSetupUtils).getAAIResourceDepthOne(aaiResourceUri);
3330         vnfc = SPY_bbInputSetup.getVnfcToConfiguration(vnfcName);
3331         Assert.assertNotNull(vnfc);
3332     }
3333 }