nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestLifecycleManager.java

   1 /*
   2  * Copyright 2016-2017, Nokia Corporation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
  17
  18 import com.google.gson.Gson;
  19 import com.google.gson.JsonElement;
  20 import com.google.gson.JsonObject;
  21 import com.google.gson.JsonParser;
  22 import com.nokia.cbam.catalog.v1.model.CatalogAdapterVnfpackage;
  23 import com.nokia.cbam.lcm.v32.model.*;
  24 import com.nokia.cbam.lcm.v32.model.OperationType;
  25 import com.nokia.cbam.lcm.v32.model.VimInfo;
  26 import com.nokia.cbam.lcm.v32.model.VnfInfo;
  27 import io.reactivex.Observable;
  28 import java.nio.file.Paths;
  29 import java.util.*;
  30 import javax.servlet.http.HttpServletResponse;
  31 import org.junit.Before;
  32 import org.junit.Test;
  33 import org.mockito.ArgumentCaptor;
  34 import org.mockito.InOrder;
  35 import org.mockito.Mock;
  36 import org.mockito.Mockito;
  37 import org.mockito.invocation.InvocationOnMock;
  38 import org.mockito.stubbing.Answer;
  39 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VimInfoProvider;
  40 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.TestVfcGrantManager;
  41 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.VfcGrantManager;
  42 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.StoreLoader;
  43 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.LifecycleChangeNotificationManager;
  44 import org.onap.vnfmdriver.model.ExtVirtualLinkInfo;
  45 import org.onap.vnfmdriver.model.*;
  46 import org.onap.vnfmdriver.model.ScaleDirection;
  47 import org.threeten.bp.OffsetDateTime;
  48
  49 import static java.lang.Boolean.parseBoolean;
  50 import static java.nio.file.Files.readAllBytes;
  51 import static java.util.Optional.empty;
  52
  53 import static junit.framework.TestCase.*;
  54 import static org.mockito.Mockito.*;
  55 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.child;
  56 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions.systemFunctions;
  57 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
  58 import static org.springframework.test.util.ReflectionTestUtils.setField;
  59
  60 public class TestLifecycleManager extends TestBase {
  61     public static final String JOB_ID = "myJobId";
  62     public static final String CBAM_VNFD_ID = "cbamVnfdId";
  63     public static final String TENANT = "myTenant";
  64     public static final String OPERATION_EXECUTION_ID = "operationExecutionId";
  65     private static final String ONAP_CSAR_ID = "myOnapCsarId";
  66     private static final String VIM_ID = "ownerId_regionId";
  67     @Mock
  68     private CatalogManager catalogManager;
  69     @Mock
  70     private VfcGrantManager vfcGrantManager;
  71     @Mock
  72     private JobManager jobManager;
  73     @Mock
  74     private LifecycleChangeNotificationManager notificationManager;
  75     @Mock
  76     private HttpServletResponse restResponse;
  77     @Mock
  78     private VimInfoProvider vimInfoProvider;
  79
  80     private ArgumentCaptor<CreateVnfRequest> createRequest = ArgumentCaptor.forClass(CreateVnfRequest.class);
  81     private AdditionalParameters additionalParam = new AdditionalParameters();
  82     private String INSTANTIATION_LEVEL = "level1";
  83     private GrantVNFResponseVim grantResponse = new GrantVNFResponseVim();
  84     private String cbamVnfdContent;
  85     private OperationExecution instantiationOperationExecution = new OperationExecution();
  86     private OperationExecution modifyPropertyoperationExecution = new OperationExecution();
  87     private OperationExecution scaleOperationExecution = new OperationExecution();
  88     private OperationExecution healOperationExecution = new OperationExecution();
  89     private OperationExecution customOperationExecution = new OperationExecution();
  90
  91
  92     private VnfInfo vnfInfo = new VnfInfo();
  93     private List<OperationExecution> operationExecutions = new ArrayList<>();
  94     private org.onap.vnfmdriver.model.VimInfo vimInfo = new org.onap.vnfmdriver.model.VimInfo();
  95     private ExtVirtualLinkInfo externalVirtualLink = new ExtVirtualLinkInfo();
  96     private ExtManagedVirtualLinkData extManVl = new ExtManagedVirtualLinkData();
  97     private ArgumentCaptor<ModifyVnfInfoRequest> actualVnfModifyRequest = ArgumentCaptor.forClass(ModifyVnfInfoRequest.class);
  98     private Set<Boolean> finished = new HashSet<>();
  99     private ArgumentCaptor<ScaleVnfRequest> actualScaleRequest = ArgumentCaptor.forClass(ScaleVnfRequest.class);
 100     private ArgumentCaptor<HealVnfRequest> actualHealRequest = ArgumentCaptor.forClass(HealVnfRequest.class);
 101     private ArgumentCaptor<CustomOperationRequest> customOperationRequestArgumentCaptor = ArgumentCaptor.forClass(CustomOperationRequest.class);
 102     private ArgumentCaptor<String> operationIdCaptor = ArgumentCaptor.forClass(String.class);
 103
 104     private LifecycleManager lifecycleManager;
 105
 106     @Before
 107     public void initMocks() throws Exception {
 108         vnfInfo.setExtensions(new ArrayList<>());
 109         vnfInfo.setOperationExecutions(new ArrayList<>());
 110         lifecycleManager = new LifecycleManager(catalogManager, vfcGrantManager, cbamRestApiProvider, vimInfoProvider, jobManager, notificationManager);
 111         cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.full.yaml").toURI())));
 112         setField(LifecycleManager.class, "logger", logger);
 113         CatalogAdapterVnfpackage cbamPackage = new CatalogAdapterVnfpackage();
 114         when(catalogManager.preparePackageInCbam(VNFM_ID, ONAP_CSAR_ID)).thenReturn(cbamPackage);
 115         cbamPackage.setVnfdId(CBAM_VNFD_ID);
 116         vnfInfo.setVnfdId(CBAM_VNFD_ID);
 117         vnfInfo.setId(VNF_ID);
 118         when(jobManager.spawnJob(VNF_ID, restResponse)).thenReturn(JOB_ID);
 119         when(catalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent);
 120         cbamPackage.setId(CBAM_VNFD_ID);
 121         vimInfo.setUrl("cloudUrl");
 122         vimInfo.setPassword("vimPassword");
 123         vimInfo.setUserName("vimUsername");
 124         vimInfo.setSslInsecure("true");
 125         vimInfo.setVimId(VIM_ID);
 126         vimInfo.setName("vimName");
 127         when(vimInfoProvider.getVimInfo((VIM_ID))).thenReturn(vimInfo);
 128         instantiationOperationExecution.setId(OPERATION_EXECUTION_ID);
 129         instantiationOperationExecution.setOperationType(OperationType.INSTANTIATE);
 130         instantiationOperationExecution.setStartTime(OffsetDateTime.now());
 131         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecutions));
 132         operationExecutions.add(modifyPropertyoperationExecution);
 133         modifyPropertyoperationExecution.setStartTime(OffsetDateTime.now());
 134         modifyPropertyoperationExecution.setOperationType(OperationType.MODIFY_INFO);
 135         operationExecutions.add(instantiationOperationExecution);
 136         instantiationOperationExecution.setStatus(OperationStatus.FINISHED);
 137         modifyPropertyoperationExecution.setStatus(OperationStatus.FINISHED);
 138         customOperationExecution.setStatus(OperationStatus.FINISHED);
 139         modifyPropertyoperationExecution.setId(UUID.randomUUID().toString());
 140         scaleOperationExecution.setId(UUID.randomUUID().toString());
 141         healOperationExecution.setId(UUID.randomUUID().toString());
 142         customOperationExecution.setId(UUID.randomUUID().toString());
 143
 144         when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(modifyPropertyoperationExecution));
 145         doAnswer(new Answer() {
 146             @Override
 147             public Object answer(InvocationOnMock invocation) throws Throwable {
 148                 finished.add(Boolean.TRUE);
 149                 return null;
 150             }
 151         }).when(jobManager).jobFinished(JOB_ID);
 152         when(vnfApi.vnfsVnfInstanceIdScalePost(eq(VNF_ID), actualScaleRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
 153             @Override
 154             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
 155                 operationExecutions.add(scaleOperationExecution);
 156                 return buildObservable(scaleOperationExecution);
 157             }
 158         });
 159         when(vnfApi.vnfsVnfInstanceIdHealPost(eq(VNF_ID), actualHealRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
 160             @Override
 161             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
 162                 operationExecutions.add(healOperationExecution);
 163                 return buildObservable(healOperationExecution);
 164             }
 165         });
 166         when(vnfApi.vnfsVnfInstanceIdCustomCustomOperationNamePost(eq(VNF_ID), operationIdCaptor.capture(), customOperationRequestArgumentCaptor.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
 167             @Override
 168             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
 169                 operationExecutions.add(customOperationExecution);
 170                 return buildObservable(customOperationExecution);
 171             }
 172         });
 173     }
 174
 175     /**
 176      * test instantiation
 177      */
 178     @Test
 179     public void testInstantiation() throws Exception {
 180         //given
 181         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 182
 183         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 184         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 185         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 186         grantResponse.setVimId(VIM_ID);
 187         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 188         accessInfo.setTenant(TENANT);
 189         grantResponse.setAccessInfo(accessInfo);
 190         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 191         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 192         //when
 193         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 194         waitForJobToFinishInJobManager(finished);
 195         //verify
 196         assertEquals(VNF_ID, response.getVnfInstanceId());
 197         assertEquals(JOB_ID, response.getJobId());
 198         assertEquals(createRequest.getAllValues().size(), 1);
 199         assertEquals("myDescription", createRequest.getValue().getDescription());
 200         assertEquals("vnfName", createRequest.getValue().getName());
 201         assertEquals(CBAM_VNFD_ID, createRequest.getValue().getVnfdId());
 202         assertEquals(1, actualInstantiationRequest.getAllValues().size());
 203         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 204         OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
 205         assertEquals(VIM_ID, actualVim.getId());
 206         assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, actualVim.getVimInfoType());
 207         assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
 208         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 209         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 210         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 211         assertEquals("regionId", actualVim.getAccessInfo().getRegion());
 212         assertEquals("myTenant", actualVim.getAccessInfo().getTenant());
 213         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 214         assertEquals(1, actualInstantiationRequest.getValue().getComputeResourceFlavours().size());
 215         assertEquals("flavourProviderId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getResourceId());
 216         assertEquals(VIM_ID, actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVimId());
 217         assertEquals("virtualComputeDescId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVnfdVirtualComputeDescId());
 218         assertEquals(1, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().size());
 219         assertEquals(extManVl, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().get(0));
 220         assertEquals(2, actualInstantiationRequest.getValue().getExtVirtualLinks().size());
 221
 222         assertEquals("myNetworkProviderId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getResourceId());
 223         assertEquals("myEVlId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtVirtualLinkId());
 224         assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().size());
 225         assertEquals("myCpdId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().get(0).getCpdId());
 226
 227         assertEquals(VIM_ID, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getVimId());
 228         assertEquals("evlId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtVirtualLinkId());
 229         assertEquals("networkProviderId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getResourceId());
 230         assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().size());
 231
 232
 233         assertEquals(Integer.valueOf(2), actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getNumDynamicAddresses());
 234         assertEquals("cpdId3", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getCpdId());
 235         assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().size());
 236         assertEquals("1.2.3.4", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getIp());
 237         assertEquals("mac", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getMac());
 238         assertEquals("subnetId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getSubnetId());
 239
 240         assertEquals("myFlavorId", actualInstantiationRequest.getValue().getFlavourId());
 241         assertEquals(Boolean.TRUE, actualInstantiationRequest.getValue().isGrantlessMode());
 242         assertEquals("level1", actualInstantiationRequest.getValue().getInstantiationLevelId());
 243         assertEquals(1, actualInstantiationRequest.getValue().getZones().size());
 244         assertEquals(VIM_ID, actualInstantiationRequest.getValue().getZones().get(0).getVimId());
 245         assertEquals("zoneProviderId", actualInstantiationRequest.getValue().getZones().get(0).getResourceId());
 246         assertEquals("zoneId", actualInstantiationRequest.getValue().getZones().get(0).getId());
 247         assertEquals(1, actualInstantiationRequest.getValue().getSoftwareImages().size());
 248         assertEquals(VIM_ID, actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVimId());
 249         assertEquals("imageProviderId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getResourceId());
 250         assertEquals("imageId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVnfdSoftwareImageId());
 251         String actualEmbeddedAdditionParams = new Gson().toJson(actualInstantiationRequest.getValue().getAdditionalParams());
 252         assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(actualEmbeddedAdditionParams) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(actualEmbeddedAdditionParams));
 253         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
 254         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 255
 256         assertEquals(1, actualVnfModifyRequest.getAllValues().size());
 257         assertEquals(2, actualVnfModifyRequest.getValue().getExtensions().size());
 258         assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getName());
 259         assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getValue());
 260         assertEquals(LifecycleManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName());
 261         assertEquals(VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getValue());
 262
 263         //the 3.2 API does not accept empty array
 264         assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties());
 265         verify(jobManager).spawnJob(VNF_ID, restResponse);
 266         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
 267         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
 268     }
 269
 270     /**
 271      * invalid VIM type results in failure
 272      */
 273     @Test
 274     public void testInstantiationWithInvalidVimType() throws Exception {
 275         //given
 276         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
 277         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 278         when(logger.isInfoEnabled()).thenReturn(false);
 279         //when
 280         try {
 281             lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 282             //verify
 283             fail();
 284         } catch (Exception e) {
 285             assertEquals("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types", e.getMessage());
 286         }
 287         verify(vnfApi, never()).vnfsPost(Mockito.any(), Mockito.any());
 288         verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
 289         verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
 290         verify(logger).error("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types");
 291     }
 292
 293     /**
 294      * test instantiation with KeyStone V2 based with SSL
 295      */
 296     @Test
 297     public void testInstantiationV2WithSsl() throws Exception {
 298         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 299         when(logger.isInfoEnabled()).thenReturn(false);
 300         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 301         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 302         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 303         grantResponse.setVimId(VIM_ID);
 304         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 305         accessInfo.setTenant(TENANT);
 306         String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
 307         vimInfo.setSslInsecure("false");
 308         vimInfo.setSslCacert(caCert);
 309         grantResponse.setAccessInfo(accessInfo);
 310         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 311         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 312         JsonObject inputs = child((JsonObject) instantiationRequest.getAdditionalParam(), "inputs");
 313         JsonObject vnfs = child(child(inputs, "vnfs"), ONAP_CSAR_ID);
 314         vnfs.remove("additionalParams");
 315         //when
 316         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 317         waitForJobToFinishInJobManager(finished);
 318         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 319         //verify
 320         OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
 321         assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
 322         assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
 323         assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 324         verify(logger).warn("No additional parameters were specified for the operation");
 325         verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), anyString(), anyString(), anyString());
 326     }
 327
 328     /**
 329      * non specified SSL verification means not verified
 330      */
 331     @Test
 332     public void testInstantiationV2WithoutSsl() throws Exception {
 333         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 334
 335         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 336         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 337         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 338         grantResponse.setVimId(VIM_ID);
 339         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 340         accessInfo.setTenant(TENANT);
 341         vimInfo.setSslInsecure(null);
 342         grantResponse.setAccessInfo(accessInfo);
 343         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 344         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 345         //when
 346         lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 347         waitForJobToFinishInJobManager(finished);
 348         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 349         //verify
 350         OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
 351         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
 352         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 353     }
 354
 355     /**
 356      * test instantiation with KeyStone V3 based
 357      */
 358     @Test
 359     public void testInstantiationV3() throws Exception {
 360         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
 361         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 362         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 363         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 364         grantResponse.setVimId(VIM_ID);
 365         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 366         accessInfo.setTenant(TENANT);
 367         grantResponse.setAccessInfo(accessInfo);
 368         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 369         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 370         //when
 371         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 372         waitForJobToFinishInJobManager(finished);
 373         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 374         //verify
 375         OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
 376         assertEquals(VIM_ID, actualVim.getId());
 377         assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
 378         assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
 379         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 380         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 381         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 382         assertEquals("regionId", actualVim.getAccessInfo().getRegion());
 383         assertEquals("myTenant", actualVim.getAccessInfo().getProject());
 384         assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
 385         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 386         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
 387         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 388     }
 389
 390     /**
 391      * test instantiation with backward compatibility test with Amsterdam release
 392      * - the vim identifier is supplied as vimid with not camel case
 393      */
 394     @Test
 395     public void testInstantiationNoVimId() throws Exception {
 396         //given
 397         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 398         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 399         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 400         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 401         grantResponse.setVimid(VIM_ID);
 402         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 403         accessInfo.setTenant(TENANT);
 404         grantResponse.setAccessinfo(accessInfo);
 405         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 406         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 407         //when
 408         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 409         waitForJobToFinishInJobManager(finished);
 410         //verify
 411         assertEquals(VNF_ID, response.getVnfInstanceId());
 412         assertEquals(JOB_ID, response.getJobId());
 413         assertEquals(createRequest.getAllValues().size(), 1);
 414         assertEquals("myDescription", createRequest.getValue().getDescription());
 415         assertEquals("vnfName", createRequest.getValue().getName());
 416         assertEquals(CBAM_VNFD_ID, createRequest.getValue().getVnfdId());
 417         assertEquals(1, actualInstantiationRequest.getAllValues().size());
 418         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 419         OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
 420         assertEquals(VIM_ID, actualVim.getId());
 421         assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, actualVim.getVimInfoType());
 422         assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
 423         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 424         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 425         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 426         assertEquals("regionId", actualVim.getAccessInfo().getRegion());
 427         assertEquals("myTenant", actualVim.getAccessInfo().getTenant());
 428         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 429         assertEquals(1, actualInstantiationRequest.getValue().getComputeResourceFlavours().size());
 430         assertEquals("flavourProviderId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getResourceId());
 431         assertEquals(VIM_ID, actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVimId());
 432         assertEquals("virtualComputeDescId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVnfdVirtualComputeDescId());
 433         assertEquals(1, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().size());
 434         assertEquals(extManVl, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().get(0));
 435         assertEquals(2, actualInstantiationRequest.getValue().getExtVirtualLinks().size());
 436
 437         assertEquals("myNetworkProviderId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getResourceId());
 438         assertEquals("myEVlId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtVirtualLinkId());
 439         assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().size());
 440         assertEquals("myCpdId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().get(0).getCpdId());
 441
 442         assertEquals(VIM_ID, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getVimId());
 443         assertEquals("evlId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtVirtualLinkId());
 444         assertEquals("networkProviderId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getResourceId());
 445         assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().size());
 446
 447
 448         assertEquals(Integer.valueOf(2), actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getNumDynamicAddresses());
 449         assertEquals("cpdId3", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getCpdId());
 450         assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().size());
 451         assertEquals("1.2.3.4", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getIp());
 452         assertEquals("mac", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getMac());
 453         assertEquals("subnetId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getSubnetId());
 454
 455         assertEquals("myFlavorId", actualInstantiationRequest.getValue().getFlavourId());
 456         assertEquals(Boolean.TRUE, actualInstantiationRequest.getValue().isGrantlessMode());
 457         assertEquals("level1", actualInstantiationRequest.getValue().getInstantiationLevelId());
 458         assertEquals(1, actualInstantiationRequest.getValue().getZones().size());
 459         assertEquals(VIM_ID, actualInstantiationRequest.getValue().getZones().get(0).getVimId());
 460         assertEquals("zoneProviderId", actualInstantiationRequest.getValue().getZones().get(0).getResourceId());
 461         assertEquals("zoneId", actualInstantiationRequest.getValue().getZones().get(0).getId());
 462         assertEquals(1, actualInstantiationRequest.getValue().getSoftwareImages().size());
 463         assertEquals(VIM_ID, actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVimId());
 464         assertEquals("imageProviderId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getResourceId());
 465         assertEquals("imageId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVnfdSoftwareImageId());
 466         String actualEmbeddedAdditionParams = new Gson().toJson(actualInstantiationRequest.getValue().getAdditionalParams());
 467         assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(actualEmbeddedAdditionParams) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(actualEmbeddedAdditionParams));
 468         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
 469         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 470
 471         assertEquals(1, actualVnfModifyRequest.getAllValues().size());
 472         assertEquals(2, actualVnfModifyRequest.getValue().getExtensions().size());
 473         assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getName());
 474         assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getValue());
 475         assertEquals(LifecycleManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName());
 476         assertEquals(VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getValue());
 477
 478         //the 3.2 API does not accept empty array
 479         assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties());
 480         verify(jobManager).spawnJob(VNF_ID, restResponse);
 481         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
 482         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
 483     }
 484
 485     /**
 486      * test instantiation with KeyStone V3 based with SSL
 487      */
 488     @Test
 489     public void testInstantiationV3WithSsl() throws Exception {
 490         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
 491         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 492         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 493         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 494         grantResponse.setVimId(VIM_ID);
 495         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 496         accessInfo.setTenant(TENANT);
 497         String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
 498         vimInfo.setSslInsecure("false");
 499         vimInfo.setSslCacert(caCert);
 500         grantResponse.setAccessInfo(accessInfo);
 501         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 502         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 503         //when
 504         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 505         waitForJobToFinishInJobManager(finished);
 506         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 507         //verify
 508         OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
 509         assertEquals(VIM_ID, actualVim.getId());
 510         assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
 511         assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
 512         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 513         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 514         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 515         assertEquals("regionId", actualVim.getAccessInfo().getRegion());
 516         assertEquals("myTenant", actualVim.getAccessInfo().getProject());
 517         assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
 518         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 519         assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
 520         assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
 521         assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 522     }
 523
 524     /**
 525      * non specified SSL verification meams not verified for KeyStone V3 based
 526      */
 527     @Test
 528     public void testInstantiationV3WithNonSpecifiedSsl() throws Exception {
 529         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
 530         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 531         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 532         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 533         grantResponse.setVimId(VIM_ID);
 534         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 535         accessInfo.setTenant(TENANT);
 536         vimInfo.setSslInsecure(null);
 537         grantResponse.setAccessInfo(accessInfo);
 538         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 539         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 540         //when
 541         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 542         waitForJobToFinishInJobManager(finished);
 543         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 544         //verify
 545         OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
 546         assertEquals(VIM_ID, actualVim.getId());
 547         assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
 548         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 549         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 550         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 551         assertEquals("regionId", actualVim.getAccessInfo().getRegion());
 552         assertEquals("myTenant", actualVim.getAccessInfo().getProject());
 553         assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
 554         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 555         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
 556         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 557     }
 558
 559     /**
 560      * verify backward compatibility with Amsterdam release
 561      */
 562     @Test
 563     public void testInstantiationV3WithNoDomain() throws Exception {
 564         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 565         additionalParam.setDomain("myDomain");
 566         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
 567         vimInfo.setDomain(null);
 568         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 569         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 570         grantResponse.setVimId(VIM_ID);
 571         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 572         accessInfo.setTenant(TENANT);
 573         vimInfo.setSslInsecure(null);
 574         grantResponse.setAccessInfo(accessInfo);
 575         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 576         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 577         //when
 578         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 579         waitForJobToFinishInJobManager(finished);
 580         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 581         //verify
 582         OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
 583         assertEquals(VIM_ID, actualVim.getId());
 584         assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
 585         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 586         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 587         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 588         assertEquals("regionId", actualVim.getAccessInfo().getRegion());
 589         assertEquals("myTenant", actualVim.getAccessInfo().getProject());
 590         assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
 591         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 592         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
 593         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 594         verify(logger).warn("Setting domain from additional parameters");
 595     }
 596
 597     /**
 598      * verify backward compatibility with Amsterdam release
 599      * if no domain is specified error is propagated
 600      */
 601     @Test
 602     public void testInstantiationV3WithNoDomainFail() throws Exception {
 603         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
 604         vimInfo.setDomain(null);
 605         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 606         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 607         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 608         grantResponse.setVimId(VIM_ID);
 609         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 610         accessInfo.setTenant(TENANT);
 611         vimInfo.setSslInsecure(null);
 612         grantResponse.setAccessInfo(accessInfo);
 613         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 614         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 615         //when
 616         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 617         waitForJobToFinishInJobManager(finished);
 618         assertEquals(0, actualInstantiationRequest.getAllValues().size());
 619         //verify
 620         verify(logger).error("The cloud did not supply the cloud domain (Amsterdam release) and was not supplied as additional data");
 621     }
 622
 623     /**
 624      * test instantiation with vcloud
 625      */
 626     @Test
 627     public void testInstantiationVcloud() throws Exception {
 628         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
 629
 630         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 631         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 632         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 633         grantResponse.setVimId(VIM_ID);
 634         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 635         accessInfo.setTenant(TENANT);
 636         grantResponse.setAccessInfo(accessInfo);
 637         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 638         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 639         //when
 640         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 641         waitForJobToFinishInJobManager(finished);
 642         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 643         //verify
 644         VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
 645         assertEquals(VIM_ID, actualVim.getId());
 646         assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
 647         assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
 648         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 649         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 650         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 651         assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
 652         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 653         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
 654         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 655     }
 656
 657     /**
 658      * test instantiation with vCloud with SSL
 659      */
 660     @Test
 661     public void testInstantiationVcloudWithSsl() throws Exception {
 662         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
 663
 664         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 665         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 666         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 667         grantResponse.setVimId(VIM_ID);
 668         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 669         accessInfo.setTenant(TENANT);
 670         String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
 671         vimInfo.setSslInsecure("false");
 672         vimInfo.setSslCacert(caCert);
 673         grantResponse.setAccessInfo(accessInfo);
 674         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 675         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 676         //when
 677         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 678         waitForJobToFinishInJobManager(finished);
 679         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 680         //verify
 681         VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
 682         assertEquals(VIM_ID, actualVim.getId());
 683         assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
 684         assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
 685         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 686         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 687         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 688         assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
 689         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 690         assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
 691         assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
 692         assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 693     }
 694
 695     /**
 696      * test instantiation with vCloud with SSL
 697      */
 698     @Test
 699     public void testInstantiationVcloudWithNonSecifedSSl() throws Exception {
 700         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
 701
 702         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 703         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 704         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 705         grantResponse.setVimId(VIM_ID);
 706         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 707         accessInfo.setTenant(TENANT);
 708         vimInfo.setSslInsecure(null);
 709         grantResponse.setAccessInfo(accessInfo);
 710         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 711         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 712         //when
 713         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 714         waitForJobToFinishInJobManager(finished);
 715         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 716         //verify
 717         VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
 718         assertEquals(VIM_ID, actualVim.getId());
 719         assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
 720         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 721         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 722         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 723         assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
 724         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 725         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
 726         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 727     }
 728
 729     /**
 730      * test failure in the instantiation request marks the job to be finished in job manager
 731      */
 732     @Test
 733     public void testFailureInTheInstantiationRequest() throws Exception {
 734         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 735         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 736         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 737         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 738         grantResponse.setVimId(VIM_ID);
 739         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 740         accessInfo.setTenant(TENANT);
 741         grantResponse.setAccessInfo(accessInfo);
 742         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 743         RuntimeException expectedException = new RuntimeException();
 744         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
 745
 746         //when
 747         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 748         //verfiy
 749         waitForJobToFinishInJobManager(finished);
 750         assertEquals(VNF_ID, response.getVnfInstanceId());
 751         assertEquals(JOB_ID, response.getJobId());
 752         verify(logger).error("Unable to instantiate VNF with myVnfId identifier", expectedException);
 753     }
 754
 755     /**
 756      * instantiation fails if VF-C does not send vim identifier in grant response
 757      */
 758     @Test
 759     public void testVfcFailsToSendVimId() throws Exception {
 760         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 761
 762         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 763         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 764         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 765         //grantResponse.setVimId(VIM_ID);
 766         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 767         accessInfo.setTenant(TENANT);
 768         String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
 769         vimInfo.setSslInsecure("false");
 770         vimInfo.setSslCacert(caCert);
 771         grantResponse.setAccessInfo(accessInfo);
 772         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 773         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 774         //when
 775         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 776         waitForJobToFinishInJobManager(finished);
 777         assertEquals(0, actualInstantiationRequest.getAllValues().size());
 778         //verify
 779         verify(logger).error("VF-C did not send VIM identifier in grant response");
 780
 781     }
 782
 783     /**
 784      * test operation execution polling is retried in case of failures
 785      */
 786     @Test
 787     public void testFailureInTheOperationExecutionPollingDuringInstantiationRequest() throws Exception {
 788         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 789         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 790         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 791         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 792         grantResponse.setVimId(VIM_ID);
 793         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 794         accessInfo.setTenant(TENANT);
 795         grantResponse.setAccessInfo(accessInfo);
 796         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 797         List<RuntimeException> polling = new ArrayList<>();
 798         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 799         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).then(new Answer<Observable<List<OperationExecution>>>() {
 800             @Override
 801             public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
 802                 if (polling.size() > 2) {
 803                     return buildObservable(operationExecutions);
 804                 }
 805                 RuntimeException runtimeException = new RuntimeException();
 806                 polling.add(runtimeException);
 807                 throw runtimeException;
 808             }
 809         });
 810         //when
 811         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 812         //verfiy
 813         waitForJobToFinishInJobManager(finished);
 814         assertEquals(VNF_ID, response.getVnfInstanceId());
 815         assertEquals(JOB_ID, response.getJobId());
 816         assertEquals(3, polling.size());
 817         for (RuntimeException e : polling) {
 818             verify(logger).warn("Unable to retrieve operations details", e);
 819         }
 820         verify(systemFunctions, Mockito.times(3)).sleep(5000);
 821     }
 822
 823     /**
 824      * failure in VNF creation is logged an proagated
 825      */
 826     @Test
 827     public void failureInVnfCreationIsPropagated() throws Exception {
 828         //given
 829         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 830
 831         RuntimeException expectedException = new RuntimeException();
 832         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
 833         //when
 834         try {
 835             lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 836             //verify
 837             fail();
 838         } catch (RuntimeException e) {
 839             assertEquals(expectedException, e.getCause());
 840             verify(logger).error("Unable to create the VNF", expectedException);
 841         }
 842     }
 843
 844     /**
 845      * failure in updating the modifyable attributes of the VNF  is logged an proagated
 846      */
 847     @Test
 848     public void failureInVnfModificationIsPropagated() throws Exception {
 849         //given
 850         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 851
 852         RuntimeException expectedException = new RuntimeException();
 853         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 854         when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
 855
 856         //when
 857         try {
 858             lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 859             //verify
 860             fail();
 861         } catch (RuntimeException e) {
 862             assertEquals(expectedException, e.getCause().getCause());
 863             verify(logger).error("Unable to set the onapCsarId property on the VNF", expectedException);
 864         }
 865     }
 866
 867     /**
 868      * if the VIM info can not be queried the VNF is not instantiated and
 869      * error propagated through job
 870      */
 871     @Test
 872     public void testFailureInQueryVimInfo() throws Exception {
 873         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 874         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 875         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 876         grantResponse.setVimId(VIM_ID);
 877         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 878         accessInfo.setTenant(TENANT);
 879         grantResponse.setAccessInfo(accessInfo);
 880
 881         when(vimInfoProvider.getVimInfo(VIM_ID)).thenThrow(new RuntimeException());
 882         //when
 883         lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 884         //verify
 885         waitForJobToFinishInJobManager(finished);
 886         verify(vnfApi, never()).vnfsVnfInstanceIdInstantiatePost(Mockito.any(), Mockito.any(), Mockito.any());
 887     }
 888
 889     /**
 890      * test termination basic success scenario
 891      * - the VNF is not deleted before the notifications are processed
 892      */
 893     @Test
 894     public void testTerminationAndDeletion() throws Exception {
 895         //given
 896         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
 897         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
 898         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
 899         vnfInfo.setOperationExecutions(operationExecutions);
 900         VnfProperty vnfdId = new VnfProperty();
 901         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
 902         vnfdId.setValue(ONAP_CSAR_ID);
 903         vnfInfo.getExtensions().add(vnfdId);
 904         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
 905         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
 906             @Override
 907             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
 908                 OperationExecution terminationOperation = new OperationExecution();
 909                 terminationOperation.setId("terminationId");
 910                 operationExecutions.add(terminationOperation);
 911                 terminationOperation.setStatus(OperationStatus.FINISHED);
 912                 return buildObservable(terminationOperation);
 913             }
 914         });
 915         when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
 916         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
 917         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
 918         //when
 919         JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
 920         //verify
 921         waitForJobToFinishInJobManager(finished);
 922         assertEquals(1, actualTerminationRequest.getAllValues().size());
 923         assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
 924         assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
 925         InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
 926         notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
 927         notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
 928         notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
 929         VOID_OBSERVABLE.assertCalled();
 930         verify(jobManager).spawnJob(VNF_ID, restResponse);
 931         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
 932     }
 933
 934     /**
 935      * test termination basic success scenario
 936      * - the VNF is not deleted before the notifications are processed
 937      */
 938     @Test
 939     public void testTermination() throws Exception {
 940         //given
 941         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
 942         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
 943         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
 944         vnfInfo.setOperationExecutions(operationExecutions);
 945         VnfProperty vnfdId = new VnfProperty();
 946         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
 947         vnfdId.setValue(ONAP_CSAR_ID);
 948         vnfInfo.getExtensions().add(vnfdId);
 949         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
 950         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
 951             @Override
 952             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
 953                 OperationExecution terminationOperation = new OperationExecution();
 954                 terminationOperation.setId("terminationId");
 955                 operationExecutions.add(terminationOperation);
 956                 terminationOperation.setStatus(OperationStatus.FINISHED);
 957                 return buildObservable(terminationOperation);
 958             }
 959         });
 960         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
 961         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
 962         //when
 963         JobInfo jobInfo = lifecycleManager.terminate(VNFM_ID, VNF_ID, terminationRequest, restResponse);
 964         //verify
 965         waitForJobToFinishInJobManager(finished);
 966         assertEquals(1, actualTerminationRequest.getAllValues().size());
 967         assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
 968         assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
 969         InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
 970         notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
 971         notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
 972         verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
 973         verify(jobManager).spawnJob(VNF_ID, restResponse);
 974         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
 975     }
 976
 977     /**
 978      * test termination of a non instantiated VNF
 979      * - the VNF is not terminated (only deleted)
 980      */
 981     @Test
 982     public void testTerminationOfNonInstantiated() throws Exception {
 983         //given
 984         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
 985         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
 986         vnfInfo.setInstantiationState(InstantiationState.NOT_INSTANTIATED);
 987         vnfInfo.setOperationExecutions(operationExecutions);
 988         VnfProperty vnfdId = new VnfProperty();
 989         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
 990         vnfdId.setValue(ONAP_CSAR_ID);
 991         vnfInfo.getExtensions().add(vnfdId);
 992         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
 993         when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
 994         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
 995         //when
 996         lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
 997         //verify
 998         boolean deleted = false;
 999         while (!deleted) {
1000             try {
1001                 verify(logger).info("The VNF with {} identifier has been deleted", VNF_ID);
1002                 deleted = true;
1003             } catch (Error e) {
1004             }
1005         }
1006         verify(vfcGrantManager, never()).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1007         verify(notificationManager, never()).waitForTerminationToBeProcessed("terminationId");
1008         verify(logger).warn("The VNF with {} identifier is not instantiated no termination is required", VNF_ID);
1009         verify(logger).info("Deleting VNF with {} identifier", VNF_ID);
1010         verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1011         VOID_OBSERVABLE.assertCalled();
1012     }
1013
1014     /**
1015      * test that the VNF deletion is not started before the termination finishes
1016      */
1017     @Test
1018     public void testTerminationOperationIsOutwaited() throws Exception {
1019         //given
1020         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1021         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1022         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1023         vnfInfo.setOperationExecutions(operationExecutions);
1024         VnfProperty vnfdId = new VnfProperty();
1025         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1026         vnfdId.setValue(ONAP_CSAR_ID);
1027         vnfInfo.getExtensions().add(vnfdId);
1028         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1029         OperationExecution terminationOperation = new OperationExecution();
1030         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
1031             terminationOperation.setId("terminationId");
1032             operationExecutions.add(terminationOperation);
1033             terminationOperation.setStatus(OperationStatus.STARTED);
1034             return buildObservable(terminationOperation);
1035         });
1036         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1037         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1038         Set<Integer> calls = new HashSet<>();
1039         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(invocation -> {
1040             if (calls.size() == 1000) {
1041                 terminationOperation.setStatus(OperationStatus.FINISHED);
1042             }
1043             calls.add(calls.size());
1044             return buildObservable(operationExecutions);
1045         });
1046         //when
1047         JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1048         //verify
1049         waitForJobToFinishInJobManager(finished);
1050         verify(vnfApi, times(1001)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
1051         verify(systemFunctions, times(1000)).sleep(5000);
1052     }
1053
1054
1055     /**
1056      * test that failured during waiting for the operation to finish is tolerated (idefineiatelly)
1057      */
1058     @Test
1059     public void testTerminationOperationIsOutwaitedWithErrors() throws Exception {
1060         //given
1061         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1062         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1063         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1064         vnfInfo.setOperationExecutions(operationExecutions);
1065         VnfProperty vnfdId = new VnfProperty();
1066         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1067         vnfdId.setValue(ONAP_CSAR_ID);
1068         vnfInfo.getExtensions().add(vnfdId);
1069         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1070         OperationExecution terminationOperation = new OperationExecution();
1071         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1072             @Override
1073             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1074                 terminationOperation.setId("terminationId");
1075                 operationExecutions.add(terminationOperation);
1076                 terminationOperation.setStatus(OperationStatus.STARTED);
1077                 return buildObservable(terminationOperation);
1078             }
1079         });
1080         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1081         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1082         Set<Integer> calls = new HashSet<>();
1083         List<RuntimeException> expectedExceptions = new ArrayList<>();
1084         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
1085             @Override
1086             public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
1087                 if (calls.size() >= 100) {
1088                     terminationOperation.setStatus(OperationStatus.FINISHED);
1089                     return buildObservable(operationExecutions);
1090                 }
1091                 calls.add(calls.size());
1092                 RuntimeException RuntimeException = new RuntimeException();
1093                 expectedExceptions.add(RuntimeException);
1094                 throw RuntimeException;
1095             }
1096         });
1097         //when
1098         JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1099         //verify
1100         waitForJobToFinishInJobManager(finished);
1101         verify(vnfApi, times(101)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
1102         verify(systemFunctions, times(100)).sleep(5000);
1103         for (RuntimeException expectedException : expectedExceptions) {
1104             verify(logger).warn("Unable to retrieve operations details", expectedException);
1105         }
1106     }
1107
1108     /**
1109      * test gracefull termination
1110      */
1111     @Test
1112     public void testGracefullTermination() throws Exception {
1113         //given
1114         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1115         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1116         terminationRequest.setTerminationType(VnfTerminationType.GRACEFUL);
1117         terminationRequest.setGracefulTerminationTimeout("1234");
1118         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1119         vnfInfo.setOperationExecutions(operationExecutions);
1120         VnfProperty vnfdId = new VnfProperty();
1121         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1122         vnfdId.setValue(ONAP_CSAR_ID);
1123         vnfInfo.getExtensions().add(vnfdId);
1124         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1125         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1126             @Override
1127             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1128                 OperationExecution terminationOperation = new OperationExecution();
1129                 terminationOperation.setId("terminationId");
1130                 operationExecutions.add(terminationOperation);
1131                 terminationOperation.setStatus(OperationStatus.FINISHED);
1132                 return buildObservable(terminationOperation);
1133             }
1134         });
1135         doAnswer(invocation -> {
1136             verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
1137             return null;
1138         }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1139         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1140         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1141         //when
1142         JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1143         //verify
1144         waitForJobToFinishInJobManager(finished);
1145         assertEquals(1, actualTerminationRequest.getAllValues().size());
1146         assertEquals(TerminationType.GRACEFUL, actualTerminationRequest.getValue().getTerminationType());
1147         assertEquals(Integer.valueOf(1234), actualTerminationRequest.getValue().getGracefulTerminationTimeout());
1148         InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
1149         notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1150         notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
1151         notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1152     }
1153
1154     /**
1155      * instantiation with missing ONAP csarId to instantiation extra param result in failure
1156      */
1157     @Test
1158     public void testMissingVnfParameters() throws Exception {
1159         //given
1160         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1161         String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "invalid" + "\" : {}}}, \"vimId\" : \"" + VIM_ID + "\"}";
1162         instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
1163         //when
1164         try {
1165             VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
1166             fail();
1167         } catch (Exception e) {
1168             assertEquals("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id", e.getMessage());
1169             verify(logger).error("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id");
1170         }
1171     }
1172
1173     /**
1174      * test explicit forceful termination
1175      */
1176     @Test
1177     public void testExplicitForcefulTermination() throws Exception {
1178         //given
1179         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1180         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1181         terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1182         terminationRequest.setGracefulTerminationTimeout("1234");
1183         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1184         vnfInfo.setOperationExecutions(operationExecutions);
1185         VnfProperty vnfdId = new VnfProperty();
1186         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1187         vnfdId.setValue(ONAP_CSAR_ID);
1188         vnfInfo.getExtensions().add(vnfdId);
1189         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1190         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
1191             OperationExecution terminationOperation = new OperationExecution();
1192             terminationOperation.setId("terminationId");
1193             operationExecutions.add(terminationOperation);
1194             terminationOperation.setStatus(OperationStatus.FINISHED);
1195             return buildObservable(terminationOperation);
1196         });
1197         doAnswer(invocation -> {
1198             verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
1199             return null;
1200         }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1201         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1202         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1203         //when
1204         JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1205         //verify
1206         waitForJobToFinishInJobManager(finished);
1207         assertEquals(1, actualTerminationRequest.getAllValues().size());
1208         assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1209         assertNull(actualTerminationRequest.getValue().getGracefulTerminationTimeout());
1210         InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
1211         notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1212         notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
1213         notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1214     }
1215
1216     /**
1217      * test failure in the termination workflow finishes the job
1218      */
1219     @Test
1220     public void testFailureInTheTerminationFinishesTheManagedJob() throws Exception {
1221         //given
1222         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1223         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1224         terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1225         terminationRequest.setGracefulTerminationTimeout("1234");
1226         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1227         vnfInfo.setOperationExecutions(operationExecutions);
1228         VnfProperty vnfdId = new VnfProperty();
1229         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1230         vnfdId.setValue(ONAP_CSAR_ID);
1231         vnfInfo.getExtensions().add(vnfdId);
1232         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1233         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
1234             @Override
1235             public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
1236                 OperationExecution terminationOperation = new OperationExecution();
1237                 terminationOperation.setId("terminationId");
1238                 operationExecutions.add(terminationOperation);
1239                 terminationOperation.setStatus(OperationStatus.FINISHED);
1240                 return terminationOperation;
1241             }
1242         });
1243         RuntimeException expectedException = new RuntimeException();
1244         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1245         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1246         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1247         //when
1248         JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1249         //verify
1250         waitForJobToFinishInJobManager(finished);
1251         assertEquals(0, actualTerminationRequest.getAllValues().size());
1252         Mockito.verifyZeroInteractions(vfcGrantManager);
1253     }
1254
1255     /**
1256      * if termination fails the VNF is not deleted
1257      */
1258     @Test
1259     public void testFailedTerminationAbortsTerminationWorkflow() throws Exception {
1260         //given
1261         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1262         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1263         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1264         vnfInfo.setOperationExecutions(operationExecutions);
1265         VnfProperty vnfdId = new VnfProperty();
1266         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1267         vnfdId.setValue(ONAP_CSAR_ID);
1268         vnfInfo.getExtensions().add(vnfdId);
1269         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1270         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1271             @Override
1272             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1273                 OperationExecution terminationOperation = new OperationExecution();
1274                 terminationOperation.setId("terminationId");
1275                 operationExecutions.add(terminationOperation);
1276                 terminationOperation.setStatus(OperationStatus.FAILED);
1277                 return buildObservable(terminationOperation);
1278             }
1279         });
1280         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1281         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1282         //when
1283         JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1284         //verify
1285         waitForJobToFinishInJobManager(finished);
1286         assertEquals(1, actualTerminationRequest.getAllValues().size());
1287         assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1288         verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1289         verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1290         verify(logger).error("Unable to terminate VNF the operation did not finish with success");
1291     }
1292
1293     /**
1294      * test VNF query basic success scenario
1295      */
1296     @Test
1297     public void testQuery() throws Exception {
1298         vnfInfo.setDescription("myDescription");
1299         vnfInfo.setName("myName");
1300         vnfInfo.setVnfSoftwareVersion("vnfSoftwareVersion");
1301         vnfInfo.setVnfProvider("myProvider");
1302         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1303         VnfProperty prop = new VnfProperty();
1304         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1305         prop.setValue(ONAP_CSAR_ID);
1306         vnfInfo.getExtensions().add(prop);
1307         //when
1308         org.onap.vnfmdriver.model.VnfInfo vnf = lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1309         //verify
1310         assertEquals(VNF_ID, vnf.getVnfInstanceId());
1311         //FIXME ? (do not know what exactly the vnf version mean in core terminology)
1312         assertEquals("vnfSoftwareVersion", vnf.getVersion());
1313         assertEquals(ONAP_CSAR_ID, vnf.getVnfdId());
1314         assertEquals("myDescription", vnf.getVnfInstanceDescription());
1315         assertEquals("myName", vnf.getVnfInstanceName());
1316         assertEquals(ONAP_CSAR_ID, vnf.getVnfPackageId());
1317         assertEquals("myProvider", vnf.getVnfProvider());
1318         //FIXME (in swagger schema )
1319         assertEquals("ACTIVE", vnf.getVnfStatus());
1320         assertEquals("Kuku", vnf.getVnfType());
1321     }
1322
1323     /**
1324      * error is propagated and logged if the queried VNF does not exist
1325      */
1326     @Test
1327     public void testQueryForNonExistingVnf() throws Exception {
1328
1329         RuntimeException expectedException = new RuntimeException();
1330         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1331         //when
1332         try {
1333             lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1334             //verify
1335             fail();
1336         } catch (Exception e) {
1337             verify(logger).error("Unable to query VNF (myVnfId)", expectedException);
1338             assertEquals(expectedException, e.getCause());
1339         }
1340     }
1341
1342     /**
1343      * test scale basic scenario
1344      */
1345     @Test
1346     public void testScale() throws Exception {
1347         VnfScaleRequest scaleRequest = new VnfScaleRequest();
1348         scaleRequest.setNumberOfSteps("2");
1349         scaleRequest.setAspectId("myAspect");
1350         scaleRequest.setType(ScaleDirection.IN);
1351         scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }"));
1352         scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1353         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1354         VnfProperty prop = new VnfProperty();
1355         prop.setValue(ONAP_CSAR_ID);
1356         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1357         vnfInfo.getExtensions().add(prop);
1358         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1359         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1360         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1361         //when
1362         JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1363         //verify
1364         waitForJobToFinishInJobManager(finished);
1365         assertEquals(1, actualScaleRequest.getAllValues().size());
1366         ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1367         InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1368         workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1369         workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1370         assertEquals("myAspect", sRequest.getAspectId());
1371         assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1372         assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1373         assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1374         verify(jobManager).spawnJob(VNF_ID, restResponse);
1375         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("scale"), eq(VNF_ID), anyString());
1376
1377     }
1378
1379     /**
1380      * the VNFM should tolerate that no additional params were supplied
1381      */
1382     @Test
1383     public void testScaleWithoutAddtionalParams() throws Exception {
1384         VnfScaleRequest scaleRequest = new VnfScaleRequest();
1385         scaleRequest.setNumberOfSteps("2");
1386         scaleRequest.setAspectId("myAspect");
1387         scaleRequest.setType(ScaleDirection.IN);
1388         scaleRequest.setAdditionalParam(null);
1389         scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1390         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1391         VnfProperty prop = new VnfProperty();
1392         prop.setValue(ONAP_CSAR_ID);
1393         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1394         vnfInfo.getExtensions().add(prop);
1395         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1396         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1397         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1398         //when
1399         JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1400         //verify
1401         waitForJobToFinishInJobManager(finished);
1402         assertEquals(1, actualScaleRequest.getAllValues().size());
1403         ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1404         InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1405         workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1406         workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1407         assertEquals("myAspect", sRequest.getAspectId());
1408         assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1409         assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1410         assertEquals("{\"jobId\":\"myJobId\"}", new Gson().toJson(sRequest.getAdditionalParams()));
1411         verify(jobManager).spawnJob(VNF_ID, restResponse);
1412     }
1413
1414     /**
1415      * test scale out basic scenario
1416      */
1417     @Test
1418     public void testScaleOut() throws Exception {
1419         VnfScaleRequest scaleRequest = new VnfScaleRequest();
1420         scaleRequest.setNumberOfSteps("2");
1421         scaleRequest.setAspectId("myAspect");
1422         scaleRequest.setType(ScaleDirection.OUT);
1423         scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1424         scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1425         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1426         VnfProperty prop = new VnfProperty();
1427         prop.setValue(ONAP_CSAR_ID);
1428         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1429         vnfInfo.getExtensions().add(prop);
1430         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1431         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1432         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1433         //when
1434         JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1435         //verify
1436         waitForJobToFinishInJobManager(finished);
1437         assertEquals(1, actualScaleRequest.getAllValues().size());
1438         ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1439         InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1440         workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1441         workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1442         assertEquals("myAspect", sRequest.getAspectId());
1443         assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.OUT, sRequest.getType());
1444         assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1445         assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1446     }
1447
1448     /**
1449      * test scale operation is out waited
1450      */
1451     @Test
1452     public void testScaleOutwait() throws Exception {
1453         VnfScaleRequest scaleRequest = new VnfScaleRequest();
1454         scaleRequest.setNumberOfSteps("2");
1455         scaleRequest.setAspectId("myAspect");
1456         scaleRequest.setType(ScaleDirection.IN);
1457         scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1458         scaleOperationExecution.setStatus(OperationStatus.STARTED);
1459         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1460         VnfProperty prop = new VnfProperty();
1461         prop.setValue(ONAP_CSAR_ID);
1462         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1463         vnfInfo.getExtensions().add(prop);
1464         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1465         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1466         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1467         List<RuntimeException> expectedExceptions = new ArrayList<>();
1468         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<Observable<List<OperationExecution>>>) invocation -> {
1469             if (expectedExceptions.size() >= 100) {
1470                 when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(scaleOperationExecution));
1471                 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1472                 return buildObservable(operationExecutions);
1473             }
1474             RuntimeException RuntimeException = new RuntimeException();
1475             expectedExceptions.add(RuntimeException);
1476             throw RuntimeException;
1477         });
1478
1479         //when
1480         JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1481         //verify
1482         waitForJobToFinishInJobManager(finished);
1483         assertEquals(100, expectedExceptions.size());
1484         for (RuntimeException expectedException : expectedExceptions) {
1485             verify(logger).warn("Unable to retrieve operations details", expectedException);
1486         }
1487         verify(systemFunctions, times(100)).sleep(5000);
1488     }
1489
1490     /**
1491      * test scale failure propagation
1492      */
1493     @Test
1494     public void testScaleFailurePropagation() throws Exception {
1495         RuntimeException expectedException = new RuntimeException();
1496         VnfScaleRequest scaleRequest = new VnfScaleRequest();
1497         scaleRequest.setNumberOfSteps("2");
1498         scaleRequest.setAspectId("myAspect");
1499         scaleRequest.setType(ScaleDirection.IN);
1500         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1501         //when
1502         lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1503         //verify
1504         waitForJobToFinishInJobManager(finished);
1505         verify(logger).error("Unable to scale VNF with myVnfId identifier", expectedException);
1506     }
1507
1508     /**
1509      * test heal basic scenario
1510      */
1511     @Test
1512     public void testHeal() throws Exception {
1513         VnfHealRequest healRequest = new VnfHealRequest();
1514         healRequest.setAction("myAction");
1515         VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1516         affectedVm.setVmname("vmName");
1517         healRequest.setAffectedvm(affectedVm);
1518         healOperationExecution.setStatus(OperationStatus.FINISHED);
1519         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1520         VnfProperty prop = new VnfProperty();
1521         prop.setValue(ONAP_CSAR_ID);
1522         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1523         vnfInfo.getExtensions().add(prop);
1524         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1525         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1526         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1527         //when
1528         JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1529         //verify
1530         waitForJobToFinishInJobManager(finished);
1531         assertEquals(1, actualHealRequest.getAllValues().size());
1532         HealVnfRequest sRequest = actualHealRequest.getValue();
1533         InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1534         workflowOrder.verify(vfcGrantManager).requestGrantForHeal(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(healRequest), eq(JOB_ID));
1535         workflowOrder.verify(vnfApi).vnfsVnfInstanceIdHealPost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1536         JsonObject root = new Gson().toJsonTree(sRequest.getAdditionalParams()).getAsJsonObject();
1537         assertEquals("myAction", root.get("action").getAsString());
1538         assertEquals("vmName", root.get("vmName").getAsString());
1539         assertEquals(JOB_ID, root.get("jobId").getAsString());
1540         verify(jobManager).spawnJob(VNF_ID, restResponse);
1541         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("heal"), eq(VNF_ID), anyString());
1542     }
1543
1544     /**
1545      * test heal operation is out waited
1546      */
1547     @Test
1548     public void testHealOutwait() throws Exception {
1549         VnfHealRequest healRequest = new VnfHealRequest();
1550         healRequest.setAction("myAction");
1551         VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1552         affectedVm.setVmname("vmName");
1553         healRequest.setAffectedvm(affectedVm);
1554         healOperationExecution.setStatus(OperationStatus.FINISHED);
1555         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1556         VnfProperty prop = new VnfProperty();
1557         prop.setValue(ONAP_CSAR_ID);
1558         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1559         vnfInfo.getExtensions().add(prop);
1560         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1561         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1562         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1563         List<RuntimeException> expectedExceptions = new ArrayList<>();
1564         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
1565             @Override
1566             public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
1567                 if (expectedExceptions.size() >= 100) {
1568                     scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1569                     return buildObservable(operationExecutions);
1570                 }
1571                 RuntimeException RuntimeException = new RuntimeException();
1572                 expectedExceptions.add(RuntimeException);
1573                 throw RuntimeException;
1574             }
1575         });
1576         //when
1577         JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1578         //verify
1579         waitForJobToFinishInJobManager(finished);
1580         assertEquals(100, expectedExceptions.size());
1581         for (RuntimeException expectedException : expectedExceptions) {
1582             verify(logger).warn("Unable to retrieve operations details", expectedException);
1583         }
1584         verify(systemFunctions, times(100)).sleep(5000);
1585     }
1586
1587     /**
1588      * failure in heal propagates in error
1589      */
1590     @Test
1591     public void testHealFailurePropagation() throws Exception {
1592         RuntimeException expectedException = new RuntimeException();
1593         VnfHealRequest healRequest = new VnfHealRequest();
1594         healRequest.setAction("myAction");
1595         VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1596         affectedVm.setVmname("vmName");
1597         healRequest.setAffectedvm(affectedVm);
1598         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1599         //when
1600         JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1601         //verify
1602         waitForJobToFinishInJobManager(finished);
1603         verify(logger).error("Unable to heal VNF with myVnfId identifier", expectedException);
1604     }
1605
1606
1607     /**
1608      * test custom operation basic scenario
1609      */
1610     @Test
1611     public void testCustomOperation() throws Exception {
1612         String operationId = "operationIdCaptor";
1613         Object additionalParams = new JsonObject();
1614         //when
1615         JobInfo job = lifecycleManager.customOperation(VNFM_ID, VNF_ID, operationId, additionalParams, restResponse);
1616         //verify
1617         waitForJobToFinishInJobManager(finished);
1618         assertEquals(operationId, operationIdCaptor.getValue());
1619         assertEquals(additionalParams, customOperationRequestArgumentCaptor.getValue().getAdditionalParams());
1620     }
1621
1622     private void waitForJobToFinishInJobManager(Set<Boolean> finished) throws InterruptedException {
1623         while (finished.size() == 0) {
1624             systemFunctions().sleep(100);
1625         }
1626     }
1627
1628     private VnfInstantiateRequest prepareInstantiationRequest(VimInfo.VimInfoTypeEnum cloudType) {
1629         VnfInstantiateRequest instantiationRequest = new VnfInstantiateRequest();
1630         instantiationRequest.setVnfPackageId(ONAP_CSAR_ID);
1631         instantiationRequest.setVnfDescriptorId(ONAP_CSAR_ID);
1632         instantiationRequest.setVnfInstanceDescription("myDescription");
1633         instantiationRequest.setVnfInstanceName("vnfName");
1634         additionalParam.setInstantiationLevel("level1");
1635         switch (cloudType) {
1636             case OPENSTACK_V2_INFO:
1637                 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1638                 break;
1639             case OPENSTACK_V3_INFO:
1640                 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
1641                 vimInfo.setDomain("myDomain");
1642                 break;
1643             case VMWARE_VCLOUD_INFO:
1644                 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
1645                 break;
1646             default:
1647                 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
1648         }
1649
1650         Map<String, List<NetworkAddress>> exteranalConnectionPointAddresses = new HashMap<>();
1651         exteranalConnectionPointAddresses.put("ecp1", new ArrayList<>());
1652         NetworkAddress networkAddress = new NetworkAddress();
1653         networkAddress.setIp("1.2.3.4");
1654         networkAddress.setMac("mac");
1655         networkAddress.setSubnetId("subnetId");
1656         exteranalConnectionPointAddresses.get("ecp1").add(networkAddress);
1657         additionalParam.setExternalConnectionPointAddresses(exteranalConnectionPointAddresses);
1658         VimComputeResourceFlavour flavor = new VimComputeResourceFlavour();
1659         flavor.setResourceId("flavourProviderId");
1660         flavor.setVimId(VIM_ID);
1661         flavor.setVnfdVirtualComputeDescId("virtualComputeDescId");
1662         additionalParam.getComputeResourceFlavours().add(flavor);
1663         ExtVirtualLinkData evl = new ExtVirtualLinkData();
1664         evl.setResourceId("networkProviderId1");
1665         evl.setVimId(VIM_ID);
1666         evl.setExtVirtualLinkId("evlId1");
1667         VnfExtCpData ecp2 = new VnfExtCpData();
1668         ecp2.setCpdId("cpdId3");
1669         ecp2.setAddresses(new ArrayList<>());
1670         ecp2.getAddresses().add(networkAddress);
1671         ecp2.setNumDynamicAddresses(2);
1672         evl.getExtCps().add(ecp2);
1673         additionalParam.getExtVirtualLinks().add(evl);
1674         externalVirtualLink.setCpdId("myCpdId");
1675         externalVirtualLink.setResourceId("myNetworkProviderId");
1676         externalVirtualLink.setVlInstanceId("myEVlId");
1677         externalVirtualLink.setResourceSubnetId("notUsedSubnetId");
1678         instantiationRequest.setExtVirtualLink(new ArrayList<>());
1679         instantiationRequest.getExtVirtualLink().add(externalVirtualLink);
1680         additionalParam.getExtManagedVirtualLinks().add(extManVl);
1681         ZoneInfo zone = new ZoneInfo();
1682         zone.setId("zoneId");
1683         zone.setResourceId("zoneProviderId");
1684         zone.setVimId(VIM_ID);
1685         additionalParam.getZones().add(zone);
1686         VimSoftwareImage image = new VimSoftwareImage();
1687         image.setResourceId("imageProviderId");
1688         image.setVimId(VIM_ID);
1689         image.setVnfdSoftwareImageId("imageId");
1690         additionalParam.getSoftwareImages().add(image);
1691         additionalParam.setAdditionalParams(new JsonParser().parse("{ \"a\" : \"b\" }"));
1692         String params = new Gson().toJson(additionalParam);
1693         String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "\" : " + params + "}}, \"vimId\" : \"" + VIM_ID + "\"}";
1694         instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
1695         return instantiationRequest;
1696     }
1697
1698     /**
1699      * Test vimId decomposition
1700      */
1701     @Test
1702     public void testVimIdSplitting() {
1703         assertEquals("regionId", LifecycleManager.getRegionName("cloudOwner_regionId"));
1704         assertEquals("cloudOwner", LifecycleManager.getCloudOwner("cloudOwner_regionId"));
1705     }
1706 }