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