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

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