gerrit.onap Code Review - vfc/nfvo/driver/vnfm/svnfm.git/blob

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