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 2c28bfc..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());
@@ -251,6 +253,8 @@ public class TestLifecycleManager extends TestBase {
         //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,9 +311,10 @@ 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
      */
@@ -311,7 +322,7 @@ public class TestLifecycleManager extends TestBase {
     public void testInstantiationV2WithoutSsl() 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);
@@ -320,9 +331,9 @@ public class TestLifecycleManager extends TestBase {
         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(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);
+        lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
         waitForJobToFinishInJobManager(finished);
         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
         //verify
@@ -338,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);
@@ -346,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
@@ -374,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);
@@ -385,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
@@ -414,7 +425,7 @@ public class TestLifecycleManager extends TestBase {
     public void testInstantiationV3WithNonSpecifiedSsl() 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);
@@ -423,9 +434,9 @@ public class TestLifecycleManager extends TestBase {
         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(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
@@ -450,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);
@@ -458,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
@@ -484,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);
@@ -495,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
@@ -522,7 +533,7 @@ public class TestLifecycleManager extends TestBase {
     public void testInstantiationVcloudWithNonSecifedSSl() 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);
@@ -531,9 +542,9 @@ public class TestLifecycleManager extends TestBase {
         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(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
@@ -555,7 +566,7 @@ public class TestLifecycleManager extends TestBase {
     @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);
@@ -563,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());
@@ -582,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);
@@ -593,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
@@ -609,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);
@@ -617,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);
@@ -652,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) {
@@ -673,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) {
@@ -695,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();
@@ -704,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());
@@ -718,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();
@@ -726,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());
     }
 
     /**
@@ -759,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();
@@ -767,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
@@ -791,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();
@@ -800,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);
@@ -838,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();
@@ -847,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
@@ -879,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);
         }
     }
@@ -891,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);
@@ -901,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 -> {
@@ -916,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
@@ -941,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());
@@ -956,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);
@@ -966,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
@@ -1002,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);
@@ -1022,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
@@ -1041,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();
@@ -1049,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
@@ -1081,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);
@@ -1108,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 {
@@ -1132,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
@@ -1154,6 +1159,8 @@ 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());
+
     }
 
     /**
@@ -1167,14 +1174,14 @@ public class TestLifecycleManager extends TestBase {
         scaleRequest.setType(ScaleDirection.IN);
         scaleRequest.setAdditionalParam(null);
         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
@@ -1202,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
@@ -1236,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
@@ -1261,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);
@@ -1272,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");
@@ -1296,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());
@@ -1318,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());
     }
 
     /**
@@ -1331,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);
@@ -1368,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();
@@ -1376,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