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.ApiException;
24 import com.nokia.cbam.lcm.v32.model.*;
25 import com.nokia.cbam.lcm.v32.model.OperationType;
26 import com.nokia.cbam.lcm.v32.model.VimInfo;
27 import com.nokia.cbam.lcm.v32.model.VnfInfo;
28 import org.junit.Before;
29 import org.junit.Test;
30 import org.mockito.ArgumentCaptor;
31 import org.mockito.InOrder;
32 import org.mockito.Mock;
33 import org.mockito.Mockito;
34 import org.mockito.invocation.InvocationOnMock;
35 import org.mockito.stubbing.Answer;
36 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VimInfoProvider;
37 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.TestVfcGrantManager;
38 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.VfcGrantManager;
39 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.StoreLoader;
40 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.LifecycleChangeNotificationManager;
41 import org.onap.vnfmdriver.model.ExtVirtualLinkInfo;
42 import org.onap.vnfmdriver.model.*;
43 import org.onap.vnfmdriver.model.ScaleDirection;
44 import org.threeten.bp.OffsetDateTime;
46 import javax.servlet.http.HttpServletResponse;
47 import java.nio.file.Paths;
50 import static java.lang.Boolean.parseBoolean;
51 import static java.nio.file.Files.readAllBytes;
52 import static junit.framework.TestCase.*;
53 import static org.mockito.Matchers.eq;
54 import static org.mockito.Mockito.*;
55 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions.systemFunctions;
56 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
57 import static org.springframework.test.util.ReflectionTestUtils.setField;
59 public class TestLifecycleManager extends TestBase {
60 public static final String JOB_ID = "myJobId";
61 public static final String CBAM_VNFD_ID = "cbamVnfdId";
62 public static final String TENANT = "myTenant";
63 public static final String OPERATION_EXECUTION_ID = "operationExecutionId";
64 private static final String ONAP_CSAR_ID = "myOnapCsarId";
65 private static final String VIM_ID = "ownerId_regionId";
66 private GrantVNFResponseVim vim = new GrantVNFResponseVim();
68 private CatalogManager catalogManager;
70 private VfcGrantManager vfcGrantManager;
72 private CbamTokenProvider tokenProvider;
74 private JobManager jobManager;
76 private LifecycleChangeNotificationManager notificationManager;
78 private HttpServletResponse restResponse;
80 private VimInfoProvider vimInfoProvider;
82 private ArgumentCaptor<CreateVnfRequest> createRequest = ArgumentCaptor.forClass(CreateVnfRequest.class);
83 private AdditionalParams additionalParam = new AdditionalParams();
84 private String INSTANTIATION_LEVEL = "level1";
85 private GrantVNFResponseVim grantResponse = new GrantVNFResponseVim();
86 private String cbamVnfdContent;
87 private OperationExecution instantiationOperationExecution = new OperationExecution();
88 private OperationExecution modifyPropertyoperationExecution = new OperationExecution();
89 private OperationExecution scaleOperationExecution = new OperationExecution();
90 private OperationExecution healOperationExecution = new OperationExecution();
92 private VnfInfo vnfInfo = new VnfInfo();
93 private List<OperationExecution> operationExecutions = new ArrayList<>();
94 private org.onap.vnfmdriver.model.VimInfo vimInfo = new org.onap.vnfmdriver.model.VimInfo();
95 private ExtVirtualLinkInfo externalVirtualLink = new ExtVirtualLinkInfo();
96 private ExtManagedVirtualLinkData extManVl = new ExtManagedVirtualLinkData();
97 private ArgumentCaptor<ModifyVnfInfoRequest> actualVnfModifyRequest = ArgumentCaptor.forClass(ModifyVnfInfoRequest.class);
98 private Set<Boolean> finished = new HashSet<>();
99 private ArgumentCaptor<ScaleVnfRequest> actualScaleRequest = ArgumentCaptor.forClass(ScaleVnfRequest.class);
100 private ArgumentCaptor<HealVnfRequest> actualHealRequest = ArgumentCaptor.forClass(HealVnfRequest.class);
102 private LifecycleManager lifecycleManager;
105 public void initMocks() throws Exception {
106 vnfInfo.setExtensions(new ArrayList<>());
107 vnfInfo.setOperationExecutions(new ArrayList<>());
108 lifecycleManager = new LifecycleManager(catalogManager, vfcGrantManager, cbamRestApiProvider, vimInfoProvider, jobManager, notificationManager);
109 cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.full.yaml").toURI())));
110 setField(LifecycleManager.class, "logger", logger);
111 CatalogAdapterVnfpackage cbamPackage = new CatalogAdapterVnfpackage();
112 when(catalogManager.preparePackageInCbam(VNFM_ID, ONAP_CSAR_ID)).thenReturn(cbamPackage);
113 cbamPackage.setVnfdId(CBAM_VNFD_ID);
114 vnfInfo.setVnfdId(CBAM_VNFD_ID);
115 vnfInfo.setId(VNF_ID);
116 when(jobManager.spawnJob(VNF_ID, restResponse)).thenReturn(JOB_ID);
117 when(catalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent);
118 cbamPackage.setId(CBAM_VNFD_ID);
119 vimInfo.setUrl("cloudUrl");
120 vimInfo.setPassword("vimPassword");
121 vimInfo.setUserName("vimUsername");
122 vimInfo.setSslInsecure("true");
123 vimInfo.setVimId(VIM_ID);
124 vimInfo.setName("vimName");
125 when(vimInfoProvider.getVimInfo((VIM_ID))).thenReturn(vimInfo);
126 instantiationOperationExecution.setId(OPERATION_EXECUTION_ID);
127 instantiationOperationExecution.setOperationType(OperationType.INSTANTIATE);
128 instantiationOperationExecution.setStartTime(OffsetDateTime.now());
129 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(operationExecutions);
130 operationExecutions.add(modifyPropertyoperationExecution);
131 modifyPropertyoperationExecution.setStartTime(OffsetDateTime.now());
132 modifyPropertyoperationExecution.setOperationType(OperationType.MODIFY_INFO);
133 operationExecutions.add(instantiationOperationExecution);
134 instantiationOperationExecution.setStatus(OperationStatus.FINISHED);
135 modifyPropertyoperationExecution.setStatus(OperationStatus.FINISHED);
136 modifyPropertyoperationExecution.setId(UUID.randomUUID().toString());
137 scaleOperationExecution.setId(UUID.randomUUID().toString());
138 healOperationExecution.setId(UUID.randomUUID().toString());
139 when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(modifyPropertyoperationExecution);
140 doAnswer(new Answer() {
142 public Object answer(InvocationOnMock invocation) throws Throwable {
143 finished.add(Boolean.TRUE);
146 }).when(jobManager).jobFinished(JOB_ID);
147 when(vnfApi.vnfsVnfInstanceIdScalePost(eq(VNF_ID), actualScaleRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
149 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
150 operationExecutions.add(scaleOperationExecution);
151 return scaleOperationExecution;
154 when(vnfApi.vnfsVnfInstanceIdHealPost(eq(VNF_ID), actualHealRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
156 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
157 operationExecutions.add(healOperationExecution);
158 return healOperationExecution;
167 public void testInstantiation() throws Exception {
169 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
171 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
172 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
173 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
174 grantResponse.setVimId(VIM_ID);
175 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
176 accessInfo.setTenant(TENANT);
177 grantResponse.setAccessInfo(accessInfo);
178 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
179 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
181 VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
182 waitForJobToFinishInJobManager(finished);
184 assertEquals(VNF_ID, response.getVnfInstanceId());
185 assertEquals(JOB_ID, response.getJobId());
186 assertEquals(createRequest.getAllValues().size(), 1);
187 assertEquals("myDescription", createRequest.getValue().getDescription());
188 assertEquals("vnfName", createRequest.getValue().getName());
189 assertEquals(CBAM_VNFD_ID, createRequest.getValue().getVnfdId());
190 assertEquals(1, actualInstantiationRequest.getAllValues().size());
191 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
192 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
193 assertEquals(VIM_ID, actualVim.getId());
194 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, actualVim.getVimInfoType());
195 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
196 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
197 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
198 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
199 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
200 assertEquals("myTenant", actualVim.getAccessInfo().getTenant());
201 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
202 assertEquals(1, actualInstantiationRequest.getValue().getComputeResourceFlavours().size());
203 assertEquals("flavourProviderId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getResourceId());
204 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVimId());
205 assertEquals("virtualComputeDescId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVnfdVirtualComputeDescId());
206 assertEquals(1, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().size());
207 assertEquals(extManVl, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().get(0));
208 assertEquals(2, actualInstantiationRequest.getValue().getExtVirtualLinks().size());
210 assertEquals("myNetworkProviderId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getResourceId());
211 assertEquals("myEVlId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtVirtualLinkId());
212 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().size());
213 assertEquals("myCpdId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().get(0).getCpdId());
215 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getVimId());
216 assertEquals("evlId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtVirtualLinkId());
217 assertEquals("networkProviderId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getResourceId());
218 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().size());
221 assertEquals(Integer.valueOf(2), actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getNumDynamicAddresses());
222 assertEquals("cpdId3", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getCpdId());
223 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().size());
224 assertEquals("1.2.3.4", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getIp());
225 assertEquals("mac", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getMac());
226 assertEquals("subnetId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getSubnetId());
228 assertEquals("myFlavorId", actualInstantiationRequest.getValue().getFlavourId());
229 assertEquals(Boolean.TRUE, actualInstantiationRequest.getValue().isGrantlessMode());
230 assertEquals("level1", actualInstantiationRequest.getValue().getInstantiationLevelId());
231 assertEquals(1, actualInstantiationRequest.getValue().getZones().size());
232 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getZones().get(0).getVimId());
233 assertEquals("zoneProviderId", actualInstantiationRequest.getValue().getZones().get(0).getResourceId());
234 assertEquals("zoneId", actualInstantiationRequest.getValue().getZones().get(0).getId());
235 assertEquals(1, actualInstantiationRequest.getValue().getSoftwareImages().size());
236 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVimId());
237 assertEquals("imageProviderId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getResourceId());
238 assertEquals("imageId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVnfdSoftwareImageId());
239 String actualEmbeddedAdditionParams = new Gson().toJson(actualInstantiationRequest.getValue().getAdditionalParams());
240 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(actualEmbeddedAdditionParams) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(actualEmbeddedAdditionParams));
241 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
242 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
244 assertEquals(1, actualVnfModifyRequest.getAllValues().size());
245 assertEquals(2, actualVnfModifyRequest.getValue().getExtensions().size());
246 assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getName());
247 assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getValue());
248 assertEquals(LifecycleManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName());
249 assertEquals(VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getValue());
251 //the 3.2 API does not accept empty array
252 assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties());
253 verify(jobManager).spawnJob(VNF_ID, restResponse);
257 * invalid VIM type results in failure
260 public void testInstantiationWithInvalidVimType() throws Exception {
262 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
263 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
266 lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
269 } catch (Exception e) {
270 assertEquals("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types", e.getMessage());
272 verify(vnfApi, never()).vnfsPost(Mockito.any(), Mockito.any());
273 verify(logger).error("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types");
277 * test instantiation with KeyStone V2 based with SSL
280 public void testInstantiationV2WithSsl() throws Exception {
281 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
283 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
284 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
285 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
286 grantResponse.setVimId(VIM_ID);
287 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
288 accessInfo.setTenant(TENANT);
289 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
290 vimInfo.setSslInsecure("false");
291 vimInfo.setSslCacert(caCert);
292 grantResponse.setAccessInfo(accessInfo);
293 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
294 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
296 VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
297 waitForJobToFinishInJobManager(finished);
298 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
300 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
301 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
302 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
303 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
308 * non specified SSL verification means not verified
311 public void testInstantiationV2WithoutSsl() throws Exception {
312 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
314 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
315 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
316 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
317 grantResponse.setVimId(VIM_ID);
318 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
319 accessInfo.setTenant(TENANT);
320 vimInfo.setSslInsecure(null);
321 grantResponse.setAccessInfo(accessInfo);
322 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
323 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
325 VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
326 waitForJobToFinishInJobManager(finished);
327 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
329 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
330 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
331 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
335 * test instantiation with KeyStone V3 based
338 public void testInstantiationV3() throws Exception {
339 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
341 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
342 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
343 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
344 grantResponse.setVimId(VIM_ID);
345 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
346 accessInfo.setTenant(TENANT);
347 grantResponse.setAccessInfo(accessInfo);
348 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
349 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
351 VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
352 waitForJobToFinishInJobManager(finished);
353 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
355 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
356 assertEquals(VIM_ID, actualVim.getId());
357 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
358 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
359 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
360 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
361 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
362 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
363 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
364 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
365 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
366 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
367 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
371 * test instantiation with KeyStone V3 based with SSL
374 public void testInstantiationV3WithSsl() throws Exception {
375 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
377 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
378 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
379 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
380 grantResponse.setVimId(VIM_ID);
381 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
382 accessInfo.setTenant(TENANT);
383 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
384 vimInfo.setSslInsecure("false");
385 vimInfo.setSslCacert(caCert);
386 grantResponse.setAccessInfo(accessInfo);
387 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
388 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
390 VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
391 waitForJobToFinishInJobManager(finished);
392 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
394 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
395 assertEquals(VIM_ID, actualVim.getId());
396 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
397 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
398 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
399 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
400 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
401 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
402 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
403 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
404 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
405 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
406 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
407 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
411 * non specified SSL verification meams not verified for KeyStone V3 based
414 public void testInstantiationV3WithNonSpecifiedSsl() throws Exception {
415 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
417 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
418 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
419 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
420 grantResponse.setVimId(VIM_ID);
421 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
422 accessInfo.setTenant(TENANT);
423 vimInfo.setSslInsecure(null);
424 grantResponse.setAccessInfo(accessInfo);
425 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
426 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
428 VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
429 waitForJobToFinishInJobManager(finished);
430 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
432 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
433 assertEquals(VIM_ID, actualVim.getId());
434 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
435 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
436 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
437 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
438 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
439 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
440 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
441 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
442 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
443 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
447 * test instantiation with vcloud
450 public void testInstantiationVcloud() throws Exception {
451 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
453 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
454 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
455 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
456 grantResponse.setVimId(VIM_ID);
457 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
458 accessInfo.setTenant(TENANT);
459 grantResponse.setAccessInfo(accessInfo);
460 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
461 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
463 VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
464 waitForJobToFinishInJobManager(finished);
465 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
467 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
468 assertEquals(VIM_ID, actualVim.getId());
469 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
470 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
471 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
472 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
473 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
474 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
475 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
476 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
477 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
481 * test instantiation with vCloud with SSL
484 public void testInstantiationVcloudWithSsl() throws Exception {
485 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
487 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
488 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
489 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
490 grantResponse.setVimId(VIM_ID);
491 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
492 accessInfo.setTenant(TENANT);
493 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
494 vimInfo.setSslInsecure("false");
495 vimInfo.setSslCacert(caCert);
496 grantResponse.setAccessInfo(accessInfo);
497 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
498 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
500 VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
501 waitForJobToFinishInJobManager(finished);
502 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
504 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
505 assertEquals(VIM_ID, actualVim.getId());
506 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
507 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
508 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
509 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
510 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
511 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
512 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
513 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
514 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
515 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
519 * test instantiation with vCloud with SSL
522 public void testInstantiationVcloudWithNonSecifedSSl() throws Exception {
523 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
525 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
526 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
527 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
528 grantResponse.setVimId(VIM_ID);
529 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
530 accessInfo.setTenant(TENANT);
531 vimInfo.setSslInsecure(null);
532 grantResponse.setAccessInfo(accessInfo);
533 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
534 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
536 VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
537 waitForJobToFinishInJobManager(finished);
538 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
540 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
541 assertEquals(VIM_ID, actualVim.getId());
542 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
543 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
544 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
545 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
546 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
547 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
548 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
549 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
553 * test failure in the instantiation request marks the job to be finished in job manager
556 public void testFailureInTheInstantiationRequest() throws Exception {
557 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
558 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
559 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
560 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
561 grantResponse.setVimId(VIM_ID);
562 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
563 accessInfo.setTenant(TENANT);
564 grantResponse.setAccessInfo(accessInfo);
565 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
566 ApiException expectedException = new ApiException();
567 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
570 VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
572 waitForJobToFinishInJobManager(finished);
573 assertEquals(VNF_ID, response.getVnfInstanceId());
574 assertEquals(JOB_ID, response.getJobId());
575 verify(logger).error("Unable to instantiate VNF with myVnfId identifier", expectedException);
579 * instantiation fails if VF-C does not send vim identifier in grant response
582 public void testVfcFailsToSendVimId() throws Exception {
583 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
585 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
586 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
587 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
588 //grantResponse.setVimId(VIM_ID);
589 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
590 accessInfo.setTenant(TENANT);
591 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
592 vimInfo.setSslInsecure("false");
593 vimInfo.setSslCacert(caCert);
594 grantResponse.setAccessInfo(accessInfo);
595 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
596 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
598 VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
599 waitForJobToFinishInJobManager(finished);
600 assertEquals(0, actualInstantiationRequest.getAllValues().size());
602 verify(logger).error("VF-C did not send VIM identifier in grant response");
607 * test operation execution polling is retried in case of failures
610 public void testFailureInTheOperationExecutionPollingDuringInstantiationRequest() throws Exception {
611 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
612 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
613 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
614 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
615 grantResponse.setVimId(VIM_ID);
616 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
617 accessInfo.setTenant(TENANT);
618 grantResponse.setAccessInfo(accessInfo);
619 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
620 ApiException expectedException = new ApiException();
621 List<ApiException> polling = new ArrayList<>();
622 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
623 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).then(new Answer<List<OperationExecution>>() {
625 public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
626 if (polling.size() > 2) {
627 return operationExecutions;
629 ApiException apiException = new ApiException();
630 polling.add(apiException);
635 VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
637 waitForJobToFinishInJobManager(finished);
638 assertEquals(VNF_ID, response.getVnfInstanceId());
639 assertEquals(JOB_ID, response.getJobId());
640 assertEquals(3, polling.size());
641 for (ApiException e : polling) {
642 verify(logger).warn("Unable to retrieve operations details", e);
644 verify(systemFunctions, Mockito.times(3)).sleep(5000);
648 * failure in VNF creation is logged an proagated
651 public void failureInVnfCreationIsPropagated() throws Exception {
653 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
655 ApiException expectedException = new ApiException();
656 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
659 lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
662 } catch (RuntimeException e) {
663 assertEquals(expectedException, e.getCause());
664 verify(logger).error("Unable to create the VNF", expectedException);
669 * failure in updating the modifyable attributes of the VNF is logged an proagated
672 public void failureInVnfModificationIsPropagated() throws Exception {
674 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
676 ApiException expectedException = new ApiException();
677 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
678 when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
682 lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
685 } catch (RuntimeException e) {
686 assertEquals(expectedException, e.getCause().getCause());
687 verify(logger).error("Unable to set the onapCsarId property on the VNF", expectedException);
692 * if the VIM info can not be queried the VNF is not instantiated and
693 * error propagated through job
696 public void testFailureInQueryVimInfo() throws Exception {
697 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
698 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
699 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
700 grantResponse.setVimId(VIM_ID);
701 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
702 accessInfo.setTenant(TENANT);
703 grantResponse.setAccessInfo(accessInfo);
705 when(vimInfoProvider.getVimInfo(VIM_ID)).thenThrow(new RuntimeException());
707 lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
709 waitForJobToFinishInJobManager(finished);
710 verify(vnfApi, never()).vnfsVnfInstanceIdInstantiatePost(Mockito.any(), Mockito.any(), Mockito.any());
714 * test termination basic success scenario
715 * - the VNF is not deleted before the notifications are processed
718 public void testTermination() throws Exception {
720 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
721 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
722 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
723 vnfInfo.setOperationExecutions(operationExecutions);
724 VnfProperty vnfdId = new VnfProperty();
725 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
726 vnfdId.setValue(ONAP_CSAR_ID);
727 vnfInfo.getExtensions().add(vnfdId);
728 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
729 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
731 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
732 OperationExecution terminationOperation = new OperationExecution();
733 terminationOperation.setId("terminationId");
734 operationExecutions.add(terminationOperation);
735 terminationOperation.setStatus(OperationStatus.FINISHED);
736 return terminationOperation;
739 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
740 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
742 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
744 waitForJobToFinishInJobManager(finished);
745 assertEquals(1, actualTerminationRequest.getAllValues().size());
746 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
747 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
748 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
749 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
750 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
751 verify(jobManager).spawnJob(VNF_ID, restResponse);
755 * test termination of a non instantiated VNF
756 * - the VNF is not terminated (only deleted)
759 public void testTerminationOfNonInstantiated() throws Exception {
761 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
762 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
763 vnfInfo.setInstantiationState(InstantiationState.NOT_INSTANTIATED);
764 vnfInfo.setOperationExecutions(operationExecutions);
765 VnfProperty vnfdId = new VnfProperty();
766 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
767 vnfdId.setValue(ONAP_CSAR_ID);
768 vnfInfo.getExtensions().add(vnfdId);
769 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
770 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
772 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
774 boolean deleted = false;
778 verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
783 verify(vfcGrantManager, never()).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
784 verify(notificationManager, never()).waitForTerminationToBeProcessed("terminationId");
788 * test that the VNF deletion is not started before the termination finishes
791 public void testTerminationOperationIsOutwaited() throws Exception {
793 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
794 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
795 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
796 vnfInfo.setOperationExecutions(operationExecutions);
797 VnfProperty vnfdId = new VnfProperty();
798 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
799 vnfdId.setValue(ONAP_CSAR_ID);
800 vnfInfo.getExtensions().add(vnfdId);
801 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
802 OperationExecution terminationOperation = new OperationExecution();
803 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
805 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
806 terminationOperation.setId("terminationId");
807 operationExecutions.add(terminationOperation);
808 terminationOperation.setStatus(OperationStatus.STARTED);
809 return terminationOperation;
812 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
813 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
814 Set<Integer> calls = new HashSet<>();
815 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<List<OperationExecution>>() {
817 public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
818 if (calls.size() == 1000) {
819 terminationOperation.setStatus(OperationStatus.FINISHED);
821 calls.add(calls.size());
822 return operationExecutions;
826 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
828 waitForJobToFinishInJobManager(finished);
829 verify(vnfApi, times(1001)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
830 verify(systemFunctions, times(1000)).sleep(5000);
835 * test that failured during waiting for the operation to finish is tolerated (idefineiatelly)
838 public void testTerminationOperationIsOutwaitedWithErrors() throws Exception {
840 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
841 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
842 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
843 vnfInfo.setOperationExecutions(operationExecutions);
844 VnfProperty vnfdId = new VnfProperty();
845 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
846 vnfdId.setValue(ONAP_CSAR_ID);
847 vnfInfo.getExtensions().add(vnfdId);
848 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
849 OperationExecution terminationOperation = new OperationExecution();
850 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
852 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
853 terminationOperation.setId("terminationId");
854 operationExecutions.add(terminationOperation);
855 terminationOperation.setStatus(OperationStatus.STARTED);
856 return terminationOperation;
859 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
860 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
861 Set<Integer> calls = new HashSet<>();
862 List<ApiException> expectedExceptions = new ArrayList<>();
863 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<List<OperationExecution>>() {
865 public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
866 if (calls.size() >= 100) {
867 terminationOperation.setStatus(OperationStatus.FINISHED);
868 return operationExecutions;
870 calls.add(calls.size());
871 ApiException apiException = new ApiException();
872 expectedExceptions.add(apiException);
877 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
879 waitForJobToFinishInJobManager(finished);
880 verify(vnfApi, times(101)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
881 verify(systemFunctions, times(100)).sleep(5000);
882 for (ApiException expectedException : expectedExceptions) {
883 verify(logger).warn("Unable to retrieve operations details", expectedException);
888 * test gracefull termination
891 public void testGracefullTermination() throws Exception {
893 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
894 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
895 terminationRequest.setTerminationType(VnfTerminationType.GRACEFUL);
896 terminationRequest.setGracefulTerminationTimeout("1234");
897 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
898 vnfInfo.setOperationExecutions(operationExecutions);
899 VnfProperty vnfdId = new VnfProperty();
900 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
901 vnfdId.setValue(ONAP_CSAR_ID);
902 vnfInfo.getExtensions().add(vnfdId);
903 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
904 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
906 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
907 OperationExecution terminationOperation = new OperationExecution();
908 terminationOperation.setId("terminationId");
909 operationExecutions.add(terminationOperation);
910 terminationOperation.setStatus(OperationStatus.FINISHED);
911 return terminationOperation;
914 doAnswer(invocation -> {
915 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
917 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
918 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
919 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
921 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
923 waitForJobToFinishInJobManager(finished);
924 assertEquals(1, actualTerminationRequest.getAllValues().size());
925 assertEquals(TerminationType.GRACEFUL, actualTerminationRequest.getValue().getTerminationType());
926 assertEquals(Integer.valueOf(1234), actualTerminationRequest.getValue().getGracefulTerminationTimeout());
927 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
928 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
929 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
930 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
934 * instantiation with missing ONAP csarId to instantiation extra param result in failure
937 public void testMissingVnfParameters() throws Exception {
939 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
940 String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "invalid" + "\" : {}}}, \"vimId\" : \"" + VIM_ID + "\"}";
941 instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
944 VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse);
946 } catch (Exception e) {
947 assertEquals("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id", e.getMessage());
948 verify(logger).error("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id");
953 * test explicit forceful termination
956 public void testExplicitForcefulTermination() throws Exception {
958 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
959 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
960 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
961 terminationRequest.setGracefulTerminationTimeout("1234");
962 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
963 vnfInfo.setOperationExecutions(operationExecutions);
964 VnfProperty vnfdId = new VnfProperty();
965 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
966 vnfdId.setValue(ONAP_CSAR_ID);
967 vnfInfo.getExtensions().add(vnfdId);
968 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
969 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
971 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
972 OperationExecution terminationOperation = new OperationExecution();
973 terminationOperation.setId("terminationId");
974 operationExecutions.add(terminationOperation);
975 terminationOperation.setStatus(OperationStatus.FINISHED);
976 return terminationOperation;
979 doAnswer(invocation -> {
980 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
982 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
983 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
984 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
986 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
988 waitForJobToFinishInJobManager(finished);
989 assertEquals(1, actualTerminationRequest.getAllValues().size());
990 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
991 assertNull(actualTerminationRequest.getValue().getGracefulTerminationTimeout());
992 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
993 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
994 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
995 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
999 * test failure in the termination workflow finishes the job
1002 public void testFailureInTheTerminationFinishesTheManagedJob() throws Exception {
1004 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1005 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1006 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1007 terminationRequest.setGracefulTerminationTimeout("1234");
1008 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1009 vnfInfo.setOperationExecutions(operationExecutions);
1010 VnfProperty vnfdId = new VnfProperty();
1011 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1012 vnfdId.setValue(ONAP_CSAR_ID);
1013 vnfInfo.getExtensions().add(vnfdId);
1014 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1015 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
1017 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
1018 OperationExecution terminationOperation = new OperationExecution();
1019 terminationOperation.setId("terminationId");
1020 operationExecutions.add(terminationOperation);
1021 terminationOperation.setStatus(OperationStatus.FINISHED);
1022 return terminationOperation;
1025 ApiException expectedException = new ApiException();
1026 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1027 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1028 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
1030 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1032 waitForJobToFinishInJobManager(finished);
1033 assertEquals(0, actualTerminationRequest.getAllValues().size());
1034 Mockito.verifyZeroInteractions(vfcGrantManager);
1038 * if termination fails the VNF is not deleted
1041 public void testFailedTerminationAbortsTerminationWorkflow() throws Exception {
1043 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1044 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1045 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1046 vnfInfo.setOperationExecutions(operationExecutions);
1047 VnfProperty vnfdId = new VnfProperty();
1048 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1049 vnfdId.setValue(ONAP_CSAR_ID);
1050 vnfInfo.getExtensions().add(vnfdId);
1051 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1052 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
1054 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
1055 OperationExecution terminationOperation = new OperationExecution();
1056 terminationOperation.setId("terminationId");
1057 operationExecutions.add(terminationOperation);
1058 terminationOperation.setStatus(OperationStatus.FAILED);
1059 return terminationOperation;
1062 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1063 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
1065 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1067 waitForJobToFinishInJobManager(finished);
1068 assertEquals(1, actualTerminationRequest.getAllValues().size());
1069 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1070 verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1071 verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1072 verify(logger).error("Unable to terminate VNF the operation did not finish with success");
1076 * test VNF query basic success scenario
1079 public void testQuery() throws Exception {
1080 vnfInfo.setDescription("myDescription");
1081 vnfInfo.setName("myName");
1082 vnfInfo.setVnfSoftwareVersion("vnfSoftwareVersion");
1083 vnfInfo.setVnfProvider("myProvider");
1084 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1085 VnfProperty prop = new VnfProperty();
1086 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1087 prop.setValue(ONAP_CSAR_ID);
1088 vnfInfo.getExtensions().add(prop);
1090 org.onap.vnfmdriver.model.VnfInfo vnf = lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1092 assertEquals(VNF_ID, vnf.getVnfInstanceId());
1093 //FIXME ? (do not know what exactly the vnf version mean in core terminology)
1094 assertEquals("vnfSoftwareVersion", vnf.getVersion());
1095 assertEquals(ONAP_CSAR_ID, vnf.getVnfdId());
1096 assertEquals("myDescription", vnf.getVnfInstanceDescription());
1097 assertEquals("myName", vnf.getVnfInstanceName());
1098 assertEquals(ONAP_CSAR_ID, vnf.getVnfPackageId());
1099 assertEquals("myProvider", vnf.getVnfProvider());
1100 //FIXME (in swagger schema )
1101 assertEquals("ACTIVE", vnf.getVnfStatus());
1102 assertEquals("Kuku", vnf.getVnfType());
1106 * error is propagated and logged if the queried VNF does not exist
1109 public void testQueryForNonExistingVnf() throws Exception {
1111 ApiException expectedException = new ApiException();
1112 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1115 lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1118 } catch (Exception e) {
1119 verify(logger).error("Unable to query VNF (myVnfId)", expectedException);
1120 assertEquals(expectedException, e.getCause());
1125 * test scale basic scenario
1128 public void testScale() throws Exception {
1129 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1130 scaleRequest.setNumberOfSteps("2");
1131 scaleRequest.setAspectId("myAspect");
1132 scaleRequest.setType(ScaleDirection.IN);
1133 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }"));
1134 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1135 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1136 VnfProperty prop = new VnfProperty();
1137 prop.setValue(ONAP_CSAR_ID);
1138 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1139 vnfInfo.getExtensions().add(prop);
1140 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1141 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1142 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
1144 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1146 waitForJobToFinishInJobManager(finished);
1147 assertEquals(1, actualScaleRequest.getAllValues().size());
1148 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1149 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1150 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1151 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1152 assertEquals("myAspect", sRequest.getAspectId());
1153 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1154 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1155 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1156 verify(jobManager).spawnJob(VNF_ID, restResponse);
1160 * the VNFM should tolerate that no additional params were supplied
1163 public void testScaleWithoutAddtionalParams() throws Exception {
1164 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1165 scaleRequest.setNumberOfSteps("2");
1166 scaleRequest.setAspectId("myAspect");
1167 scaleRequest.setType(ScaleDirection.IN);
1168 scaleRequest.setAdditionalParam(null);
1169 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1170 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1171 VnfProperty prop = new VnfProperty();
1172 prop.setValue(ONAP_CSAR_ID);
1173 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1174 vnfInfo.getExtensions().add(prop);
1175 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1176 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1177 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
1179 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1181 waitForJobToFinishInJobManager(finished);
1182 assertEquals(1, actualScaleRequest.getAllValues().size());
1183 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1184 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1185 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1186 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1187 assertEquals("myAspect", sRequest.getAspectId());
1188 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1189 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1190 assertEquals("{\"jobId\":\"myJobId\"}", new Gson().toJson(sRequest.getAdditionalParams()));
1191 verify(jobManager).spawnJob(VNF_ID, restResponse);
1195 * test scale out basic scenario
1198 public void testScaleOut() throws Exception {
1199 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1200 scaleRequest.setNumberOfSteps("2");
1201 scaleRequest.setAspectId("myAspect");
1202 scaleRequest.setType(ScaleDirection.OUT);
1203 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1204 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1205 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1206 VnfProperty prop = new VnfProperty();
1207 prop.setValue(ONAP_CSAR_ID);
1208 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1209 vnfInfo.getExtensions().add(prop);
1210 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1211 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1212 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
1214 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1216 waitForJobToFinishInJobManager(finished);
1217 assertEquals(1, actualScaleRequest.getAllValues().size());
1218 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1219 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1220 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1221 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1222 assertEquals("myAspect", sRequest.getAspectId());
1223 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.OUT, sRequest.getType());
1224 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1225 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1229 * test scale operation is out waited
1232 public void testScaleOutwait() throws Exception {
1233 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1234 scaleRequest.setNumberOfSteps("2");
1235 scaleRequest.setAspectId("myAspect");
1236 scaleRequest.setType(ScaleDirection.IN);
1237 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1238 scaleOperationExecution.setStatus(OperationStatus.STARTED);
1239 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1240 VnfProperty prop = new VnfProperty();
1241 prop.setValue(ONAP_CSAR_ID);
1242 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1243 vnfInfo.getExtensions().add(prop);
1244 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1245 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1246 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
1247 List<ApiException> expectedExceptions = new ArrayList<>();
1248 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<List<OperationExecution>>) invocation -> {
1249 if (expectedExceptions.size() >= 100) {
1250 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1251 return operationExecutions;
1253 ApiException apiException = new ApiException();
1254 expectedExceptions.add(apiException);
1255 // when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(scaleOperationExecution);
1260 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1262 waitForJobToFinishInJobManager(finished);
1263 assertEquals(100, expectedExceptions.size());
1264 for (ApiException expectedException : expectedExceptions) {
1265 verify(logger).warn("Unable to retrieve operations details", expectedException);
1267 verify(systemFunctions, times(100)).sleep(5000);
1271 * test scale failure propagation
1274 public void testScaleFailurePropagation() throws Exception {
1275 ApiException expectedException = new ApiException();
1276 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1277 scaleRequest.setNumberOfSteps("2");
1278 scaleRequest.setAspectId("myAspect");
1279 scaleRequest.setType(ScaleDirection.IN);
1280 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1282 lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1284 waitForJobToFinishInJobManager(finished);
1285 verify(logger).error("Unable to scale VNF with myVnfId identifier", expectedException);
1289 * test heal basic scenario
1292 public void testHeal() throws Exception {
1293 VnfHealRequest healRequest = new VnfHealRequest();
1294 healRequest.setAction("myAction");
1295 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1296 affectedVm.setVmname("vmName");
1297 healRequest.setAffectedvm(affectedVm);
1298 healOperationExecution.setStatus(OperationStatus.FINISHED);
1299 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1300 VnfProperty prop = new VnfProperty();
1301 prop.setValue(ONAP_CSAR_ID);
1302 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1303 vnfInfo.getExtensions().add(prop);
1304 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1305 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1306 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
1308 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, restResponse);
1310 waitForJobToFinishInJobManager(finished);
1311 assertEquals(1, actualHealRequest.getAllValues().size());
1312 HealVnfRequest sRequest = actualHealRequest.getValue();
1313 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1314 workflowOrder.verify(vfcGrantManager).requestGrantForHeal(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(healRequest), eq(JOB_ID));
1315 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdHealPost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1316 JsonObject root = new Gson().toJsonTree(sRequest.getAdditionalParams()).getAsJsonObject();
1317 assertEquals("myAction", root.get("action").getAsString());
1318 assertEquals("vmName", root.get("vmName").getAsString());
1319 assertEquals(JOB_ID, root.get("jobId").getAsString());
1320 verify(jobManager).spawnJob(VNF_ID, restResponse);
1324 * test heal operation is out waited
1327 public void testHealOutwait() throws Exception {
1328 VnfHealRequest healRequest = new VnfHealRequest();
1329 healRequest.setAction("myAction");
1330 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1331 affectedVm.setVmname("vmName");
1332 healRequest.setAffectedvm(affectedVm);
1333 healOperationExecution.setStatus(OperationStatus.FINISHED);
1334 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1335 VnfProperty prop = new VnfProperty();
1336 prop.setValue(ONAP_CSAR_ID);
1337 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1338 vnfInfo.getExtensions().add(prop);
1339 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1340 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1341 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
1342 List<ApiException> expectedExceptions = new ArrayList<>();
1343 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<List<OperationExecution>>() {
1345 public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1346 if (expectedExceptions.size() >= 100) {
1347 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1348 return operationExecutions;
1350 ApiException apiException = new ApiException();
1351 expectedExceptions.add(apiException);
1356 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, restResponse);
1358 waitForJobToFinishInJobManager(finished);
1359 assertEquals(100, expectedExceptions.size());
1360 for (ApiException expectedException : expectedExceptions) {
1361 verify(logger).warn("Unable to retrieve operations details", expectedException);
1363 verify(systemFunctions, times(100)).sleep(5000);
1367 * failure in heal propagates in error
1370 public void testHealFailurePropagation() throws Exception {
1371 ApiException expectedException = new ApiException();
1372 VnfHealRequest healRequest = new VnfHealRequest();
1373 healRequest.setAction("myAction");
1374 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1375 affectedVm.setVmname("vmName");
1376 healRequest.setAffectedvm(affectedVm);
1377 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1379 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, restResponse);
1381 waitForJobToFinishInJobManager(finished);
1382 verify(logger).error("Unable to heal VNF with myVnfId identifier", expectedException);
1385 private void waitForJobToFinishInJobManager(Set<Boolean> finished) throws InterruptedException {
1386 while (finished.size() == 0) {
1387 systemFunctions().sleep(100);
1391 private VnfInstantiateRequest prepareInstantiationRequest(VimInfo.VimInfoTypeEnum cloudType) {
1392 VnfInstantiateRequest instantiationRequest = new VnfInstantiateRequest();
1393 instantiationRequest.setVnfPackageId(ONAP_CSAR_ID);
1394 instantiationRequest.setVnfDescriptorId(ONAP_CSAR_ID);
1395 instantiationRequest.setVnfInstanceDescription("myDescription");
1396 instantiationRequest.setVnfInstanceName("vnfName");
1397 additionalParam.setInstantiationLevel("level1");
1398 switch (cloudType) {
1399 case OPENSTACK_V2_INFO:
1400 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1402 case OPENSTACK_V3_INFO:
1403 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
1404 additionalParam.setDomain("myDomain");
1406 case VMWARE_VCLOUD_INFO:
1407 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
1410 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
1413 Map<String, List<NetworkAddress>> exteranalConnectionPointAddresses = new HashMap<>();
1414 exteranalConnectionPointAddresses.put("ecp1", new ArrayList<>());
1415 NetworkAddress networkAddress = new NetworkAddress();
1416 networkAddress.setIp("1.2.3.4");
1417 networkAddress.setMac("mac");
1418 networkAddress.setSubnetId("subnetId");
1419 exteranalConnectionPointAddresses.get("ecp1").add(networkAddress);
1420 additionalParam.setExternalConnectionPointAddresses(exteranalConnectionPointAddresses);
1421 VimComputeResourceFlavour flavor = new VimComputeResourceFlavour();
1422 flavor.setResourceId("flavourProviderId");
1423 flavor.setVimId(VIM_ID);
1424 flavor.setVnfdVirtualComputeDescId("virtualComputeDescId");
1425 additionalParam.getComputeResourceFlavours().add(flavor);
1426 ExtVirtualLinkData evl = new ExtVirtualLinkData();
1427 evl.setResourceId("networkProviderId1");
1428 evl.setVimId(VIM_ID);
1429 evl.setExtVirtualLinkId("evlId1");
1430 VnfExtCpData ecp2 = new VnfExtCpData();
1431 ecp2.setCpdId("cpdId3");
1432 ecp2.setAddresses(new ArrayList<>());
1433 ecp2.getAddresses().add(networkAddress);
1434 ecp2.setNumDynamicAddresses(2);
1435 evl.getExtCps().add(ecp2);
1436 additionalParam.getExtVirtualLinks().add(evl);
1437 externalVirtualLink.setCpdId("myCpdId");
1438 externalVirtualLink.setResourceId("myNetworkProviderId");
1439 externalVirtualLink.setVlInstanceId("myEVlId");
1440 externalVirtualLink.setResourceSubnetId("notUsedSubnetId");
1441 instantiationRequest.setExtVirtualLink(new ArrayList<>());
1442 instantiationRequest.getExtVirtualLink().add(externalVirtualLink);
1443 additionalParam.getExtManagedVirtualLinks().add(extManVl);
1444 ZoneInfo zone = new ZoneInfo();
1445 zone.setId("zoneId");
1446 zone.setResourceId("zoneProviderId");
1447 zone.setVimId(VIM_ID);
1448 additionalParam.getZones().add(zone);
1449 VimSoftwareImage image = new VimSoftwareImage();
1450 image.setResourceId("imageProviderId");
1451 image.setVimId(VIM_ID);
1452 image.setVnfdSoftwareImageId("imageId");
1453 additionalParam.getSoftwareImages().add(image);
1454 additionalParam.setAdditionalParams(new JsonParser().parse("{ \"a\" : \"b\" }"));
1455 String params = new Gson().toJson(additionalParam);
1456 String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "\" : " + params + "}}, \"vimId\" : \"" + VIM_ID + "\"}";
1457 instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
1458 return instantiationRequest;
1462 * Test vimId decomposition
1465 public void testVimIdSplitting() {
1466 assertEquals("regionId", LifecycleManager.getRegionName("cloudOwner_regionId"));
1467 assertEquals("cloudOwner", LifecycleManager.getCloudOwner("cloudOwner_regionId"));