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

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