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