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

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