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

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