Code Review / vfc / nfvo / driver / vnfm / svnfm.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Fix sonar issues
[vfc/nfvo/driver/vnfm/svnfm.git] / nokiav2 / driver / src / test / java / org / onap / vfc / nfvo / driver / vnfm / svnfm / nokia / vnfm / TestLifecycleManager.java
diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestLifecycleManager.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestLifecycleManager.java
index 64adaab..178f0b5 100644 (file)
--- a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestLifecycleManager.java
+++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestLifecycleManager.java
@@ -20,11 +20,14 @@ import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonParser;
 import com.nokia.cbam.catalog.v1.model.CatalogAdapterVnfpackage;
-import com.nokia.cbam.lcm.v32.ApiException;
 import com.nokia.cbam.lcm.v32.model.*;
 import com.nokia.cbam.lcm.v32.model.OperationType;
 import com.nokia.cbam.lcm.v32.model.VimInfo;
 import com.nokia.cbam.lcm.v32.model.VnfInfo;
+import io.reactivex.Observable;
+import java.nio.file.Paths;
+import java.util.*;
+import javax.servlet.http.HttpServletResponse;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;
@@ -43,15 +46,14 @@ import org.onap.vnfmdriver.model.*;
 import org.onap.vnfmdriver.model.ScaleDirection;
 import org.threeten.bp.OffsetDateTime;
 
-import javax.servlet.http.HttpServletResponse;
-import java.nio.file.Paths;
-import java.util.*;
-
 import static java.lang.Boolean.parseBoolean;
 import static java.nio.file.Files.readAllBytes;
+import static java.util.Optional.empty;
+
 import static junit.framework.TestCase.*;
 import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.*;
+import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.child;
 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions.systemFunctions;
 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
 import static org.springframework.test.util.ReflectionTestUtils.setField;
@@ -80,7 +82,7 @@ public class TestLifecycleManager extends TestBase {
     private VimInfoProvider vimInfoProvider;
 
     private ArgumentCaptor<CreateVnfRequest> createRequest = ArgumentCaptor.forClass(CreateVnfRequest.class);
-    private AdditionalParams additionalParam = new AdditionalParams();
+    private AdditionalParameters additionalParam = new AdditionalParameters();
     private String INSTANTIATION_LEVEL = "level1";
     private GrantVNFResponseVim grantResponse = new GrantVNFResponseVim();
     private String cbamVnfdContent;
@@ -126,7 +128,7 @@ public class TestLifecycleManager extends TestBase {
         instantiationOperationExecution.setId(OPERATION_EXECUTION_ID);
         instantiationOperationExecution.setOperationType(OperationType.INSTANTIATE);
         instantiationOperationExecution.setStartTime(OffsetDateTime.now());
-        when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(operationExecutions);
+        when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecutions));
         operationExecutions.add(modifyPropertyoperationExecution);
         modifyPropertyoperationExecution.setStartTime(OffsetDateTime.now());
         modifyPropertyoperationExecution.setOperationType(OperationType.MODIFY_INFO);
