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