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

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