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

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