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 AdditionalParameters additionalParam = new AdditionalParameters();
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.createAndInstantiate(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);
254 //verify(logger).info(eq("Additional parameters for instantiation: {}"), anyString());
259 * invalid VIM type results in failure
262 public void testInstantiationWithInvalidVimType() throws Exception {
264 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
265 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
266 when(logger.isDebugEnabled()).thenReturn(false);
269 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
272 } catch (Exception e) {
273 assertEquals("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types", e.getMessage());
275 verify(vnfApi, never()).vnfsPost(Mockito.any(), Mockito.any());
276 verify(logger, never()).debug(eq("Additional parameters for instantiation: {}"), anyString());
277 verify(logger).error("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types");
281 * test instantiation with KeyStone V2 based with SSL
284 public void testInstantiationV2WithSsl() throws Exception {
285 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
287 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
288 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
289 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
290 grantResponse.setVimId(VIM_ID);
291 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
292 accessInfo.setTenant(TENANT);
293 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
294 vimInfo.setSslInsecure("false");
295 vimInfo.setSslCacert(caCert);
296 grantResponse.setAccessInfo(accessInfo);
297 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
298 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
300 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
301 waitForJobToFinishInJobManager(finished);
302 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
304 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
305 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
306 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
307 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
312 * non specified SSL verification means not verified
315 public void testInstantiationV2WithoutSsl() throws Exception {
316 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
318 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
319 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
320 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
321 grantResponse.setVimId(VIM_ID);
322 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
323 accessInfo.setTenant(TENANT);
324 vimInfo.setSslInsecure(null);
325 grantResponse.setAccessInfo(accessInfo);
326 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
327 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
329 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
330 waitForJobToFinishInJobManager(finished);
331 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
333 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
334 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
335 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
339 * test instantiation with KeyStone V3 based
342 public void testInstantiationV3() throws Exception {
343 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
345 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
346 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
347 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
348 grantResponse.setVimId(VIM_ID);
349 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
350 accessInfo.setTenant(TENANT);
351 grantResponse.setAccessInfo(accessInfo);
352 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
353 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
355 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
356 waitForJobToFinishInJobManager(finished);
357 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
359 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
360 assertEquals(VIM_ID, actualVim.getId());
361 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
362 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
363 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
364 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
365 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
366 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
367 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
368 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
369 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
370 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
371 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
375 * test instantiation with KeyStone V3 based with SSL
378 public void testInstantiationV3WithSsl() throws Exception {
379 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
381 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
382 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
383 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
384 grantResponse.setVimId(VIM_ID);
385 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
386 accessInfo.setTenant(TENANT);
387 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
388 vimInfo.setSslInsecure("false");
389 vimInfo.setSslCacert(caCert);
390 grantResponse.setAccessInfo(accessInfo);
391 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
392 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
394 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
395 waitForJobToFinishInJobManager(finished);
396 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
398 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
399 assertEquals(VIM_ID, actualVim.getId());
400 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
401 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
402 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
403 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
404 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
405 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
406 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
407 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
408 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
409 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
410 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
411 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
415 * non specified SSL verification meams not verified for KeyStone V3 based
418 public void testInstantiationV3WithNonSpecifiedSsl() throws Exception {
419 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
421 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
422 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
423 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
424 grantResponse.setVimId(VIM_ID);
425 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
426 accessInfo.setTenant(TENANT);
427 vimInfo.setSslInsecure(null);
428 grantResponse.setAccessInfo(accessInfo);
429 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
430 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
432 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
433 waitForJobToFinishInJobManager(finished);
434 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
436 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
437 assertEquals(VIM_ID, actualVim.getId());
438 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
439 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
440 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
441 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
442 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
443 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
444 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
445 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
446 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
447 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
451 * test instantiation with vcloud
454 public void testInstantiationVcloud() throws Exception {
455 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
457 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
458 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
459 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
460 grantResponse.setVimId(VIM_ID);
461 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
462 accessInfo.setTenant(TENANT);
463 grantResponse.setAccessInfo(accessInfo);
464 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
465 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
467 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
468 waitForJobToFinishInJobManager(finished);
469 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
471 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
472 assertEquals(VIM_ID, actualVim.getId());
473 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
474 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
475 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
476 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
477 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
478 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
479 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
480 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
481 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
485 * test instantiation with vCloud with SSL
488 public void testInstantiationVcloudWithSsl() throws Exception {
489 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
491 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
492 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
493 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
494 grantResponse.setVimId(VIM_ID);
495 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
496 accessInfo.setTenant(TENANT);
497 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
498 vimInfo.setSslInsecure("false");
499 vimInfo.setSslCacert(caCert);
500 grantResponse.setAccessInfo(accessInfo);
501 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
502 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
504 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
505 waitForJobToFinishInJobManager(finished);
506 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
508 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
509 assertEquals(VIM_ID, actualVim.getId());
510 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
511 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
512 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
513 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
514 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
515 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
516 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
517 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
518 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
519 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
523 * test instantiation with vCloud with SSL
526 public void testInstantiationVcloudWithNonSecifedSSl() throws Exception {
527 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
529 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
530 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
531 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
532 grantResponse.setVimId(VIM_ID);
533 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
534 accessInfo.setTenant(TENANT);
535 vimInfo.setSslInsecure(null);
536 grantResponse.setAccessInfo(accessInfo);
537 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
538 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
540 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
541 waitForJobToFinishInJobManager(finished);
542 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
544 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
545 assertEquals(VIM_ID, actualVim.getId());
546 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
547 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
548 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
549 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
550 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
551 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
552 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
553 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
557 * test failure in the instantiation request marks the job to be finished in job manager
560 public void testFailureInTheInstantiationRequest() throws Exception {
561 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
562 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
563 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
564 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
565 grantResponse.setVimId(VIM_ID);
566 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
567 accessInfo.setTenant(TENANT);
568 grantResponse.setAccessInfo(accessInfo);
569 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
570 ApiException expectedException = new ApiException();
571 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
574 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
576 waitForJobToFinishInJobManager(finished);
577 assertEquals(VNF_ID, response.getVnfInstanceId());
578 assertEquals(JOB_ID, response.getJobId());
579 verify(logger).error("Unable to instantiate VNF with myVnfId identifier", expectedException);
583 * instantiation fails if VF-C does not send vim identifier in grant response
586 public void testVfcFailsToSendVimId() throws Exception {
587 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
589 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
590 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
591 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
592 //grantResponse.setVimId(VIM_ID);
593 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
594 accessInfo.setTenant(TENANT);
595 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
596 vimInfo.setSslInsecure("false");
597 vimInfo.setSslCacert(caCert);
598 grantResponse.setAccessInfo(accessInfo);
599 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
600 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
602 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
603 waitForJobToFinishInJobManager(finished);
604 assertEquals(0, actualInstantiationRequest.getAllValues().size());
606 verify(logger).error("VF-C did not send VIM identifier in grant response");
611 * test operation execution polling is retried in case of failures
614 public void testFailureInTheOperationExecutionPollingDuringInstantiationRequest() throws Exception {
615 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
616 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
617 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
618 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
619 grantResponse.setVimId(VIM_ID);
620 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
621 accessInfo.setTenant(TENANT);
622 grantResponse.setAccessInfo(accessInfo);
623 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
624 ApiException expectedException = new ApiException();
625 List<ApiException> polling = new ArrayList<>();
626 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
627 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).then(new Answer<List<OperationExecution>>() {
629 public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
630 if (polling.size() > 2) {
631 return operationExecutions;
633 ApiException apiException = new ApiException();
634 polling.add(apiException);
639 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
641 waitForJobToFinishInJobManager(finished);
642 assertEquals(VNF_ID, response.getVnfInstanceId());
643 assertEquals(JOB_ID, response.getJobId());
644 assertEquals(3, polling.size());
645 for (ApiException e : polling) {
646 verify(logger).warn("Unable to retrieve operations details", e);
648 verify(systemFunctions, Mockito.times(3)).sleep(5000);
652 * failure in VNF creation is logged an proagated
655 public void failureInVnfCreationIsPropagated() throws Exception {
657 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
659 ApiException expectedException = new ApiException();
660 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
663 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
666 } catch (RuntimeException e) {
667 assertEquals(expectedException, e.getCause());
668 verify(logger).error("Unable to create the VNF", expectedException);
673 * failure in updating the modifyable attributes of the VNF is logged an proagated
676 public void failureInVnfModificationIsPropagated() throws Exception {
678 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
680 ApiException expectedException = new ApiException();
681 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
682 when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
686 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
689 } catch (RuntimeException e) {
690 assertEquals(expectedException, e.getCause().getCause());
691 verify(logger).error("Unable to set the onapCsarId property on the VNF", expectedException);
696 * if the VIM info can not be queried the VNF is not instantiated and
697 * error propagated through job
700 public void testFailureInQueryVimInfo() throws Exception {
701 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
702 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
703 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
704 grantResponse.setVimId(VIM_ID);
705 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
706 accessInfo.setTenant(TENANT);
707 grantResponse.setAccessInfo(accessInfo);
709 when(vimInfoProvider.getVimInfo(VIM_ID)).thenThrow(new RuntimeException());
711 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
713 waitForJobToFinishInJobManager(finished);
714 verify(vnfApi, never()).vnfsVnfInstanceIdInstantiatePost(Mockito.any(), Mockito.any(), Mockito.any());
718 * test termination basic success scenario
719 * - the VNF is not deleted before the notifications are processed
722 public void testTermination() throws Exception {
724 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
725 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
726 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
727 vnfInfo.setOperationExecutions(operationExecutions);
728 VnfProperty vnfdId = new VnfProperty();
729 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
730 vnfdId.setValue(ONAP_CSAR_ID);
731 vnfInfo.getExtensions().add(vnfdId);
732 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
733 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
735 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
736 OperationExecution terminationOperation = new OperationExecution();
737 terminationOperation.setId("terminationId");
738 operationExecutions.add(terminationOperation);
739 terminationOperation.setStatus(OperationStatus.FINISHED);
740 return terminationOperation;
743 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
744 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
746 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
748 waitForJobToFinishInJobManager(finished);
749 assertEquals(1, actualTerminationRequest.getAllValues().size());
750 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
751 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
752 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
753 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
754 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
755 verify(jobManager).spawnJob(VNF_ID, restResponse);
759 * test termination of a non instantiated VNF
760 * - the VNF is not terminated (only deleted)
763 public void testTerminationOfNonInstantiated() throws Exception {
765 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
766 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
767 vnfInfo.setInstantiationState(InstantiationState.NOT_INSTANTIATED);
768 vnfInfo.setOperationExecutions(operationExecutions);
769 VnfProperty vnfdId = new VnfProperty();
770 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
771 vnfdId.setValue(ONAP_CSAR_ID);
772 vnfInfo.getExtensions().add(vnfdId);
773 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
774 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
776 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
778 boolean deleted = false;
782 verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
787 verify(vfcGrantManager, never()).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
788 verify(notificationManager, never()).waitForTerminationToBeProcessed("terminationId");
792 * test that the VNF deletion is not started before the termination finishes
795 public void testTerminationOperationIsOutwaited() throws Exception {
797 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
798 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
799 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
800 vnfInfo.setOperationExecutions(operationExecutions);
801 VnfProperty vnfdId = new VnfProperty();
802 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
803 vnfdId.setValue(ONAP_CSAR_ID);
804 vnfInfo.getExtensions().add(vnfdId);
805 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
806 OperationExecution terminationOperation = new OperationExecution();
807 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
809 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
810 terminationOperation.setId("terminationId");
811 operationExecutions.add(terminationOperation);
812 terminationOperation.setStatus(OperationStatus.STARTED);
813 return terminationOperation;
816 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
817 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
818 Set<Integer> calls = new HashSet<>();
819 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<List<OperationExecution>>() {
821 public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
822 if (calls.size() == 1000) {
823 terminationOperation.setStatus(OperationStatus.FINISHED);
825 calls.add(calls.size());
826 return operationExecutions;
830 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
832 waitForJobToFinishInJobManager(finished);
833 verify(vnfApi, times(1001)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
834 verify(systemFunctions, times(1000)).sleep(5000);
839 * test that failured during waiting for the operation to finish is tolerated (idefineiatelly)
842 public void testTerminationOperationIsOutwaitedWithErrors() throws Exception {
844 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
845 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
846 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
847 vnfInfo.setOperationExecutions(operationExecutions);
848 VnfProperty vnfdId = new VnfProperty();
849 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
850 vnfdId.setValue(ONAP_CSAR_ID);
851 vnfInfo.getExtensions().add(vnfdId);
852 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
853 OperationExecution terminationOperation = new OperationExecution();
854 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
856 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
857 terminationOperation.setId("terminationId");
858 operationExecutions.add(terminationOperation);
859 terminationOperation.setStatus(OperationStatus.STARTED);
860 return terminationOperation;
863 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
864 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
865 Set<Integer> calls = new HashSet<>();
866 List<ApiException> expectedExceptions = new ArrayList<>();
867 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<List<OperationExecution>>() {
869 public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
870 if (calls.size() >= 100) {
871 terminationOperation.setStatus(OperationStatus.FINISHED);
872 return operationExecutions;
874 calls.add(calls.size());
875 ApiException apiException = new ApiException();
876 expectedExceptions.add(apiException);
881 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
883 waitForJobToFinishInJobManager(finished);
884 verify(vnfApi, times(101)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
885 verify(systemFunctions, times(100)).sleep(5000);
886 for (ApiException expectedException : expectedExceptions) {
887 verify(logger).warn("Unable to retrieve operations details", expectedException);
892 * test gracefull termination
895 public void testGracefullTermination() throws Exception {
897 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
898 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
899 terminationRequest.setTerminationType(VnfTerminationType.GRACEFUL);
900 terminationRequest.setGracefulTerminationTimeout("1234");
901 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
902 vnfInfo.setOperationExecutions(operationExecutions);
903 VnfProperty vnfdId = new VnfProperty();
904 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
905 vnfdId.setValue(ONAP_CSAR_ID);
906 vnfInfo.getExtensions().add(vnfdId);
907 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
908 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
910 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
911 OperationExecution terminationOperation = new OperationExecution();
912 terminationOperation.setId("terminationId");
913 operationExecutions.add(terminationOperation);
914 terminationOperation.setStatus(OperationStatus.FINISHED);
915 return terminationOperation;
918 doAnswer(invocation -> {
919 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
921 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
922 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
923 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
925 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
927 waitForJobToFinishInJobManager(finished);
928 assertEquals(1, actualTerminationRequest.getAllValues().size());
929 assertEquals(TerminationType.GRACEFUL, actualTerminationRequest.getValue().getTerminationType());
930 assertEquals(Integer.valueOf(1234), actualTerminationRequest.getValue().getGracefulTerminationTimeout());
931 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
932 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
933 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
934 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
938 * instantiation with missing ONAP csarId to instantiation extra param result in failure
941 public void testMissingVnfParameters() throws Exception {
943 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
944 String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "invalid" + "\" : {}}}, \"vimId\" : \"" + VIM_ID + "\"}";
945 instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
948 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
950 } catch (Exception e) {
951 assertEquals("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id", e.getMessage());
952 verify(logger).error("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id");
957 * test explicit forceful termination
960 public void testExplicitForcefulTermination() throws Exception {
962 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
963 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
964 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
965 terminationRequest.setGracefulTerminationTimeout("1234");
966 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
967 vnfInfo.setOperationExecutions(operationExecutions);
968 VnfProperty vnfdId = new VnfProperty();
969 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
970 vnfdId.setValue(ONAP_CSAR_ID);
971 vnfInfo.getExtensions().add(vnfdId);
972 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
973 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
975 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
976 OperationExecution terminationOperation = new OperationExecution();
977 terminationOperation.setId("terminationId");
978 operationExecutions.add(terminationOperation);
979 terminationOperation.setStatus(OperationStatus.FINISHED);
980 return terminationOperation;
983 doAnswer(invocation -> {
984 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
986 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
987 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
988 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
990 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
992 waitForJobToFinishInJobManager(finished);
993 assertEquals(1, actualTerminationRequest.getAllValues().size());
994 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
995 assertNull(actualTerminationRequest.getValue().getGracefulTerminationTimeout());
996 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
997 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
998 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
999 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1003 * test failure in the termination workflow finishes the job
1006 public void testFailureInTheTerminationFinishesTheManagedJob() throws Exception {
1008 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1009 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1010 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1011 terminationRequest.setGracefulTerminationTimeout("1234");
1012 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1013 vnfInfo.setOperationExecutions(operationExecutions);
1014 VnfProperty vnfdId = new VnfProperty();
1015 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1016 vnfdId.setValue(ONAP_CSAR_ID);
1017 vnfInfo.getExtensions().add(vnfdId);
1018 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1019 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
1021 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
1022 OperationExecution terminationOperation = new OperationExecution();
1023 terminationOperation.setId("terminationId");
1024 operationExecutions.add(terminationOperation);
1025 terminationOperation.setStatus(OperationStatus.FINISHED);
1026 return terminationOperation;
1029 ApiException expectedException = new ApiException();
1030 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1031 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1032 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
1034 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1036 waitForJobToFinishInJobManager(finished);
1037 assertEquals(0, actualTerminationRequest.getAllValues().size());
1038 Mockito.verifyZeroInteractions(vfcGrantManager);
1042 * if termination fails the VNF is not deleted
1045 public void testFailedTerminationAbortsTerminationWorkflow() throws Exception {
1047 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1048 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1049 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1050 vnfInfo.setOperationExecutions(operationExecutions);
1051 VnfProperty vnfdId = new VnfProperty();
1052 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1053 vnfdId.setValue(ONAP_CSAR_ID);
1054 vnfInfo.getExtensions().add(vnfdId);
1055 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1056 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
1058 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
1059 OperationExecution terminationOperation = new OperationExecution();
1060 terminationOperation.setId("terminationId");
1061 operationExecutions.add(terminationOperation);
1062 terminationOperation.setStatus(OperationStatus.FAILED);
1063 return terminationOperation;
1066 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1067 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
1069 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1071 waitForJobToFinishInJobManager(finished);
1072 assertEquals(1, actualTerminationRequest.getAllValues().size());
1073 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1074 verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1075 verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1076 verify(logger).error("Unable to terminate VNF the operation did not finish with success");
1080 * test VNF query basic success scenario
1083 public void testQuery() throws Exception {
1084 vnfInfo.setDescription("myDescription");
1085 vnfInfo.setName("myName");
1086 vnfInfo.setVnfSoftwareVersion("vnfSoftwareVersion");
1087 vnfInfo.setVnfProvider("myProvider");
1088 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1089 VnfProperty prop = new VnfProperty();
1090 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1091 prop.setValue(ONAP_CSAR_ID);
1092 vnfInfo.getExtensions().add(prop);
1094 org.onap.vnfmdriver.model.VnfInfo vnf = lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1096 assertEquals(VNF_ID, vnf.getVnfInstanceId());
1097 //FIXME ? (do not know what exactly the vnf version mean in core terminology)
1098 assertEquals("vnfSoftwareVersion", vnf.getVersion());
1099 assertEquals(ONAP_CSAR_ID, vnf.getVnfdId());
1100 assertEquals("myDescription", vnf.getVnfInstanceDescription());
1101 assertEquals("myName", vnf.getVnfInstanceName());
1102 assertEquals(ONAP_CSAR_ID, vnf.getVnfPackageId());
1103 assertEquals("myProvider", vnf.getVnfProvider());
1104 //FIXME (in swagger schema )
1105 assertEquals("ACTIVE", vnf.getVnfStatus());
1106 assertEquals("Kuku", vnf.getVnfType());
1110 * error is propagated and logged if the queried VNF does not exist
1113 public void testQueryForNonExistingVnf() throws Exception {
1115 ApiException expectedException = new ApiException();
1116 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1119 lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1122 } catch (Exception e) {
1123 verify(logger).error("Unable to query VNF (myVnfId)", expectedException);
1124 assertEquals(expectedException, e.getCause());
1129 * test scale basic scenario
1132 public void testScale() throws Exception {
1133 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1134 scaleRequest.setNumberOfSteps("2");
1135 scaleRequest.setAspectId("myAspect");
1136 scaleRequest.setType(ScaleDirection.IN);
1137 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }"));
1138 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1139 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1140 VnfProperty prop = new VnfProperty();
1141 prop.setValue(ONAP_CSAR_ID);
1142 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1143 vnfInfo.getExtensions().add(prop);
1144 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1145 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1146 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
1148 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1150 waitForJobToFinishInJobManager(finished);
1151 assertEquals(1, actualScaleRequest.getAllValues().size());
1152 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1153 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1154 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1155 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1156 assertEquals("myAspect", sRequest.getAspectId());
1157 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1158 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1159 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1160 verify(jobManager).spawnJob(VNF_ID, restResponse);
1164 * the VNFM should tolerate that no additional params were supplied
1167 public void testScaleWithoutAddtionalParams() throws Exception {
1168 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1169 scaleRequest.setNumberOfSteps("2");
1170 scaleRequest.setAspectId("myAspect");
1171 scaleRequest.setType(ScaleDirection.IN);
1172 scaleRequest.setAdditionalParam(null);
1173 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1174 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1175 VnfProperty prop = new VnfProperty();
1176 prop.setValue(ONAP_CSAR_ID);
1177 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1178 vnfInfo.getExtensions().add(prop);
1179 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1180 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1181 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
1183 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1185 waitForJobToFinishInJobManager(finished);
1186 assertEquals(1, actualScaleRequest.getAllValues().size());
1187 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1188 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1189 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1190 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1191 assertEquals("myAspect", sRequest.getAspectId());
1192 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1193 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1194 assertEquals("{\"jobId\":\"myJobId\"}", new Gson().toJson(sRequest.getAdditionalParams()));
1195 verify(jobManager).spawnJob(VNF_ID, restResponse);
1199 * test scale out basic scenario
1202 public void testScaleOut() throws Exception {
1203 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1204 scaleRequest.setNumberOfSteps("2");
1205 scaleRequest.setAspectId("myAspect");
1206 scaleRequest.setType(ScaleDirection.OUT);
1207 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1208 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1209 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1210 VnfProperty prop = new VnfProperty();
1211 prop.setValue(ONAP_CSAR_ID);
1212 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1213 vnfInfo.getExtensions().add(prop);
1214 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1215 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1216 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
1218 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1220 waitForJobToFinishInJobManager(finished);
1221 assertEquals(1, actualScaleRequest.getAllValues().size());
1222 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1223 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1224 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1225 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1226 assertEquals("myAspect", sRequest.getAspectId());
1227 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.OUT, sRequest.getType());
1228 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1229 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1233 * test scale operation is out waited
1236 public void testScaleOutwait() throws Exception {
1237 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1238 scaleRequest.setNumberOfSteps("2");
1239 scaleRequest.setAspectId("myAspect");
1240 scaleRequest.setType(ScaleDirection.IN);
1241 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1242 scaleOperationExecution.setStatus(OperationStatus.STARTED);
1243 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1244 VnfProperty prop = new VnfProperty();
1245 prop.setValue(ONAP_CSAR_ID);
1246 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1247 vnfInfo.getExtensions().add(prop);
1248 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1249 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1250 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
1251 List<ApiException> expectedExceptions = new ArrayList<>();
1252 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<List<OperationExecution>>) invocation -> {
1253 if (expectedExceptions.size() >= 100) {
1254 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1255 return operationExecutions;
1257 ApiException apiException = new ApiException();
1258 expectedExceptions.add(apiException);
1259 // when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(scaleOperationExecution);
1264 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1266 waitForJobToFinishInJobManager(finished);
1267 assertEquals(100, expectedExceptions.size());
1268 for (ApiException expectedException : expectedExceptions) {
1269 verify(logger).warn("Unable to retrieve operations details", expectedException);
1271 verify(systemFunctions, times(100)).sleep(5000);
1275 * test scale failure propagation
1278 public void testScaleFailurePropagation() throws Exception {
1279 ApiException expectedException = new ApiException();
1280 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1281 scaleRequest.setNumberOfSteps("2");
1282 scaleRequest.setAspectId("myAspect");
1283 scaleRequest.setType(ScaleDirection.IN);
1284 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1286 lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1288 waitForJobToFinishInJobManager(finished);
1289 verify(logger).error("Unable to scale VNF with myVnfId identifier", expectedException);
1293 * test heal basic scenario
1296 public void testHeal() throws Exception {
1297 VnfHealRequest healRequest = new VnfHealRequest();
1298 healRequest.setAction("myAction");
1299 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1300 affectedVm.setVmname("vmName");
1301 healRequest.setAffectedvm(affectedVm);
1302 healOperationExecution.setStatus(OperationStatus.FINISHED);
1303 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1304 VnfProperty prop = new VnfProperty();
1305 prop.setValue(ONAP_CSAR_ID);
1306 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1307 vnfInfo.getExtensions().add(prop);
1308 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1309 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1310 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
1312 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, restResponse);
1314 waitForJobToFinishInJobManager(finished);
1315 assertEquals(1, actualHealRequest.getAllValues().size());
1316 HealVnfRequest sRequest = actualHealRequest.getValue();
1317 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1318 workflowOrder.verify(vfcGrantManager).requestGrantForHeal(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(healRequest), eq(JOB_ID));
1319 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdHealPost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1320 JsonObject root = new Gson().toJsonTree(sRequest.getAdditionalParams()).getAsJsonObject();
1321 assertEquals("myAction", root.get("action").getAsString());
1322 assertEquals("vmName", root.get("vmName").getAsString());
1323 assertEquals(JOB_ID, root.get("jobId").getAsString());
1324 verify(jobManager).spawnJob(VNF_ID, restResponse);
1328 * test heal operation is out waited
1331 public void testHealOutwait() throws Exception {
1332 VnfHealRequest healRequest = new VnfHealRequest();
1333 healRequest.setAction("myAction");
1334 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1335 affectedVm.setVmname("vmName");
1336 healRequest.setAffectedvm(affectedVm);
1337 healOperationExecution.setStatus(OperationStatus.FINISHED);
1338 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
1339 VnfProperty prop = new VnfProperty();
1340 prop.setValue(ONAP_CSAR_ID);
1341 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1342 vnfInfo.getExtensions().add(prop);
1343 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1344 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1345 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
1346 List<ApiException> expectedExceptions = new ArrayList<>();
1347 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<List<OperationExecution>>() {
1349 public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1350 if (expectedExceptions.size() >= 100) {
1351 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1352 return operationExecutions;
1354 ApiException apiException = new ApiException();
1355 expectedExceptions.add(apiException);
1360 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, restResponse);
1362 waitForJobToFinishInJobManager(finished);
1363 assertEquals(100, expectedExceptions.size());
1364 for (ApiException expectedException : expectedExceptions) {
1365 verify(logger).warn("Unable to retrieve operations details", expectedException);
1367 verify(systemFunctions, times(100)).sleep(5000);
1371 * failure in heal propagates in error
1374 public void testHealFailurePropagation() throws Exception {
1375 ApiException expectedException = new ApiException();
1376 VnfHealRequest healRequest = new VnfHealRequest();
1377 healRequest.setAction("myAction");
1378 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1379 affectedVm.setVmname("vmName");
1380 healRequest.setAffectedvm(affectedVm);
1381 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1383 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, restResponse);
1385 waitForJobToFinishInJobManager(finished);
1386 verify(logger).error("Unable to heal VNF with myVnfId identifier", expectedException);
1389 private void waitForJobToFinishInJobManager(Set<Boolean> finished) throws InterruptedException {
1390 while (finished.size() == 0) {
1391 systemFunctions().sleep(100);
1395 private VnfInstantiateRequest prepareInstantiationRequest(VimInfo.VimInfoTypeEnum cloudType) {
1396 VnfInstantiateRequest instantiationRequest = new VnfInstantiateRequest();
1397 instantiationRequest.setVnfPackageId(ONAP_CSAR_ID);
1398 instantiationRequest.setVnfDescriptorId(ONAP_CSAR_ID);
1399 instantiationRequest.setVnfInstanceDescription("myDescription");
1400 instantiationRequest.setVnfInstanceName("vnfName");
1401 additionalParam.setInstantiationLevel("level1");
1402 switch (cloudType) {
1403 case OPENSTACK_V2_INFO:
1404 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1406 case OPENSTACK_V3_INFO:
1407 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
1408 additionalParam.setDomain("myDomain");
1410 case VMWARE_VCLOUD_INFO:
1411 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
1414 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
1417 Map<String, List<NetworkAddress>> exteranalConnectionPointAddresses = new HashMap<>();
1418 exteranalConnectionPointAddresses.put("ecp1", new ArrayList<>());
1419 NetworkAddress networkAddress = new NetworkAddress();
1420 networkAddress.setIp("1.2.3.4");
1421 networkAddress.setMac("mac");
1422 networkAddress.setSubnetId("subnetId");
1423 exteranalConnectionPointAddresses.get("ecp1").add(networkAddress);
1424 additionalParam.setExternalConnectionPointAddresses(exteranalConnectionPointAddresses);
1425 VimComputeResourceFlavour flavor = new VimComputeResourceFlavour();
1426 flavor.setResourceId("flavourProviderId");
1427 flavor.setVimId(VIM_ID);
1428 flavor.setVnfdVirtualComputeDescId("virtualComputeDescId");
1429 additionalParam.getComputeResourceFlavours().add(flavor);
1430 ExtVirtualLinkData evl = new ExtVirtualLinkData();
1431 evl.setResourceId("networkProviderId1");
1432 evl.setVimId(VIM_ID);
1433 evl.setExtVirtualLinkId("evlId1");
1434 VnfExtCpData ecp2 = new VnfExtCpData();
1435 ecp2.setCpdId("cpdId3");
1436 ecp2.setAddresses(new ArrayList<>());
1437 ecp2.getAddresses().add(networkAddress);
1438 ecp2.setNumDynamicAddresses(2);
1439 evl.getExtCps().add(ecp2);
1440 additionalParam.getExtVirtualLinks().add(evl);
1441 externalVirtualLink.setCpdId("myCpdId");
1442 externalVirtualLink.setResourceId("myNetworkProviderId");
1443 externalVirtualLink.setVlInstanceId("myEVlId");
1444 externalVirtualLink.setResourceSubnetId("notUsedSubnetId");
1445 instantiationRequest.setExtVirtualLink(new ArrayList<>());
1446 instantiationRequest.getExtVirtualLink().add(externalVirtualLink);
1447 additionalParam.getExtManagedVirtualLinks().add(extManVl);
1448 ZoneInfo zone = new ZoneInfo();
1449 zone.setId("zoneId");
1450 zone.setResourceId("zoneProviderId");
1451 zone.setVimId(VIM_ID);
1452 additionalParam.getZones().add(zone);
1453 VimSoftwareImage image = new VimSoftwareImage();
1454 image.setResourceId("imageProviderId");
1455 image.setVimId(VIM_ID);
1456 image.setVnfdSoftwareImageId("imageId");
1457 additionalParam.getSoftwareImages().add(image);
1458 additionalParam.setAdditionalParams(new JsonParser().parse("{ \"a\" : \"b\" }"));
1459 String params = new Gson().toJson(additionalParam);
1460 String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "\" : " + params + "}}, \"vimId\" : \"" + VIM_ID + "\"}";
1461 instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
1462 return instantiationRequest;
1466 * Test vimId decomposition
1469 public void testVimIdSplitting() {
1470 assertEquals("regionId", LifecycleManager.getRegionName("cloudOwner_regionId"));
1471 assertEquals("cloudOwner", LifecycleManager.getCloudOwner("cloudOwner_regionId"));