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