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