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

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