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         doReturn(ModelType.volumeGroup).when(modelInfo).getModelType();
 892         resourceId = "volumeGroupId";
 893         parameter.setResourceId(resourceId);
 894         doNothing().when(SPY_bbInputSetup).populateVolumeGroup(parameter);
 895         SPY_bbInputSetup.populateObjectsOnAssignAndCreateFlows(parameter);
 896         verify(SPY_bbInputSetup, times(1)).populateVolumeGroup(parameter);
 897         assertEquals("VolumeGroupId populated", true,
 898                 lookupKeyMap.get(ResourceKey.VOLUME_GROUP_ID).equalsIgnoreCase(resourceId));
 899
 900         doReturn(ModelType.vfModule).when(modelInfo).getModelType();
 901         resourceId = "vfModuleId";
 902         parameter.setResourceId(resourceId);
 903         doNothing().when(SPY_bbInputSetup).populateVfModule(parameter);
 904         SPY_bbInputSetup.populateObjectsOnAssignAndCreateFlows(parameter);
 905         verify(SPY_bbInputSetup, times(1)).populateVfModule(parameter);
 906         assertEquals("VfModuleId populated", true,
 907                 lookupKeyMap.get(ResourceKey.VF_MODULE_ID).equalsIgnoreCase(resourceId));
 908
 909         String bbNameAssignVolume = AssignFlows.VOLUME_GROUP.toString();
 910         doReturn(ModelType.vfModule).when(modelInfo).getModelType();
 911         resourceId = "vfModuleId";
 912         parameter.setResourceId(resourceId);
 913         parameter.setBbName(bbNameAssignVolume);
 914         doNothing().when(SPY_bbInputSetup).populateVolumeGroup(parameter);
 915         SPY_bbInputSetup.populateObjectsOnAssignAndCreateFlows(parameter);
 916         verify(SPY_bbInputSetup, times(2)).populateVolumeGroup(parameter);
 917         assertEquals(resourceId, lookupKeyMap.get(ResourceKey.VOLUME_GROUP_ID));
 918     }
 919
 920     @Test
 921     public void testPopulateGBBWithSIAndAdditionalInfo() throws Exception {
 922         GeneralBuildingBlock expected =
 923                 mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpectedWUserParamsInfo.json"),
 924                         GeneralBuildingBlock.class);
 925         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
 926                 ExecuteBuildingBlock.class);
 927         RequestDetails requestDetails = mapper.readValue(
 928                 new File(RESOURCE_PATH + "RequestDetailsInput_withRelatedInstanceList.json"), RequestDetails.class);
 929         RequestContext requestContext =
 930                 mapper.readValue(new File(RESOURCE_PATH + "RequestContextExpected.json"), RequestContext.class);
 931         ServiceInstance serviceInstance =
 932                 mapper.readValue(new File(RESOURCE_PATH + "ServiceInstance_getServiceInstanceNOAAIExpected.json"),
 933                         ServiceInstance.class);
 934         CloudConfiguration cloudConfiguration = new CloudConfiguration();
 935         cloudConfiguration.setTenantId("tenantId");
 936         requestDetails.setCloudConfiguration(cloudConfiguration);
 937         OrchestrationContext orchestrationContext = new OrchestrationContext();
 938         orchestrationContext.setIsRollbackEnabled(false);
 939
 940         CloudRegion cloudRegion = new CloudRegion();
 941         cloudRegion.setCloudOwner("test-owner-name");
 942         cloudRegion.setLcpCloudRegionId("lcpCloudRegionId");
 943         cloudRegion.setComplex("complexName");
 944         cloudRegion.setTenantId("tenantId");
 945
 946         Map<String, String> uriKeys = new HashMap<>();
 947         uriKeys.put("global-customer-id", "global-customer-id");
 948         uriKeys.put("service-type", "service-type");
 949
 950         Customer customer = new Customer();
 951         ServiceSubscription serviceSubscription = new ServiceSubscription();
 952         serviceSubscription.setServiceType("subscriptionServiceType");
 953         customer.setGlobalCustomerId("globalCustomerId");
 954         customer.setSubscriberName("subscriberName");
 955         customer.setSubscriberType("subscriberType");
 956         customer.setServiceSubscription(serviceSubscription);
 957
 958         org.onap.so.bpmn.servicedecomposition.bbobjects.Tenant tenant =
 959                 new org.onap.so.bpmn.servicedecomposition.bbobjects.Tenant();
 960         tenant.setTenantContext("tenantContext");
 961         tenant.setTenantId("tenantId");
 962         tenant.setTenantName("tenantName");
 963
 964         org.onap.aai.domain.yang.CloudRegion aaiCloudRegion = Mockito.mock(org.onap.aai.domain.yang.CloudRegion.class);
 965         org.onap.aai.domain.yang.Tenants aaiTenants = Mockito.mock(org.onap.aai.domain.yang.Tenants.class);
 966         org.onap.aai.domain.yang.Tenant aaiTenant = new org.onap.aai.domain.yang.Tenant();
 967         aaiTenant.setTenantId("tenantId");
 968         List<org.onap.aai.domain.yang.Tenant> tenants = new ArrayList<>();
 969         tenants.add(aaiTenant);
 970
 971         String requestAction = "createInstance";
 972
 973         doReturn(uriKeys).when(SPY_bbInputSetupUtils)
 974                 .getURIKeysFromServiceInstance(serviceInstance.getServiceInstanceId());
 975         doReturn(customer).when(SPY_bbInputSetup).mapCustomer(uriKeys.get("global-customer-id"),
 976                 uriKeys.get("service-type"));
 977         doReturn(aaiCloudRegion).when(SPY_bbInputSetupUtils).getCloudRegion(requestDetails.getCloudConfiguration());
 978         doReturn(orchestrationContext).when(bbInputSetupMapperLayer).mapOrchestrationContext(requestDetails);
 979         doReturn(requestContext).when(bbInputSetupMapperLayer).mapRequestContext(requestDetails);
 980         doReturn(cloudRegion).when(bbInputSetupMapperLayer).mapCloudRegion(requestDetails.getCloudConfiguration(),
 981                 aaiCloudRegion);
 982         doReturn(tenant).when(bbInputSetupMapperLayer).mapTenant(aaiTenant);
 983         doReturn(aaiTenants).when(aaiCloudRegion).getTenants();
 984         doReturn(tenants).when(aaiTenants).getTenant();
 985         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setServiceInstance(serviceInstance)
 986                 .setRequestDetails(requestDetails).setExecuteBB(executeBB).setRequestAction(requestAction).build();
 987         GeneralBuildingBlock actual = SPY_bbInputSetup.populateGBBWithSIAndAdditionalInfo(parameter);
 988
 989         assertThat(actual, sameBeanAs(expected));
 990     }
 991
 992     @Test
 993     public void testGetServiceInstanceNOAAI() throws Exception {
 994         ServiceInstance expected =
 995                 mapper.readValue(new File(RESOURCE_PATH + "ServiceInstance_getServiceInstanceNOAAIExpected.json"),
 996                         ServiceInstance.class);
 997         Service service = mapper.readValue(
 998                 new File(RESOURCE_PATH + "CatalogDBService_getServiceInstanceNOAAIInput.json"), Service.class);
 999         Customer customer = mapper.readValue(new File(RESOURCE_PATH + "Customer.json"), Customer.class);
1000         Project project = mapper.readValue(new File(RESOURCE_PATH + "Project.json"), Project.class);
1001         OwningEntity owningEntity = mapper.readValue(new File(RESOURCE_PATH + "OwningEntity.json"), OwningEntity.class);
1002         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
1003
1004         BuildingBlock buildingBlock = new BuildingBlock().setBpmnFlowName(AssignFlows.SERVICE_INSTANCE.toString());
1005         ExecuteBuildingBlock executeBB = new ExecuteBuildingBlock().setaLaCarte(true).setBuildingBlock(buildingBlock);
1006         RequestDetails requestDetails = new RequestDetails();
1007         RequestInfo reqInfo = new RequestInfo();
1008         reqInfo.setInstanceName("serviceInstanceName");
1009         requestDetails.setRequestInfo(reqInfo);
1010         ModelInfo modelInfo = new ModelInfo();
1011         modelInfo.setModelType(ModelType.service);
1012         requestDetails.setModelInfo(modelInfo);
1013         doReturn(null).when(SPY_bbInputSetupUtils)
1014                 .getAAIServiceInstanceByName(requestDetails.getRequestInfo().getInstanceName(), customer);
1015         doReturn(expected.getModelInfoServiceInstance()).when(bbInputSetupMapperLayer)
1016                 .mapCatalogServiceIntoServiceInstance(service);
1017         doReturn(null).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById(any(String.class));
1018         String serviceInstanceId = "3655a595-05d1-433c-93c0-3afd6b572545";
1019         boolean aLaCarte = true;
1020
1021         ServiceInstance actual =
1022                 SPY_bbInputSetup.getALaCarteServiceInstance(service, requestDetails, customer, project, owningEntity,
1023                         lookupKeyMap, serviceInstanceId, aLaCarte, executeBB.getBuildingBlock().getBpmnFlowName());
1024
1025         assertThat(actual, sameBeanAs(expected));
1026     }
1027
1028     @Test
1029     public void testGetServiceSubscription() throws IOException {
1030         ServiceSubscription expected = new ServiceSubscription();
1031         RequestDetails requestDetails = new RequestDetails();
1032         RequestParameters params = new RequestParameters();
1033         params.setSubscriptionServiceType("subscriptionServiceType");
1034         requestDetails.setRequestParameters(params);
1035         org.onap.aai.domain.yang.ServiceSubscription aaiServiceSubscription =
1036                 new org.onap.aai.domain.yang.ServiceSubscription();
1037         Customer customer = new Customer();
1038         customer.setGlobalCustomerId("globalCustomerId");
1039         doReturn(aaiServiceSubscription).when(SPY_bbInputSetupUtils).getAAIServiceSubscription(
1040                 customer.getGlobalCustomerId(), requestDetails.getRequestParameters().getSubscriptionServiceType());
1041         doReturn(expected).when(bbInputSetupMapperLayer).mapAAIServiceSubscription(aaiServiceSubscription);
1042
1043         ServiceSubscription actual = SPY_bbInputSetup.getServiceSubscription(requestDetails, customer);
1044         assertThat(actual, sameBeanAs(expected));
1045     }
1046
1047     @Test
1048     public void testGetCustomer() throws IOException {
1049         Customer expected = new Customer();
1050         RequestDetails requestDetails = new RequestDetails();
1051         SubscriberInfo subscriberInfo = new SubscriberInfo();
1052         subscriberInfo.setGlobalSubscriberId("globalSubscriberId");
1053         requestDetails.setSubscriberInfo(subscriberInfo);
1054         org.onap.aai.domain.yang.Customer aaiCustomer = new org.onap.aai.domain.yang.Customer();
1055         doReturn(aaiCustomer).when(SPY_bbInputSetupUtils)
1056                 .getAAICustomer(requestDetails.getSubscriberInfo().getGlobalSubscriberId());
1057         doReturn(expected).when(bbInputSetupMapperLayer).mapAAICustomer(aaiCustomer);
1058
1059         Customer actual = SPY_bbInputSetup.getCustomerFromRequest(requestDetails);
1060         assertThat(actual, sameBeanAs(expected));
1061     }
1062
1063     @Test
1064     public void testGetExistingServiceInstance() throws Exception {
1065         org.onap.aai.domain.yang.ServiceInstance serviceInstanceAAI = new org.onap.aai.domain.yang.ServiceInstance();
1066         ServiceInstance expected = new ServiceInstance();
1067
1068         doReturn(expected).when(bbInputSetupMapperLayer).mapAAIServiceInstanceIntoServiceInstance(serviceInstanceAAI);
1069
1070
1071         ServiceInstance actual = SPY_bbInputSetup.getExistingServiceInstance(serviceInstanceAAI);
1072         assertThat(actual, sameBeanAs(expected));
1073     }
1074
1075     @Test
1076     public void testPopulateNetworkCollectionAndInstanceGroupAssign() throws Exception {
1077         Service service = Mockito.mock(Service.class);
1078         String key = "collectionCustId";
1079         ServiceInstance serviceInstance =
1080                 mapper.readValue(new File(RESOURCE_PATH + "ServiceInstance_getServiceInstanceNOAAIExpected.json"),
1081                         ServiceInstance.class);
1082         String resourceId = "123";
1083         Collection collection = SPY_bbInputSetup.createCollection(resourceId);
1084         InstanceGroup instanceGroup = SPY_bbInputSetup.createInstanceGroup();
1085         assertNull(serviceInstance.getCollection());
1086         doReturn(true).when(SPY_bbInputSetup).isVlanTagging(service, key);
1087
1088         doReturn(collection).when(SPY_bbInputSetup).createCollection(resourceId);
1089         doReturn(instanceGroup).when(SPY_bbInputSetup).createInstanceGroup();
1090         doNothing().when(SPY_bbInputSetup).mapCatalogCollection(service, collection, key);
1091
1092         NetworkCollectionResourceCustomization networkCollection = new NetworkCollectionResourceCustomization();
1093         networkCollection.setModelCustomizationUUID(key);
1094         networkCollection.setCollectionResource(new CollectionResource());
1095         networkCollection.getCollectionResource().setInstanceGroup(new org.onap.so.db.catalog.beans.InstanceGroup());
1096         networkCollection.getCollectionResource().getInstanceGroup().setToscaNodeType("NetworkCollectionResource");
1097         networkCollection.getCollectionResource().getInstanceGroup().setType(InstanceGroupType.L3_NETWORK);
1098         networkCollection.getCollectionResource().getInstanceGroup()
1099                 .setCollectionInstanceGroupCustomizations(new ArrayList<>());
1100         List<CollectionResourceCustomization> customizations = new ArrayList<>();
1101         customizations.add(networkCollection);
1102         doReturn(customizations).when(service).getCollectionResourceCustomizations();
1103         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setService(service)
1104                 .setServiceInstance(serviceInstance).setResourceId(resourceId).setKey(key)
1105                 .setBbName(AssignFlows.NETWORK_COLLECTION.toString()).build();
1106
1107         SPY_bbInputSetup.populateNetworkCollectionAndInstanceGroupAssign(parameter);
1108         assertNotNull(serviceInstance.getCollection());
1109         assertNotNull(serviceInstance.getCollection().getInstanceGroup());
1110
1111         verify(SPY_bbInputSetup, times(1)).mapCatalogCollection(service, serviceInstance.getCollection(), key);
1112         verify(SPY_bbInputSetup, times(1)).mapCatalogNetworkCollectionInstanceGroup(service,
1113                 serviceInstance.getCollection().getInstanceGroup(), key);
1114     }
1115
1116     @Test
1117     public void testPopulateInstanceGroup() throws Exception {
1118         ModelInfo modelInfo = Mockito.mock(ModelInfo.class);
1119         Service service = Mockito.mock(Service.class);
1120         List<InstanceGroup> instanceGroups = Mockito.spy(new ArrayList<>());
1121         ServiceInstance serviceInstance = Mockito.spy(new ServiceInstance());
1122         serviceInstance.setServiceInstanceId("si-001");
1123         serviceInstance.setServiceInstanceName("test service instance");
1124         serviceInstance.setInstanceGroups(instanceGroups);
1125
1126         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setModelInfo(modelInfo)
1127                 .setService(service).setServiceInstance(serviceInstance).setResourceId("instance-group-001")
1128                 .setInstanceName("test instance group").build();
1129         SPY_bbInputSetup.populateInstanceGroup(parameter);
1130         verify(SPY_bbInputSetup, times(1)).mapCatalogInstanceGroup(isA(InstanceGroup.class), isA(ModelInfo.class),
1131                 isA(Service.class));
1132         verify(instanceGroups, times(1)).add(isA(InstanceGroup.class));
1133     }
1134
1135     @Test
1136     public void testIsVlanTagging() throws Exception {
1137         boolean expected = true;
1138         Service service = Mockito.mock(Service.class);
1139         String key = "collectionCustId";
1140         NetworkCollectionResourceCustomization networkCollection = new NetworkCollectionResourceCustomization();
1141         networkCollection.setModelCustomizationUUID(key);
1142         networkCollection.setCollectionResource(new CollectionResource());
1143         networkCollection.getCollectionResource().setInstanceGroup(new org.onap.so.db.catalog.beans.InstanceGroup());
1144         networkCollection.getCollectionResource().getInstanceGroup()
1145                 .setToscaNodeType("org.openecomp.resource.cr.NetworkCollectionResource1806");
1146         List<CollectionResourceCustomization> customizations = new ArrayList<>();
1147         customizations.add(networkCollection);
1148         doReturn(customizations).when(service).getCollectionResourceCustomizations();
1149         boolean actual = SPY_bbInputSetup.isVlanTagging(service, key);
1150         assertEquals("Is Vlan Tagging check.", expected, actual);
1151     }
1152
1153     @Test
1154     public void testPopulateVolumeGroup() throws Exception {
1155         RequestDetails requestDetails = new RequestDetails();
1156         RelatedInstanceList ril = new RelatedInstanceList();
1157         RelatedInstance ri = new RelatedInstance();
1158         ModelInfo mi = new ModelInfo();
1159         mi.setModelType(ModelType.vnf);
1160         mi.setModelCustomizationUuid("vnfModelCustomizationUUID");
1161         mi.setModelCustomizationId("vnfModelCustomizationUUID");
1162         ri.setModelInfo(mi);
1163         ril.setRelatedInstance(ri);
1164         requestDetails.setRelatedInstanceList(new RelatedInstanceList[] {ril});
1165
1166         ModelInfo modelInfo = new ModelInfo();
1167         modelInfo.setModelCustomizationId("volumeGroupCustId");
1168
1169         RequestInfo reqInfo = new RequestInfo();
1170         reqInfo.setInstanceName("volumeGroupName");
1171         requestDetails.setModelInfo(modelInfo);
1172         requestDetails.setRequestInfo(reqInfo);
1173
1174         ServiceInstance serviceInstance = new ServiceInstance();
1175         GenericVnf vnf = new GenericVnf();
1176         vnf.setVnfId("genericVnfId");
1177
1178         VolumeGroup vg = new VolumeGroup();
1179         vg.setVolumeGroupName("volumeGroupName");
1180         vg.setVolumeGroupId("volumeGroupId");
1181         vg.setModelInfoVfModule(new ModelInfoVfModule());
1182         vg.getModelInfoVfModule().setModelCustomizationUUID("volumeGroupCustId");
1183         vnf.getVolumeGroups().add(vg);
1184         serviceInstance.getVnfs().add(vnf);
1185
1186         Service service = mapper.readValue(
1187                 new File(RESOURCE_PATH + "CatalogDBService_getServiceInstanceNOAAIInput.json"), Service.class);
1188         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
1189         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "genericVnfId");
1190
1191         ServiceModel serviceModel = new ServiceModel();
1192         serviceModel.setCurrentService(service);
1193         String bbName = AssignFlows.VOLUME_GROUP.toString();
1194         String resourceId = "123";
1195         doNothing().when(SPY_bbInputSetup).mapCatalogVolumeGroup(isA(VolumeGroup.class), eq(modelInfo), eq(service),
1196                 eq("vnfModelCustomizationUUID"));
1197         org.onap.aai.domain.yang.GenericVnf aaiGenericVnf = new org.onap.aai.domain.yang.GenericVnf();
1198         aaiGenericVnf.setModelCustomizationId("vnfModelCustomizationUUID");
1199         doReturn(aaiGenericVnf).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
1200
1201         lookupKeyMap.put(ResourceKey.VOLUME_GROUP_ID, "volumeGroupId");
1202         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
1203                 .setModelInfo(modelInfo).setService(service).setBbName(bbName).setServiceInstance(serviceInstance)
1204                 .setLookupKeyMap(lookupKeyMap).setResourceId(resourceId).setRequestDetails(requestDetails)
1205                 .setInstanceName(reqInfo.getInstanceName()).setServiceModel(serviceModel).build();
1206         SPY_bbInputSetup.populateVolumeGroup(parameter);
1207         verify(SPY_bbInputSetup, times(1)).mapCatalogVolumeGroup(eq(vg), isA(ModelInfo.class), eq(service),
1208                 eq("vnfModelCustomizationUUID"));
1209         vnf.getVolumeGroups().clear();
1210         SPY_bbInputSetup.populateVolumeGroup(parameter);
1211         verify(SPY_bbInputSetup, times(1)).mapCatalogVolumeGroup(vnf.getVolumeGroups().get(0), modelInfo, service,
1212                 "vnfModelCustomizationUUID");
1213     }
1214
1215     @Test
1216     public void testMapCatalogVolumeGroup() {
1217         VolumeGroup volumeGroup = new VolumeGroup();
1218         RequestDetails requestDetails = new RequestDetails();
1219         ModelInfo modelInfo = new ModelInfo();
1220         modelInfo.setModelCustomizationUuid("modelCustomizationUUID");
1221         requestDetails.setModelInfo(modelInfo);
1222         Service service = new Service();
1223         VnfResourceCustomization resourceCust = new VnfResourceCustomization();
1224         resourceCust.setModelCustomizationUUID("vnfModelCustomizationUUID");
1225         service.getVnfCustomizations().add(resourceCust);
1226         VfModuleCustomization vfResourceCust = new VfModuleCustomization();
1227         vfResourceCust.setModelCustomizationUUID("modelCustomizationUUID");
1228         ModelInfoVfModule modelInfoVfModule = new ModelInfoVfModule();
1229         resourceCust.getVfModuleCustomizations().add(vfResourceCust);
1230
1231         doReturn(modelInfoVfModule).when(bbInputSetupMapperLayer).mapCatalogVfModuleToVfModule(vfResourceCust);
1232
1233         SPY_bbInputSetup.mapCatalogVolumeGroup(volumeGroup, modelInfo, service, "vnfModelCustomizationUUID");
1234
1235         assertEquals(modelInfoVfModule, volumeGroup.getModelInfoVfModule());
1236     }
1237
1238     @Test
1239     public void testPopulateL3Network() throws JsonParseException, JsonMappingException, IOException {
1240         String instanceName = "networkName";
1241         ModelInfo modelInfo = new ModelInfo();
1242         modelInfo.setModelType(ModelType.network);
1243
1244         ServiceInstance serviceInstance = new ServiceInstance();
1245         L3Network network = new L3Network();
1246         network.setNetworkId("networkId");
1247         network.setNetworkName("networkName");
1248         serviceInstance.getNetworks().add(network);
1249         String resourceId = "123";
1250         // Mock service
1251         Service service = mapper.readValue(
1252                 new File(RESOURCE_PATH + "CatalogDBService_getServiceInstanceNOAAIInput.json"), Service.class);
1253         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
1254         lookupKeyMap.put(ResourceKey.NETWORK_ID, "networkId");
1255         String bbName = AssignFlows.NETWORK_A_LA_CARTE.toString();
1256
1257         doNothing().when(SPY_bbInputSetup).mapCatalogNetwork(network, modelInfo, service);
1258
1259         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
1260                 .setInstanceName(instanceName).setModelInfo(modelInfo).setService(service).setBbName(bbName)
1261                 .setServiceInstance(serviceInstance).setLookupKeyMap(lookupKeyMap).setResourceId(resourceId).build();
1262         SPY_bbInputSetup.populateL3Network(parameter);
1263
1264         lookupKeyMap.put(ResourceKey.NETWORK_ID, null);
1265
1266         SPY_bbInputSetup.populateL3Network(parameter);
1267         verify(SPY_bbInputSetup, times(1)).mapCatalogNetwork(network, modelInfo, service);
1268
1269         instanceName = "networkName2";
1270         L3Network network2 = SPY_bbInputSetup.createNetwork(lookupKeyMap, instanceName, resourceId, null, parameter);
1271         SPY_bbInputSetup.populateL3Network(parameter);
1272         verify(SPY_bbInputSetup, times(2)).mapCatalogNetwork(network2, modelInfo, service);
1273     }
1274
1275     @Test
1276     public void testMapCatalogNetwork() {
1277         ModelInfoNetwork modelInfoNetwork = new ModelInfoNetwork();
1278         L3Network network = new L3Network();
1279
1280         RequestDetails requestDetails = new RequestDetails();
1281         ModelInfo modelInfo = new ModelInfo();
1282         modelInfo.setModelCustomizationUuid("modelCustomizationUUID");
1283         requestDetails.setModelInfo(modelInfo);
1284         Service service = new Service();
1285         NetworkResourceCustomization resourceCust = new NetworkResourceCustomization();
1286         resourceCust.setModelCustomizationUUID("modelCustomizationUUID");
1287         service.setNetworkCustomizations(Arrays.asList(new NetworkResourceCustomization[] {resourceCust}));
1288
1289         doReturn(modelInfoNetwork).when(bbInputSetupMapperLayer).mapCatalogNetworkToNetwork(resourceCust);
1290
1291         SPY_bbInputSetup.mapCatalogNetwork(network, modelInfo, service);
1292
1293         assertEquals(modelInfoNetwork, network.getModelInfoNetwork());
1294     }
1295
1296     @Test
1297     public void testPopulateConfiguration() throws JsonParseException, JsonMappingException, IOException {
1298         String instanceName = "configurationName";
1299         ModelInfo modelInfo = new ModelInfo();
1300         modelInfo.setModelCustomizationUuid("72d9d1cd-f46d-447a-abdb-451d6fb05fa9");
1301
1302         ServiceInstance serviceInstance = new ServiceInstance();
1303         Configuration configuration = new Configuration();
1304         configuration.setConfigurationId("configurationId");
1305         configuration.setConfigurationName("configurationName");
1306         serviceInstance.getConfigurations().add(configuration);
1307         String resourceId = "configurationId";
1308         String vnfcName = "vnfcName";
1309         // Mock service
1310         Service service = mapper.readValue(
1311                 new File(RESOURCE_PATH + "CatalogDBService_getServiceInstanceNOAAIInput.json"), Service.class);
1312         ConfigurationResourceCustomization configurationCust = new ConfigurationResourceCustomization();
1313         configurationCust.setModelCustomizationUUID("72d9d1cd-f46d-447a-abdb-451d6fb05fa9");
1314         service.getConfigurationCustomizations().add(configurationCust);
1315         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
1316         lookupKeyMap.put(ResourceKey.CONFIGURATION_ID, "configurationId");
1317         String bbName = AssignFlows.FABRIC_CONFIGURATION.toString();
1318         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
1319         configResourceKeys.setVnfcName(vnfcName);
1320         Vnfc vnfc = new Vnfc();
1321         vnfc.setVnfcName(vnfcName);
1322         RequestDetails requestDetails = new RequestDetails();
1323         doNothing().when(SPY_bbInputSetup).mapCatalogConfiguration(configuration, modelInfo, service,
1324                 configResourceKeys);
1325         doReturn(vnfc).when(SPY_bbInputSetup).getVnfcToConfiguration(vnfcName);
1326         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
1327                 .setModelInfo(modelInfo).setService(service).setBbName(bbName).setServiceInstance(serviceInstance)
1328                 .setLookupKeyMap(lookupKeyMap).setResourceId(resourceId).setInstanceName(instanceName)
1329                 .setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails).build();
1330         SPY_bbInputSetup.populateConfiguration(parameter);
1331         verify(SPY_bbInputSetup, times(1)).mapCatalogConfiguration(configuration, modelInfo, service,
1332                 configResourceKeys);
1333
1334         lookupKeyMap.put(ResourceKey.CONFIGURATION_ID, null);
1335
1336         SPY_bbInputSetup.populateConfiguration(parameter);
1337         verify(SPY_bbInputSetup, times(2)).mapCatalogConfiguration(configuration, modelInfo, service,
1338                 configResourceKeys);
1339
1340         instanceName = "configurationName2";
1341         resourceId = "resourceId2";
1342         lookupKeyMap.put(ResourceKey.CONFIGURATION_ID, "configurationId2");
1343         parameter.setInstanceName(instanceName);
1344         parameter.setResourceId(resourceId);
1345         Configuration configuration2 = SPY_bbInputSetup.createConfiguration(lookupKeyMap, instanceName, resourceId);
1346         doReturn(configuration2).when(SPY_bbInputSetup).createConfiguration(lookupKeyMap, instanceName, resourceId);
1347         doNothing().when(SPY_bbInputSetup).mapCatalogConfiguration(configuration2, modelInfo, service,
1348                 configResourceKeys);
1349         SPY_bbInputSetup.populateConfiguration(parameter);
1350         verify(SPY_bbInputSetup, times(1)).mapCatalogConfiguration(configuration2, modelInfo, service,
1351                 configResourceKeys);
1352     }
1353
1354     @Test
1355     public void testMapCatalogConfiguration() {
1356         ModelInfoNetwork modelInfoNetwork = new ModelInfoNetwork();
1357         L3Network network = new L3Network();
1358
1359         RequestDetails requestDetails = new RequestDetails();
1360         ModelInfo modelInfo = new ModelInfo();
1361         modelInfo.setModelCustomizationUuid("modelCustomizationUUID");
1362         requestDetails.setModelInfo(modelInfo);
1363         Service service = new Service();
1364         NetworkResourceCustomization resourceCust = new NetworkResourceCustomization();
1365         resourceCust.setModelCustomizationUUID("modelCustomizationUUID");
1366         service.setNetworkCustomizations(Arrays.asList(new NetworkResourceCustomization[] {resourceCust}));
1367
1368         doReturn(modelInfoNetwork).when(bbInputSetupMapperLayer).mapCatalogNetworkToNetwork(resourceCust);
1369
1370         SPY_bbInputSetup.mapCatalogNetwork(network, modelInfo, service);
1371
1372         assertEquals(modelInfoNetwork, network.getModelInfoNetwork());
1373     }
1374
1375     @Test
1376     public void testPopulateFabricConfiguration() throws JsonParseException, JsonMappingException, IOException {
1377         String instanceName = "configurationName";
1378         ModelInfo modelInfo = new ModelInfo();
1379         modelInfo.setModelCustomizationUuid("72d9d1cd-f46d-447a-abdb-451d6fb05fa9");
1380
1381         ServiceInstance serviceInstance = new ServiceInstance();
1382         Configuration configuration = new Configuration();
1383         configuration.setConfigurationId("configurationId");
1384         configuration.setConfigurationName("configurationName");
1385         configuration.setConfigurationSubType("Fabric Config");
1386         serviceInstance.getConfigurations().add(configuration);
1387         String resourceId = "configurationId";
1388         String vnfcName = "vnfcName";
1389         // Mock service
1390         Service service = mapper.readValue(
1391                 new File(RESOURCE_PATH + "CatalogDBService_getServiceInstanceNOAAIInput.json"), Service.class);
1392         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
1393         lookupKeyMap.put(ResourceKey.CONFIGURATION_ID, "configurationId");
1394         String bbName = AssignFlows.FABRIC_CONFIGURATION.toString();
1395         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
1396         configResourceKeys.setVnfcName(vnfcName);
1397         Vnfc vnfc = new Vnfc();
1398         vnfc.setVnfcName(vnfcName);
1399         RequestDetails requestDetails = new RequestDetails();
1400
1401         CvnfcConfigurationCustomization vnfVfmoduleCvnfcConfigurationCustomization =
1402                 new CvnfcConfigurationCustomization();
1403         ConfigurationResource configurationResource = new ConfigurationResource();
1404         configurationResource.setModelUUID("modelUUID");
1405         configurationResource.setModelInvariantUUID("modelInvariantUUID");
1406         vnfVfmoduleCvnfcConfigurationCustomization.setConfigurationResource(configurationResource);
1407
1408         doReturn(null).when(SPY_bbInputSetup).findConfigurationResourceCustomization(modelInfo, service);
1409         doReturn(vnfc).when(SPY_bbInputSetup).getVnfcToConfiguration(vnfcName);
1410         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
1411                 .setModelInfo(modelInfo).setService(service).setBbName(bbName).setServiceInstance(serviceInstance)
1412                 .setLookupKeyMap(lookupKeyMap).setResourceId(resourceId).setInstanceName(instanceName)
1413                 .setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails).build();
1414         SPY_bbInputSetup.populateConfiguration(parameter);
1415         verify(SPY_bbInputSetup, times(1)).mapCatalogConfiguration(configuration, modelInfo, service,
1416                 configResourceKeys);
1417     }
1418
1419     @Test
1420     public void testPopulateGenericVnf() throws JsonParseException, JsonMappingException, IOException {
1421         org.onap.so.serviceinstancebeans.Platform platform = new org.onap.so.serviceinstancebeans.Platform();
1422         org.onap.so.serviceinstancebeans.LineOfBusiness lineOfBusiness =
1423                 new org.onap.so.serviceinstancebeans.LineOfBusiness();
1424         String instanceName = "vnfName";
1425         ModelInfo modelInfo = new ModelInfo();
1426         modelInfo.setModelType(ModelType.vnf);
1427         ServiceInstance serviceInstance = new ServiceInstance();
1428         GenericVnf vnf = new GenericVnf();
1429         vnf.setVnfId("genericVnfId");
1430         vnf.setVnfName("vnfName");
1431         serviceInstance.getVnfs().add(vnf);
1432         String vnfType = "vnfType";
1433         String applicationId = "applicationId";
1434         RequestDetails requestDetails =
1435                 mapper.readValue(new File(RESOURCE_PATH + "RequestDetails_CreateVnf.json"), RequestDetails.class);
1436
1437         Service service = mapper.readValue(
1438                 new File(RESOURCE_PATH + "CatalogDBService_getServiceInstanceNOAAIInput.json"), Service.class);
1439         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
1440         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "genericVnfId");
1441         String bbName = AssignFlows.VNF.toString();
1442
1443         Platform expectedPlatform = new Platform();
1444         LineOfBusiness expectedLineOfBusiness = new LineOfBusiness();
1445         String resourceId = "123";
1446         doReturn(expectedPlatform).when(bbInputSetupMapperLayer).mapRequestPlatform(platform);
1447         doReturn(expectedLineOfBusiness).when(bbInputSetupMapperLayer).mapRequestLineOfBusiness(lineOfBusiness);
1448         org.onap.aai.domain.yang.GenericVnf vnfAAI = new org.onap.aai.domain.yang.GenericVnf();
1449         vnfAAI.setModelCustomizationId("modelCustId");
1450         doReturn(vnfAAI).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
1451         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(vnf, modelInfo, service);
1452         org.onap.aai.domain.yang.InstanceGroup instanceGroupAAI = new org.onap.aai.domain.yang.InstanceGroup();
1453         doReturn(instanceGroupAAI).when(SPY_bbInputSetupUtils).getAAIInstanceGroup(any());
1454         org.onap.so.db.catalog.beans.InstanceGroup catalogInstanceGroup =
1455                 new org.onap.so.db.catalog.beans.InstanceGroup();
1456         doReturn(catalogInstanceGroup).when(SPY_bbInputSetupUtils).getCatalogInstanceGroup(any());
1457         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
1458                 .setModelInfo(modelInfo).setInstanceName(instanceName).setPlatform(platform)
1459                 .setLineOfBusiness(lineOfBusiness).setService(service).setBbName(bbName)
1460                 .setServiceInstance(serviceInstance).setLookupKeyMap(lookupKeyMap)
1461                 .setRelatedInstanceList(requestDetails.getRelatedInstanceList()).setResourceId(resourceId)
1462                 .setVnfType(vnfType).setProductFamilyId(requestDetails.getRequestInfo().getProductFamilyId()).build();
1463         SPY_bbInputSetup.populateGenericVnf(parameter);
1464
1465         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, null);
1466
1467         SPY_bbInputSetup.populateGenericVnf(parameter);
1468         verify(SPY_bbInputSetup, times(1)).mapCatalogVnf(vnf, modelInfo, service);
1469
1470         instanceName = "vnfName2";
1471         GenericVnf vnf2 = SPY_bbInputSetup.createGenericVnf(lookupKeyMap, instanceName, platform, lineOfBusiness,
1472                 resourceId, vnfType, null, requestDetails.getRequestInfo().getProductFamilyId(), applicationId);
1473
1474         doNothing().when(SPY_bbInputSetup).mapNetworkCollectionInstanceGroup(vnf2, "{instanceGroupId}");
1475         doNothing().when(SPY_bbInputSetup).mapVnfcCollectionInstanceGroup(vnf2, modelInfo, service);
1476
1477         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "genericVnfId2");
1478
1479         SPY_bbInputSetup.populateGenericVnf(parameter);
1480         verify(SPY_bbInputSetup, times(2)).mapCatalogVnf(vnf2, modelInfo, service);
1481         verify(SPY_bbInputSetup, times(2)).mapNetworkCollectionInstanceGroup(vnf2, "{instanceGroupId}");
1482         verify(SPY_bbInputSetup, times(2)).mapVnfcCollectionInstanceGroup(vnf2, modelInfo, service);
1483
1484         assertEquals("modelCustId", modelInfo.getModelCustomizationUuid());
1485
1486     }
1487
1488     @Test
1489     public void testPopulateGenericVnfReplace() throws JsonParseException, JsonMappingException, IOException {
1490         org.onap.so.serviceinstancebeans.Platform platform = new org.onap.so.serviceinstancebeans.Platform();
1491         org.onap.so.serviceinstancebeans.LineOfBusiness lineOfBusiness =
1492                 new org.onap.so.serviceinstancebeans.LineOfBusiness();
1493         String instanceName = "vnfName";
1494         ModelInfo modelInfo = new ModelInfo();
1495         modelInfo.setModelType(ModelType.vnf);
1496         ServiceInstance serviceInstance = new ServiceInstance();
1497         GenericVnf vnf = new GenericVnf();
1498         vnf.setVnfId("genericVnfId");
1499         vnf.setVnfName("vnfName");
1500         serviceInstance.getVnfs().add(vnf);
1501         String vnfType = "vnfType";
1502         String applicationId = "applicationId";
1503         RequestDetails requestDetails =
1504                 mapper.readValue(new File(RESOURCE_PATH + "RequestDetails_CreateVnf.json"), RequestDetails.class);
1505
1506         Service service = mapper.readValue(
1507                 new File(RESOURCE_PATH + "CatalogDBService_getServiceInstanceNOAAIInput.json"), Service.class);
1508         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
1509         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "genericVnfId");
1510         String bbName = AssignFlows.VNF.toString();
1511
1512         String resourceId = "123";
1513         org.onap.aai.domain.yang.GenericVnf vnfAAI = new org.onap.aai.domain.yang.GenericVnf();
1514         vnfAAI.setModelCustomizationId("modelCustId");
1515         doReturn(vnfAAI).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
1516         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(vnf, modelInfo, service);
1517         org.onap.aai.domain.yang.InstanceGroup instanceGroupAAI = new org.onap.aai.domain.yang.InstanceGroup();
1518         doReturn(instanceGroupAAI).when(SPY_bbInputSetupUtils).getAAIInstanceGroup(any());
1519         org.onap.so.db.catalog.beans.InstanceGroup catalogInstanceGroup =
1520                 new org.onap.so.db.catalog.beans.InstanceGroup();
1521         doReturn(catalogInstanceGroup).when(SPY_bbInputSetupUtils).getCatalogInstanceGroup(any());
1522
1523         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setModelInfo(modelInfo)
1524                 .setInstanceName(instanceName).setPlatform(platform).setLineOfBusiness(lineOfBusiness)
1525                 .setService(service).setBbName(bbName).setServiceInstance(serviceInstance).setLookupKeyMap(lookupKeyMap)
1526                 .setRelatedInstanceList(requestDetails.getRelatedInstanceList()).setResourceId(resourceId)
1527                 .setVnfType(vnfType).setProductFamilyId(requestDetails.getRequestInfo().getProductFamilyId())
1528                 .setApplicationId(applicationId).setIsReplace(true).build();
1529
1530         SPY_bbInputSetup.populateGenericVnf(parameter);
1531
1532         assertEquals("my-test-uuid", modelInfo.getModelCustomizationUuid());
1533
1534     }
1535
1536     @Test
1537     public void testMapVnfcCollectionInstanceGroup() {
1538         VnfResourceCustomization vnfResourceCust = Mockito.mock(VnfResourceCustomization.class);
1539         GenericVnf genericVnf = new GenericVnf();
1540         ModelInfo modelInfo = Mockito.mock(ModelInfo.class);
1541         Service service = Mockito.mock(Service.class);
1542         org.onap.so.db.catalog.beans.InstanceGroup instanceGroup = new org.onap.so.db.catalog.beans.InstanceGroup();
1543         instanceGroup.setModelUUID("modelUUID");
1544         List<VnfcInstanceGroupCustomization> vnfcInstanceGroups = new ArrayList<>();
1545         VnfcInstanceGroupCustomization vnfcInstanceGroupCust = new VnfcInstanceGroupCustomization();
1546         vnfcInstanceGroupCust.setInstanceGroup(instanceGroup);
1547         vnfcInstanceGroupCust.setFunction("function");
1548         vnfcInstanceGroupCust.setDescription("description");
1549         vnfcInstanceGroups.add(vnfcInstanceGroupCust);
1550
1551         ModelInfoInstanceGroup modelInfoInstanceGroup = new ModelInfoInstanceGroup();
1552         modelInfoInstanceGroup.setModelUUID("modelUUID");
1553         doReturn(vnfResourceCust).when(SPY_bbInputSetup).getVnfResourceCustomizationFromService(modelInfo, service);
1554         doReturn(vnfcInstanceGroups).when(vnfResourceCust).getVnfcInstanceGroupCustomizations();
1555         doReturn(instanceGroup).when(SPY_bbInputSetupUtils).getCatalogInstanceGroup("modelUUID");
1556         doReturn(modelInfoInstanceGroup).when(bbInputSetupMapperLayer).mapCatalogInstanceGroupToInstanceGroup(null,
1557                 instanceGroup);
1558
1559         SPY_bbInputSetup.mapVnfcCollectionInstanceGroup(genericVnf, modelInfo, service);
1560
1561         assertEquals("Instance Group was created", true, genericVnf.getInstanceGroups().size() == 1);
1562     }
1563
1564     @Test
1565     public void testPopulateGenericVnfWhereVnfTypeIsNull()
1566             throws JsonParseException, JsonMappingException, IOException {
1567         org.onap.so.serviceinstancebeans.Platform platform = new org.onap.so.serviceinstancebeans.Platform();
1568         org.onap.so.serviceinstancebeans.LineOfBusiness lineOfBusiness =
1569                 new org.onap.so.serviceinstancebeans.LineOfBusiness();
1570         String instanceName = "vnfName";
1571         ModelInfo modelInfo = new ModelInfo();
1572         modelInfo.setModelType(ModelType.vnf);
1573
1574         ServiceInstance serviceInstance = new ServiceInstance();
1575         GenericVnf vnf = new GenericVnf();
1576         vnf.setVnfId("genericVnfId");
1577         vnf.setVnfName("vnfName");
1578         serviceInstance.getVnfs().add(vnf);
1579         String vnfType = null;
1580         RequestDetails requestDetails =
1581                 mapper.readValue(new File(RESOURCE_PATH + "RequestDetails_CreateVnf.json"), RequestDetails.class);
1582
1583         Service service = mapper.readValue(
1584                 new File(RESOURCE_PATH + "CatalogDBService_getServiceInstanceNOAAIInput.json"), Service.class);
1585         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
1586         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "genericVnfId");
1587         String bbName = AssignFlows.VNF.toString();
1588
1589         Platform expectedPlatform = new Platform();
1590         LineOfBusiness expectedLineOfBusiness = new LineOfBusiness();
1591         String resourceId = "123";
1592         String applicationId = "applicationId";
1593         doReturn(expectedPlatform).when(bbInputSetupMapperLayer).mapRequestPlatform(platform);
1594         doReturn(expectedLineOfBusiness).when(bbInputSetupMapperLayer).mapRequestLineOfBusiness(lineOfBusiness);
1595         org.onap.aai.domain.yang.GenericVnf vnfAAI = new org.onap.aai.domain.yang.GenericVnf();
1596         vnfAAI.setModelCustomizationId("modelCustId");
1597         doReturn(vnfAAI).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
1598         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(vnf, modelInfo, service);
1599         org.onap.aai.domain.yang.InstanceGroup instanceGroupAAI = new org.onap.aai.domain.yang.InstanceGroup();
1600         doReturn(instanceGroupAAI).when(SPY_bbInputSetupUtils).getAAIInstanceGroup(any());
1601         org.onap.so.db.catalog.beans.InstanceGroup catalogInstanceGroup =
1602                 new org.onap.so.db.catalog.beans.InstanceGroup();
1603         doReturn(catalogInstanceGroup).when(SPY_bbInputSetupUtils).getCatalogInstanceGroup(any());
1604         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
1605                 .setModelInfo(modelInfo).setInstanceName(instanceName).setPlatform(platform)
1606                 .setLineOfBusiness(lineOfBusiness).setService(service).setBbName(bbName)
1607                 .setServiceInstance(serviceInstance).setLookupKeyMap(lookupKeyMap)
1608                 .setRelatedInstanceList(requestDetails.getRelatedInstanceList()).setResourceId(resourceId)
1609                 .setVnfType(vnfType).setProductFamilyId(requestDetails.getRequestInfo().getProductFamilyId()).build();
1610         SPY_bbInputSetup.populateGenericVnf(parameter);
1611
1612         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, null);
1613
1614         SPY_bbInputSetup.populateGenericVnf(parameter);
1615         verify(SPY_bbInputSetup, times(1)).mapCatalogVnf(vnf, modelInfo, service);
1616
1617         instanceName = "vnfName2";
1618         GenericVnf vnf2 = SPY_bbInputSetup.createGenericVnf(lookupKeyMap, instanceName, platform, lineOfBusiness,
1619                 resourceId, vnfType, null, requestDetails.getRequestInfo().getProductFamilyId(), applicationId);
1620
1621         org.onap.aai.domain.yang.GenericVnf vnf2AAI = new org.onap.aai.domain.yang.GenericVnf();
1622         vnfAAI.setModelCustomizationId("modelCustId2");
1623         doReturn(vnf2AAI).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf2.getVnfId());
1624         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(vnf2, modelInfo, service);
1625         doNothing().when(SPY_bbInputSetup).mapNetworkCollectionInstanceGroup(vnf2, "{instanceGroupId}");
1626         SPY_bbInputSetup.populateGenericVnf(parameter);
1627         verify(SPY_bbInputSetup, times(2)).mapCatalogVnf(vnf2, modelInfo, service);
1628         verify(SPY_bbInputSetup, times(2)).mapNetworkCollectionInstanceGroup(vnf2, "{instanceGroupId}");
1629         verify(SPY_bbInputSetup, times(1)).mapVnfcCollectionInstanceGroup(vnf2, modelInfo, service);
1630     }
1631
1632     @Test
1633     public void testMapCatalogVnf() {
1634         ModelInfoGenericVnf modelInfoGenericVnf = new ModelInfoGenericVnf();
1635         GenericVnf genericVnf = new GenericVnf();
1636         RequestDetails requestDetails = new RequestDetails();
1637         ModelInfo modelInfo = new ModelInfo();
1638         modelInfo.setModelCustomizationUuid("modelCustomizationUUID");
1639         requestDetails.setModelInfo(modelInfo);
1640         Service service = new Service();
1641         VnfResourceCustomization resourceCust = new VnfResourceCustomization();
1642         resourceCust.setModelCustomizationUUID("vnfModelCustomizationUUID");
1643         service.getVnfCustomizations().add(resourceCust);
1644         resourceCust.setModelCustomizationUUID("modelCustomizationUUID");
1645
1646         doReturn(modelInfoGenericVnf).when(bbInputSetupMapperLayer).mapCatalogVnfToVnf(resourceCust);
1647
1648         SPY_bbInputSetup.mapCatalogVnf(genericVnf, modelInfo, service);
1649
1650         assertEquals(modelInfoGenericVnf, genericVnf.getModelInfoGenericVnf());
1651     }
1652
1653     @Test
1654     public void testMapCatalogCollectionAndInstanceGroup() {
1655         ModelInfoCollection modelInfoCollection = new ModelInfoCollection();
1656         modelInfoCollection.setCollectionFunction("collectionFunction");
1657         modelInfoCollection.setCollectionRole("collectionRole");
1658         modelInfoCollection.setCollectionType("collectionType");
1659         modelInfoCollection.setDescription("description");
1660         modelInfoCollection.setModelInvariantUUID("modelInvariantUUID");
1661         modelInfoCollection.setQuantity(0);
1662
1663         ModelInfoInstanceGroup modelInfoInstanceGroup = new ModelInfoInstanceGroup();
1664         modelInfoInstanceGroup.setFunction("function");
1665         modelInfoInstanceGroup.setInstanceGroupRole("instanceGroupRole");
1666         modelInfoInstanceGroup.setModelInvariantUUID("modelInvariantUUID");
1667         modelInfoInstanceGroup.setModelUUID("modelUUID");
1668         modelInfoInstanceGroup.setType("VNFC");
1669         modelInfoInstanceGroup.setDescription("description");
1670
1671         InstanceGroup instanceGroup = new InstanceGroup();
1672         Collection collection = new Collection();
1673         collection.setInstanceGroup(instanceGroup);
1674
1675         CollectionResource collectionResource = new CollectionResource();
1676         org.onap.so.db.catalog.beans.InstanceGroup catalogInstanceGroup =
1677                 new org.onap.so.db.catalog.beans.InstanceGroup();
1678         collectionResource.setToscaNodeType("NetworkCollection");
1679         collectionResource.setInstanceGroup(catalogInstanceGroup);
1680
1681         CollectionResourceCustomization collectionCust = new NetworkCollectionResourceCustomization();
1682         collectionCust.setModelCustomizationUUID("modelCustomizationUUID");
1683         collectionCust.setCollectionResource(collectionResource);
1684
1685         Service service = new Service();
1686         service.getCollectionResourceCustomizations().add(collectionCust);
1687         ServiceInstance serviceInstance = new ServiceInstance();
1688         serviceInstance.setCollection(collection);
1689
1690         List<CollectionResourceInstanceGroupCustomization> instanceGroupCustList = new ArrayList<>();
1691         CollectionResourceInstanceGroupCustomization instanceGroupCust =
1692                 new CollectionResourceInstanceGroupCustomization();
1693         instanceGroupCust.setFunction("function");
1694         instanceGroupCust.setDescription("description");
1695
1696         doReturn(modelInfoCollection).when(bbInputSetupMapperLayer).mapCatalogCollectionToCollection(collectionCust,
1697                 collectionResource);
1698
1699         doReturn(modelInfoInstanceGroup).when(bbInputSetupMapperLayer)
1700                 .mapCatalogInstanceGroupToInstanceGroup(collectionCust, catalogInstanceGroup);
1701
1702         SPY_bbInputSetup.mapCatalogCollection(service, serviceInstance.getCollection(), "modelCustomizationUUID");
1703         SPY_bbInputSetup.mapCatalogNetworkCollectionInstanceGroup(service,
1704                 serviceInstance.getCollection().getInstanceGroup(), collectionCust.getModelCustomizationUUID());
1705
1706         assertThat(collection.getModelInfoCollection(), sameBeanAs(modelInfoCollection));
1707         assertThat(instanceGroup.getModelInfoInstanceGroup(), sameBeanAs(modelInfoInstanceGroup));
1708     }
1709
1710     @Test
1711     public void testAddRelationshipsToSI() throws Exception {
1712         ServiceInstance serviceInstance = new ServiceInstance();
1713         org.onap.aai.domain.yang.ServiceInstance serviceInstanceAAI = new org.onap.aai.domain.yang.ServiceInstance();
1714         serviceInstanceAAI.setServiceInstanceId("serviceInstanceId");
1715
1716         org.onap.aai.domain.yang.RelationshipList relationshipList = new org.onap.aai.domain.yang.RelationshipList();
1717         org.onap.aai.domain.yang.Relationship relationship = new org.onap.aai.domain.yang.Relationship();
1718         relationshipList.getRelationship().add(relationship);
1719         serviceInstanceAAI.setRelationshipList(relationshipList);
1720
1721         Map<String, String> uriKeys = new HashMap<>();
1722         uriKeys.put("global-customer-id", "globalCustomerId");
1723         uriKeys.put("service-type", "serviceType");
1724
1725
1726         doNothing().when(SPY_bbInputSetup).mapProject(any(), eq(serviceInstance));
1727         doNothing().when(SPY_bbInputSetup).mapOwningEntity(any(), eq(serviceInstance));
1728         doNothing().when(SPY_bbInputSetup).mapL3Networks(any(), eq(serviceInstance.getNetworks()));
1729         doNothing().when(SPY_bbInputSetup).mapGenericVnfs(any(), eq(serviceInstance.getVnfs()));
1730         doNothing().when(SPY_bbInputSetup).mapCollection(any(), eq(serviceInstance));
1731
1732         SPY_bbInputSetup.addRelationshipsToSI(serviceInstanceAAI, serviceInstance);
1733
1734         verify(SPY_bbInputSetup, times(1)).mapProject(any(), eq(serviceInstance));
1735         verify(SPY_bbInputSetup, times(1)).mapOwningEntity(any(), eq(serviceInstance));
1736         verify(SPY_bbInputSetup, times(1)).mapL3Networks(any(), eq(serviceInstance.getNetworks()));
1737         verify(SPY_bbInputSetup, times(1)).mapGenericVnfs(any(), eq(serviceInstance.getVnfs()));
1738         verify(SPY_bbInputSetup, times(1)).mapCollection(any(), eq(serviceInstance));
1739         verify(SPY_bbInputSetup, times(1)).mapConfigurations(any(), eq(serviceInstance.getConfigurations()));
1740     }
1741
1742     @Test
1743     public void testMapConfigurations() throws JsonProcessingException {
1744         org.onap.aai.domain.yang.Configuration expectedAAI = new org.onap.aai.domain.yang.Configuration();
1745         org.onap.aai.domain.yang.RelationshipList relationshipList = new org.onap.aai.domain.yang.RelationshipList();
1746         org.onap.aai.domain.yang.Relationship relationship = new org.onap.aai.domain.yang.Relationship();
1747         relationshipList.getRelationship().add(relationship);
1748         expectedAAI.setRelationshipList(relationshipList);
1749
1750         Configuration expected = new Configuration();
1751         AAIResourceUri aaiResourceUri = AAIUriFactory.createResourceUri(AAIObjectType.CONFIGURATION, "configurationId");
1752         AAIResultWrapper configurationWrapper =
1753                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1754
1755         doReturn(configurationWrapper).when(SPY_bbInputSetupUtils).getAAIResourceDepthOne(aaiResourceUri);
1756         doReturn(expected).when(bbInputSetupMapperLayer)
1757                 .mapAAIConfiguration(isA(org.onap.aai.domain.yang.Configuration.class));
1758
1759         List<Configuration> configurations = new ArrayList<>();
1760
1761         SPY_bbInputSetup.mapConfigurations(Arrays.asList(new AAIResourceUri[] {aaiResourceUri}), configurations);
1762
1763         assertEquals(expected, configurations.get(0));
1764     }
1765
1766     @Test
1767     public void testMapGenericVnfs() throws JsonProcessingException {
1768         org.onap.aai.domain.yang.GenericVnf expectedAAI = new org.onap.aai.domain.yang.GenericVnf();
1769         org.onap.aai.domain.yang.RelationshipList relationshipList = new org.onap.aai.domain.yang.RelationshipList();
1770         org.onap.aai.domain.yang.Relationship relationship = new org.onap.aai.domain.yang.Relationship();
1771         relationshipList.getRelationship().add(relationship);
1772         expectedAAI.setRelationshipList(relationshipList);
1773
1774         GenericVnf expected = new GenericVnf();
1775         AAIResourceUri aaiResourceUri = AAIUriFactory.createResourceUri(AAIObjectType.GENERIC_VNF, "vnfId");
1776         AAIResultWrapper vnfWrapper =
1777                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1778
1779         doReturn(vnfWrapper).when(SPY_bbInputSetupUtils).getAAIResourceDepthOne(aaiResourceUri);
1780         doReturn(expected).when(bbInputSetupMapperLayer)
1781                 .mapAAIGenericVnfIntoGenericVnf(isA(org.onap.aai.domain.yang.GenericVnf.class));
1782         doNothing().when(SPY_bbInputSetup).mapPlatform(any(), eq(expected));
1783         doNothing().when(SPY_bbInputSetup).mapLineOfBusiness(any(), eq(expected));
1784         doReturn(new ArrayList<>()).when(SPY_bbInputSetup).mapVolumeGroups(any());
1785
1786         List<GenericVnf> genericVnfs = new ArrayList<>();
1787
1788         SPY_bbInputSetup.mapGenericVnfs(Arrays.asList(new AAIResourceUri[] {aaiResourceUri}), genericVnfs);
1789
1790         assertEquals(expected, genericVnfs.get(0));
1791         verify(SPY_bbInputSetup, times(1)).mapPlatform(any(), eq(expected));
1792         verify(SPY_bbInputSetup, times(1)).mapLineOfBusiness(any(), eq(expected));
1793         verify(SPY_bbInputSetup, times(1)).mapVolumeGroups(any());
1794     }
1795
1796     @Test
1797     public void testMapVolumeGroups() throws JsonProcessingException {
1798         org.onap.aai.domain.yang.VolumeGroup expectedAAI = new org.onap.aai.domain.yang.VolumeGroup();
1799
1800         VolumeGroup expected = new VolumeGroup();
1801         AAIResultWrapper vnfWrapper =
1802                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1803
1804         doReturn(expected).when(bbInputSetupMapperLayer)
1805                 .mapAAIVolumeGroup(isA(org.onap.aai.domain.yang.VolumeGroup.class));
1806
1807         List<VolumeGroup> volumeGroupsList =
1808                 SPY_bbInputSetup.mapVolumeGroups(Arrays.asList(new AAIResultWrapper[] {vnfWrapper}));
1809
1810         assertEquals(expected, volumeGroupsList.get(0));
1811     }
1812
1813     @Test
1814     public void testMapLineOfBusiness() throws JsonProcessingException {
1815         org.onap.aai.domain.yang.LineOfBusiness expectedAAI = new org.onap.aai.domain.yang.LineOfBusiness();
1816
1817         LineOfBusiness expected = new LineOfBusiness();
1818         AAIResultWrapper vnfWrapper =
1819                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1820
1821         doReturn(expected).when(bbInputSetupMapperLayer)
1822                 .mapAAILineOfBusiness(isA(org.onap.aai.domain.yang.LineOfBusiness.class));
1823
1824         GenericVnf vnf = new GenericVnf();
1825
1826         SPY_bbInputSetup.mapLineOfBusiness(Arrays.asList(new AAIResultWrapper[] {vnfWrapper}), vnf);
1827
1828         assertEquals(expected, vnf.getLineOfBusiness());
1829     }
1830
1831     @Test
1832     public void testMapPlatform() throws JsonProcessingException {
1833         org.onap.aai.domain.yang.Platform expectedAAI = new org.onap.aai.domain.yang.Platform();
1834
1835         Platform expected = new Platform();
1836         AAIResultWrapper vnfWrapper =
1837                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1838
1839         doReturn(expected).when(bbInputSetupMapperLayer).mapAAIPlatform(isA(org.onap.aai.domain.yang.Platform.class));
1840
1841         GenericVnf vnf = new GenericVnf();
1842
1843         SPY_bbInputSetup.mapPlatform(Arrays.asList(new AAIResultWrapper[] {vnfWrapper}), vnf);
1844
1845         assertEquals(expected, vnf.getPlatform());
1846     }
1847
1848     @Test
1849     public void testMapCollection() throws JsonProcessingException {
1850         List<AAIResultWrapper> collections = new ArrayList<>();
1851         ServiceInstance serviceInstance = new ServiceInstance();
1852
1853         org.onap.aai.domain.yang.Collection aaiCollection = new org.onap.aai.domain.yang.Collection();
1854         org.onap.aai.domain.yang.RelationshipList collectionRelationshipList =
1855                 new org.onap.aai.domain.yang.RelationshipList();
1856         org.onap.aai.domain.yang.Relationship collectionInstanceGroupRelationship =
1857                 new org.onap.aai.domain.yang.Relationship();
1858         collectionRelationshipList.getRelationship().add(collectionInstanceGroupRelationship);
1859         aaiCollection.setRelationshipList(collectionRelationshipList);
1860
1861         collections.add(new AAIResultWrapper(
1862                 new AAICommonObjectMapperProvider().getMapper().writeValueAsString(aaiCollection)));
1863
1864         Collection collection = new Collection();
1865         ModelInfoCollection modelInfoCollection = new ModelInfoCollection();
1866         List<InstanceGroup> instanceGroupsList = new ArrayList<>();
1867         InstanceGroup instanceGroup = new InstanceGroup();
1868         instanceGroupsList.add(instanceGroup);
1869         NetworkCollectionResourceCustomization networkCollectionCust =
1870                 Mockito.mock(NetworkCollectionResourceCustomization.class);
1871         CollectionResource collectionResource = new CollectionResource();
1872         doReturn(collection).when(bbInputSetupMapperLayer)
1873                 .mapAAICollectionIntoCollection(isA(org.onap.aai.domain.yang.Collection.class));
1874         doReturn(instanceGroupsList).when(SPY_bbInputSetup).mapInstanceGroups(any());
1875         doReturn(networkCollectionCust).when(SPY_bbInputSetupUtils)
1876                 .getCatalogNetworkCollectionResourceCustByID(aaiCollection.getCollectionCustomizationId());
1877         doReturn(collectionResource).when(networkCollectionCust).getCollectionResource();
1878         doReturn(modelInfoCollection).when(bbInputSetupMapperLayer)
1879                 .mapCatalogCollectionToCollection(networkCollectionCust, collectionResource);
1880
1881         SPY_bbInputSetup.mapCollection(collections, serviceInstance);
1882
1883         assertEquals(collection, serviceInstance.getCollection());
1884         assertEquals(instanceGroup, collection.getInstanceGroup());
1885
1886         instanceGroupsList.clear();
1887         collection = new Collection();
1888
1889         SPY_bbInputSetup.mapCollection(collections, serviceInstance);
1890         assertEquals(collection, serviceInstance.getCollection());
1891         assertNull(collection.getInstanceGroup());
1892     }
1893
1894     @Test
1895     public void testMapL3Networks() throws JsonProcessingException {
1896         org.onap.aai.domain.yang.L3Network expectedAAI = new org.onap.aai.domain.yang.L3Network();
1897         org.onap.aai.domain.yang.RelationshipList relationshipList = new org.onap.aai.domain.yang.RelationshipList();
1898         org.onap.aai.domain.yang.Relationship relationship = new org.onap.aai.domain.yang.Relationship();
1899         relationshipList.getRelationship().add(relationship);
1900         expectedAAI.setRelationshipList(relationshipList);
1901
1902         L3Network expected = new L3Network();
1903         List<L3Network> l3Networks = new ArrayList<>();
1904         AAIResultWrapper l3NetworksWrapper =
1905                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1906         AAIResourceUri aaiResourceUri = AAIUriFactory.createResourceUri(AAIObjectType.L3_NETWORK, "networkId");
1907
1908         doReturn(l3NetworksWrapper).when(SPY_bbInputSetupUtils).getAAIResourceDepthTwo(aaiResourceUri);
1909         doReturn(expected).when(bbInputSetupMapperLayer).mapAAIL3Network(isA(org.onap.aai.domain.yang.L3Network.class));
1910         doNothing().when(SPY_bbInputSetup).mapNetworkPolicies(any(), eq(expected.getNetworkPolicies()));
1911         doNothing().when(SPY_bbInputSetup).mapRouteTableReferences(any(),
1912                 eq(expected.getContrailNetworkRouteTableReferences()));
1913
1914         SPY_bbInputSetup.mapL3Networks(Arrays.asList(new AAIResourceUri[] {aaiResourceUri}), l3Networks);
1915
1916         assertEquals(expected, l3Networks.get(0));
1917         verify(SPY_bbInputSetup, times(1)).mapNetworkPolicies(any(), eq(expected.getNetworkPolicies()));
1918         verify(SPY_bbInputSetup, times(1)).mapRouteTableReferences(any(),
1919                 eq(expected.getContrailNetworkRouteTableReferences()));
1920     }
1921
1922     @Test
1923     public void testMapRouteTableReferences() throws JsonProcessingException {
1924         org.onap.aai.domain.yang.RouteTableReference expectedAAI = new org.onap.aai.domain.yang.RouteTableReference();
1925
1926         RouteTableReference expected = new RouteTableReference();
1927         List<RouteTableReference> contrailNetworkRouteTableReferences = new ArrayList<>();
1928         AAIResultWrapper vnfWrapper =
1929                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1930
1931         doReturn(expected).when(bbInputSetupMapperLayer).mapAAIRouteTableReferenceIntoRouteTableReference(
1932                 isA(org.onap.aai.domain.yang.RouteTableReference.class));
1933
1934         SPY_bbInputSetup.mapRouteTableReferences(Arrays.asList(new AAIResultWrapper[] {vnfWrapper}),
1935                 contrailNetworkRouteTableReferences);
1936
1937         assertEquals(expected, contrailNetworkRouteTableReferences.get(0));
1938     }
1939
1940     @Test
1941     public void testMapOwningEntity() throws JsonProcessingException {
1942         org.onap.aai.domain.yang.OwningEntity expectedAAI = new org.onap.aai.domain.yang.OwningEntity();
1943
1944         OwningEntity expected = new OwningEntity();
1945         AAIResultWrapper vnfWrapper =
1946                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1947
1948         doReturn(expected).when(bbInputSetupMapperLayer)
1949                 .mapAAIOwningEntity(isA(org.onap.aai.domain.yang.OwningEntity.class));
1950
1951         ServiceInstance serviceInstance = new ServiceInstance();
1952
1953         SPY_bbInputSetup.mapOwningEntity(Arrays.asList(new AAIResultWrapper[] {vnfWrapper}), serviceInstance);
1954
1955         assertEquals(expected, serviceInstance.getOwningEntity());
1956     }
1957
1958     @Test
1959     public void testMapProject() throws JsonProcessingException {
1960         org.onap.aai.domain.yang.Project expectedAAI = new org.onap.aai.domain.yang.Project();
1961
1962         Project expected = new Project();
1963         AAIResultWrapper vnfWrapper =
1964                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
1965
1966         doReturn(expected).when(bbInputSetupMapperLayer).mapAAIProject(isA(org.onap.aai.domain.yang.Project.class));
1967
1968         ServiceInstance serviceInstance = new ServiceInstance();
1969
1970         SPY_bbInputSetup.mapProject(Arrays.asList(new AAIResultWrapper[] {vnfWrapper}), serviceInstance);
1971
1972         assertEquals(expected, serviceInstance.getProject());
1973     }
1974
1975     @Test
1976     public void testMapCustomer() throws Exception {
1977         org.onap.aai.domain.yang.Customer customerAAI = new org.onap.aai.domain.yang.Customer();
1978         org.onap.aai.domain.yang.ServiceSubscription serviceSubscriptionAAI =
1979                 new org.onap.aai.domain.yang.ServiceSubscription();
1980
1981         Customer expected = new Customer();
1982         ServiceSubscription serviceSubscription = new ServiceSubscription();
1983
1984         String globalCustomerId = "globalCustomerId";
1985         String subscriptionServiceType = "subscriptionServiceType";
1986
1987         doReturn(customerAAI).when(SPY_bbInputSetupUtils).getAAICustomer(globalCustomerId);
1988         doReturn(serviceSubscriptionAAI).when(SPY_bbInputSetupUtils).getAAIServiceSubscription(globalCustomerId,
1989                 subscriptionServiceType);
1990         doReturn(expected).when(bbInputSetupMapperLayer).mapAAICustomer(isA(org.onap.aai.domain.yang.Customer.class));
1991         doReturn(serviceSubscription).when(bbInputSetupMapperLayer)
1992                 .mapAAIServiceSubscription(isA(org.onap.aai.domain.yang.ServiceSubscription.class));
1993
1994         Customer actual = SPY_bbInputSetup.mapCustomer(globalCustomerId, subscriptionServiceType);
1995
1996         assertEquals(expected, actual);
1997         assertEquals(serviceSubscription, expected.getServiceSubscription());
1998     }
1999
2000     @Test
2001     public void testPopulateLookupKeyMapWithIds() {
2002         Map<ResourceKey, String> expected = new HashMap<>();
2003         Map<ResourceKey, String> actual = new HashMap<>();
2004         String serviceInstanceId = "serviceInstanceId";
2005         String networkId = "networkId";
2006         String vnfId = "vnfId";
2007         String pnfId = "pnfId";
2008         String vfModuleId = "vfModuleId";
2009         String volumeGroupId = "volumeGroupId";
2010         String configurationId = "configurationId";
2011         String instanceGroupId = "instancegroupId";
2012
2013         expected.put(ResourceKey.SERVICE_INSTANCE_ID, serviceInstanceId);
2014         expected.put(ResourceKey.NETWORK_ID, networkId);
2015         expected.put(ResourceKey.GENERIC_VNF_ID, vnfId);
2016         expected.put(ResourceKey.PNF, pnfId);
2017         expected.put(ResourceKey.VF_MODULE_ID, vfModuleId);
2018         expected.put(ResourceKey.VOLUME_GROUP_ID, volumeGroupId);
2019         expected.put(ResourceKey.CONFIGURATION_ID, configurationId);
2020         expected.put(ResourceKey.INSTANCE_GROUP_ID, instanceGroupId);
2021
2022         WorkflowResourceIds workflowResourceIds = new WorkflowResourceIds();
2023         workflowResourceIds.setServiceInstanceId(serviceInstanceId);
2024         workflowResourceIds.setNetworkId(networkId);
2025         workflowResourceIds.setVnfId(vnfId);
2026         workflowResourceIds.setPnfId(pnfId);
2027         workflowResourceIds.setVfModuleId(vfModuleId);
2028         workflowResourceIds.setVolumeGroupId(volumeGroupId);
2029         workflowResourceIds.setConfigurationId(configurationId);
2030         workflowResourceIds.setInstanceGroupId(instanceGroupId);
2031
2032         SPY_bbInputSetup.populateLookupKeyMapWithIds(workflowResourceIds, actual);
2033
2034         assertThat(actual, sameBeanAs(expected));
2035     }
2036
2037     @Test
2038     public void testGBBMacroNoUserParamsVrfConfiguration() throws Exception {
2039         String resourceId = "123";
2040         String vnfType = "vnfType";
2041         String requestAction = "createInstance";
2042         Service service = Mockito.mock(Service.class);
2043         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2044                 GeneralBuildingBlock.class);
2045         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2046                 ExecuteBuildingBlock.class);
2047         RequestDetails requestDetails = mapper
2048                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacroVrf.json"), RequestDetails.class);
2049         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2050
2051         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2052         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2053         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2054         buildingBlock.setBpmnFlowName("AssignVrfConfigurationBB");
2055         buildingBlock.setKey("72d9d1cd-f46d-447a-abdb-451d6fb05fa9");
2056
2057         doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
2058                 requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2059         doReturn(service).when(SPY_bbInputSetupUtils)
2060                 .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
2061
2062         RelatedInstance relatedVpnBinding = new RelatedInstance();
2063         relatedVpnBinding.setInstanceId("vpnBindingInstanceId");
2064         RelatedInstance relatedLocalNetwork = new RelatedInstance();
2065         relatedLocalNetwork.setInstanceId("localNetworkInstanceId");
2066         org.onap.aai.domain.yang.VpnBinding aaiVpnBinding = new org.onap.aai.domain.yang.VpnBinding();
2067         aaiVpnBinding.setVpnId("vpnBindingId");
2068         org.onap.aai.domain.yang.L3Network aaiLocalNetwork = new org.onap.aai.domain.yang.L3Network();
2069         aaiLocalNetwork.setNetworkId("localNetworkId");
2070         Optional<org.onap.aai.domain.yang.VpnBinding> aaiAICVpnBindingOp =
2071                 Optional.of(new org.onap.aai.domain.yang.VpnBinding());
2072         aaiAICVpnBindingOp.get().setVpnId("AICVpnBindingId");
2073         ServiceProxy proxy = new ServiceProxy();
2074         proxy.setType("transport");
2075         proxy.setServiceInstance(new ServiceInstance());
2076         proxy.getServiceInstance().setModelInfoServiceInstance(new ModelInfoServiceInstance());
2077         proxy.getServiceInstance().getModelInfoServiceInstance().setModelUuid("sourceServiceModelUUID");
2078         doReturn(relatedVpnBinding).when(SPY_bbInputSetupUtils).getRelatedInstanceByType(requestDetails,
2079                 ModelType.vpnBinding);
2080         doReturn(relatedLocalNetwork).when(SPY_bbInputSetupUtils).getRelatedInstanceByType(requestDetails,
2081                 ModelType.network);
2082         doReturn(aaiVpnBinding).when(SPY_bbInputSetupUtils).getAAIVpnBinding(relatedVpnBinding.getInstanceId());
2083         doReturn(aaiLocalNetwork).when(SPY_bbInputSetupUtils).getAAIL3Network(relatedLocalNetwork.getInstanceId());
2084         doReturn(aaiAICVpnBindingOp).when(SPY_bbInputSetupUtils).getAICVpnBindingFromNetwork(aaiLocalNetwork);
2085         doReturn(proxy).when(SPY_bbInputSetup).getServiceProxy(service);
2086
2087         Configuration configuration = new Configuration();
2088         configuration.setConfigurationId("configurationId");
2089         gBB.getServiceInstance().getConfigurations().add(configuration);
2090         List<ConfigurationResourceCustomization> configurationCustList = new ArrayList<>();
2091         ConfigurationResourceCustomization configurationCust = new ConfigurationResourceCustomization();
2092         configurationCust.setModelCustomizationUUID("72d9d1cd-f46d-447a-abdb-451d6fb05fa9");
2093         configurationCustList.add(configurationCust);
2094         doNothing().when(SPY_bbInputSetup).populateConfiguration(any(BBInputSetupParameter.class));
2095
2096         gBB = SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
2097         verify(SPY_bbInputSetup, times(1)).populateConfiguration(any(BBInputSetupParameter.class));
2098         assertEquals(gBB.getCustomer().getVpnBindings().get(0).getVpnId(), "vpnBindingId");
2099         assertEquals(gBB.getServiceInstance().getNetworks().get(0).getNetworkId(), "localNetworkId");
2100         assertEquals(gBB.getServiceInstance().getNetworks().get(0).getVpnBindings().get(0).getVpnId(),
2101                 "AICVpnBindingId");
2102         assertEquals(gBB.getServiceInstance().getServiceProxies().get(0).getType(), "transport");
2103     }
2104
2105     @Test
2106     public void testGetServiceProxy() {
2107         ServiceProxy expected = new ServiceProxy();
2108         expected.setType("TRANSPORT");
2109         expected.setModelInfoServiceProxy(new ModelInfoServiceProxy());
2110         expected.getModelInfoServiceProxy().setModelUuid("modelUUID");
2111         expected.getModelInfoServiceProxy().setModelInstanceName("modelInstanceName");
2112         expected.setServiceInstance(new ServiceInstance());
2113         expected.getServiceInstance().setModelInfoServiceInstance(new ModelInfoServiceInstance());
2114         expected.getServiceInstance().getModelInfoServiceInstance().setModelUuid("modelUUID");
2115         expected.getServiceInstance().getModelInfoServiceInstance().setServiceType("TRANSPORT");
2116         Service service = new Service();
2117         ServiceProxyResourceCustomization serviceProxyCatalog = new ServiceProxyResourceCustomization();
2118         serviceProxyCatalog.setModelCustomizationUUID("modelCustomizationUUID");
2119         serviceProxyCatalog.setModelInstanceName("modelInstanceName");
2120         Service sourceService = new Service();
2121         sourceService.setModelUUID("modelUUID");
2122         sourceService.setServiceType("TRANSPORT");
2123         serviceProxyCatalog.setSourceService(sourceService);
2124         service.setServiceProxyCustomizations(new ArrayList<ServiceProxyResourceCustomization>());
2125         service.getServiceProxyCustomizations().add(serviceProxyCatalog);
2126         ServiceProxy actual = SPY_bbInputSetup.getServiceProxy(service);
2127         assertThat(actual, sameBeanAs(expected));
2128     }
2129
2130     @Test
2131     public void testgetGBBMacroCloudConfiguration() throws Exception {
2132         org.onap.so.serviceinstancebeans.Service serviceMacro = mapper.readValue(
2133                 new File(RESOURCE_PATH + "ServiceMacroVfModules.json"), org.onap.so.serviceinstancebeans.Service.class);
2134         CloudConfiguration cloudConfig = null;
2135         org.onap.aai.domain.yang.CloudRegion aaiCloudRegion = new org.onap.aai.domain.yang.CloudRegion();
2136         aaiCloudRegion.setCloudOwner("test-owner-name");
2137         Resources resources = serviceMacro.getResources();
2138         doReturn(aaiCloudRegion).when(SPY_bbInputSetupUtils).getCloudRegion(any(CloudConfiguration.class));
2139         CloudRegion expected = new CloudRegion();
2140         expected.setLcpCloudRegionId("mdt1");
2141         expected.setCloudOwner("test-owner-name");
2142         expected.setTenantId("88a6ca3ee0394ade9403f075db23167e");
2143
2144         CloudRegion actual = SPY_bbInputSetup.getCloudRegionFromMacroRequest(cloudConfig, resources);
2145         assertThat(actual, sameBeanAs(expected));
2146
2147         serviceMacro = mapper.readValue(new File(RESOURCE_PATH + "ServiceMacroVnfs.json"),
2148                 org.onap.so.serviceinstancebeans.Service.class);
2149         resources = serviceMacro.getResources();
2150
2151         actual = SPY_bbInputSetup.getCloudRegionFromMacroRequest(cloudConfig, resources);
2152         assertThat(actual, sameBeanAs(expected));
2153
2154         serviceMacro = mapper.readValue(new File(RESOURCE_PATH + "ServiceMacroNetworks.json"),
2155                 org.onap.so.serviceinstancebeans.Service.class);
2156         resources = serviceMacro.getResources();
2157
2158         actual = SPY_bbInputSetup.getCloudRegionFromMacroRequest(cloudConfig, resources);
2159         assertThat(actual, sameBeanAs(expected));
2160
2161         serviceMacro = mapper.readValue(new File(RESOURCE_PATH + "ServiceMacroNoCloudConfig.json"),
2162                 org.onap.so.serviceinstancebeans.Service.class);
2163         resources = serviceMacro.getResources();
2164
2165         actual = SPY_bbInputSetup.getCloudRegionFromMacroRequest(cloudConfig, resources);
2166         assertNull(actual);
2167     }
2168
2169     @Test
2170     public void testgetGBBMacroWithEmptyUserParams() throws Exception {
2171         String resourceId = "123";
2172         String vnfType = "vnfType";
2173         String requestAction = "createInstance";
2174         Service service = Mockito.mock(Service.class);
2175         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2176                 GeneralBuildingBlock.class);
2177         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2178                 ExecuteBuildingBlock.class);
2179         RequestDetails requestDetails = mapper
2180                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2181         requestDetails.getRequestParameters().getUserParams().clear();
2182         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2183         aaiVnf.setModelCustomizationId("modelCustId");
2184         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2185         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2186         buildingBlock.setBpmnFlowName(AssignFlows.NETWORK_MACRO.toString())
2187                 .setKey("ab153b6e-c364-44c0-bef6-1f2982117f04").setIsVirtualLink(false);
2188
2189         doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
2190                 requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2191         doReturn(service).when(SPY_bbInputSetupUtils)
2192                 .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
2193
2194         SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
2195         verify(SPY_bbInputSetup, times(1)).getGBBMacroNoUserParamsCreate(any(ExecuteBuildingBlock.class), any(),
2196                 any(String.class), any(String.class), any(GeneralBuildingBlock.class), any(Service.class));
2197     }
2198
2199     @Test(expected = Exception.class)
2200     public void testgetGBBMacroException() throws Exception {
2201         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2202                 ExecuteBuildingBlock.class);
2203         RequestDetails requestDetails = mapper
2204                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2205         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2206         String resourceId = "123";
2207         String vnfType = "vnfType";
2208         String requestAction = "createInstance";
2209
2210         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2211         buildingBlock.setBpmnFlowName("Network").setKey("ab153b6e-c364-44c0-bef6-1f2982117f04");
2212
2213         SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
2214     }
2215
2216     @Test
2217     public void test_getGBBMacroForVnfTypeNull_populateL3Network_shouldBeCalled() throws Exception {
2218         // given
2219         String resourceId = "123";
2220         String vnfType = "null";
2221         String requestAction = "createInstance";
2222         Service service = Mockito.mock(Service.class);
2223         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2224                 GeneralBuildingBlock.class);
2225         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2226
2227         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2228         RequestDetails requestDetails = mapper
2229                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2230         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2231                 ExecuteBuildingBlock.class);
2232         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2233         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2234         buildingBlock.setBpmnFlowName(AssignFlows.NETWORK_MACRO.toString())
2235                 .setKey("ab153b6e-c364-44c0-bef6-1f2982117f04");
2236
2237         doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
2238                 requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2239         doReturn(service).when(SPY_bbInputSetupUtils)
2240                 .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
2241         // when
2242         SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
2243         // then
2244         verify(SPY_bbInputSetup, times(1)).populateL3Network(any(BBInputSetupParameter.class));
2245     }
2246
2247     @Test
2248     public void testgetGBBMacroNoUserParamsDeactivateInstnace() throws Exception {
2249         String resourceId = "123";
2250         String vnfType = "vnfType";
2251         String requestAction = "deactivateInstance";
2252         Service service = Mockito.mock(Service.class);
2253         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2254                 GeneralBuildingBlock.class);
2255         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2256                 ExecuteBuildingBlock.class);
2257         RequestDetails requestDetails = mapper
2258                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2259         requestDetails.getRequestParameters().setUserParams(null);
2260         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2261         aaiVnf.setModelCustomizationId("modelCustId");
2262         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2263         lookupKeyMap.put(ResourceKey.NETWORK_ID, "networkId");
2264         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "vnfId");
2265         lookupKeyMap.put(ResourceKey.VF_MODULE_ID, "vfModuleId");
2266         lookupKeyMap.put(ResourceKey.VOLUME_GROUP_ID, "volumeGroupId");
2267         lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "serviceInstanceId");
2268         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2269         buildingBlock.setBpmnFlowName("DeactivateServiceInstanceBB").setKey("3c40d244-808e-42ca-b09a-256d83d19d0a");
2270
2271         doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
2272                 requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2273         doReturn(service).when(SPY_bbInputSetupUtils)
2274                 .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
2275
2276         GeneralBuildingBlock actual = SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap,
2277                 requestAction, resourceId, vnfType);
2278         assertThat(actual, sameBeanAs(gBB));
2279     }
2280
2281     @Test
2282     public void test_getGBBMacroNoUserParamsCreate_shouldBeCalled() throws Exception {
2283         // given
2284         String resourceId = "123";
2285         String vnfType = "vnfType";
2286         String requestAction = "createInstance";
2287         Service service = Mockito.mock(Service.class);
2288         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2289                 GeneralBuildingBlock.class);
2290         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2291         List<NetworkResourceCustomization> networkCustList = new ArrayList<>();
2292         NetworkResourceCustomization networkCust = Mockito.mock(NetworkResourceCustomization.class);
2293         networkCustList.add(networkCust);
2294
2295         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2296         RequestDetails requestDetails = mapper
2297                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2298         requestDetails.getRequestParameters().setUserParams(null);
2299         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2300                 ExecuteBuildingBlock.class);
2301         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2302         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2303         buildingBlock.setBpmnFlowName(AssignFlows.NETWORK_MACRO.toString())
2304                 .setKey("ab153b6e-c364-44c0-bef6-1f2982117f04").setIsVirtualLink(false);
2305
2306         doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
2307                 requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2308         doReturn(service).when(SPY_bbInputSetupUtils)
2309                 .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
2310         doReturn(networkCustList).when(service).getNetworkCustomizations();
2311         doReturn("ab153b6e-c364-44c0-bef6-1f2982117f04").when(networkCust).getModelCustomizationUUID();
2312         doNothing().when(SPY_bbInputSetup).populateL3Network(any(BBInputSetupParameter.class));
2313         // when
2314         SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
2315         // then
2316         verify(SPY_bbInputSetup, times(1)).getGBBMacroNoUserParamsCreate(executeBB, lookupKeyMap,
2317                 executeBB.getBuildingBlock().getBpmnFlowName(), "ab153b6e-c364-44c0-bef6-1f2982117f04", gBB, service);
2318     }
2319
2320     @Test
2321     public void test_getGBBMacroNoUserParamsCreate_shouldBeCalled_whenBBhasVirtualLink() throws Exception {
2322         // given
2323         String resourceId = "123";
2324         String vnfType = "vnfType";
2325         String requestAction = "createInstance";
2326         Service service = Mockito.mock(Service.class);
2327         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2328                 GeneralBuildingBlock.class);
2329         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2330         List<NetworkResourceCustomization> networkCustList = new ArrayList<>();
2331         NetworkResourceCustomization networkCust = Mockito.mock(NetworkResourceCustomization.class);
2332         networkCustList.add(networkCust);
2333         CollectionNetworkResourceCustomization collectionNetworkResourceCust =
2334                 Mockito.mock(CollectionNetworkResourceCustomization.class);
2335         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2336         aaiVnf.setModelCustomizationId("modelCustId");
2337         ModelInfoNetwork modelInfoNetwork = Mockito.mock(ModelInfoNetwork.class);
2338         NetworkResourceCustomization networkResourceCustomization = Mockito.mock(NetworkResourceCustomization.class);
2339
2340         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2341         RequestDetails requestDetails = mapper
2342                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2343         requestDetails.getRequestParameters().setUserParams(null);
2344         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2345                 ExecuteBuildingBlock.class);
2346         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2347         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2348         buildingBlock.setBpmnFlowName(AssignFlows.NETWORK_MACRO.toString())
2349                 .setKey("ab153b6e-c364-44c0-bef6-1f2982117f04").setIsVirtualLink(true);
2350
2351         doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
2352                 requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2353         doReturn(service).when(SPY_bbInputSetupUtils)
2354                 .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
2355         doReturn(collectionNetworkResourceCust).when(SPY_bbInputSetupUtils)
2356                 .getCatalogCollectionNetworkResourceCustByID(any(String.class));
2357         doReturn(networkResourceCustomization).when(bbInputSetupMapperLayer)
2358                 .mapCollectionNetworkResourceCustToNetworkResourceCust(collectionNetworkResourceCust);
2359         doReturn(modelInfoNetwork).when(bbInputSetupMapperLayer)
2360                 .mapCatalogNetworkToNetwork(networkResourceCustomization);
2361         // when
2362         SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
2363         // then
2364         verify(SPY_bbInputSetup, times(1)).getGBBMacroNoUserParamsCreate(executeBB, lookupKeyMap,
2365                 executeBB.getBuildingBlock().getBpmnFlowName(), "ab153b6e-c364-44c0-bef6-1f2982117f04", gBB, service);
2366     }
2367
2368     @Test
2369     public void test_getGBBMacroNoUserParamsCreate_shouldBeCalled_whenBBhasVirtualLinkAndOtherFlowName()
2370             throws Exception {
2371         // given
2372         String otherFlowName = "CreateNetworkBB";
2373         String resourceId = "123";
2374         String vnfType = "vnfType";
2375         String requestAction = "createInstance";
2376         Service service = Mockito.mock(Service.class);
2377         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2378                 GeneralBuildingBlock.class);
2379         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2380         List<NetworkResourceCustomization> networkCustList = new ArrayList<>();
2381         NetworkResourceCustomization networkCust = Mockito.mock(NetworkResourceCustomization.class);
2382         networkCustList.add(networkCust);
2383         CollectionNetworkResourceCustomization collectionNetworkResourceCust =
2384                 Mockito.mock(CollectionNetworkResourceCustomization.class);
2385
2386         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2387         RequestDetails requestDetails = mapper
2388                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2389         requestDetails.getRequestParameters().setUserParams(null);
2390         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2391                 ExecuteBuildingBlock.class);
2392         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2393         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2394         buildingBlock.setBpmnFlowName(otherFlowName).setKey("ab153b6e-c364-44c0-bef6-1f2982117f04")
2395                 .setIsVirtualLink(true);
2396
2397         doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
2398                 requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2399         doReturn(service).when(SPY_bbInputSetupUtils)
2400                 .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
2401         doReturn(collectionNetworkResourceCust).when(SPY_bbInputSetupUtils)
2402                 .getCatalogCollectionNetworkResourceCustByID(any(String.class));
2403         // when
2404         SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
2405         // then
2406         verify(SPY_bbInputSetup, times(1)).getGBBMacroNoUserParamsCreate(executeBB, lookupKeyMap,
2407                 executeBB.getBuildingBlock().getBpmnFlowName(), "ab153b6e-c364-44c0-bef6-1f2982117f04", gBB, service);
2408     }
2409
2410     @Test(expected = IllegalArgumentException.class)
2411     public void testgetGBBMacroNoUserParamsOtherException() throws Exception {
2412         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2413                 GeneralBuildingBlock.class);
2414         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2415                 ExecuteBuildingBlock.class);
2416         RequestDetails requestDetails = mapper
2417                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2418         requestDetails.getRequestParameters().setUserParams(null);
2419         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2420         aaiVnf.setModelCustomizationId("modelCustId");
2421         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2422         lookupKeyMap.put(ResourceKey.NETWORK_ID, "networkId");
2423         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "vnfId");
2424         lookupKeyMap.put(ResourceKey.VF_MODULE_ID, "vfModuleId");
2425         lookupKeyMap.put(ResourceKey.VOLUME_GROUP_ID, "volumeGroupId");
2426         lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "serviceInstanceId");
2427         String resourceId = "123";
2428         String vnfType = "vnfType";
2429         Service service = Mockito.mock(Service.class);
2430         String requestAction = "assignInstance";
2431         doReturn(gBB).when(SPY_bbInputSetup).getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
2432                 requestAction, lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2433         doReturn(service).when(SPY_bbInputSetupUtils)
2434                 .getCatalogServiceByModelUUID(gBB.getServiceInstance().getModelInfoServiceInstance().getModelUuid());
2435         String generatedId = "12131";
2436
2437         SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId, vnfType);
2438     }
2439
2440     @Test
2441     public void test_getGBBMacroNoUserParamsExistingService_forCatalogNetwork() throws Exception {
2442         // given
2443         String requestAction = "unassignInstance";
2444         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2445                 GeneralBuildingBlock.class);
2446         L3Network network = new L3Network();
2447         network.setNetworkId("networkId");
2448         gBB.getServiceInstance().getNetworks().add(network);
2449         ServiceInstance serviceInstance = gBB.getServiceInstance();
2450         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2451                 ExecuteBuildingBlock.class);
2452         RequestDetails requestDetails = mapper
2453                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2454         requestDetails.getRequestParameters().setUserParams(null);
2455         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2456         Service service = Mockito.mock(Service.class);
2457         CloudConfiguration cloudConfiguration = new CloudConfiguration();
2458         cloudConfiguration.setLcpCloudRegionId("cloudRegionId");
2459         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
2460         org.onap.aai.domain.yang.L3Network aaiNetwork = new org.onap.aai.domain.yang.L3Network();
2461         aaiNetwork.setModelCustomizationId("modelCustId");
2462
2463         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2464         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2465         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2466         buildingBlock.setBpmnFlowName("DeleteNetworkBB").setKey("ab153b6e-c364-44c0-bef6-1f2982117f04");
2467
2468         aaiServiceInstance.setModelVersionId("modelVersionId");
2469         doReturn(service).when(SPY_bbInputSetupUtils)
2470                 .getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
2471         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils)
2472                 .getAAIServiceInstanceById(lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2473         doReturn(serviceInstance).when(SPY_bbInputSetup).getExistingServiceInstance(aaiServiceInstance);
2474         doReturn(gBB).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
2475         doReturn(aaiNetwork).when(SPY_bbInputSetupUtils).getAAIL3Network(network.getNetworkId());
2476         doNothing().when(SPY_bbInputSetup).mapCatalogNetwork(any(L3Network.class), any(ModelInfo.class),
2477                 any(Service.class));
2478         // when
2479         SPY_bbInputSetup.getGBBMacroExistingService(executeBB, lookupKeyMap,
2480                 executeBB.getBuildingBlock().getBpmnFlowName(), requestAction, null);
2481         // then
2482         verify(SPY_bbInputSetup, times(1)).mapCatalogNetwork(any(L3Network.class), any(ModelInfo.class),
2483                 any(Service.class));
2484     }
2485
2486     @Test
2487     public void test_getGBBMacroNoUserParamsExistingService_forActivateVnfBB() throws Exception {
2488         // given
2489         String requestAction = "unassignInstance";
2490         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2491                 GeneralBuildingBlock.class);
2492         L3Network network = new L3Network();
2493         network.setNetworkId("networkId");
2494         gBB.getServiceInstance().getNetworks().add(network);
2495         ServiceInstance serviceInstance = gBB.getServiceInstance();
2496         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2497                 ExecuteBuildingBlock.class);
2498         RequestDetails requestDetails = mapper
2499                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2500         requestDetails.getRequestParameters().setUserParams(null);
2501         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2502         Service service = Mockito.mock(Service.class);
2503         CloudConfiguration cloudConfiguration = new CloudConfiguration();
2504         cloudConfiguration.setLcpCloudRegionId("cloudRegionId");
2505         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
2506         org.onap.aai.domain.yang.L3Network aaiNetwork = new org.onap.aai.domain.yang.L3Network();
2507         aaiNetwork.setModelCustomizationId("modelCustId");
2508         GenericVnf vnf = new GenericVnf();
2509         vnf.setVnfId("vnfId");
2510         gBB.getServiceInstance().getVnfs().add(vnf);
2511         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2512         aaiVnf.setModelCustomizationId("modelCustId");
2513
2514         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2515         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2516         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2517         buildingBlock.setBpmnFlowName("ActivateVnfBB").setKey("ab153b6e-c364-44c0-bef6-1f2982117f04");
2518
2519         aaiServiceInstance.setModelVersionId("modelVersionId");
2520         doReturn(service).when(SPY_bbInputSetupUtils)
2521                 .getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
2522         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils)
2523                 .getAAIServiceInstanceById(lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2524         doReturn(serviceInstance).when(SPY_bbInputSetup).getExistingServiceInstance(aaiServiceInstance);
2525         doReturn(gBB).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
2526         doReturn(aaiVnf).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
2527         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(any(GenericVnf.class), any(ModelInfo.class),
2528                 any(Service.class));
2529         // when
2530         SPY_bbInputSetup.getGBBMacroExistingService(executeBB, lookupKeyMap,
2531                 executeBB.getBuildingBlock().getBpmnFlowName(), requestAction, cloudConfiguration);
2532         // then
2533         verify(SPY_bbInputSetup, times(1)).mapCatalogVnf(any(GenericVnf.class), any(ModelInfo.class),
2534                 any(Service.class));
2535     }
2536
2537     @Test
2538     public void test_getGBBMacroNoUserParamsExistingService_forUnassignVfModuleBB() throws Exception {
2539         // given
2540         String requestAction = "unassignInstance";
2541         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2542                 GeneralBuildingBlock.class);
2543         L3Network network = new L3Network();
2544         network.setNetworkId("networkId");
2545         gBB.getServiceInstance().getNetworks().add(network);
2546         ServiceInstance serviceInstance = gBB.getServiceInstance();
2547         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2548                 ExecuteBuildingBlock.class);
2549         RequestDetails requestDetails = mapper
2550                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2551         requestDetails.getRequestParameters().setUserParams(null);
2552         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2553         Service service = Mockito.mock(Service.class);
2554         CloudConfiguration cloudConfiguration = new CloudConfiguration();
2555         cloudConfiguration.setLcpCloudRegionId("cloudRegionId");
2556         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
2557         org.onap.aai.domain.yang.L3Network aaiNetwork = new org.onap.aai.domain.yang.L3Network();
2558         aaiNetwork.setModelCustomizationId("modelCustId");
2559         GenericVnf vnf = new GenericVnf();
2560         vnf.setVnfId("vnfId");
2561         gBB.getServiceInstance().getVnfs().add(vnf);
2562         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2563         aaiVnf.setModelCustomizationId("modelCustId");
2564         VfModule vfModule = new VfModule();
2565         vfModule.setVfModuleId("vfModuleId");
2566         gBB.getServiceInstance().getVnfs().get(0).getVfModules().add(vfModule);
2567         org.onap.aai.domain.yang.VfModule aaiVfModule = new org.onap.aai.domain.yang.VfModule();
2568         aaiVfModule.setModelCustomizationId("modelCustId");
2569
2570         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2571         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2572         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2573         buildingBlock.setBpmnFlowName("UnassignVfModuleBB").setKey("a25e8e8c-58b8-4eec-810c-97dcc1f5cb7f");
2574
2575         aaiServiceInstance.setModelVersionId("modelVersionId");
2576         doReturn(service).when(SPY_bbInputSetupUtils)
2577                 .getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
2578         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils)
2579                 .getAAIServiceInstanceById(lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2580         doReturn(serviceInstance).when(SPY_bbInputSetup).getExistingServiceInstance(aaiServiceInstance);
2581         doReturn(gBB).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
2582         doReturn(aaiVnf).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
2583         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(any(GenericVnf.class), any(ModelInfo.class),
2584                 any(Service.class));
2585         doReturn(aaiVfModule).when(SPY_bbInputSetupUtils).getAAIVfModule(vnf.getVnfId(), vfModule.getVfModuleId());
2586         // when
2587         SPY_bbInputSetup.getGBBMacroExistingService(executeBB, lookupKeyMap,
2588                 executeBB.getBuildingBlock().getBpmnFlowName(), requestAction, cloudConfiguration);
2589         // then
2590         verify(SPY_bbInputSetup, times(1)).mapCatalogVnf(any(GenericVnf.class), any(ModelInfo.class),
2591                 any(Service.class));
2592         verify(SPY_bbInputSetup, times(1)).mapCatalogVfModule(any(VfModule.class), any(ModelInfo.class),
2593                 any(Service.class), any(String.class));
2594     }
2595
2596     @Test
2597     public void test_getGBBMacroNoUserParamsExistingService_forUnassignVolumeGroupBB() throws Exception {
2598         // given
2599         String requestAction = "unassignInstance";
2600         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2601                 GeneralBuildingBlock.class);
2602         L3Network network = new L3Network();
2603         network.setNetworkId("networkId");
2604         gBB.getServiceInstance().getNetworks().add(network);
2605         ServiceInstance serviceInstance = gBB.getServiceInstance();
2606         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2607                 ExecuteBuildingBlock.class);
2608         RequestDetails requestDetails = mapper
2609                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2610         requestDetails.getRequestParameters().setUserParams(null);
2611         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2612         Service service = Mockito.mock(Service.class);
2613         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
2614         GenericVnf vnf = new GenericVnf();
2615         vnf.setVnfId("vnfId");
2616         gBB.getServiceInstance().getVnfs().add(vnf);
2617         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2618         aaiVnf.setModelCustomizationId("modelCustId");
2619         VfModule vfModule = new VfModule();
2620         vfModule.setVfModuleId("vfModuleId");
2621         gBB.getServiceInstance().getVnfs().get(0).getVfModules().add(vfModule);
2622         CloudRegion cloudRegion = new CloudRegion();
2623         cloudRegion.setLcpCloudRegionId("cloudRegionId");
2624         cloudRegion.setCloudOwner("CloudOwner");
2625         VolumeGroup volumeGroup = new VolumeGroup();
2626         volumeGroup.setVolumeGroupId("volumeGroupId");
2627         gBB.getServiceInstance().getVnfs().get(0).getVolumeGroups().add(volumeGroup);
2628         org.onap.aai.domain.yang.VolumeGroup aaiVolumeGroup = new org.onap.aai.domain.yang.VolumeGroup();
2629         aaiVolumeGroup.setModelCustomizationId("modelCustId");
2630
2631         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2632         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2633         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2634         buildingBlock.setBpmnFlowName("UnassignVolumeGroupBB").setKey("72d9d1cd-f46d-447a-abdb-451d6fb05fa8");
2635
2636         aaiServiceInstance.setModelVersionId("modelVersionId");
2637         doReturn(service).when(SPY_bbInputSetupUtils)
2638                 .getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
2639         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils)
2640                 .getAAIServiceInstanceById(lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2641         doReturn(serviceInstance).when(SPY_bbInputSetup).getExistingServiceInstance(aaiServiceInstance);
2642         doReturn(gBB).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
2643         doReturn(aaiVnf).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
2644         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(any(GenericVnf.class), any(ModelInfo.class),
2645                 any(Service.class));
2646         doReturn(aaiVolumeGroup).when(SPY_bbInputSetupUtils).getAAIVolumeGroup(cloudRegion.getCloudOwner(),
2647                 cloudRegion.getLcpCloudRegionId(), volumeGroup.getVolumeGroupId());
2648         doReturn(Optional.of(cloudRegion)).when(SPY_cloudInfoFromAAI).getCloudInfoFromAAI(gBB.getServiceInstance());
2649
2650         // when
2651         SPY_bbInputSetup.getGBBMacroExistingService(executeBB, lookupKeyMap,
2652                 executeBB.getBuildingBlock().getBpmnFlowName(), requestAction, null);
2653         // then
2654         verify(SPY_bbInputSetup, times(1)).mapCatalogVnf(any(GenericVnf.class), any(ModelInfo.class),
2655                 any(Service.class));
2656         verify(SPY_bbInputSetup, times(1)).mapCatalogVolumeGroup(isA(VolumeGroup.class), isA(ModelInfo.class),
2657                 isA(Service.class), isA(String.class));
2658     }
2659
2660     @Test
2661     public void test_getGBBMacroNoUserParamsExistingService_forActivateFabricConfigurationBB() throws Exception {
2662         // given
2663         String requestAction = "unassignInstance";
2664         GeneralBuildingBlock gBB = mapper.readValue(new File(RESOURCE_PATH + "GeneralBuildingBlockExpected.json"),
2665                 GeneralBuildingBlock.class);
2666         L3Network network = new L3Network();
2667         network.setNetworkId("networkId");
2668         gBB.getServiceInstance().getNetworks().add(network);
2669         ServiceInstance serviceInstance = gBB.getServiceInstance();
2670         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2671                 ExecuteBuildingBlock.class);
2672         RequestDetails requestDetails = mapper
2673                 .readValue(new File(RESOURCE_PATH + "RequestDetailsInput_serviceMacro.json"), RequestDetails.class);
2674         requestDetails.getRequestParameters().setUserParams(null);
2675         Map<ResourceKey, String> lookupKeyMap = prepareLookupKeyMap();
2676         Service service = Mockito.mock(Service.class);
2677         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
2678         GenericVnf vnf = new GenericVnf();
2679         vnf.setVnfId("vnfId");
2680         gBB.getServiceInstance().getVnfs().add(vnf);
2681         org.onap.aai.domain.yang.GenericVnf aaiVnf = new org.onap.aai.domain.yang.GenericVnf();
2682         aaiVnf.setModelCustomizationId("modelCustId");
2683         VfModule vfModule = new VfModule();
2684         vfModule.setVfModuleId("vfModuleId");
2685         gBB.getServiceInstance().getVnfs().get(0).getVfModules().add(vfModule);
2686         VolumeGroup volumeGroup = new VolumeGroup();
2687         volumeGroup.setVolumeGroupId("volumeGroupId");
2688         gBB.getServiceInstance().getVnfs().get(0).getVolumeGroups().add(volumeGroup);
2689         CloudConfiguration cloudConfiguration = new CloudConfiguration();
2690         cloudConfiguration.setLcpCloudRegionId("cloudRegionId");
2691         Configuration configuration = new Configuration();
2692         configuration.setConfigurationId("configurationId");
2693         gBB.getServiceInstance().getConfigurations().add(configuration);
2694         org.onap.aai.domain.yang.Configuration aaiConfiguration = new org.onap.aai.domain.yang.Configuration();
2695         aaiConfiguration.setModelCustomizationId("modelCustId");
2696
2697         ConfigurationResourceKeys configResourceKeys = prepareConfigurationResourceKeys();
2698         executeBB.setConfigurationResourceKeys(configResourceKeys).setRequestDetails(requestDetails);
2699         BuildingBlock buildingBlock = executeBB.getBuildingBlock();
2700         buildingBlock.setBpmnFlowName("ActivateFabricConfigurationBB").setKey("72d9d1cd-f46d-447a-abdb-451d6fb05fa9");
2701
2702         aaiServiceInstance.setModelVersionId("modelVersionId");
2703         doReturn(service).when(SPY_bbInputSetupUtils)
2704                 .getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
2705         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils)
2706                 .getAAIServiceInstanceById(lookupKeyMap.get(ResourceKey.SERVICE_INSTANCE_ID));
2707         doReturn(serviceInstance).when(SPY_bbInputSetup).getExistingServiceInstance(aaiServiceInstance);
2708         doReturn(gBB).when(SPY_bbInputSetup).populateGBBWithSIAndAdditionalInfo(any(BBInputSetupParameter.class));
2709         doReturn(aaiConfiguration).when(SPY_bbInputSetupUtils).getAAIConfiguration(configuration.getConfigurationId());
2710         doNothing().when(SPY_bbInputSetup).mapCatalogConfiguration(isA(Configuration.class), isA(ModelInfo.class),
2711                 isA(Service.class), isA(ConfigurationResourceKeys.class));
2712
2713         // when
2714         SPY_bbInputSetup.getGBBMacroExistingService(executeBB, lookupKeyMap,
2715                 executeBB.getBuildingBlock().getBpmnFlowName(), requestAction, cloudConfiguration);
2716         // then
2717         verify(SPY_bbInputSetup, times(1)).mapCatalogConfiguration(any(Configuration.class), any(ModelInfo.class),
2718                 any(Service.class), isA(ConfigurationResourceKeys.class));
2719     }
2720
2721     @Test
2722     public void testGetGBBMacroExistingServiceServiceinstancenotFoundInAai() throws Exception {
2723         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2724                 ExecuteBuildingBlock.class);
2725         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2726         lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "si123");
2727
2728         CloudConfiguration cloudConfiguration = new CloudConfiguration();
2729         cloudConfiguration.setLcpCloudRegionId("cloudRegionId");
2730
2731         doReturn(null).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById("si123");
2732
2733         expectedException.expect(NoServiceInstanceFoundException.class);
2734         expectedException.expectMessage("Related service instance from AAI not found: service-instance-id=si123");
2735
2736         SPY_bbInputSetup.getGBBMacroExistingService(executeBB, lookupKeyMap, "AssignVnfBB", "assign",
2737                 cloudConfiguration);
2738     }
2739
2740     @Test
2741     public void testGetGBBMacroExistingServiceServiceModelNotFound() throws Exception {
2742         ExecuteBuildingBlock executeBB = mapper.readValue(new File(RESOURCE_PATH + "ExecuteBuildingBlockSimple.json"),
2743                 ExecuteBuildingBlock.class);
2744         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2745         lookupKeyMap.put(ResourceKey.SERVICE_INSTANCE_ID, "si123");
2746         org.onap.aai.domain.yang.ServiceInstance aaiServiceInstance = new org.onap.aai.domain.yang.ServiceInstance();
2747         aaiServiceInstance.setModelVersionId("modelVersionId");
2748
2749         CloudConfiguration cloudConfiguration = new CloudConfiguration();
2750         cloudConfiguration.setLcpCloudRegionId("cloudRegionId");
2751
2752         doReturn(aaiServiceInstance).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById("si123");
2753         doReturn(null).when(SPY_bbInputSetupUtils).getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
2754
2755         expectedException.expect(ServiceModelNotFoundException.class);
2756         expectedException.expectMessage(
2757                 "Related service instance model not found in MSO CatalogDB: model-version-id=modelVersionId");
2758
2759         SPY_bbInputSetup.getGBBMacroExistingService(executeBB, lookupKeyMap, "AssignVnfBB", "assign",
2760                 cloudConfiguration);
2761     }
2762
2763     @Test
2764     public void testGetVnfId() {
2765         String expected = "vnfId";
2766         ExecuteBuildingBlock executeBB = new ExecuteBuildingBlock().setRequestId("requestId");
2767         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2768         InfraActiveRequests request = new InfraActiveRequests();
2769         request.setVnfId(expected);
2770         doReturn(request).when(SPY_bbInputSetupUtils).getInfraActiveRequest(executeBB.getRequestId());
2771
2772         String actual = SPY_bbInputSetup.getVnfId(executeBB, lookupKeyMap);
2773
2774         assertEquals("VnfId is set correctly", expected, actual);
2775     }
2776
2777     @Test
2778     public void testCreateVfModule() {
2779         String vfModuleId = "vfModuleId";
2780         String instanceName = "vfModuleName";
2781         Map<String, String> cloudParams = new HashMap<>();
2782         cloudParams.put("param1", "param1Value");
2783         VfModule expected = new VfModule();
2784         expected.setVfModuleId(vfModuleId);
2785         expected.setVfModuleName(instanceName);
2786         expected.setCloudParams(cloudParams);
2787         expected.setOrchestrationStatus(OrchestrationStatus.PRECREATED);
2788         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2789         List<Map<String, String>> instanceParams = new ArrayList<>();
2790         instanceParams.add(cloudParams);
2791
2792         VfModule actual = SPY_bbInputSetup.createVfModule(lookupKeyMap, vfModuleId, instanceName, instanceParams);
2793
2794         assertThat(actual, sameBeanAs(expected));
2795         assertEquals("LookupKeyMap is populated", vfModuleId, lookupKeyMap.get(ResourceKey.VF_MODULE_ID));
2796
2797         expected.getCloudParams().clear();
2798         actual = SPY_bbInputSetup.createVfModule(lookupKeyMap, vfModuleId, instanceName, null);
2799         assertThat(actual, sameBeanAs(expected));
2800     }
2801
2802     @Test
2803     public void testCreateVolumeGroup() {
2804         String volumeGroupId = "volumeGroupId";
2805         String instanceName = "vfModuleName";
2806         String vnfType = "vnfType";
2807         Map<String, String> cloudParams = new HashMap<>();
2808         cloudParams.put("param1", "param1Value");
2809         VolumeGroup expected = new VolumeGroup();
2810         expected.setVolumeGroupId(volumeGroupId);
2811         expected.setVolumeGroupName(instanceName);
2812         expected.setCloudParams(cloudParams);
2813         expected.setVnfType(vnfType);
2814         expected.setOrchestrationStatus(OrchestrationStatus.PRECREATED);
2815         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2816         List<Map<String, String>> instanceParams = new ArrayList<>();
2817         instanceParams.add(cloudParams);
2818
2819         VolumeGroup actual =
2820                 SPY_bbInputSetup.createVolumeGroup(lookupKeyMap, volumeGroupId, instanceName, vnfType, instanceParams);
2821
2822         assertThat(actual, sameBeanAs(expected));
2823         assertEquals("LookupKeyMap is populated", volumeGroupId, lookupKeyMap.get(ResourceKey.VOLUME_GROUP_ID));
2824
2825         expected.getCloudParams().clear();
2826         actual = SPY_bbInputSetup.createVolumeGroup(lookupKeyMap, volumeGroupId, instanceName, vnfType, null);
2827         assertThat(actual, sameBeanAs(expected));
2828     }
2829
2830     @Test
2831     public void testCreateNetwork() {
2832         String networkId = "networkId";
2833         String instanceName = "networkName";
2834         Map<String, String> cloudParams = new HashMap<>();
2835         cloudParams.put("param1", "param1Value");
2836         L3Network expected = new L3Network();
2837         expected.setNetworkId(networkId);
2838         expected.setNetworkName(instanceName);
2839         expected.setCloudParams(cloudParams);
2840         Platform platform = new Platform();
2841         platform.setPlatformName("platformName");
2842         expected.setPlatform(platform);
2843         LineOfBusiness lineOfBusiness = new LineOfBusiness();
2844         lineOfBusiness.setLineOfBusinessName("lineOfBusiness");
2845         expected.setLineOfBusiness(lineOfBusiness);
2846         expected.setOrchestrationStatus(OrchestrationStatus.PRECREATED);
2847         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2848         List<Map<String, String>> instanceParams = new ArrayList<>();
2849         instanceParams.add(cloudParams);
2850         org.onap.so.serviceinstancebeans.Platform platformRequest = new org.onap.so.serviceinstancebeans.Platform();
2851         org.onap.so.serviceinstancebeans.LineOfBusiness lineOfBusinessRequest =
2852                 new org.onap.so.serviceinstancebeans.LineOfBusiness();
2853         lineOfBusinessRequest.setLineOfBusinessName("lineOfBusiness");
2854         platformRequest.setPlatformName("platformName");
2855         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
2856                 .setPlatform(platformRequest).setLineOfBusiness(lineOfBusinessRequest).build();
2857         L3Network actual =
2858                 SPY_bbInputSetup.createNetwork(lookupKeyMap, instanceName, networkId, instanceParams, parameter);
2859
2860         assertThat(actual, sameBeanAs(expected));
2861         assertEquals("LookupKeyMap is populated", networkId, lookupKeyMap.get(ResourceKey.NETWORK_ID));
2862
2863         expected.getCloudParams().clear();
2864
2865         actual = SPY_bbInputSetup.createNetwork(lookupKeyMap, instanceName, networkId, null, parameter);
2866         assertThat(actual, sameBeanAs(expected));
2867     }
2868
2869     @Test
2870     public void testCreateGenericVnf() {
2871         String vnfId = "vnfId";
2872         String instanceName = "vnfName";
2873         String vnfType = "vnfType";
2874         String platformName = "platformName";
2875         String lineOfBusinessName = "lineOfBusinessName";
2876         String productFamilyId = "productFamilyId";
2877         String applicationId = "applicationId";
2878         Platform platform = new Platform();
2879         platform.setPlatformName(platformName);
2880         LineOfBusiness lineOfBusiness = new LineOfBusiness();
2881         lineOfBusiness.setLineOfBusinessName(lineOfBusinessName);
2882         Map<String, String> cloudParams = new HashMap<>();
2883         cloudParams.put("param1", "param1Value");
2884         GenericVnf expected = new GenericVnf();
2885         expected.setVnfId(vnfId);
2886         expected.setVnfName(instanceName);
2887         expected.setVnfType(vnfType);
2888         expected.setCloudParams(cloudParams);
2889         expected.setOrchestrationStatus(OrchestrationStatus.PRECREATED);
2890         expected.setPlatform(platform);
2891         expected.setLineOfBusiness(lineOfBusiness);
2892         expected.setProvStatus("PREPROV");
2893         expected.setServiceId(productFamilyId);
2894         expected.setApplicationId(applicationId);
2895         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
2896         List<Map<String, String>> instanceParams = new ArrayList<>();
2897         instanceParams.add(cloudParams);
2898         org.onap.so.serviceinstancebeans.Platform requestPlatform = new org.onap.so.serviceinstancebeans.Platform();
2899         platform.setPlatformName(platformName);
2900         org.onap.so.serviceinstancebeans.LineOfBusiness requestLineOfBusiness =
2901                 new org.onap.so.serviceinstancebeans.LineOfBusiness();
2902         lineOfBusiness.setLineOfBusinessName(lineOfBusinessName);
2903
2904         doReturn(platform).when(bbInputSetupMapperLayer).mapRequestPlatform(requestPlatform);
2905         doReturn(lineOfBusiness).when(bbInputSetupMapperLayer).mapRequestLineOfBusiness(requestLineOfBusiness);
2906
2907         GenericVnf actual = SPY_bbInputSetup.createGenericVnf(lookupKeyMap, instanceName, requestPlatform,
2908                 requestLineOfBusiness, vnfId, vnfType, instanceParams, productFamilyId, applicationId);
2909
2910         assertThat(actual, sameBeanAs(expected));
2911         assertEquals("LookupKeyMap is populated", vnfId, lookupKeyMap.get(ResourceKey.GENERIC_VNF_ID));
2912
2913         expected.getCloudParams().clear();
2914         actual = SPY_bbInputSetup.createGenericVnf(lookupKeyMap, instanceName, requestPlatform, requestLineOfBusiness,
2915                 vnfId, vnfType, null, productFamilyId, applicationId);
2916         assertThat(actual, sameBeanAs(expected));
2917     }
2918
2919     @Test
2920     public void testMapCatalogVfModule() {
2921         String vnfModelCustomizationUUID = "vnfResourceCustUUID";
2922         String vfModuleCustomizationUUID = "vfModelCustomizationUUID";
2923         VfModule vfModule = new VfModule();
2924         ModelInfo modelInfo = new ModelInfo();
2925         modelInfo.setModelCustomizationUuid(vfModuleCustomizationUUID);
2926         Service service = new Service();
2927         VnfResourceCustomization vnfResourceCust = new VnfResourceCustomization();
2928         vnfResourceCust.setModelCustomizationUUID(vnfModelCustomizationUUID);
2929         VfModuleCustomization vfModuleCust = new VfModuleCustomization();
2930         vfModuleCust.setModelCustomizationUUID(vfModuleCustomizationUUID);
2931         vnfResourceCust.getVfModuleCustomizations().add(vfModuleCust);
2932         service.getVnfCustomizations().add(vnfResourceCust);
2933         ModelInfoVfModule modelInfoVfModule = new ModelInfoVfModule();
2934
2935         doReturn(modelInfoVfModule).when(bbInputSetupMapperLayer).mapCatalogVfModuleToVfModule(vfModuleCust);
2936
2937         SPY_bbInputSetup.mapCatalogVfModule(vfModule, modelInfo, service, vnfModelCustomizationUUID);
2938
2939         assertThat(vfModule.getModelInfoVfModule(), sameBeanAs(modelInfoVfModule));
2940
2941         modelInfo.setModelCustomizationUuid(null);
2942         modelInfo.setModelCustomizationId(vfModuleCustomizationUUID);
2943
2944         SPY_bbInputSetup.mapCatalogVfModule(vfModule, modelInfo, service, vnfModelCustomizationUUID);
2945
2946         assertThat(vfModule.getModelInfoVfModule(), sameBeanAs(modelInfoVfModule));
2947     }
2948
2949     @Test
2950     public void testMapCatalogVfModuleIfNoVnf() {
2951         String vnfModelCustomizationUUID = "vnfResourceCustUUID";
2952         String vfModuleCustomizationUUID = "vfModelCustomizationUUID";
2953         VfModule vfModule = new VfModule();
2954         ModelInfo modelInfo = new ModelInfo();
2955         modelInfo.setModelCustomizationUuid(vfModuleCustomizationUUID);
2956         Service service = new Service();
2957         VnfResourceCustomization vnfResourceCust = new VnfResourceCustomization();
2958         vnfResourceCust.setModelCustomizationUUID(vnfModelCustomizationUUID);
2959         VfModuleCustomization vfModuleCust = new VfModuleCustomization();
2960         vfModuleCust.setModelCustomizationUUID(vfModuleCustomizationUUID);
2961         vnfResourceCust.getVfModuleCustomizations().add(vfModuleCust);
2962         ModelInfoVfModule modelInfoVfModule = new ModelInfoVfModule();
2963         doReturn(vfModuleCust).when(SPY_bbInputSetupUtils)
2964                 .getVfModuleCustomizationByModelCuztomizationUUID(vfModuleCustomizationUUID);
2965         doReturn(modelInfoVfModule).when(bbInputSetupMapperLayer).mapCatalogVfModuleToVfModule(vfModuleCust);
2966
2967         SPY_bbInputSetup.mapCatalogVfModule(vfModule, modelInfo, service, vnfModelCustomizationUUID);
2968
2969         assertThat(vfModule.getModelInfoVfModule(), sameBeanAs(modelInfoVfModule));
2970
2971         verify(SPY_bbInputSetupUtils, times(1))
2972                 .getVfModuleCustomizationByModelCuztomizationUUID(modelInfo.getModelCustomizationId());
2973     }
2974
2975     @Test
2976     public void testPopulateVfModule() throws Exception {
2977         String vnfId = "vnfId";
2978         String vfModuleId = "vfModuleId";
2979         String volumeGroupId = "volumeGroupId";
2980         String vfModuleCustomizationId = "vfModuleCustomizationId";
2981         ModelInfo modelInfo = new ModelInfo();
2982         modelInfo.setModelCustomizationId(vfModuleCustomizationId);
2983         Service service = new Service();
2984         ServiceModel serviceModel = new ServiceModel();
2985         serviceModel.setCurrentService(service);
2986         String bbName = AssignFlows.VF_MODULE.toString();
2987         ServiceInstance serviceInstance = new ServiceInstance();
2988         GenericVnf vnf = new GenericVnf();
2989         vnf.setVnfId(vnfId);
2990         VolumeGroup volumeGroup = new VolumeGroup();
2991         volumeGroup.setVolumeGroupId(volumeGroupId);
2992         vnf.getVolumeGroups().add(volumeGroup);
2993         serviceInstance.getVnfs().add(vnf);
2994         VfModule vfModule1 = new VfModule();
2995         vfModule1.setVfModuleId("vfModuleId1");
2996         VfModule vfModule2 = new VfModule();
2997         vfModule2.setVfModuleId("vfModuleId2");
2998         vnf.getVfModules().add(vfModule1);
2999         vnf.getVfModules().add(vfModule2);
3000         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
3001         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, vnfId);
3002         String resourceId = vfModuleId;
3003         RelatedInstanceList[] relatedInstanceList = null;
3004         String instanceName = "vfModuleName";
3005         List<Map<String, String>> instanceParams = null;
3006         CloudConfiguration cloudConfiguration = new CloudConfiguration();
3007
3008         org.onap.aai.domain.yang.GenericVnf vnfAAI = new org.onap.aai.domain.yang.GenericVnf();
3009         vnfAAI.setModelCustomizationId("vnfModelCustId");
3010         org.onap.aai.domain.yang.VolumeGroup volumeGroupAAI = new org.onap.aai.domain.yang.VolumeGroup();
3011         volumeGroupAAI.setModelCustomizationId(vfModuleCustomizationId);
3012         org.onap.aai.domain.yang.VfModule vfModuleAAI = new org.onap.aai.domain.yang.VfModule();
3013         vfModuleAAI.setModelCustomizationId(vfModuleCustomizationId);
3014
3015         doReturn(vnfAAI).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
3016         doReturn(volumeGroupAAI).when(SPY_bbInputSetupUtils).getAAIVolumeGroup(CLOUD_OWNER,
3017                 cloudConfiguration.getLcpCloudRegionId(), volumeGroup.getVolumeGroupId());
3018         doReturn(vfModuleAAI).when(SPY_bbInputSetupUtils).getAAIVfModule(isA(String.class), isA(String.class));
3019         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(isA(GenericVnf.class), isA(ModelInfo.class),
3020                 isA(Service.class));
3021         doNothing().when(SPY_bbInputSetup).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class),
3022                 isA(Service.class), isA(String.class));
3023
3024         SPY_bbInputSetup.populateVfModule(new BBInputSetupParameter.Builder().setRequestId(REQUEST_ID)
3025                 .setModelInfo(modelInfo).setService(service).setBbName(bbName).setServiceInstance(serviceInstance)
3026                 .setLookupKeyMap(lookupKeyMap).setResourceId(resourceId).setRelatedInstanceList(relatedInstanceList)
3027                 .setInstanceName(instanceName).setInstanceParams(instanceParams)
3028                 .setCloudConfiguration(cloudConfiguration).setServiceModel(serviceModel).build());
3029
3030         verify(SPY_bbInputSetup, times(3)).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class),
3031                 isA(Service.class), isA(String.class));
3032         assertEquals("Lookup Key Map populated with VfModule Id", vfModuleId,
3033                 lookupKeyMap.get(ResourceKey.VF_MODULE_ID));
3034         assertEquals("Lookup Key Map populated with VolumeGroup Id", volumeGroupId,
3035                 lookupKeyMap.get(ResourceKey.VOLUME_GROUP_ID));
3036     }
3037
3038     @Test
3039     public void testPopulateVfModuleIsReplaceCorrectPopulationOfVfs() throws Exception {
3040         String vnfId = "vnfId";
3041         String vfModuleId = "vfModuleId";
3042         String volumeGroupId = "volumeGroupId";
3043         String vfModuleCustomizationId = "vfModuleCustomizationId";
3044         ModelInfo modelInfo = new ModelInfo();
3045         modelInfo.setModelCustomizationId(vfModuleCustomizationId);
3046         Service currentService = new Service();
3047         currentService.setModelUUID("currentUUID");
3048         Service newService = new Service();
3049         newService.setModelUUID("newUUID");
3050         ServiceModel serviceModel = new ServiceModel();
3051         serviceModel.setCurrentService(currentService);
3052         serviceModel.setNewService(newService);
3053         String bbName = "ActivateVfModuleBB";
3054         ServiceInstance serviceInstance = new ServiceInstance();
3055         GenericVnf vnf = new GenericVnf();
3056         vnf.setVnfId(vnfId);
3057         VolumeGroup volumeGroup = new VolumeGroup();
3058         volumeGroup.setVolumeGroupId(volumeGroupId);
3059         vnf.getVolumeGroups().add(volumeGroup);
3060         serviceInstance.getVnfs().add(vnf);
3061         VfModule vfModule1 = new VfModule();
3062         vfModule1.setVfModuleId("vfModuleId1");
3063         VfModule vfModule2 = new VfModule();
3064         vfModule2.setVfModuleId("vfModuleId2");
3065         vnf.getVfModules().add(vfModule1);
3066         vnf.getVfModules().add(vfModule2);
3067         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
3068         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, vnfId);
3069         lookupKeyMap.put(ResourceKey.VF_MODULE_ID, "vfModuleId1");
3070         String resourceId = vfModuleId;
3071         RelatedInstanceList[] relatedInstanceList = new RelatedInstanceList[1];
3072         RelatedInstanceList relatedInstanceListObj = new RelatedInstanceList();
3073         RelatedInstance relatedInstance = new RelatedInstance();
3074         relatedInstance.setInstanceId(vnfId);
3075
3076         ModelInfo vnfModelInfo = new ModelInfo();
3077         vnfModelInfo.setModelCustomizationId("vnfCustomizationId");
3078         vnfModelInfo.setModelType(ModelType.vnf);
3079         relatedInstance.setModelInfo(vnfModelInfo);
3080         relatedInstanceListObj.setRelatedInstance(relatedInstance);
3081         relatedInstanceList[0] = relatedInstanceListObj;
3082
3083         String instanceName = "vfModuleName";
3084         List<Map<String, String>> instanceParams = null;
3085         CloudConfiguration cloudConfiguration = new CloudConfiguration();
3086
3087         org.onap.aai.domain.yang.GenericVnf vnfAAI = new org.onap.aai.domain.yang.GenericVnf();
3088         vnfAAI.setModelCustomizationId("vnfModelCustId");
3089         org.onap.aai.domain.yang.VolumeGroup volumeGroupAAI = new org.onap.aai.domain.yang.VolumeGroup();
3090         volumeGroupAAI.setModelCustomizationId(vfModuleCustomizationId);
3091         org.onap.aai.domain.yang.VfModule vfModuleAAI = new org.onap.aai.domain.yang.VfModule();
3092         vfModuleAAI.setModelCustomizationId(vfModuleCustomizationId);
3093
3094         doReturn(vnfAAI).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
3095         doReturn(volumeGroupAAI).when(SPY_bbInputSetupUtils).getAAIVolumeGroup(CLOUD_OWNER,
3096                 cloudConfiguration.getLcpCloudRegionId(), volumeGroup.getVolumeGroupId());
3097         doReturn(vfModuleAAI).when(SPY_bbInputSetupUtils).getAAIVfModule(isA(String.class), isA(String.class));
3098         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(isA(GenericVnf.class), isA(ModelInfo.class),
3099                 isA(Service.class));
3100         doNothing().when(SPY_bbInputSetup).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class),
3101                 isA(Service.class), isA(String.class));
3102
3103         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setModelInfo(modelInfo)
3104                 .setService(newService).setBbName(bbName).setServiceInstance(serviceInstance)
3105                 .setLookupKeyMap(lookupKeyMap).setResourceId(resourceId).setRelatedInstanceList(relatedInstanceList)
3106                 .setInstanceName(instanceName).setInstanceParams(instanceParams)
3107                 .setCloudConfiguration(cloudConfiguration).setIsReplace(true).setServiceModel(serviceModel).build();
3108         SPY_bbInputSetup.populateVfModule(parameter);
3109
3110         verify(SPY_bbInputSetup, times(1)).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class),
3111                 eq(currentService), eq("vnfModelCustId"));
3112         verify(SPY_bbInputSetup, times(1)).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class), eq(newService),
3113                 eq("vnfCustomizationId"));
3114         assertEquals("Lookup Key Map populated with VfModule Id", "vfModuleId1",
3115                 lookupKeyMap.get(ResourceKey.VF_MODULE_ID));
3116         assertEquals("Lookup Key Map populated with VolumeGroup Id", volumeGroupId,
3117                 lookupKeyMap.get(ResourceKey.VOLUME_GROUP_ID));
3118     }
3119
3120     @Test
3121     public void testPopulateVfModuleIsReplace() throws Exception {
3122         String vnfId = "vnfId";
3123         String vfModuleId = "vfModuleId";
3124         String volumeGroupId = "volumeGroupId";
3125         String vfModuleCustomizationId = "vfModuleCustomizationId";
3126         ModelInfo modelInfo = new ModelInfo();
3127         modelInfo.setModelCustomizationId(vfModuleCustomizationId);
3128         Service currentService = new Service();
3129         Service newService = new Service();
3130         ServiceModel serviceModel = new ServiceModel();
3131         serviceModel.setCurrentService(currentService);
3132         currentService.setModelUUID("currentUUID");
3133         serviceModel.setNewService(newService);
3134         currentService.setModelUUID("newUUID");
3135         String bbName = AssignFlows.VF_MODULE.toString();
3136         ServiceInstance serviceInstance = new ServiceInstance();
3137         GenericVnf vnf = new GenericVnf();
3138         vnf.setVnfId(vnfId);
3139         VolumeGroup volumeGroup = new VolumeGroup();
3140         volumeGroup.setVolumeGroupId(volumeGroupId);
3141         vnf.getVolumeGroups().add(volumeGroup);
3142         serviceInstance.getVnfs().add(vnf);
3143         VfModule vfModule1 = new VfModule();
3144         vfModule1.setVfModuleId("vfModuleId1");
3145         VfModule vfModule2 = new VfModule();
3146         vfModule2.setVfModuleId("vfModuleId2");
3147         vnf.getVfModules().add(vfModule1);
3148         vnf.getVfModules().add(vfModule2);
3149         Map<ResourceKey, String> lookupKeyMap = new HashMap<>();
3150         lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, vnfId);
3151         lookupKeyMap.put(ResourceKey.VF_MODULE_ID, vfModuleId);
3152         String resourceId = vfModuleId;
3153         RelatedInstanceList[] relatedInstanceList = new RelatedInstanceList[1];
3154         RelatedInstanceList relatedInstanceListObj = new RelatedInstanceList();
3155         RelatedInstance relatedInstance = new RelatedInstance();
3156         relatedInstance.setInstanceId(vnfId);
3157
3158         ModelInfo vnfModelInfo = new ModelInfo();
3159         vnfModelInfo.setModelCustomizationId("vnfCustomizationId");
3160         vnfModelInfo.setModelType(ModelType.vnf);
3161         relatedInstance.setModelInfo(vnfModelInfo);
3162         relatedInstanceListObj.setRelatedInstance(relatedInstance);
3163         relatedInstanceList[0] = relatedInstanceListObj;
3164
3165         String instanceName = "vfModuleName";
3166         List<Map<String, String>> instanceParams = null;
3167         CloudConfiguration cloudConfiguration = new CloudConfiguration();
3168
3169         org.onap.aai.domain.yang.GenericVnf vnfAAI = new org.onap.aai.domain.yang.GenericVnf();
3170         vnfAAI.setModelCustomizationId("vnfModelCustId");
3171         org.onap.aai.domain.yang.VolumeGroup volumeGroupAAI = new org.onap.aai.domain.yang.VolumeGroup();
3172         volumeGroupAAI.setModelCustomizationId(vfModuleCustomizationId);
3173         org.onap.aai.domain.yang.VfModule vfModuleAAI = new org.onap.aai.domain.yang.VfModule();
3174         vfModuleAAI.setModelCustomizationId(vfModuleCustomizationId);
3175
3176         doReturn(vnfAAI).when(SPY_bbInputSetupUtils).getAAIGenericVnf(vnf.getVnfId());
3177         doReturn(volumeGroupAAI).when(SPY_bbInputSetupUtils).getAAIVolumeGroup(CLOUD_OWNER,
3178                 cloudConfiguration.getLcpCloudRegionId(), volumeGroup.getVolumeGroupId());
3179         doReturn(vfModuleAAI).when(SPY_bbInputSetupUtils).getAAIVfModule(isA(String.class), isA(String.class));
3180         doNothing().when(SPY_bbInputSetup).mapCatalogVnf(isA(GenericVnf.class), isA(ModelInfo.class),
3181                 isA(Service.class));
3182         doNothing().when(SPY_bbInputSetup).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class),
3183                 isA(Service.class), isA(String.class));
3184
3185         BBInputSetupParameter parameter = new BBInputSetupParameter.Builder().setModelInfo(modelInfo)
3186                 .setService(newService).setServiceInstance(serviceInstance).setBbName(bbName)
3187                 .setLookupKeyMap(lookupKeyMap).setResourceId(resourceId).setRelatedInstanceList(relatedInstanceList)
3188                 .setInstanceName(instanceName).setInstanceParams(instanceParams)
3189                 .setCloudConfiguration(cloudConfiguration).setIsReplace(true).setServiceModel(serviceModel).build();
3190
3191
3192         SPY_bbInputSetup.populateVfModule(parameter);
3193
3194         verify(SPY_bbInputSetup, times(2)).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class),
3195                 eq(serviceModel.getCurrentService()), isA(String.class));
3196         verify(SPY_bbInputSetup, times(1)).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class),
3197                 eq(serviceModel.getNewService()), isA(String.class));
3198         assertEquals("Lookup Key Map populated with VfModule Id", vfModuleId,
3199                 lookupKeyMap.get(ResourceKey.VF_MODULE_ID));
3200         assertEquals("Lookup Key Map populated with VolumeGroup Id", volumeGroupId,
3201                 lookupKeyMap.get(ResourceKey.VOLUME_GROUP_ID));
3202     }
3203
3204     @Test
3205     public void testGettingVnfcToConfiguration() throws Exception {
3206
3207         String vnfcName = "vnfcName";
3208         org.onap.aai.domain.yang.Configuration expectedAAI = new org.onap.aai.domain.yang.Configuration();
3209         AAIResourceUri aaiResourceUri = AAIUriFactory.createResourceUri(AAIObjectType.VNFC, vnfcName);
3210         AAIResultWrapper configurationWrapper =
3211                 new AAIResultWrapper(new AAICommonObjectMapperProvider().getMapper().writeValueAsString(expectedAAI));
3212
3213         doReturn(new AAIResultWrapper(null)).when(SPY_bbInputSetupUtils).getAAIResourceDepthOne(aaiResourceUri);
3214         Vnfc vnfc = SPY_bbInputSetup.getVnfcToConfiguration(vnfcName);
3215         Assert.assertNull(vnfc);
3216
3217         doReturn(configurationWrapper).when(SPY_bbInputSetupUtils).getAAIResourceDepthOne(aaiResourceUri);
3218         vnfc = SPY_bbInputSetup.getVnfcToConfiguration(vnfcName);
3219         Assert.assertNotNull(vnfc);
3220     }
3221 }