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

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