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