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

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