2 * Copyright 2016-2017, Nokia Corporation
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
18 import com.google.gson.Gson;
19 import com.google.gson.JsonElement;
20 import com.google.gson.JsonObject;
21 import com.google.gson.JsonParser;
22 import com.nokia.cbam.catalog.v1.model.CatalogAdapterVnfpackage;
23 import com.nokia.cbam.lcm.v32.model.*;
24 import com.nokia.cbam.lcm.v32.model.OperationType;
25 import com.nokia.cbam.lcm.v32.model.VimInfo;
26 import com.nokia.cbam.lcm.v32.model.VnfInfo;
27 import io.reactivex.Observable;
28 import java.nio.file.Paths;
30 import javax.servlet.http.HttpServletResponse;
31 import org.junit.Before;
32 import org.junit.Test;
33 import org.mockito.ArgumentCaptor;
34 import org.mockito.InOrder;
35 import org.mockito.Mock;
36 import org.mockito.Mockito;
37 import org.mockito.invocation.InvocationOnMock;
38 import org.mockito.stubbing.Answer;
39 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VimInfoProvider;
40 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.TestVfcGrantManager;
41 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.VfcGrantManager;
42 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.StoreLoader;
43 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.LifecycleChangeNotificationManager;
44 import org.onap.vnfmdriver.model.ExtVirtualLinkInfo;
45 import org.onap.vnfmdriver.model.*;
46 import org.onap.vnfmdriver.model.ScaleDirection;
47 import org.threeten.bp.OffsetDateTime;
49 import static java.lang.Boolean.parseBoolean;
50 import static java.nio.file.Files.readAllBytes;
51 import static java.util.Optional.empty;
53 import static junit.framework.TestCase.*;
54 import static org.mockito.Matchers.eq;
55 import static org.mockito.Mockito.*;
56 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.child;
57 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions.systemFunctions;
58 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
59 import static org.springframework.test.util.ReflectionTestUtils.setField;
61 public class TestLifecycleManager extends TestBase {
62 public static final String JOB_ID = "myJobId";
63 public static final String CBAM_VNFD_ID = "cbamVnfdId";
64 public static final String TENANT = "myTenant";
65 public static final String OPERATION_EXECUTION_ID = "operationExecutionId";
66 private static final String ONAP_CSAR_ID = "myOnapCsarId";
67 private static final String VIM_ID = "ownerId_regionId";
69 private CatalogManager catalogManager;
71 private VfcGrantManager vfcGrantManager;
73 private JobManager jobManager;
75 private LifecycleChangeNotificationManager notificationManager;
77 private HttpServletResponse restResponse;
79 private VimInfoProvider vimInfoProvider;
81 private ArgumentCaptor<CreateVnfRequest> createRequest = ArgumentCaptor.forClass(CreateVnfRequest.class);
82 private AdditionalParameters additionalParam = new AdditionalParameters();
83 private String INSTANTIATION_LEVEL = "level1";
84 private GrantVNFResponseVim grantResponse = new GrantVNFResponseVim();
85 private String cbamVnfdContent;
86 private OperationExecution instantiationOperationExecution = new OperationExecution();
87 private OperationExecution modifyPropertyoperationExecution = new OperationExecution();
88 private OperationExecution scaleOperationExecution = new OperationExecution();
89 private OperationExecution healOperationExecution = new OperationExecution();
90 private OperationExecution customOperationExecution = new OperationExecution();
93 private VnfInfo vnfInfo = new VnfInfo();
94 private List<OperationExecution> operationExecutions = new ArrayList<>();
95 private org.onap.vnfmdriver.model.VimInfo vimInfo = new org.onap.vnfmdriver.model.VimInfo();
96 private ExtVirtualLinkInfo externalVirtualLink = new ExtVirtualLinkInfo();
97 private ExtManagedVirtualLinkData extManVl = new ExtManagedVirtualLinkData();
98 private ArgumentCaptor<ModifyVnfInfoRequest> actualVnfModifyRequest = ArgumentCaptor.forClass(ModifyVnfInfoRequest.class);
99 private Set<Boolean> finished = new HashSet<>();
100 private ArgumentCaptor<ScaleVnfRequest> actualScaleRequest = ArgumentCaptor.forClass(ScaleVnfRequest.class);
101 private ArgumentCaptor<HealVnfRequest> actualHealRequest = ArgumentCaptor.forClass(HealVnfRequest.class);
102 private ArgumentCaptor<CustomOperationRequest> customOperationRequestArgumentCaptor = ArgumentCaptor.forClass(CustomOperationRequest.class);
103 private ArgumentCaptor<String> operationIdCaptor = ArgumentCaptor.forClass(String.class);
105 private LifecycleManager lifecycleManager;
108 public void initMocks() throws Exception {
109 vnfInfo.setExtensions(new ArrayList<>());
110 vnfInfo.setOperationExecutions(new ArrayList<>());
111 lifecycleManager = new LifecycleManager(catalogManager, vfcGrantManager, cbamRestApiProvider, vimInfoProvider, jobManager, notificationManager);
112 cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.full.yaml").toURI())));
113 setField(LifecycleManager.class, "logger", logger);
114 CatalogAdapterVnfpackage cbamPackage = new CatalogAdapterVnfpackage();
115 when(catalogManager.preparePackageInCbam(VNFM_ID, ONAP_CSAR_ID)).thenReturn(cbamPackage);
116 cbamPackage.setVnfdId(CBAM_VNFD_ID);
117 vnfInfo.setVnfdId(CBAM_VNFD_ID);
118 vnfInfo.setId(VNF_ID);
119 when(jobManager.spawnJob(VNF_ID, restResponse)).thenReturn(JOB_ID);
120 when(catalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent);
121 cbamPackage.setId(CBAM_VNFD_ID);
122 vimInfo.setUrl("cloudUrl");
123 vimInfo.setPassword("vimPassword");
124 vimInfo.setUserName("vimUsername");
125 vimInfo.setSslInsecure("true");
126 vimInfo.setVimId(VIM_ID);
127 vimInfo.setName("vimName");
128 when(vimInfoProvider.getVimInfo((VIM_ID))).thenReturn(vimInfo);
129 instantiationOperationExecution.setId(OPERATION_EXECUTION_ID);
130 instantiationOperationExecution.setOperationType(OperationType.INSTANTIATE);
131 instantiationOperationExecution.setStartTime(OffsetDateTime.now());
132 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecutions));
133 operationExecutions.add(modifyPropertyoperationExecution);
134 modifyPropertyoperationExecution.setStartTime(OffsetDateTime.now());
135 modifyPropertyoperationExecution.setOperationType(OperationType.MODIFY_INFO);
136 operationExecutions.add(instantiationOperationExecution);
137 instantiationOperationExecution.setStatus(OperationStatus.FINISHED);
138 modifyPropertyoperationExecution.setStatus(OperationStatus.FINISHED);
139 customOperationExecution.setStatus(OperationStatus.FINISHED);
140 modifyPropertyoperationExecution.setId(UUID.randomUUID().toString());
141 scaleOperationExecution.setId(UUID.randomUUID().toString());
142 healOperationExecution.setId(UUID.randomUUID().toString());
143 customOperationExecution.setId(UUID.randomUUID().toString());
145 when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(modifyPropertyoperationExecution));
146 doAnswer(new Answer() {
148 public Object answer(InvocationOnMock invocation) throws Throwable {
149 finished.add(Boolean.TRUE);
152 }).when(jobManager).jobFinished(JOB_ID);
153 when(vnfApi.vnfsVnfInstanceIdScalePost(eq(VNF_ID), actualScaleRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
155 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
156 operationExecutions.add(scaleOperationExecution);
157 return buildObservable(scaleOperationExecution);
160 when(vnfApi.vnfsVnfInstanceIdHealPost(eq(VNF_ID), actualHealRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
162 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
163 operationExecutions.add(healOperationExecution);
164 return buildObservable(healOperationExecution);
167 when(vnfApi.vnfsVnfInstanceIdCustomCustomOperationNamePost(eq(VNF_ID), operationIdCaptor.capture(), customOperationRequestArgumentCaptor.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
169 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
170 operationExecutions.add(customOperationExecution);
171 return buildObservable(customOperationExecution);
180 public void testInstantiation() throws Exception {
182 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
184 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
185 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
186 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
187 grantResponse.setVimId(VIM_ID);
188 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
189 accessInfo.setTenant(TENANT);
190 grantResponse.setAccessInfo(accessInfo);
191 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
192 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
194 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
195 waitForJobToFinishInJobManager(finished);
197 assertEquals(VNF_ID, response.getVnfInstanceId());
198 assertEquals(JOB_ID, response.getJobId());
199 assertEquals(createRequest.getAllValues().size(), 1);
200 assertEquals("myDescription", createRequest.getValue().getDescription());
201 assertEquals("vnfName", createRequest.getValue().getName());
202 assertEquals(CBAM_VNFD_ID, createRequest.getValue().getVnfdId());
203 assertEquals(1, actualInstantiationRequest.getAllValues().size());
204 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
205 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
206 assertEquals(VIM_ID, actualVim.getId());
207 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, actualVim.getVimInfoType());
208 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
209 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
210 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
211 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
212 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
213 assertEquals("myTenant", actualVim.getAccessInfo().getTenant());
214 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
215 assertEquals(1, actualInstantiationRequest.getValue().getComputeResourceFlavours().size());
216 assertEquals("flavourProviderId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getResourceId());
217 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVimId());
218 assertEquals("virtualComputeDescId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVnfdVirtualComputeDescId());
219 assertEquals(1, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().size());
220 assertEquals(extManVl, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().get(0));
221 assertEquals(2, actualInstantiationRequest.getValue().getExtVirtualLinks().size());
223 assertEquals("myNetworkProviderId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getResourceId());
224 assertEquals("myEVlId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtVirtualLinkId());
225 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().size());
226 assertEquals("myCpdId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().get(0).getCpdId());
228 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getVimId());
229 assertEquals("evlId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtVirtualLinkId());
230 assertEquals("networkProviderId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getResourceId());
231 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().size());
234 assertEquals(Integer.valueOf(2), actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getNumDynamicAddresses());
235 assertEquals("cpdId3", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getCpdId());
236 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().size());
237 assertEquals("1.2.3.4", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getIp());
238 assertEquals("mac", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getMac());
239 assertEquals("subnetId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getSubnetId());
241 assertEquals("myFlavorId", actualInstantiationRequest.getValue().getFlavourId());
242 assertEquals(Boolean.TRUE, actualInstantiationRequest.getValue().isGrantlessMode());
243 assertEquals("level1", actualInstantiationRequest.getValue().getInstantiationLevelId());
244 assertEquals(1, actualInstantiationRequest.getValue().getZones().size());
245 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getZones().get(0).getVimId());
246 assertEquals("zoneProviderId", actualInstantiationRequest.getValue().getZones().get(0).getResourceId());
247 assertEquals("zoneId", actualInstantiationRequest.getValue().getZones().get(0).getId());
248 assertEquals(1, actualInstantiationRequest.getValue().getSoftwareImages().size());
249 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVimId());
250 assertEquals("imageProviderId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getResourceId());
251 assertEquals("imageId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVnfdSoftwareImageId());
252 String actualEmbeddedAdditionParams = new Gson().toJson(actualInstantiationRequest.getValue().getAdditionalParams());
253 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(actualEmbeddedAdditionParams) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(actualEmbeddedAdditionParams));
254 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
255 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
257 assertEquals(1, actualVnfModifyRequest.getAllValues().size());
258 assertEquals(2, actualVnfModifyRequest.getValue().getExtensions().size());
259 assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getName());
260 assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getValue());
261 assertEquals(LifecycleManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName());
262 assertEquals(VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getValue());
264 //the 3.2 API does not accept empty array
265 assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties());
266 verify(jobManager).spawnJob(VNF_ID, restResponse);
267 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
268 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
272 * invalid VIM type results in failure
275 public void testInstantiationWithInvalidVimType() throws Exception {
277 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
278 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
279 when(logger.isInfoEnabled()).thenReturn(false);
282 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
285 } catch (Exception e) {
286 assertEquals("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types", e.getMessage());
288 verify(vnfApi, never()).vnfsPost(Mockito.any(), Mockito.any());
289 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
290 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
291 verify(logger).error("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types");
295 * test instantiation with KeyStone V2 based with SSL
298 public void testInstantiationV2WithSsl() throws Exception {
299 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
300 when(logger.isInfoEnabled()).thenReturn(false);
301 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
302 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
303 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
304 grantResponse.setVimId(VIM_ID);
305 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
306 accessInfo.setTenant(TENANT);
307 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
308 vimInfo.setSslInsecure("false");
309 vimInfo.setSslCacert(caCert);
310 grantResponse.setAccessInfo(accessInfo);
311 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
312 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
313 JsonObject inputs = child((JsonObject) instantiationRequest.getAdditionalParam(), "inputs");
314 JsonObject vnfs = child(child(inputs, "vnfs"), ONAP_CSAR_ID);
315 vnfs.remove("additionalParams");
317 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
318 waitForJobToFinishInJobManager(finished);
319 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
321 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
322 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
323 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
324 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
325 verify(logger).warn("No additional parameters were specified for the operation");
326 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), anyString(), anyString(), anyString());
330 * non specified SSL verification means not verified
333 public void testInstantiationV2WithoutSsl() throws Exception {
334 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
336 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
337 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
338 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
339 grantResponse.setVimId(VIM_ID);
340 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
341 accessInfo.setTenant(TENANT);
342 vimInfo.setSslInsecure(null);
343 grantResponse.setAccessInfo(accessInfo);
344 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
345 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
347 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
348 waitForJobToFinishInJobManager(finished);
349 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
351 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
352 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
353 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
357 * test instantiation with KeyStone V3 based
360 public void testInstantiationV3() throws Exception {
361 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
362 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
363 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
364 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
365 grantResponse.setVimId(VIM_ID);
366 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
367 accessInfo.setTenant(TENANT);
368 grantResponse.setAccessInfo(accessInfo);
369 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
370 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
372 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
373 waitForJobToFinishInJobManager(finished);
374 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
376 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
377 assertEquals(VIM_ID, actualVim.getId());
378 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
379 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
380 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
381 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
382 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
383 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
384 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
385 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
386 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
387 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
388 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
392 * test instantiation with backward compatibility test with Amsterdam release
393 * - the vim identifier is supplied as vimid with not camel case
396 public void testInstantiationNoVimId() throws Exception {
398 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
399 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
400 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
401 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
402 grantResponse.setVimid(VIM_ID);
403 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
404 accessInfo.setTenant(TENANT);
405 grantResponse.setAccessinfo(accessInfo);
406 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
407 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
409 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
410 waitForJobToFinishInJobManager(finished);
412 assertEquals(VNF_ID, response.getVnfInstanceId());
413 assertEquals(JOB_ID, response.getJobId());
414 assertEquals(createRequest.getAllValues().size(), 1);
415 assertEquals("myDescription", createRequest.getValue().getDescription());
416 assertEquals("vnfName", createRequest.getValue().getName());
417 assertEquals(CBAM_VNFD_ID, createRequest.getValue().getVnfdId());
418 assertEquals(1, actualInstantiationRequest.getAllValues().size());
419 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
420 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
421 assertEquals(VIM_ID, actualVim.getId());
422 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, actualVim.getVimInfoType());
423 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
424 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
425 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
426 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
427 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
428 assertEquals("myTenant", actualVim.getAccessInfo().getTenant());
429 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
430 assertEquals(1, actualInstantiationRequest.getValue().getComputeResourceFlavours().size());
431 assertEquals("flavourProviderId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getResourceId());
432 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVimId());
433 assertEquals("virtualComputeDescId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVnfdVirtualComputeDescId());
434 assertEquals(1, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().size());
435 assertEquals(extManVl, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().get(0));
436 assertEquals(2, actualInstantiationRequest.getValue().getExtVirtualLinks().size());
438 assertEquals("myNetworkProviderId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getResourceId());
439 assertEquals("myEVlId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtVirtualLinkId());
440 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().size());
441 assertEquals("myCpdId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().get(0).getCpdId());
443 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getVimId());
444 assertEquals("evlId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtVirtualLinkId());
445 assertEquals("networkProviderId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getResourceId());
446 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().size());
449 assertEquals(Integer.valueOf(2), actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getNumDynamicAddresses());
450 assertEquals("cpdId3", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getCpdId());
451 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().size());
452 assertEquals("1.2.3.4", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getIp());
453 assertEquals("mac", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getMac());
454 assertEquals("subnetId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getSubnetId());
456 assertEquals("myFlavorId", actualInstantiationRequest.getValue().getFlavourId());
457 assertEquals(Boolean.TRUE, actualInstantiationRequest.getValue().isGrantlessMode());
458 assertEquals("level1", actualInstantiationRequest.getValue().getInstantiationLevelId());
459 assertEquals(1, actualInstantiationRequest.getValue().getZones().size());
460 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getZones().get(0).getVimId());
461 assertEquals("zoneProviderId", actualInstantiationRequest.getValue().getZones().get(0).getResourceId());
462 assertEquals("zoneId", actualInstantiationRequest.getValue().getZones().get(0).getId());
463 assertEquals(1, actualInstantiationRequest.getValue().getSoftwareImages().size());
464 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVimId());
465 assertEquals("imageProviderId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getResourceId());
466 assertEquals("imageId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVnfdSoftwareImageId());
467 String actualEmbeddedAdditionParams = new Gson().toJson(actualInstantiationRequest.getValue().getAdditionalParams());
468 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(actualEmbeddedAdditionParams) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(actualEmbeddedAdditionParams));
469 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
470 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
472 assertEquals(1, actualVnfModifyRequest.getAllValues().size());
473 assertEquals(2, actualVnfModifyRequest.getValue().getExtensions().size());
474 assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getName());
475 assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getValue());
476 assertEquals(LifecycleManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName());
477 assertEquals(VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getValue());
479 //the 3.2 API does not accept empty array
480 assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties());
481 verify(jobManager).spawnJob(VNF_ID, restResponse);
482 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
483 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
487 * test instantiation with KeyStone V3 based with SSL
490 public void testInstantiationV3WithSsl() throws Exception {
491 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
492 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
493 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
494 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
495 grantResponse.setVimId(VIM_ID);
496 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
497 accessInfo.setTenant(TENANT);
498 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
499 vimInfo.setSslInsecure("false");
500 vimInfo.setSslCacert(caCert);
501 grantResponse.setAccessInfo(accessInfo);
502 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
503 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
505 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
506 waitForJobToFinishInJobManager(finished);
507 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
509 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
510 assertEquals(VIM_ID, actualVim.getId());
511 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
512 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
513 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
514 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
515 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
516 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
517 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
518 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
519 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
520 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
521 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
522 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
526 * non specified SSL verification meams not verified for KeyStone V3 based
529 public void testInstantiationV3WithNonSpecifiedSsl() throws Exception {
530 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
531 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
532 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
533 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
534 grantResponse.setVimId(VIM_ID);
535 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
536 accessInfo.setTenant(TENANT);
537 vimInfo.setSslInsecure(null);
538 grantResponse.setAccessInfo(accessInfo);
539 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
540 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
542 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
543 waitForJobToFinishInJobManager(finished);
544 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
546 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
547 assertEquals(VIM_ID, actualVim.getId());
548 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
549 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
550 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
551 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
552 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
553 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
554 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
555 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
556 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
557 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
561 * verify backward compatibility with Amsterdam release
564 public void testInstantiationV3WithNoDomain() throws Exception {
565 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
566 additionalParam.setDomain("myDomain");
567 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
568 vimInfo.setDomain(null);
569 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
570 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
571 grantResponse.setVimId(VIM_ID);
572 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
573 accessInfo.setTenant(TENANT);
574 vimInfo.setSslInsecure(null);
575 grantResponse.setAccessInfo(accessInfo);
576 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
577 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
579 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
580 waitForJobToFinishInJobManager(finished);
581 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
583 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
584 assertEquals(VIM_ID, actualVim.getId());
585 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
586 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
587 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
588 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
589 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
590 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
591 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
592 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
593 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
594 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
595 verify(logger).warn("Setting domain from additional parameters");
599 * verify backward compatibility with Amsterdam release
600 * if no domain is specified error is propagated
603 public void testInstantiationV3WithNoDomainFail() throws Exception {
604 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
605 vimInfo.setDomain(null);
606 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
607 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
608 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
609 grantResponse.setVimId(VIM_ID);
610 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
611 accessInfo.setTenant(TENANT);
612 vimInfo.setSslInsecure(null);
613 grantResponse.setAccessInfo(accessInfo);
614 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
615 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
617 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
618 waitForJobToFinishInJobManager(finished);
619 assertEquals(0, actualInstantiationRequest.getAllValues().size());
621 verify(logger).error("The cloud did not supply the cloud domain (Amsterdam release) and was not supplied as additional data");
625 * test instantiation with vcloud
628 public void testInstantiationVcloud() throws Exception {
629 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
631 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
632 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
633 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
634 grantResponse.setVimId(VIM_ID);
635 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
636 accessInfo.setTenant(TENANT);
637 grantResponse.setAccessInfo(accessInfo);
638 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
639 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
641 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
642 waitForJobToFinishInJobManager(finished);
643 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
645 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
646 assertEquals(VIM_ID, actualVim.getId());
647 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
648 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
649 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
650 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
651 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
652 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
653 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
654 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
655 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
659 * test instantiation with vCloud with SSL
662 public void testInstantiationVcloudWithSsl() throws Exception {
663 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
665 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
666 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
667 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
668 grantResponse.setVimId(VIM_ID);
669 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
670 accessInfo.setTenant(TENANT);
671 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
672 vimInfo.setSslInsecure("false");
673 vimInfo.setSslCacert(caCert);
674 grantResponse.setAccessInfo(accessInfo);
675 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
676 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
678 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
679 waitForJobToFinishInJobManager(finished);
680 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
682 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
683 assertEquals(VIM_ID, actualVim.getId());
684 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
685 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
686 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
687 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
688 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
689 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
690 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
691 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
692 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
693 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
697 * test instantiation with vCloud with SSL
700 public void testInstantiationVcloudWithNonSecifedSSl() throws Exception {
701 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
703 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
704 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
705 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
706 grantResponse.setVimId(VIM_ID);
707 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
708 accessInfo.setTenant(TENANT);
709 vimInfo.setSslInsecure(null);
710 grantResponse.setAccessInfo(accessInfo);
711 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
712 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
714 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
715 waitForJobToFinishInJobManager(finished);
716 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
718 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
719 assertEquals(VIM_ID, actualVim.getId());
720 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
721 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
722 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
723 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
724 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
725 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
726 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
727 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
731 * test failure in the instantiation request marks the job to be finished in job manager
734 public void testFailureInTheInstantiationRequest() throws Exception {
735 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
736 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
737 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
738 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
739 grantResponse.setVimId(VIM_ID);
740 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
741 accessInfo.setTenant(TENANT);
742 grantResponse.setAccessInfo(accessInfo);
743 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
744 RuntimeException expectedException = new RuntimeException();
745 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
748 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
750 waitForJobToFinishInJobManager(finished);
751 assertEquals(VNF_ID, response.getVnfInstanceId());
752 assertEquals(JOB_ID, response.getJobId());
753 verify(logger).error("Unable to instantiate VNF with myVnfId identifier", expectedException);
757 * instantiation fails if VF-C does not send vim identifier in grant response
760 public void testVfcFailsToSendVimId() throws Exception {
761 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
763 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
764 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
765 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
766 //grantResponse.setVimId(VIM_ID);
767 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
768 accessInfo.setTenant(TENANT);
769 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
770 vimInfo.setSslInsecure("false");
771 vimInfo.setSslCacert(caCert);
772 grantResponse.setAccessInfo(accessInfo);
773 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
774 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
776 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
777 waitForJobToFinishInJobManager(finished);
778 assertEquals(0, actualInstantiationRequest.getAllValues().size());
780 verify(logger).error("VF-C did not send VIM identifier in grant response");
785 * test operation execution polling is retried in case of failures
788 public void testFailureInTheOperationExecutionPollingDuringInstantiationRequest() throws Exception {
789 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
790 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
791 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
792 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
793 grantResponse.setVimId(VIM_ID);
794 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
795 accessInfo.setTenant(TENANT);
796 grantResponse.setAccessInfo(accessInfo);
797 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
798 List<RuntimeException> polling = new ArrayList<>();
799 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
800 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).then(new Answer<Observable<List<OperationExecution>>>() {
802 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
803 if (polling.size() > 2) {
804 return buildObservable(operationExecutions);
806 RuntimeException runtimeException = new RuntimeException();
807 polling.add(runtimeException);
808 throw runtimeException;
812 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
814 waitForJobToFinishInJobManager(finished);
815 assertEquals(VNF_ID, response.getVnfInstanceId());
816 assertEquals(JOB_ID, response.getJobId());
817 assertEquals(3, polling.size());
818 for (RuntimeException e : polling) {
819 verify(logger).warn("Unable to retrieve operations details", e);
821 verify(systemFunctions, Mockito.times(3)).sleep(5000);
825 * failure in VNF creation is logged an proagated
828 public void failureInVnfCreationIsPropagated() throws Exception {
830 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
832 RuntimeException expectedException = new RuntimeException();
833 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
836 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
839 } catch (RuntimeException e) {
840 assertEquals(expectedException, e.getCause());
841 verify(logger).error("Unable to create the VNF", expectedException);
846 * failure in updating the modifyable attributes of the VNF is logged an proagated
849 public void failureInVnfModificationIsPropagated() throws Exception {
851 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
853 RuntimeException expectedException = new RuntimeException();
854 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
855 when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
859 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
862 } catch (RuntimeException e) {
863 assertEquals(expectedException, e.getCause().getCause());
864 verify(logger).error("Unable to set the onapCsarId property on the VNF", expectedException);
869 * if the VIM info can not be queried the VNF is not instantiated and
870 * error propagated through job
873 public void testFailureInQueryVimInfo() throws Exception {
874 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
875 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
876 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
877 grantResponse.setVimId(VIM_ID);
878 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
879 accessInfo.setTenant(TENANT);
880 grantResponse.setAccessInfo(accessInfo);
882 when(vimInfoProvider.getVimInfo(VIM_ID)).thenThrow(new RuntimeException());
884 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
886 waitForJobToFinishInJobManager(finished);
887 verify(vnfApi, never()).vnfsVnfInstanceIdInstantiatePost(Mockito.any(), Mockito.any(), Mockito.any());
891 * test termination basic success scenario
892 * - the VNF is not deleted before the notifications are processed
895 public void testTerminationAndDeletion() throws Exception {
897 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
898 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
899 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
900 vnfInfo.setOperationExecutions(operationExecutions);
901 VnfProperty vnfdId = new VnfProperty();
902 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
903 vnfdId.setValue(ONAP_CSAR_ID);
904 vnfInfo.getExtensions().add(vnfdId);
905 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
906 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
908 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
909 OperationExecution terminationOperation = new OperationExecution();
910 terminationOperation.setId("terminationId");
911 operationExecutions.add(terminationOperation);
912 terminationOperation.setStatus(OperationStatus.FINISHED);
913 return buildObservable(terminationOperation);
916 when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
917 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
918 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
920 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
922 waitForJobToFinishInJobManager(finished);
923 assertEquals(1, actualTerminationRequest.getAllValues().size());
924 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
925 assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
926 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
927 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
928 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
929 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
930 VOID_OBSERVABLE.assertCalled();
931 verify(jobManager).spawnJob(VNF_ID, restResponse);
932 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
936 * test termination basic success scenario
937 * - the VNF is not deleted before the notifications are processed
940 public void testTermination() throws Exception {
942 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
943 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
944 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
945 vnfInfo.setOperationExecutions(operationExecutions);
946 VnfProperty vnfdId = new VnfProperty();
947 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
948 vnfdId.setValue(ONAP_CSAR_ID);
949 vnfInfo.getExtensions().add(vnfdId);
950 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
951 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
953 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
954 OperationExecution terminationOperation = new OperationExecution();
955 terminationOperation.setId("terminationId");
956 operationExecutions.add(terminationOperation);
957 terminationOperation.setStatus(OperationStatus.FINISHED);
958 return buildObservable(terminationOperation);
961 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
962 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
964 JobInfo jobInfo = lifecycleManager.terminate(VNFM_ID, VNF_ID, terminationRequest, restResponse);
966 waitForJobToFinishInJobManager(finished);
967 assertEquals(1, actualTerminationRequest.getAllValues().size());
968 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
969 assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
970 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
971 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
972 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
973 verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
974 verify(jobManager).spawnJob(VNF_ID, restResponse);
975 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
979 * test termination of a non instantiated VNF
980 * - the VNF is not terminated (only deleted)
983 public void testTerminationOfNonInstantiated() throws Exception {
985 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
986 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
987 vnfInfo.setInstantiationState(InstantiationState.NOT_INSTANTIATED);
988 vnfInfo.setOperationExecutions(operationExecutions);
989 VnfProperty vnfdId = new VnfProperty();
990 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
991 vnfdId.setValue(ONAP_CSAR_ID);
992 vnfInfo.getExtensions().add(vnfdId);
993 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
994 when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
995 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
997 lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
999 boolean deleted = false;
1002 verify(logger).info("The VNF with {} identifier has been deleted", VNF_ID);
1007 verify(vfcGrantManager, never()).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1008 verify(notificationManager, never()).waitForTerminationToBeProcessed("terminationId");
1009 verify(logger).warn("The VNF with {} identifier is not instantiated no termination is required", VNF_ID);
1010 verify(logger).info("Deleting VNF with {} identifier", VNF_ID);
1011 verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1012 VOID_OBSERVABLE.assertCalled();
1016 * test that the VNF deletion is not started before the termination finishes
1019 public void testTerminationOperationIsOutwaited() throws Exception {
1021 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1022 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1023 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1024 vnfInfo.setOperationExecutions(operationExecutions);
1025 VnfProperty vnfdId = new VnfProperty();
1026 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1027 vnfdId.setValue(ONAP_CSAR_ID);
1028 vnfInfo.getExtensions().add(vnfdId);
1029 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1030 OperationExecution terminationOperation = new OperationExecution();
1031 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
1032 terminationOperation.setId("terminationId");
1033 operationExecutions.add(terminationOperation);
1034 terminationOperation.setStatus(OperationStatus.STARTED);
1035 return buildObservable(terminationOperation);
1037 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1038 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1039 Set<Integer> calls = new HashSet<>();
1040 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(invocation -> {
1041 if (calls.size() == 1000) {
1042 terminationOperation.setStatus(OperationStatus.FINISHED);
1044 calls.add(calls.size());
1045 return buildObservable(operationExecutions);
1048 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1050 waitForJobToFinishInJobManager(finished);
1051 verify(vnfApi, times(1001)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
1052 verify(systemFunctions, times(1000)).sleep(5000);
1057 * test that failured during waiting for the operation to finish is tolerated (idefineiatelly)
1060 public void testTerminationOperationIsOutwaitedWithErrors() throws Exception {
1062 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1063 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1064 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1065 vnfInfo.setOperationExecutions(operationExecutions);
1066 VnfProperty vnfdId = new VnfProperty();
1067 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1068 vnfdId.setValue(ONAP_CSAR_ID);
1069 vnfInfo.getExtensions().add(vnfdId);
1070 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1071 OperationExecution terminationOperation = new OperationExecution();
1072 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1074 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1075 terminationOperation.setId("terminationId");
1076 operationExecutions.add(terminationOperation);
1077 terminationOperation.setStatus(OperationStatus.STARTED);
1078 return buildObservable(terminationOperation);
1081 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1082 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1083 Set<Integer> calls = new HashSet<>();
1084 List<RuntimeException> expectedExceptions = new ArrayList<>();
1085 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
1087 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
1088 if (calls.size() >= 100) {
1089 terminationOperation.setStatus(OperationStatus.FINISHED);
1090 return buildObservable(operationExecutions);
1092 calls.add(calls.size());
1093 RuntimeException RuntimeException = new RuntimeException();
1094 expectedExceptions.add(RuntimeException);
1095 throw RuntimeException;
1099 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1101 waitForJobToFinishInJobManager(finished);
1102 verify(vnfApi, times(101)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
1103 verify(systemFunctions, times(100)).sleep(5000);
1104 for (RuntimeException expectedException : expectedExceptions) {
1105 verify(logger).warn("Unable to retrieve operations details", expectedException);
1110 * test gracefull termination
1113 public void testGracefullTermination() throws Exception {
1115 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1116 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1117 terminationRequest.setTerminationType(VnfTerminationType.GRACEFUL);
1118 terminationRequest.setGracefulTerminationTimeout("1234");
1119 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1120 vnfInfo.setOperationExecutions(operationExecutions);
1121 VnfProperty vnfdId = new VnfProperty();
1122 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1123 vnfdId.setValue(ONAP_CSAR_ID);
1124 vnfInfo.getExtensions().add(vnfdId);
1125 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1126 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1128 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1129 OperationExecution terminationOperation = new OperationExecution();
1130 terminationOperation.setId("terminationId");
1131 operationExecutions.add(terminationOperation);
1132 terminationOperation.setStatus(OperationStatus.FINISHED);
1133 return buildObservable(terminationOperation);
1136 doAnswer(invocation -> {
1137 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
1139 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1140 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1141 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1143 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1145 waitForJobToFinishInJobManager(finished);
1146 assertEquals(1, actualTerminationRequest.getAllValues().size());
1147 assertEquals(TerminationType.GRACEFUL, actualTerminationRequest.getValue().getTerminationType());
1148 assertEquals(Integer.valueOf(1234), actualTerminationRequest.getValue().getGracefulTerminationTimeout());
1149 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
1150 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1151 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
1152 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1156 * instantiation with missing ONAP csarId to instantiation extra param result in failure
1159 public void testMissingVnfParameters() throws Exception {
1161 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1162 String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "invalid" + "\" : {}}}, \"vimId\" : \"" + VIM_ID + "\"}";
1163 instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
1166 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
1168 } catch (Exception e) {
1169 assertEquals("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id", e.getMessage());
1170 verify(logger).error("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id");
1175 * test explicit forceful termination
1178 public void testExplicitForcefulTermination() throws Exception {
1180 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1181 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1182 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1183 terminationRequest.setGracefulTerminationTimeout("1234");
1184 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1185 vnfInfo.setOperationExecutions(operationExecutions);
1186 VnfProperty vnfdId = new VnfProperty();
1187 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1188 vnfdId.setValue(ONAP_CSAR_ID);
1189 vnfInfo.getExtensions().add(vnfdId);
1190 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1191 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
1192 OperationExecution terminationOperation = new OperationExecution();
1193 terminationOperation.setId("terminationId");
1194 operationExecutions.add(terminationOperation);
1195 terminationOperation.setStatus(OperationStatus.FINISHED);
1196 return buildObservable(terminationOperation);
1198 doAnswer(invocation -> {
1199 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
1201 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1202 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1203 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1205 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1207 waitForJobToFinishInJobManager(finished);
1208 assertEquals(1, actualTerminationRequest.getAllValues().size());
1209 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1210 assertNull(actualTerminationRequest.getValue().getGracefulTerminationTimeout());
1211 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
1212 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1213 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
1214 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1218 * test failure in the termination workflow finishes the job
1221 public void testFailureInTheTerminationFinishesTheManagedJob() throws Exception {
1223 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1224 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1225 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1226 terminationRequest.setGracefulTerminationTimeout("1234");
1227 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1228 vnfInfo.setOperationExecutions(operationExecutions);
1229 VnfProperty vnfdId = new VnfProperty();
1230 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1231 vnfdId.setValue(ONAP_CSAR_ID);
1232 vnfInfo.getExtensions().add(vnfdId);
1233 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1234 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
1236 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
1237 OperationExecution terminationOperation = new OperationExecution();
1238 terminationOperation.setId("terminationId");
1239 operationExecutions.add(terminationOperation);
1240 terminationOperation.setStatus(OperationStatus.FINISHED);
1241 return terminationOperation;
1244 RuntimeException expectedException = new RuntimeException();
1245 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1246 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1247 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1249 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1251 waitForJobToFinishInJobManager(finished);
1252 assertEquals(0, actualTerminationRequest.getAllValues().size());
1253 Mockito.verifyZeroInteractions(vfcGrantManager);
1257 * if termination fails the VNF is not deleted
1260 public void testFailedTerminationAbortsTerminationWorkflow() throws Exception {
1262 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1263 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1264 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1265 vnfInfo.setOperationExecutions(operationExecutions);
1266 VnfProperty vnfdId = new VnfProperty();
1267 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1268 vnfdId.setValue(ONAP_CSAR_ID);
1269 vnfInfo.getExtensions().add(vnfdId);
1270 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1271 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1273 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1274 OperationExecution terminationOperation = new OperationExecution();
1275 terminationOperation.setId("terminationId");
1276 operationExecutions.add(terminationOperation);
1277 terminationOperation.setStatus(OperationStatus.FAILED);
1278 return buildObservable(terminationOperation);
1281 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1282 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1284 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1286 waitForJobToFinishInJobManager(finished);
1287 assertEquals(1, actualTerminationRequest.getAllValues().size());
1288 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1289 verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1290 verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1291 verify(logger).error("Unable to terminate VNF the operation did not finish with success");
1295 * test VNF query basic success scenario
1298 public void testQuery() throws Exception {
1299 vnfInfo.setDescription("myDescription");
1300 vnfInfo.setName("myName");
1301 vnfInfo.setVnfSoftwareVersion("vnfSoftwareVersion");
1302 vnfInfo.setVnfProvider("myProvider");
1303 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1304 VnfProperty prop = new VnfProperty();
1305 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1306 prop.setValue(ONAP_CSAR_ID);
1307 vnfInfo.getExtensions().add(prop);
1309 org.onap.vnfmdriver.model.VnfInfo vnf = lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1311 assertEquals(VNF_ID, vnf.getVnfInstanceId());
1312 //FIXME ? (do not know what exactly the vnf version mean in core terminology)
1313 assertEquals("vnfSoftwareVersion", vnf.getVersion());
1314 assertEquals(ONAP_CSAR_ID, vnf.getVnfdId());
1315 assertEquals("myDescription", vnf.getVnfInstanceDescription());
1316 assertEquals("myName", vnf.getVnfInstanceName());
1317 assertEquals(ONAP_CSAR_ID, vnf.getVnfPackageId());
1318 assertEquals("myProvider", vnf.getVnfProvider());
1319 //FIXME (in swagger schema )
1320 assertEquals("ACTIVE", vnf.getVnfStatus());
1321 assertEquals("Kuku", vnf.getVnfType());
1325 * error is propagated and logged if the queried VNF does not exist
1328 public void testQueryForNonExistingVnf() throws Exception {
1330 RuntimeException expectedException = new RuntimeException();
1331 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1334 lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1337 } catch (Exception e) {
1338 verify(logger).error("Unable to query VNF (myVnfId)", expectedException);
1339 assertEquals(expectedException, e.getCause());
1344 * test scale basic scenario
1347 public void testScale() throws Exception {
1348 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1349 scaleRequest.setNumberOfSteps("2");
1350 scaleRequest.setAspectId("myAspect");
1351 scaleRequest.setType(ScaleDirection.IN);
1352 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }"));
1353 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1354 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1355 VnfProperty prop = new VnfProperty();
1356 prop.setValue(ONAP_CSAR_ID);
1357 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1358 vnfInfo.getExtensions().add(prop);
1359 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1360 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1361 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1363 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1365 waitForJobToFinishInJobManager(finished);
1366 assertEquals(1, actualScaleRequest.getAllValues().size());
1367 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1368 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1369 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1370 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1371 assertEquals("myAspect", sRequest.getAspectId());
1372 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1373 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1374 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1375 verify(jobManager).spawnJob(VNF_ID, restResponse);
1376 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("scale"), eq(VNF_ID), anyString());
1381 * the VNFM should tolerate that no additional params were supplied
1384 public void testScaleWithoutAddtionalParams() throws Exception {
1385 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1386 scaleRequest.setNumberOfSteps("2");
1387 scaleRequest.setAspectId("myAspect");
1388 scaleRequest.setType(ScaleDirection.IN);
1389 scaleRequest.setAdditionalParam(null);
1390 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1391 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1392 VnfProperty prop = new VnfProperty();
1393 prop.setValue(ONAP_CSAR_ID);
1394 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1395 vnfInfo.getExtensions().add(prop);
1396 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1397 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1398 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1400 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1402 waitForJobToFinishInJobManager(finished);
1403 assertEquals(1, actualScaleRequest.getAllValues().size());
1404 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1405 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1406 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1407 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1408 assertEquals("myAspect", sRequest.getAspectId());
1409 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1410 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1411 assertEquals("{\"jobId\":\"myJobId\"}", new Gson().toJson(sRequest.getAdditionalParams()));
1412 verify(jobManager).spawnJob(VNF_ID, restResponse);
1416 * test scale out basic scenario
1419 public void testScaleOut() throws Exception {
1420 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1421 scaleRequest.setNumberOfSteps("2");
1422 scaleRequest.setAspectId("myAspect");
1423 scaleRequest.setType(ScaleDirection.OUT);
1424 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1425 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1426 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1427 VnfProperty prop = new VnfProperty();
1428 prop.setValue(ONAP_CSAR_ID);
1429 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1430 vnfInfo.getExtensions().add(prop);
1431 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1432 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1433 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1435 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1437 waitForJobToFinishInJobManager(finished);
1438 assertEquals(1, actualScaleRequest.getAllValues().size());
1439 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1440 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1441 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1442 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1443 assertEquals("myAspect", sRequest.getAspectId());
1444 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.OUT, sRequest.getType());
1445 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1446 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1450 * test scale operation is out waited
1453 public void testScaleOutwait() throws Exception {
1454 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1455 scaleRequest.setNumberOfSteps("2");
1456 scaleRequest.setAspectId("myAspect");
1457 scaleRequest.setType(ScaleDirection.IN);
1458 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1459 scaleOperationExecution.setStatus(OperationStatus.STARTED);
1460 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1461 VnfProperty prop = new VnfProperty();
1462 prop.setValue(ONAP_CSAR_ID);
1463 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1464 vnfInfo.getExtensions().add(prop);
1465 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1466 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1467 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1468 List<RuntimeException> expectedExceptions = new ArrayList<>();
1469 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<Observable<List<OperationExecution>>>) invocation -> {
1470 if (expectedExceptions.size() >= 100) {
1471 when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(scaleOperationExecution));
1472 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1473 return buildObservable(operationExecutions);
1475 RuntimeException RuntimeException = new RuntimeException();
1476 expectedExceptions.add(RuntimeException);
1477 throw RuntimeException;
1481 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1483 waitForJobToFinishInJobManager(finished);
1484 assertEquals(100, expectedExceptions.size());
1485 for (RuntimeException expectedException : expectedExceptions) {
1486 verify(logger).warn("Unable to retrieve operations details", expectedException);
1488 verify(systemFunctions, times(100)).sleep(5000);
1492 * test scale failure propagation
1495 public void testScaleFailurePropagation() throws Exception {
1496 RuntimeException expectedException = new RuntimeException();
1497 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1498 scaleRequest.setNumberOfSteps("2");
1499 scaleRequest.setAspectId("myAspect");
1500 scaleRequest.setType(ScaleDirection.IN);
1501 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1503 lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1505 waitForJobToFinishInJobManager(finished);
1506 verify(logger).error("Unable to scale VNF with myVnfId identifier", expectedException);
1510 * test heal basic scenario
1513 public void testHeal() throws Exception {
1514 VnfHealRequest healRequest = new VnfHealRequest();
1515 healRequest.setAction("myAction");
1516 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1517 affectedVm.setVmname("vmName");
1518 healRequest.setAffectedvm(affectedVm);
1519 healOperationExecution.setStatus(OperationStatus.FINISHED);
1520 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1521 VnfProperty prop = new VnfProperty();
1522 prop.setValue(ONAP_CSAR_ID);
1523 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1524 vnfInfo.getExtensions().add(prop);
1525 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1526 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1527 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1529 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1531 waitForJobToFinishInJobManager(finished);
1532 assertEquals(1, actualHealRequest.getAllValues().size());
1533 HealVnfRequest sRequest = actualHealRequest.getValue();
1534 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1535 workflowOrder.verify(vfcGrantManager).requestGrantForHeal(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(healRequest), eq(JOB_ID));
1536 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdHealPost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1537 JsonObject root = new Gson().toJsonTree(sRequest.getAdditionalParams()).getAsJsonObject();
1538 assertEquals("myAction", root.get("action").getAsString());
1539 assertEquals("vmName", root.get("vmName").getAsString());
1540 assertEquals(JOB_ID, root.get("jobId").getAsString());
1541 verify(jobManager).spawnJob(VNF_ID, restResponse);
1542 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("heal"), eq(VNF_ID), anyString());
1546 * test heal operation is out waited
1549 public void testHealOutwait() throws Exception {
1550 VnfHealRequest healRequest = new VnfHealRequest();
1551 healRequest.setAction("myAction");
1552 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1553 affectedVm.setVmname("vmName");
1554 healRequest.setAffectedvm(affectedVm);
1555 healOperationExecution.setStatus(OperationStatus.FINISHED);
1556 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1557 VnfProperty prop = new VnfProperty();
1558 prop.setValue(ONAP_CSAR_ID);
1559 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1560 vnfInfo.getExtensions().add(prop);
1561 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1562 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1563 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1564 List<RuntimeException> expectedExceptions = new ArrayList<>();
1565 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
1567 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
1568 if (expectedExceptions.size() >= 100) {
1569 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1570 return buildObservable(operationExecutions);
1572 RuntimeException RuntimeException = new RuntimeException();
1573 expectedExceptions.add(RuntimeException);
1574 throw RuntimeException;
1578 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1580 waitForJobToFinishInJobManager(finished);
1581 assertEquals(100, expectedExceptions.size());
1582 for (RuntimeException expectedException : expectedExceptions) {
1583 verify(logger).warn("Unable to retrieve operations details", expectedException);
1585 verify(systemFunctions, times(100)).sleep(5000);
1589 * failure in heal propagates in error
1592 public void testHealFailurePropagation() throws Exception {
1593 RuntimeException expectedException = new RuntimeException();
1594 VnfHealRequest healRequest = new VnfHealRequest();
1595 healRequest.setAction("myAction");
1596 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1597 affectedVm.setVmname("vmName");
1598 healRequest.setAffectedvm(affectedVm);
1599 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1601 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1603 waitForJobToFinishInJobManager(finished);
1604 verify(logger).error("Unable to heal VNF with myVnfId identifier", expectedException);
1609 * test custom operation basic scenario
1612 public void testCustomOperation() throws Exception {
1613 String operationId = "operationIdCaptor";
1614 Object additionalParams = new JsonObject();
1616 JobInfo job = lifecycleManager.customOperation(VNFM_ID, VNF_ID, operationId, additionalParams, restResponse);
1618 waitForJobToFinishInJobManager(finished);
1619 assertEquals(operationId, operationIdCaptor.getValue());
1620 assertEquals(additionalParams, customOperationRequestArgumentCaptor.getValue().getAdditionalParams());
1623 private void waitForJobToFinishInJobManager(Set<Boolean> finished) throws InterruptedException {
1624 while (finished.size() == 0) {
1625 systemFunctions().sleep(100);
1629 private VnfInstantiateRequest prepareInstantiationRequest(VimInfo.VimInfoTypeEnum cloudType) {
1630 VnfInstantiateRequest instantiationRequest = new VnfInstantiateRequest();
1631 instantiationRequest.setVnfPackageId(ONAP_CSAR_ID);
1632 instantiationRequest.setVnfDescriptorId(ONAP_CSAR_ID);
1633 instantiationRequest.setVnfInstanceDescription("myDescription");
1634 instantiationRequest.setVnfInstanceName("vnfName");
1635 additionalParam.setInstantiationLevel("level1");
1636 switch (cloudType) {
1637 case OPENSTACK_V2_INFO:
1638 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1640 case OPENSTACK_V3_INFO:
1641 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
1642 vimInfo.setDomain("myDomain");
1644 case VMWARE_VCLOUD_INFO:
1645 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
1648 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
1651 Map<String, List<NetworkAddress>> exteranalConnectionPointAddresses = new HashMap<>();
1652 exteranalConnectionPointAddresses.put("ecp1", new ArrayList<>());
1653 NetworkAddress networkAddress = new NetworkAddress();
1654 networkAddress.setIp("1.2.3.4");
1655 networkAddress.setMac("mac");
1656 networkAddress.setSubnetId("subnetId");
1657 exteranalConnectionPointAddresses.get("ecp1").add(networkAddress);
1658 additionalParam.setExternalConnectionPointAddresses(exteranalConnectionPointAddresses);
1659 VimComputeResourceFlavour flavor = new VimComputeResourceFlavour();
1660 flavor.setResourceId("flavourProviderId");
1661 flavor.setVimId(VIM_ID);
1662 flavor.setVnfdVirtualComputeDescId("virtualComputeDescId");
1663 additionalParam.getComputeResourceFlavours().add(flavor);
1664 ExtVirtualLinkData evl = new ExtVirtualLinkData();
1665 evl.setResourceId("networkProviderId1");
1666 evl.setVimId(VIM_ID);
1667 evl.setExtVirtualLinkId("evlId1");
1668 VnfExtCpData ecp2 = new VnfExtCpData();
1669 ecp2.setCpdId("cpdId3");
1670 ecp2.setAddresses(new ArrayList<>());
1671 ecp2.getAddresses().add(networkAddress);
1672 ecp2.setNumDynamicAddresses(2);
1673 evl.getExtCps().add(ecp2);
1674 additionalParam.getExtVirtualLinks().add(evl);
1675 externalVirtualLink.setCpdId("myCpdId");
1676 externalVirtualLink.setResourceId("myNetworkProviderId");
1677 externalVirtualLink.setVlInstanceId("myEVlId");
1678 externalVirtualLink.setResourceSubnetId("notUsedSubnetId");
1679 instantiationRequest.setExtVirtualLink(new ArrayList<>());
1680 instantiationRequest.getExtVirtualLink().add(externalVirtualLink);
1681 additionalParam.getExtManagedVirtualLinks().add(extManVl);
1682 ZoneInfo zone = new ZoneInfo();
1683 zone.setId("zoneId");
1684 zone.setResourceId("zoneProviderId");
1685 zone.setVimId(VIM_ID);
1686 additionalParam.getZones().add(zone);
1687 VimSoftwareImage image = new VimSoftwareImage();
1688 image.setResourceId("imageProviderId");
1689 image.setVimId(VIM_ID);
1690 image.setVnfdSoftwareImageId("imageId");
1691 additionalParam.getSoftwareImages().add(image);
1692 additionalParam.setAdditionalParams(new JsonParser().parse("{ \"a\" : \"b\" }"));
1693 String params = new Gson().toJson(additionalParam);
1694 String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "\" : " + params + "}}, \"vimId\" : \"" + VIM_ID + "\"}";
1695 instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
1696 return instantiationRequest;
1700 * Test vimId decomposition
1703 public void testVimIdSplitting() {
1704 assertEquals("regionId", LifecycleManager.getRegionName("cloudOwner_regionId"));
1705 assertEquals("cloudOwner", LifecycleManager.getCloudOwner("cloudOwner_regionId"));