@@ -136,7 +138,7 @@ public class TestLifecycleManager extends TestBase {
         modifyPropertyoperationExecution.setId(UUID.randomUUID().toString());
         scaleOperationExecution.setId(UUID.randomUUID().toString());
         healOperationExecution.setId(UUID.randomUUID().toString());
-        when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(modifyPropertyoperationExecution);
+        when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(modifyPropertyoperationExecution));
         doAnswer(new Answer() {
             @Override
             public Object answer(InvocationOnMock invocation) throws Throwable {
@@ -144,18 +146,18 @@ public class TestLifecycleManager extends TestBase {
                 return null;
             }
         }).when(jobManager).jobFinished(JOB_ID);
-        when(vnfApi.vnfsVnfInstanceIdScalePost(eq(VNF_ID), actualScaleRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
+        when(vnfApi.vnfsVnfInstanceIdScalePost(eq(VNF_ID), actualScaleRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
             @Override
-            public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
+            public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
                 operationExecutions.add(scaleOperationExecution);
-                return scaleOperationExecution;
+                return buildObservable(scaleOperationExecution);
             }
         });
-        when(vnfApi.vnfsVnfInstanceIdHealPost(eq(VNF_ID), actualHealRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
+        when(vnfApi.vnfsVnfInstanceIdHealPost(eq(VNF_ID), actualHealRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
             @Override
-            public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
+            public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
                 operationExecutions.add(healOperationExecution);
-                return healOperationExecution;
+                return buildObservable(healOperationExecution);
             }
         });
     }
@@ -168,7 +170,7 @@ public class TestLifecycleManager extends TestBase {
         //given
         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 
-        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
         grantResponse.setVimId(VIM_ID);
@@ -176,9 +178,9 @@ public class TestLifecycleManager extends TestBase {
         accessInfo.setTenant(TENANT);
         grantResponse.setAccessInfo(accessInfo);
         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
-        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
         //when
-        VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
+        VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
         waitForJobToFinishInJobManager(finished);
         //verify
         assertEquals(VNF_ID, response.getVnfInstanceId());
@@ -245,12 +247,14 @@ public class TestLifecycleManager extends TestBase {
         assertEquals(2, actualVnfModifyRequest.getValue().getExtensions().size());
         assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getName());
         assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getValue());
-        assertEquals(ILifecycleChangeNotificationManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName());
+        assertEquals(LifecycleManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName());
         assertEquals(VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getValue());
 
         //the 3.2 API does not accept empty array
         assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties());
         verify(jobManager).spawnJob(VNF_ID, restResponse);
+        verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
+        verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
     }
 
     /**
@@ -260,16 +264,19 @@ public class TestLifecycleManager extends TestBase {
     public void testInstantiationWithInvalidVimType() throws Exception {
         //given
         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
-        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
+        when(logger.isInfoEnabled()).thenReturn(false);
         //when
         try {
-            lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
+            lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
             //verify
             fail();
         } catch (Exception e) {
             assertEquals("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types", e.getMessage());
         }
         verify(vnfApi, never()).vnfsPost(Mockito.any(), Mockito.any());
+        verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
+        verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
         verify(logger).error("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types");
     }
 
@@ -279,8 +286,8 @@ public class TestLifecycleManager extends TestBase {
     @Test
     public void testInstantiationV2WithSsl() throws Exception {
         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
-
-        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+        when(logger.isInfoEnabled()).thenReturn(false);
+        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
         grantResponse.setVimId(VIM_ID);
@@ -291,9 +298,12 @@ public class TestLifecycleManager extends TestBase {
         vimInfo.setSslCacert(caCert);
         grantResponse.setAccessInfo(accessInfo);
         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
-        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
+        JsonObject inputs = child((JsonObject) instantiationRequest.getAdditionalParam(), "inputs");
+        JsonObject vnfs = child(child(inputs, "vnfs"), ONAP_CSAR_ID);
+        vnfs.remove("additionalParams");
         //when
-        VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
+        VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
         waitForJobToFinishInJobManager(finished);
         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
         //verify
@@ -301,6 +311,35 @@ public class TestLifecycleManager extends TestBase {
         assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
         assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
         assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
+        verify(logger).warn("No additional parameters were specified for the operation");
+        verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), anyString(), anyString(), anyString());
+    }
+
+    /**
+     * non specified SSL verification means not verified
+     */
+    @Test
+    public void testInstantiationV2WithoutSsl() throws Exception {
+        VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
+
+        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
+        additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
+        when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
+        grantResponse.setVimId(VIM_ID);
+        GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
+        accessInfo.setTenant(TENANT);
+        vimInfo.setSslInsecure(null);
+        grantResponse.setAccessInfo(accessInfo);
+        ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
+        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
+        //when
+        lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
+        waitForJobToFinishInJobManager(finished);
+        assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
+        //verify
+        OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
+        assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
+        assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
     }
 
     /**
@@ -310,7 +349,7 @@ public class TestLifecycleManager extends TestBase {
     public void testInstantiationV3() throws Exception {
         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
 
-        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
         grantResponse.setVimId(VIM_ID);
@@ -318,9 +357,9 @@ public class TestLifecycleManager extends TestBase {
         accessInfo.setTenant(TENANT);
         grantResponse.setAccessInfo(accessInfo);
         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
-        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
         //when
-        VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
+        VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
         waitForJobToFinishInJobManager(finished);
         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
         //verify
@@ -346,7 +385,7 @@ public class TestLifecycleManager extends TestBase {
     public void testInstantiationV3WithSsl() throws Exception {
         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
 
-        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
         grantResponse.setVimId(VIM_ID);
@@ -357,9 +396,9 @@ public class TestLifecycleManager extends TestBase {
         vimInfo.setSslCacert(caCert);
         grantResponse.setAccessInfo(accessInfo);
         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
-        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
         //when
-        VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
+        VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
         waitForJobToFinishInJobManager(finished);
         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
         //verify
@@ -379,6 +418,42 @@ public class TestLifecycleManager extends TestBase {
         assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
     }
 
+    /**
+     * non specified SSL verification meams not verified for KeyStone V3 based
+     */
+    @Test
+    public void testInstantiationV3WithNonSpecifiedSsl() throws Exception {
+        VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
+
+        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
+        additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
+        when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
+        grantResponse.setVimId(VIM_ID);
+        GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
+        accessInfo.setTenant(TENANT);
+        vimInfo.setSslInsecure(null);
+        grantResponse.setAccessInfo(accessInfo);
+        ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
+        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
+        //when
+        VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
+        waitForJobToFinishInJobManager(finished);
+        assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
+        //verify
+        OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
+        assertEquals(VIM_ID, actualVim.getId());
+        assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
+        assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
+        //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
+        assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
+        assertEquals("regionId", actualVim.getAccessInfo().getRegion());
+        assertEquals("myTenant", actualVim.getAccessInfo().getProject());
+        assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
+        assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
+        assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
+        assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
+    }
+
     /**
      * test instantiation with vcloud
      */
@@ -386,7 +461,7 @@ public class TestLifecycleManager extends TestBase {
     public void testInstantiationVcloud() throws Exception {
         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
 
-        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
         grantResponse.setVimId(VIM_ID);
@@ -394,9 +469,9 @@ public class TestLifecycleManager extends TestBase {
         accessInfo.setTenant(TENANT);
         grantResponse.setAccessInfo(accessInfo);
         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
-        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
         //when
-        VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
+        VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
         waitForJobToFinishInJobManager(finished);
         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
         //verify
@@ -420,7 +495,7 @@ public class TestLifecycleManager extends TestBase {
     public void testInstantiationVcloudWithSsl() throws Exception {
         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
 
-        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
         grantResponse.setVimId(VIM_ID);
@@ -431,9 +506,9 @@ public class TestLifecycleManager extends TestBase {
         vimInfo.setSslCacert(caCert);
         grantResponse.setAccessInfo(accessInfo);
         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
-        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
         //when
-        VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
+        VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
         waitForJobToFinishInJobManager(finished);
         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
         //verify
@@ -451,13 +526,47 @@ public class TestLifecycleManager extends TestBase {
         assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
     }
 
+    /**
+     * test instantiation with vCloud with SSL
+     */
+    @Test
+    public void testInstantiationVcloudWithNonSecifedSSl() throws Exception {
+        VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
+
+        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
+        additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
+        when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
+        grantResponse.setVimId(VIM_ID);
+        GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
+        accessInfo.setTenant(TENANT);
+        vimInfo.setSslInsecure(null);
+        grantResponse.setAccessInfo(accessInfo);
+        ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
+        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
+        //when
+        VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
+        waitForJobToFinishInJobManager(finished);
+        assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
+        //verify
+        VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
+        assertEquals(VIM_ID, actualVim.getId());
+        assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
+        assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
+        //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
+        assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
+        assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
+        assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
+        assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
+        assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
+    }
+
     /**
      * test failure in the instantiation request marks the job to be finished in job manager
      */
     @Test
     public void testFailureInTheInstantiationRequest() throws Exception {
         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
-        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
         grantResponse.setVimId(VIM_ID);
@@ -465,11 +574,11 @@ public class TestLifecycleManager extends TestBase {
         accessInfo.setTenant(TENANT);
         grantResponse.setAccessInfo(accessInfo);
         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
-        ApiException expectedException = new ApiException();
+        RuntimeException expectedException = new RuntimeException();
         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
 
         //when
-        VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
+        VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
         //verfiy
         waitForJobToFinishInJobManager(finished);
         assertEquals(VNF_ID, response.getVnfInstanceId());
@@ -484,7 +593,7 @@ public class TestLifecycleManager extends TestBase {
     public void testVfcFailsToSendVimId() throws Exception {
         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 
-        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
         //grantResponse.setVimId(VIM_ID);
@@ -495,9 +604,9 @@ public class TestLifecycleManager extends TestBase {
         vimInfo.setSslCacert(caCert);
         grantResponse.setAccessInfo(accessInfo);
         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
-        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
         //when
-        VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
+        VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
         waitForJobToFinishInJobManager(finished);
         assertEquals(0, actualInstantiationRequest.getAllValues().size());
         //verify
@@ -511,7 +620,7 @@ public class TestLifecycleManager extends TestBase {
     @Test
     public void testFailureInTheOperationExecutionPollingDuringInstantiationRequest() throws Exception {
         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
-        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
         grantResponse.setVimId(VIM_ID);
@@ -519,28 +628,27 @@ public class TestLifecycleManager extends TestBase {
         accessInfo.setTenant(TENANT);
         grantResponse.setAccessInfo(accessInfo);
         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
-        ApiException expectedException = new ApiException();
-        List<ApiException> polling = new ArrayList<>();
-        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
-        when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).then(new Answer<List<OperationExecution>>() {
+        List<RuntimeException> polling = new ArrayList<>();
+        when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
+        when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).then(new Answer<Observable<List<OperationExecution>>>() {
             @Override
-            public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
+            public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
                 if (polling.size() > 2) {
-                    return operationExecutions;
+                    return buildObservable(operationExecutions);
                 }
-                ApiException apiException = new ApiException();
-                polling.add(apiException);
-                throw apiException;
+                RuntimeException runtimeException = new RuntimeException();
+                polling.add(runtimeException);
+                throw runtimeException;
             }
         });
         //when
-        VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
+        VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
         //verfiy
         waitForJobToFinishInJobManager(finished);
         assertEquals(VNF_ID, response.getVnfInstanceId());
         assertEquals(JOB_ID, response.getJobId());
         assertEquals(3, polling.size());
-        for (ApiException e : polling) {
+        for (RuntimeException e : polling) {
             verify(logger).warn("Unable to retrieve operations details", e);
         }
         verify(systemFunctions, Mockito.times(3)).sleep(5000);
@@ -554,11 +662,11 @@ public class TestLifecycleManager extends TestBase {
         //given
         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 
-        ApiException expectedException = new ApiException();
+        RuntimeException expectedException = new RuntimeException();
         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
         //when
         try {
-            lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
+            lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
             //verify
             fail();
         } catch (RuntimeException e) {
@@ -575,13 +683,13 @@ public class TestLifecycleManager extends TestBase {
         //given
         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 
-        ApiException expectedException = new ApiException();
-        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+        RuntimeException expectedException = new RuntimeException();
+        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
         when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
 
         //when
         try {
-            lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
+            lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
             //verify
             fail();
         } catch (RuntimeException e) {
@@ -597,7 +705,7 @@ public class TestLifecycleManager extends TestBase {
     @Test
     public void testFailureInQueryVimInfo() throws Exception {
         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
-        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+        when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
         grantResponse.setVimId(VIM_ID);
         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
@@ -606,7 +714,7 @@ public class TestLifecycleManager extends TestBase {
 
         when(vimInfoProvider.getVimInfo(VIM_ID)).thenThrow(new RuntimeException());
         //when
-        lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
+        lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
         //verify
         waitForJobToFinishInJobManager(finished);
         verify(vnfApi, never()).vnfsVnfInstanceIdInstantiatePost(Mockito.any(), Mockito.any(), Mockito.any());
@@ -620,7 +728,7 @@ public class TestLifecycleManager extends TestBase {
     public void testTermination() throws Exception {
         //given
         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
-        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
         vnfInfo.setOperationExecutions(operationExecutions);
         VnfProperty vnfdId = new VnfProperty();
@@ -628,29 +736,33 @@ public class TestLifecycleManager extends TestBase {
         vnfdId.setValue(ONAP_CSAR_ID);
         vnfInfo.getExtensions().add(vnfdId);
         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
-        when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
+        when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
             @Override
-            public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
+            public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
                 OperationExecution terminationOperation = new OperationExecution();
                 terminationOperation.setId("terminationId");
                 operationExecutions.add(terminationOperation);
                 terminationOperation.setStatus(OperationStatus.FINISHED);
-                return terminationOperation;
+                return buildObservable(terminationOperation);
             }
         });
+        when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
-        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
+        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
         //when
         JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
         //verify
         waitForJobToFinishInJobManager(finished);
         assertEquals(1, actualTerminationRequest.getAllValues().size());
         assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
+        assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
         InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
         notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
         notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
         notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
+        VOID_OBSERVABLE.assertCalled();
         verify(jobManager).spawnJob(VNF_ID, restResponse);
+        verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
     }
 
     /**
@@ -661,7 +773,7 @@ public class TestLifecycleManager extends TestBase {
     public void testTerminationOfNonInstantiated() throws Exception {
         //given
         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
-        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
         vnfInfo.setInstantiationState(InstantiationState.NOT_INSTANTIATED);
         vnfInfo.setOperationExecutions(operationExecutions);
         VnfProperty vnfdId = new VnfProperty();
@@ -669,7 +781,7 @@ public class TestLifecycleManager extends TestBase {
         vnfdId.setValue(ONAP_CSAR_ID);
         vnfInfo.getExtensions().add(vnfdId);
         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
-        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
+        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
         //when
         JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
         //verify
@@ -693,7 +805,7 @@ public class TestLifecycleManager extends TestBase {
     public void testTerminationOperationIsOutwaited() throws Exception {
         //given
         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
-        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
         vnfInfo.setOperationExecutions(operationExecutions);
         VnfProperty vnfdId = new VnfProperty();
@@ -702,27 +814,21 @@ public class TestLifecycleManager extends TestBase {
         vnfInfo.getExtensions().add(vnfdId);
         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
         OperationExecution terminationOperation = new OperationExecution();
-        when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
-            @Override
-            public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
-                terminationOperation.setId("terminationId");
-                operationExecutions.add(terminationOperation);
-                terminationOperation.setStatus(OperationStatus.STARTED);
-                return terminationOperation;
-            }
+        when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
+            terminationOperation.setId("terminationId");
+            operationExecutions.add(terminationOperation);
+            terminationOperation.setStatus(OperationStatus.STARTED);
+            return buildObservable(terminationOperation);
         });
         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
-        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
+        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
         Set<Integer> calls = new HashSet<>();
-        when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<List<OperationExecution>>() {
-            @Override
-            public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
-                if (calls.size() == 1000) {
-                    terminationOperation.setStatus(OperationStatus.FINISHED);
-                }
-                calls.add(calls.size());
-                return operationExecutions;
+        when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(invocation -> {
+            if (calls.size() == 1000) {
+                terminationOperation.setStatus(OperationStatus.FINISHED);
             }
+            calls.add(calls.size());
+            return buildObservable(operationExecutions);
         });
         //when
         JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
@@ -740,7 +846,7 @@ public class TestLifecycleManager extends TestBase {
     public void testTerminationOperationIsOutwaitedWithErrors() throws Exception {
         //given
         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
-        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
         vnfInfo.setOperationExecutions(operationExecutions);
         VnfProperty vnfdId = new VnfProperty();
@@ -749,30 +855,30 @@ public class TestLifecycleManager extends TestBase {
         vnfInfo.getExtensions().add(vnfdId);
         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
         OperationExecution terminationOperation = new OperationExecution();
-        when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
+        when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
             @Override
-            public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
+            public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
                 terminationOperation.setId("terminationId");
                 operationExecutions.add(terminationOperation);
                 terminationOperation.setStatus(OperationStatus.STARTED);
-                return terminationOperation;
+                return buildObservable(terminationOperation);
             }
         });
         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
-        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
+        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
         Set<Integer> calls = new HashSet<>();
-        List<ApiException> expectedExceptions = new ArrayList<>();
-        when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<List<OperationExecution>>() {
+        List<RuntimeException> expectedExceptions = new ArrayList<>();
+        when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
             @Override
-            public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
+            public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
                 if (calls.size() >= 100) {
                     terminationOperation.setStatus(OperationStatus.FINISHED);
-                    return operationExecutions;
+                    return buildObservable(operationExecutions);
                 }
                 calls.add(calls.size());
-                ApiException apiException = new ApiException();
-                expectedExceptions.add(apiException);
-                throw apiException;
+                RuntimeException RuntimeException = new RuntimeException();
+                expectedExceptions.add(RuntimeException);
+                throw RuntimeException;
             }
         });
         //when
@@ -781,7 +887,7 @@ public class TestLifecycleManager extends TestBase {
         waitForJobToFinishInJobManager(finished);
         verify(vnfApi, times(101)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
         verify(systemFunctions, times(100)).sleep(5000);
-        for (ApiException expectedException : expectedExceptions) {
+        for (RuntimeException expectedException : expectedExceptions) {
             verify(logger).warn("Unable to retrieve operations details", expectedException);
         }
     }
@@ -793,7 +899,7 @@ public class TestLifecycleManager extends TestBase {
     public void testGracefullTermination() throws Exception {
         //given
         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
-        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
         terminationRequest.setTerminationType(VnfTerminationType.GRACEFUL);
         terminationRequest.setGracefulTerminationTimeout("1234");
         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
@@ -803,14 +909,14 @@ public class TestLifecycleManager extends TestBase {
         vnfdId.setValue(ONAP_CSAR_ID);
         vnfInfo.getExtensions().add(vnfdId);
         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
-        when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
+        when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
             @Override
-            public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
+            public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
                 OperationExecution terminationOperation = new OperationExecution();
                 terminationOperation.setId("terminationId");
                 operationExecutions.add(terminationOperation);
                 terminationOperation.setStatus(OperationStatus.FINISHED);
-                return terminationOperation;
+                return buildObservable(terminationOperation);
             }
         });
         doAnswer(invocation -> {
@@ -818,7 +924,7 @@ public class TestLifecycleManager extends TestBase {
             return null;
         }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
-        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
+        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
         //when
         JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
         //verify
@@ -843,7 +949,7 @@ public class TestLifecycleManager extends TestBase {
         instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
         //when
         try {
-            VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
+            VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
             fail();
         } catch (Exception e) {
             assertEquals("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id", e.getMessage());
@@ -858,7 +964,7 @@ public class TestLifecycleManager extends TestBase {
     public void testExplicitForcefulTermination() throws Exception {
         //given
         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
-        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
         terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
         terminationRequest.setGracefulTerminationTimeout("1234");
         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
@@ -868,22 +974,19 @@ public class TestLifecycleManager extends TestBase {
         vnfdId.setValue(ONAP_CSAR_ID);
         vnfInfo.getExtensions().add(vnfdId);
         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
-        when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
-            @Override
-            public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
-                OperationExecution terminationOperation = new OperationExecution();
-                terminationOperation.setId("terminationId");
-                operationExecutions.add(terminationOperation);
-                terminationOperation.setStatus(OperationStatus.FINISHED);
-                return terminationOperation;
-            }
+        when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
+            OperationExecution terminationOperation = new OperationExecution();
+            terminationOperation.setId("terminationId");
+            operationExecutions.add(terminationOperation);
+            terminationOperation.setStatus(OperationStatus.FINISHED);
+            return buildObservable(terminationOperation);
         });
         doAnswer(invocation -> {
             verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
             return null;
         }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
-        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
+        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
         //when
         JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
         //verify
@@ -904,7 +1007,7 @@ public class TestLifecycleManager extends TestBase {
     public void testFailureInTheTerminationFinishesTheManagedJob() throws Exception {
         //given
         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
-        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
         terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
         terminationRequest.setGracefulTerminationTimeout("1234");
         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
@@ -924,10 +1027,10 @@ public class TestLifecycleManager extends TestBase {
                 return terminationOperation;
             }
         });
-        ApiException expectedException = new ApiException();
+        RuntimeException expectedException = new RuntimeException();
         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
-        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
+        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
         //when
         JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
         //verify
@@ -943,7 +1046,7 @@ public class TestLifecycleManager extends TestBase {
     public void testFailedTerminationAbortsTerminationWorkflow() throws Exception {
         //given
         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
-        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
         vnfInfo.setOperationExecutions(operationExecutions);
         VnfProperty vnfdId = new VnfProperty();
@@ -951,18 +1054,18 @@ public class TestLifecycleManager extends TestBase {
         vnfdId.setValue(ONAP_CSAR_ID);
         vnfInfo.getExtensions().add(vnfdId);
         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
-        when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
+        when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
             @Override
-            public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
+            public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
                 OperationExecution terminationOperation = new OperationExecution();
                 terminationOperation.setId("terminationId");
                 operationExecutions.add(terminationOperation);
                 terminationOperation.setStatus(OperationStatus.FAILED);
-                return terminationOperation;
+                return buildObservable(terminationOperation);
             }
         });
         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
-        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
+        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
         //when
         JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
         //verify
@@ -983,7 +1086,7 @@ public class TestLifecycleManager extends TestBase {
         vnfInfo.setName("myName");
         vnfInfo.setVnfSoftwareVersion("vnfSoftwareVersion");
         vnfInfo.setVnfProvider("myProvider");
-        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
         VnfProperty prop = new VnfProperty();
         prop.setName(LifecycleManager.ONAP_CSAR_ID);
         prop.setValue(ONAP_CSAR_ID);
@@ -1010,7 +1113,7 @@ public class TestLifecycleManager extends TestBase {
     @Test
     public void testQueryForNonExistingVnf() throws Exception {
 
-        ApiException expectedException = new ApiException();
+        RuntimeException expectedException = new RuntimeException();
         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
         //when
         try {
@@ -1034,14 +1137,14 @@ public class TestLifecycleManager extends TestBase {
         scaleRequest.setType(ScaleDirection.IN);
         scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }"));
         scaleOperationExecution.setStatus(OperationStatus.FINISHED);
-        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
         VnfProperty prop = new VnfProperty();
         prop.setValue(ONAP_CSAR_ID);
         prop.setName(LifecycleManager.ONAP_CSAR_ID);
         vnfInfo.getExtensions().add(prop);
         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
-        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
+        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
         //when
         JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
         //verify
@@ -1056,6 +1159,43 @@ public class TestLifecycleManager extends TestBase {
         assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
         assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
         verify(jobManager).spawnJob(VNF_ID, restResponse);
+        verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("scale"), eq(VNF_ID), anyString());
+
+    }
+
+    /**
+     * the VNFM should tolerate that no additional params were supplied
+     */
+    @Test
+    public void testScaleWithoutAddtionalParams() throws Exception {
+        VnfScaleRequest scaleRequest = new VnfScaleRequest();
+        scaleRequest.setNumberOfSteps("2");
+        scaleRequest.setAspectId("myAspect");
+        scaleRequest.setType(ScaleDirection.IN);
+        scaleRequest.setAdditionalParam(null);
+        scaleOperationExecution.setStatus(OperationStatus.FINISHED);
+        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
+        VnfProperty prop = new VnfProperty();
+        prop.setValue(ONAP_CSAR_ID);
+        prop.setName(LifecycleManager.ONAP_CSAR_ID);
+        vnfInfo.getExtensions().add(prop);
+        vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
+        String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
+        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
+        //when
+        JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
+        //verify
+        waitForJobToFinishInJobManager(finished);
+        assertEquals(1, actualScaleRequest.getAllValues().size());
+        ScaleVnfRequest sRequest = actualScaleRequest.getValue();
+        InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
+        workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
+        workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
+        assertEquals("myAspect", sRequest.getAspectId());
+        assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
+        assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
+        assertEquals("{\"jobId\":\"myJobId\"}", new Gson().toJson(sRequest.getAdditionalParams()));
+        verify(jobManager).spawnJob(VNF_ID, restResponse);
     }
 
     /**
@@ -1069,14 +1209,14 @@ public class TestLifecycleManager extends TestBase {
         scaleRequest.setType(ScaleDirection.OUT);
         scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
         scaleOperationExecution.setStatus(OperationStatus.FINISHED);
-        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
         VnfProperty prop = new VnfProperty();
         prop.setValue(ONAP_CSAR_ID);
         prop.setName(LifecycleManager.ONAP_CSAR_ID);
         vnfInfo.getExtensions().add(prop);
         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
-        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
+        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
         //when
         JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
         //verify
@@ -1103,24 +1243,24 @@ public class TestLifecycleManager extends TestBase {
         scaleRequest.setType(ScaleDirection.IN);
         scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
         scaleOperationExecution.setStatus(OperationStatus.STARTED);
-        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
         VnfProperty prop = new VnfProperty();
         prop.setValue(ONAP_CSAR_ID);
         prop.setName(LifecycleManager.ONAP_CSAR_ID);
         vnfInfo.getExtensions().add(prop);
         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
-        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
-        List<ApiException> expectedExceptions = new ArrayList<>();
-        when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<List<OperationExecution>>) invocation -> {
+        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
+        List<RuntimeException> expectedExceptions = new ArrayList<>();
+        when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<Observable<List<OperationExecution>>>) invocation -> {
             if (expectedExceptions.size() >= 100) {
+                when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(scaleOperationExecution));
                 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
-                return operationExecutions;
+                return buildObservable(operationExecutions);
             }
-            ApiException apiException = new ApiException();
-            expectedExceptions.add(apiException);
-            // when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(scaleOperationExecution);
-            throw apiException;
+            RuntimeException RuntimeException = new RuntimeException();
+            expectedExceptions.add(RuntimeException);
+            throw RuntimeException;
         });
 
         //when
@@ -1128,7 +1268,7 @@ public class TestLifecycleManager extends TestBase {
         //verify
         waitForJobToFinishInJobManager(finished);
         assertEquals(100, expectedExceptions.size());
-        for (ApiException expectedException : expectedExceptions) {
+        for (RuntimeException expectedException : expectedExceptions) {
             verify(logger).warn("Unable to retrieve operations details", expectedException);
         }
         verify(systemFunctions, times(100)).sleep(5000);
@@ -1139,7 +1279,7 @@ public class TestLifecycleManager extends TestBase {
      */
     @Test
     public void testScaleFailurePropagation() throws Exception {
-        ApiException expectedException = new ApiException();
+        RuntimeException expectedException = new RuntimeException();
         VnfScaleRequest scaleRequest = new VnfScaleRequest();
         scaleRequest.setNumberOfSteps("2");
         scaleRequest.setAspectId("myAspect");
@@ -1163,16 +1303,16 @@ public class TestLifecycleManager extends TestBase {
         affectedVm.setVmname("vmName");
         healRequest.setAffectedvm(affectedVm);
         healOperationExecution.setStatus(OperationStatus.FINISHED);
-        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
         VnfProperty prop = new VnfProperty();
         prop.setValue(ONAP_CSAR_ID);
         prop.setName(LifecycleManager.ONAP_CSAR_ID);
         vnfInfo.getExtensions().add(prop);
         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
-        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
+        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
         //when
-        JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, restResponse);
+        JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
         //verify
         waitForJobToFinishInJobManager(finished);
         assertEquals(1, actualHealRequest.getAllValues().size());
@@ -1185,6 +1325,7 @@ public class TestLifecycleManager extends TestBase {
         assertEquals("vmName", root.get("vmName").getAsString());
         assertEquals(JOB_ID, root.get("jobId").getAsString());
         verify(jobManager).spawnJob(VNF_ID, restResponse);
+        verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("heal"), eq(VNF_ID), anyString());
     }
 
     /**
@@ -1198,33 +1339,33 @@ public class TestLifecycleManager extends TestBase {
         affectedVm.setVmname("vmName");
         healRequest.setAffectedvm(affectedVm);
         healOperationExecution.setStatus(OperationStatus.FINISHED);
-        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+        when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
         VnfProperty prop = new VnfProperty();
         prop.setValue(ONAP_CSAR_ID);
         prop.setName(LifecycleManager.ONAP_CSAR_ID);
         vnfInfo.getExtensions().add(prop);
         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
-        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
-        List<ApiException> expectedExceptions = new ArrayList<>();
-        when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<List<OperationExecution>>() {
+        when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
+        List<RuntimeException> expectedExceptions = new ArrayList<>();
+        when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
             @Override
-            public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
+            public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
                 if (expectedExceptions.size() >= 100) {
                     scaleOperationExecution.setStatus(OperationStatus.FINISHED);
-                    return operationExecutions;
+                    return buildObservable(operationExecutions);
                 }
-                ApiException apiException = new ApiException();
-                expectedExceptions.add(apiException);
-                throw apiException;
+                RuntimeException RuntimeException = new RuntimeException();
+                expectedExceptions.add(RuntimeException);
+                throw RuntimeException;
             }
         });
         //when
-        JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, restResponse);
+        JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
         //verify
         waitForJobToFinishInJobManager(finished);
         assertEquals(100, expectedExceptions.size());
-        for (ApiException expectedException : expectedExceptions) {
+        for (RuntimeException expectedException : expectedExceptions) {
             verify(logger).warn("Unable to retrieve operations details", expectedException);
         }
         verify(systemFunctions, times(100)).sleep(5000);
@@ -1235,7 +1376,7 @@ public class TestLifecycleManager extends TestBase {
      */
     @Test
     public void testHealFailurePropagation() throws Exception {
-        ApiException expectedException = new ApiException();
+        RuntimeException expectedException = new RuntimeException();
         VnfHealRequest healRequest = new VnfHealRequest();
         healRequest.setAction("myAction");
         VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
@@ -1243,7 +1384,7 @@ public class TestLifecycleManager extends TestBase {
         healRequest.setAffectedvm(affectedVm);
         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
         //when
-        JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, restResponse);
+        JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
         //verify
         waitForJobToFinishInJobManager(finished);
         verify(logger).error("Unable to heal VNF with myVnfId identifier", expectedException);
Specific VNFM drivers