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

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