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

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