2 * Copyright 2016-2017, Nokia Corporation
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
16 package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
18 import com.google.gson.Gson;
19 import com.google.gson.JsonElement;
20 import com.google.gson.JsonObject;
21 import com.google.gson.JsonParser;
22 import com.nokia.cbam.catalog.v1.model.CatalogAdapterVnfpackage;
23 import com.nokia.cbam.lcm.v32.model.*;
24 import com.nokia.cbam.lcm.v32.model.OperationType;
25 import com.nokia.cbam.lcm.v32.model.VimInfo;
26 import com.nokia.cbam.lcm.v32.model.VnfInfo;
27 import io.reactivex.Observable;
28 import java.nio.file.Paths;
30 import javax.servlet.http.HttpServletResponse;
31 import org.junit.Before;
32 import org.junit.Test;
33 import org.mockito.ArgumentCaptor;
34 import org.mockito.InOrder;
35 import org.mockito.Mock;
36 import org.mockito.Mockito;
37 import org.mockito.invocation.InvocationOnMock;
38 import org.mockito.stubbing.Answer;
39 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VimInfoProvider;
40 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.TestVfcGrantManager;
41 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.VfcGrantManager;
42 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.StoreLoader;
43 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.LifecycleChangeNotificationManager;
44 import org.onap.vnfmdriver.model.ExtVirtualLinkInfo;
45 import org.onap.vnfmdriver.model.*;
46 import org.onap.vnfmdriver.model.ScaleDirection;
47 import org.threeten.bp.OffsetDateTime;
49 import static java.lang.Boolean.parseBoolean;
50 import static java.nio.file.Files.readAllBytes;
51 import static java.util.Optional.empty;
53 import static junit.framework.TestCase.*;
54 import static org.mockito.Mockito.*;
55 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.child;
56 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions.systemFunctions;
57 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
58 import static org.springframework.test.util.ReflectionTestUtils.setField;
60 public class TestLifecycleManager extends TestBase {
61 public static final String JOB_ID = "myJobId";
62 public static final String CBAM_VNFD_ID = "cbamVnfdId";
63 public static final String TENANT = "myTenant";
64 public static final String OPERATION_EXECUTION_ID = "operationExecutionId";
65 private static final String ONAP_CSAR_ID = "myOnapCsarId";
66 private static final String VIM_ID = "ownerId_regionId";
68 private CatalogManager catalogManager;
70 private VfcGrantManager vfcGrantManager;
72 private JobManager jobManager;
74 private LifecycleChangeNotificationManager notificationManager;
76 private HttpServletResponse restResponse;
78 private VimInfoProvider vimInfoProvider;
80 private ArgumentCaptor<CreateVnfRequest> createRequest = ArgumentCaptor.forClass(CreateVnfRequest.class);
81 private AdditionalParameters additionalParam = new AdditionalParameters();
82 private String INSTANTIATION_LEVEL = "level1";
83 private GrantVNFResponseVim grantResponse = new GrantVNFResponseVim();
84 private String cbamVnfdContent;
85 private OperationExecution instantiationOperationExecution = new OperationExecution();
86 private OperationExecution modifyPropertyoperationExecution = new OperationExecution();
87 private OperationExecution scaleOperationExecution = new OperationExecution();
88 private OperationExecution healOperationExecution = new OperationExecution();
89 private OperationExecution customOperationExecution = new OperationExecution();
92 private VnfInfo vnfInfo = new VnfInfo();
93 private List<OperationExecution> operationExecutions = new ArrayList<>();
94 private org.onap.vnfmdriver.model.VimInfo vimInfo = new org.onap.vnfmdriver.model.VimInfo();
95 private ExtVirtualLinkInfo externalVirtualLink = new ExtVirtualLinkInfo();
96 private ExtManagedVirtualLinkData extManVl = new ExtManagedVirtualLinkData();
97 private ArgumentCaptor<ModifyVnfInfoRequest> actualVnfModifyRequest = ArgumentCaptor.forClass(ModifyVnfInfoRequest.class);
98 private Set<Boolean> finished = new HashSet<>();
99 private ArgumentCaptor<ScaleVnfRequest> actualScaleRequest = ArgumentCaptor.forClass(ScaleVnfRequest.class);
100 private ArgumentCaptor<HealVnfRequest> actualHealRequest = ArgumentCaptor.forClass(HealVnfRequest.class);
101 private ArgumentCaptor<CustomOperationRequest> customOperationRequestArgumentCaptor = ArgumentCaptor.forClass(CustomOperationRequest.class);
102 private ArgumentCaptor<String> operationIdCaptor = ArgumentCaptor.forClass(String.class);
104 private LifecycleManager lifecycleManager;
107 public void initMocks() throws Exception {
108 vnfInfo.setExtensions(new ArrayList<>());
109 vnfInfo.setOperationExecutions(new ArrayList<>());
110 lifecycleManager = new LifecycleManager(catalogManager, vfcGrantManager, cbamRestApiProvider, vimInfoProvider, jobManager, notificationManager);
111 cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.full.yaml").toURI())));
112 setField(LifecycleManager.class, "logger", logger);
113 CatalogAdapterVnfpackage cbamPackage = new CatalogAdapterVnfpackage();
114 when(catalogManager.preparePackageInCbam(VNFM_ID, ONAP_CSAR_ID)).thenReturn(cbamPackage);
115 cbamPackage.setVnfdId(CBAM_VNFD_ID);
116 vnfInfo.setVnfdId(CBAM_VNFD_ID);
117 vnfInfo.setId(VNF_ID);
118 when(jobManager.spawnJob(VNF_ID, restResponse)).thenReturn(JOB_ID);
119 when(catalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent);
120 cbamPackage.setId(CBAM_VNFD_ID);
121 vimInfo.setUrl("cloudUrl");
122 vimInfo.setPassword("vimPassword");
123 vimInfo.setUserName("vimUsername");
124 vimInfo.setSslInsecure("true");
125 vimInfo.setVimId(VIM_ID);
126 vimInfo.setName("vimName");
127 when(vimInfoProvider.getVimInfo((VIM_ID))).thenReturn(vimInfo);
128 instantiationOperationExecution.setId(OPERATION_EXECUTION_ID);
129 instantiationOperationExecution.setOperationType(OperationType.INSTANTIATE);
130 instantiationOperationExecution.setStartTime(OffsetDateTime.now());
131 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecutions));
132 operationExecutions.add(modifyPropertyoperationExecution);
133 modifyPropertyoperationExecution.setStartTime(OffsetDateTime.now());
134 modifyPropertyoperationExecution.setOperationType(OperationType.MODIFY_INFO);
135 operationExecutions.add(instantiationOperationExecution);
136 instantiationOperationExecution.setStatus(OperationStatus.FINISHED);
137 modifyPropertyoperationExecution.setStatus(OperationStatus.FINISHED);
138 customOperationExecution.setStatus(OperationStatus.FINISHED);
139 modifyPropertyoperationExecution.setId(UUID.randomUUID().toString());
140 scaleOperationExecution.setId(UUID.randomUUID().toString());
141 healOperationExecution.setId(UUID.randomUUID().toString());
142 customOperationExecution.setId(UUID.randomUUID().toString());
144 when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(modifyPropertyoperationExecution));
145 doAnswer(new Answer() {
147 public Object answer(InvocationOnMock invocation) throws Throwable {
148 finished.add(Boolean.TRUE);
151 }).when(jobManager).jobFinished(JOB_ID);
152 when(vnfApi.vnfsVnfInstanceIdScalePost(eq(VNF_ID), actualScaleRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
154 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
155 operationExecutions.add(scaleOperationExecution);
156 return buildObservable(scaleOperationExecution);
159 when(vnfApi.vnfsVnfInstanceIdHealPost(eq(VNF_ID), actualHealRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
161 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
162 operationExecutions.add(healOperationExecution);
163 return buildObservable(healOperationExecution);
166 when(vnfApi.vnfsVnfInstanceIdCustomCustomOperationNamePost(eq(VNF_ID), operationIdCaptor.capture(), customOperationRequestArgumentCaptor.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
168 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
169 operationExecutions.add(customOperationExecution);
170 return buildObservable(customOperationExecution);
179 public void testInstantiation() throws Exception {
181 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
183 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
184 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
185 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
186 grantResponse.setVimId(VIM_ID);
187 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
188 accessInfo.setTenant(TENANT);
189 grantResponse.setAccessInfo(accessInfo);
190 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
191 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
193 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
194 waitForJobToFinishInJobManager(finished);
196 assertEquals(VNF_ID, response.getVnfInstanceId());
197 assertEquals(JOB_ID, response.getJobId());
198 assertEquals(createRequest.getAllValues().size(), 1);
199 assertEquals("myDescription", createRequest.getValue().getDescription());
200 assertEquals("vnfName", createRequest.getValue().getName());
201 assertEquals(CBAM_VNFD_ID, createRequest.getValue().getVnfdId());
202 assertEquals(1, actualInstantiationRequest.getAllValues().size());
203 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
204 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
205 assertEquals(VIM_ID, actualVim.getId());
206 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, actualVim.getVimInfoType());
207 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
208 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
209 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
210 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
211 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
212 assertEquals("myTenant", actualVim.getAccessInfo().getTenant());
213 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
214 assertEquals(1, actualInstantiationRequest.getValue().getComputeResourceFlavours().size());
215 assertEquals("flavourProviderId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getResourceId());
216 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVimId());
217 assertEquals("virtualComputeDescId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVnfdVirtualComputeDescId());
218 assertEquals(1, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().size());
219 assertEquals(extManVl, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().get(0));
220 assertEquals(2, actualInstantiationRequest.getValue().getExtVirtualLinks().size());
222 assertEquals("myNetworkProviderId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getResourceId());
223 assertEquals("myEVlId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtVirtualLinkId());
224 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().size());
225 assertEquals("myCpdId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().get(0).getCpdId());
227 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getVimId());
228 assertEquals("evlId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtVirtualLinkId());
229 assertEquals("networkProviderId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getResourceId());
230 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().size());
233 assertEquals(Integer.valueOf(2), actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getNumDynamicAddresses());
234 assertEquals("cpdId3", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getCpdId());
235 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().size());
236 assertEquals("1.2.3.4", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getIp());
237 assertEquals("mac", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getMac());
238 assertEquals("subnetId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getSubnetId());
240 assertEquals("myFlavorId", actualInstantiationRequest.getValue().getFlavourId());
241 assertEquals(Boolean.TRUE, actualInstantiationRequest.getValue().isGrantlessMode());
242 assertEquals("level1", actualInstantiationRequest.getValue().getInstantiationLevelId());
243 assertEquals(1, actualInstantiationRequest.getValue().getZones().size());
244 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getZones().get(0).getVimId());
245 assertEquals("zoneProviderId", actualInstantiationRequest.getValue().getZones().get(0).getResourceId());
246 assertEquals("zoneId", actualInstantiationRequest.getValue().getZones().get(0).getId());
247 assertEquals(1, actualInstantiationRequest.getValue().getSoftwareImages().size());
248 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVimId());
249 assertEquals("imageProviderId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getResourceId());
250 assertEquals("imageId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVnfdSoftwareImageId());
251 String actualEmbeddedAdditionParams = new Gson().toJson(actualInstantiationRequest.getValue().getAdditionalParams());
252 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(actualEmbeddedAdditionParams) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(actualEmbeddedAdditionParams));
253 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
254 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
256 assertEquals(1, actualVnfModifyRequest.getAllValues().size());
257 assertEquals(2, actualVnfModifyRequest.getValue().getExtensions().size());
258 assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getName());
259 assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getValue());
260 assertEquals(LifecycleManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName());
261 assertEquals(VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getValue());
263 //the 3.2 API does not accept empty array
264 assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties());
265 verify(jobManager).spawnJob(VNF_ID, restResponse);
266 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
267 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
271 * invalid VIM type results in failure
274 public void testInstantiationWithInvalidVimType() throws Exception {
276 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
277 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
278 when(logger.isInfoEnabled()).thenReturn(false);
281 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
284 } catch (Exception e) {
285 assertEquals("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types", e.getMessage());
287 verify(vnfApi, never()).vnfsPost(Mockito.any(), Mockito.any());
288 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
289 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
290 verify(logger).error("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types");
294 * test instantiation with KeyStone V2 based with SSL
297 public void testInstantiationV2WithSsl() throws Exception {
298 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
299 when(logger.isInfoEnabled()).thenReturn(false);
300 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
301 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
302 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
303 grantResponse.setVimId(VIM_ID);
304 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
305 accessInfo.setTenant(TENANT);
306 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
307 vimInfo.setSslInsecure("false");
308 vimInfo.setSslCacert(caCert);
309 grantResponse.setAccessInfo(accessInfo);
310 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
311 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
312 JsonObject inputs = child((JsonObject) instantiationRequest.getAdditionalParam(), "inputs");
313 JsonObject vnfs = child(child(inputs, "vnfs"), ONAP_CSAR_ID);
314 vnfs.remove("additionalParams");
316 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
317 waitForJobToFinishInJobManager(finished);
318 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
320 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
321 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
322 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
323 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
324 verify(logger).warn("No additional parameters were specified for the operation");
325 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), anyString(), anyString(), anyString());
329 * non specified SSL verification means not verified
332 public void testInstantiationV2WithoutSsl() throws Exception {
333 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
335 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
336 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
337 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
338 grantResponse.setVimId(VIM_ID);
339 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
340 accessInfo.setTenant(TENANT);
341 vimInfo.setSslInsecure(null);
342 grantResponse.setAccessInfo(accessInfo);
343 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
344 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
346 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
347 waitForJobToFinishInJobManager(finished);
348 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
350 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
351 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
352 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
356 * test instantiation with KeyStone V3 based
359 public void testInstantiationV3() throws Exception {
360 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
361 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
362 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
363 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
364 grantResponse.setVimId(VIM_ID);
365 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
366 accessInfo.setTenant(TENANT);
367 grantResponse.setAccessInfo(accessInfo);
368 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
369 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
371 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
372 waitForJobToFinishInJobManager(finished);
373 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
375 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
376 assertEquals(VIM_ID, actualVim.getId());
377 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
378 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
379 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
380 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
381 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
382 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
383 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
384 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
385 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
386 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
387 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
391 * test instantiation with backward compatibility test with Amsterdam release
392 * - the vim identifier is supplied as vimid with not camel case
393 * - the access info is supplied as accessinfo with not camel case
396 public void testInstantiationNoVimId() throws Exception {
398 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
399 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
400 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
401 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
402 grantResponse.setVimid(VIM_ID);
403 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
404 accessInfo.setTenant(TENANT);
405 grantResponse.setAccessinfo(accessInfo);
406 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
407 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
409 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
410 waitForJobToFinishInJobManager(finished);
412 assertEquals(VNF_ID, response.getVnfInstanceId());
413 assertEquals(JOB_ID, response.getJobId());
414 assertEquals(createRequest.getAllValues().size(), 1);
415 assertEquals("myDescription", createRequest.getValue().getDescription());
416 assertEquals("vnfName", createRequest.getValue().getName());
417 assertEquals(CBAM_VNFD_ID, createRequest.getValue().getVnfdId());
418 assertEquals(1, actualInstantiationRequest.getAllValues().size());
419 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
420 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
421 assertEquals(VIM_ID, actualVim.getId());
422 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, actualVim.getVimInfoType());
423 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
424 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
425 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
426 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
427 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
428 assertEquals("myTenant", actualVim.getAccessInfo().getTenant());
429 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
430 assertEquals(1, actualInstantiationRequest.getValue().getComputeResourceFlavours().size());
431 assertEquals("flavourProviderId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getResourceId());
432 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVimId());
433 assertEquals("virtualComputeDescId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVnfdVirtualComputeDescId());
434 assertEquals(1, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().size());
435 assertEquals(extManVl, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().get(0));
436 assertEquals(2, actualInstantiationRequest.getValue().getExtVirtualLinks().size());
438 assertEquals("myNetworkProviderId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getResourceId());
439 assertEquals("myEVlId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtVirtualLinkId());
440 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().size());
441 assertEquals("myCpdId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().get(0).getCpdId());
443 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getVimId());
444 assertEquals("evlId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtVirtualLinkId());
445 assertEquals("networkProviderId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getResourceId());
446 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().size());
449 assertEquals(Integer.valueOf(2), actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getNumDynamicAddresses());
450 assertEquals("cpdId3", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getCpdId());
451 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().size());
452 assertEquals("1.2.3.4", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getIp());
453 assertEquals("mac", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getMac());
454 assertEquals("subnetId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getSubnetId());
456 assertEquals("myFlavorId", actualInstantiationRequest.getValue().getFlavourId());
457 assertEquals(Boolean.TRUE, actualInstantiationRequest.getValue().isGrantlessMode());
458 assertEquals("level1", actualInstantiationRequest.getValue().getInstantiationLevelId());
459 assertEquals(1, actualInstantiationRequest.getValue().getZones().size());
460 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getZones().get(0).getVimId());
461 assertEquals("zoneProviderId", actualInstantiationRequest.getValue().getZones().get(0).getResourceId());
462 assertEquals("zoneId", actualInstantiationRequest.getValue().getZones().get(0).getId());
463 assertEquals(1, actualInstantiationRequest.getValue().getSoftwareImages().size());
464 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVimId());
465 assertEquals("imageProviderId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getResourceId());
466 assertEquals("imageId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVnfdSoftwareImageId());
467 String actualEmbeddedAdditionParams = new Gson().toJson(actualInstantiationRequest.getValue().getAdditionalParams());
468 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(actualEmbeddedAdditionParams) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(actualEmbeddedAdditionParams));
469 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
470 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
472 assertEquals(1, actualVnfModifyRequest.getAllValues().size());
473 assertEquals(2, actualVnfModifyRequest.getValue().getExtensions().size());
474 assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getName());
475 assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getValue());
476 assertEquals(LifecycleManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName());
477 assertEquals(VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getValue());
479 //the 3.2 API does not accept empty array
480 assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties());
481 verify(jobManager).spawnJob(VNF_ID, restResponse);
482 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
483 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
487 * test instantiation with KeyStone V3 based with SSL
490 public void testInstantiationV3WithSsl() throws Exception {
491 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
492 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
493 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
494 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
495 grantResponse.setVimId(VIM_ID);
496 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
497 accessInfo.setTenant(TENANT);
498 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
499 vimInfo.setSslInsecure("false");
500 vimInfo.setSslCacert(caCert);
501 grantResponse.setAccessInfo(accessInfo);
502 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
503 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
505 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
506 waitForJobToFinishInJobManager(finished);
507 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
509 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
510 assertEquals(VIM_ID, actualVim.getId());
511 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
512 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
513 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
514 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
515 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
516 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
517 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
518 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
519 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
520 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
521 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
522 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
526 * non specified SSL verification meams not verified for KeyStone V3 based
529 public void testInstantiationV3WithNonSpecifiedSsl() throws Exception {
530 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
531 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
532 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
533 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
534 grantResponse.setVimId(VIM_ID);
535 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
536 accessInfo.setTenant(TENANT);
537 vimInfo.setSslInsecure(null);
538 grantResponse.setAccessInfo(accessInfo);
539 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
540 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
542 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
543 waitForJobToFinishInJobManager(finished);
544 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
546 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
547 assertEquals(VIM_ID, actualVim.getId());
548 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
549 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
550 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
551 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
552 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
553 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
554 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
555 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
556 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
557 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
561 * verify backward compatibility with Amsterdam release
564 public void testInstantiationV3WithNoDomain() throws Exception {
565 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
566 additionalParam.setDomain("myDomain");
567 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
568 vimInfo.setDomain(null);
569 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
570 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
571 grantResponse.setVimId(VIM_ID);
572 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
573 accessInfo.setTenant(TENANT);
574 vimInfo.setSslInsecure(null);
575 grantResponse.setAccessInfo(accessInfo);
576 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
577 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
579 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
580 waitForJobToFinishInJobManager(finished);
581 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
583 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
584 assertEquals(VIM_ID, actualVim.getId());
585 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
586 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
587 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
588 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
589 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
590 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
591 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
592 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
593 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
594 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
595 verify(logger).warn("Setting domain from additional parameters");
599 * verify backward compatibility with Amsterdam release
600 * if no domain is specified error is propagated
603 public void testInstantiationV3WithNoDomainFail() throws Exception {
604 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
605 vimInfo.setDomain(null);
606 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
607 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
608 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
609 grantResponse.setVimId(VIM_ID);
610 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
611 accessInfo.setTenant(TENANT);
612 vimInfo.setSslInsecure(null);
613 grantResponse.setAccessInfo(accessInfo);
614 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
615 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
617 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
618 waitForJobToFinishInJobManager(finished);
619 assertEquals(0, actualInstantiationRequest.getAllValues().size());
621 verify(logger).error("The cloud did not supply the cloud domain (Amsterdam release) and was not supplied as additional data");
625 * test instantiation with vcloud
628 public void testInstantiationVcloud() throws Exception {
629 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
631 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
632 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
633 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
634 grantResponse.setVimId(VIM_ID);
635 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
636 accessInfo.setTenant(TENANT);
637 grantResponse.setAccessInfo(accessInfo);
638 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
639 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
641 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
642 waitForJobToFinishInJobManager(finished);
643 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
645 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
646 assertEquals(VIM_ID, actualVim.getId());
647 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
648 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
649 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
650 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
651 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
652 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
653 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
654 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
655 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
659 * test instantiation with vCloud with SSL
662 public void testInstantiationVcloudWithSsl() throws Exception {
663 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
665 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
666 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
667 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
668 grantResponse.setVimId(VIM_ID);
669 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
670 accessInfo.setTenant(TENANT);
671 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
672 vimInfo.setSslInsecure("false");
673 vimInfo.setSslCacert(caCert);
674 grantResponse.setAccessInfo(accessInfo);
675 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
676 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
678 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
679 waitForJobToFinishInJobManager(finished);
680 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
682 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
683 assertEquals(VIM_ID, actualVim.getId());
684 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
685 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
686 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
687 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
688 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
689 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
690 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
691 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
692 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
693 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
697 * test instantiation with vCloud with SSL
700 public void testInstantiationVcloudWithNonSecifedSSl() throws Exception {
701 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
703 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
704 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
705 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
706 grantResponse.setVimId(VIM_ID);
707 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
708 accessInfo.setTenant(TENANT);
709 vimInfo.setSslInsecure(null);
710 grantResponse.setAccessInfo(accessInfo);
711 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
712 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
714 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
715 waitForJobToFinishInJobManager(finished);
716 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
718 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
719 assertEquals(VIM_ID, actualVim.getId());
720 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
721 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
722 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
723 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
724 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
725 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
726 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
727 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
731 * test failure in the instantiation request marks the job to be finished in job manager
734 public void testFailureInTheInstantiationRequest() throws Exception {
735 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
736 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
737 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
738 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
739 grantResponse.setVimId(VIM_ID);
740 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
741 accessInfo.setTenant(TENANT);
742 grantResponse.setAccessInfo(accessInfo);
743 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
744 RuntimeException expectedException = new RuntimeException();
745 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
748 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
750 waitForJobToFinishInJobManager(finished);
751 assertEquals(VNF_ID, response.getVnfInstanceId());
752 assertEquals(JOB_ID, response.getJobId());
753 verify(logger).error("Unable to instantiate VNF with myVnfId identifier", expectedException);
757 * instantiation fails if VF-C does not send vim identifier in grant response
760 public void testVfcFailsToSendVimId() throws Exception {
761 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
763 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
764 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
765 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
766 //grantResponse.setVimId(VIM_ID);
767 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
768 accessInfo.setTenant(TENANT);
769 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
770 vimInfo.setSslInsecure("false");
771 vimInfo.setSslCacert(caCert);
772 grantResponse.setAccessInfo(accessInfo);
773 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
774 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
776 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
777 waitForJobToFinishInJobManager(finished);
778 assertEquals(0, actualInstantiationRequest.getAllValues().size());
780 verify(logger).error("VF-C did not send VIM identifier in grant response");
784 * instantiation fails if VF-C does not send access info in grant response
787 public void testVfcFailsToSendAccessInfo() throws Exception {
788 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
790 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
791 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
792 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
793 grantResponse.setVimId(VIM_ID);
794 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
795 accessInfo.setTenant(TENANT);
796 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
797 vimInfo.setSslInsecure("false");
798 vimInfo.setSslCacert(caCert);
799 //grantResponse.setAccessInfo(accessInfo);
800 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
801 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
803 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
804 waitForJobToFinishInJobManager(finished);
805 assertEquals(0, actualInstantiationRequest.getAllValues().size());
807 verify(logger).error("VF-C did not send access info in grant response");
811 * test operation execution polling is retried in case of failures
814 public void testFailureInTheOperationExecutionPollingDuringInstantiationRequest() throws Exception {
815 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
816 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
817 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
818 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
819 grantResponse.setVimId(VIM_ID);
820 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
821 accessInfo.setTenant(TENANT);
822 grantResponse.setAccessInfo(accessInfo);
823 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
824 List<RuntimeException> polling = new ArrayList<>();
825 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
826 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).then(new Answer<Observable<List<OperationExecution>>>() {
828 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
829 if (polling.size() > 2) {
830 return buildObservable(operationExecutions);
832 RuntimeException runtimeException = new RuntimeException();
833 polling.add(runtimeException);
834 throw runtimeException;
838 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
840 waitForJobToFinishInJobManager(finished);
841 assertEquals(VNF_ID, response.getVnfInstanceId());
842 assertEquals(JOB_ID, response.getJobId());
843 assertEquals(3, polling.size());
844 for (RuntimeException e : polling) {
845 verify(logger).warn("Unable to retrieve operations details", e);
847 verify(systemFunctions, Mockito.times(3)).sleep(5000);
851 * failure in VNF creation is logged an proagated
854 public void failureInVnfCreationIsPropagated() throws Exception {
856 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
858 RuntimeException expectedException = new RuntimeException();
859 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
862 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
865 } catch (RuntimeException e) {
866 assertEquals(expectedException, e.getCause());
867 verify(logger).error("Unable to create the VNF", expectedException);
872 * failure in updating the modifyable attributes of the VNF is logged an proagated
875 public void failureInVnfModificationIsPropagated() throws Exception {
877 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
879 RuntimeException expectedException = new RuntimeException();
880 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
881 when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
885 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
888 } catch (RuntimeException e) {
889 assertEquals(expectedException, e.getCause().getCause());
890 verify(logger).error("Unable to set the onapCsarId property on the VNF", expectedException);
895 * if the VIM info can not be queried the VNF is not instantiated and
896 * error propagated through job
899 public void testFailureInQueryVimInfo() throws Exception {
900 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
901 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
902 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
903 grantResponse.setVimId(VIM_ID);
904 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
905 accessInfo.setTenant(TENANT);
906 grantResponse.setAccessInfo(accessInfo);
908 when(vimInfoProvider.getVimInfo(VIM_ID)).thenThrow(new RuntimeException());
910 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
912 waitForJobToFinishInJobManager(finished);
913 verify(vnfApi, never()).vnfsVnfInstanceIdInstantiatePost(Mockito.any(), Mockito.any(), Mockito.any());
917 * test termination basic success scenario
918 * - the VNF is not deleted before the notifications are processed
921 public void testTerminationAndDeletion() throws Exception {
923 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
924 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
925 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
926 vnfInfo.setOperationExecutions(operationExecutions);
927 VnfProperty vnfdId = new VnfProperty();
928 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
929 vnfdId.setValue(ONAP_CSAR_ID);
930 vnfInfo.getExtensions().add(vnfdId);
931 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
932 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
934 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
935 OperationExecution terminationOperation = new OperationExecution();
936 terminationOperation.setId("terminationId");
937 operationExecutions.add(terminationOperation);
938 terminationOperation.setStatus(OperationStatus.FINISHED);
939 return buildObservable(terminationOperation);
942 when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
943 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
944 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
946 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
948 waitForJobToFinishInJobManager(finished);
949 assertEquals(1, actualTerminationRequest.getAllValues().size());
950 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
951 assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
952 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
953 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
954 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
955 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
956 VOID_OBSERVABLE.assertCalled();
957 verify(jobManager).spawnJob(VNF_ID, restResponse);
958 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
962 * test termination basic success scenario
963 * - the VNF is not deleted before the notifications are processed
966 public void testTermination() throws Exception {
968 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
969 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
970 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
971 vnfInfo.setOperationExecutions(operationExecutions);
972 VnfProperty vnfdId = new VnfProperty();
973 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
974 vnfdId.setValue(ONAP_CSAR_ID);
975 vnfInfo.getExtensions().add(vnfdId);
976 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
977 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
979 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
980 OperationExecution terminationOperation = new OperationExecution();
981 terminationOperation.setId("terminationId");
982 operationExecutions.add(terminationOperation);
983 terminationOperation.setStatus(OperationStatus.FINISHED);
984 return buildObservable(terminationOperation);
987 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
988 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
990 JobInfo jobInfo = lifecycleManager.terminate(VNFM_ID, VNF_ID, terminationRequest, restResponse);
992 waitForJobToFinishInJobManager(finished);
993 assertEquals(1, actualTerminationRequest.getAllValues().size());
994 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
995 assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
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 verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1000 verify(jobManager).spawnJob(VNF_ID, restResponse);
1001 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
1005 * test termination of a non instantiated VNF
1006 * - the VNF is not terminated (only deleted)
1009 public void testTerminationOfNonInstantiated() throws Exception {
1011 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1012 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1013 vnfInfo.setInstantiationState(InstantiationState.NOT_INSTANTIATED);
1014 vnfInfo.setOperationExecutions(operationExecutions);
1015 VnfProperty vnfdId = new VnfProperty();
1016 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1017 vnfdId.setValue(ONAP_CSAR_ID);
1018 vnfInfo.getExtensions().add(vnfdId);
1019 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1020 when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
1021 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1023 lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1025 boolean deleted = false;
1028 verify(logger).info("The VNF with {} identifier has been deleted", VNF_ID);
1033 verify(vfcGrantManager, never()).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1034 verify(notificationManager, never()).waitForTerminationToBeProcessed("terminationId");
1035 verify(logger).warn("The VNF with {} identifier is not instantiated no termination is required", VNF_ID);
1036 verify(logger).info("Deleting VNF with {} identifier", VNF_ID);
1037 verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1038 VOID_OBSERVABLE.assertCalled();
1042 * test that the VNF deletion is not started before the termination finishes
1045 public void testTerminationOperationIsOutwaited() throws Exception {
1047 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1048 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(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 OperationExecution terminationOperation = new OperationExecution();
1057 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
1058 terminationOperation.setId("terminationId");
1059 operationExecutions.add(terminationOperation);
1060 terminationOperation.setStatus(OperationStatus.STARTED);
1061 return buildObservable(terminationOperation);
1063 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1064 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1065 Set<Integer> calls = new HashSet<>();
1066 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(invocation -> {
1067 if (calls.size() == 1000) {
1068 terminationOperation.setStatus(OperationStatus.FINISHED);
1070 calls.add(calls.size());
1071 return buildObservable(operationExecutions);
1074 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1076 waitForJobToFinishInJobManager(finished);
1077 verify(vnfApi, times(1001)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
1078 verify(systemFunctions, times(1000)).sleep(5000);
1083 * test that failured during waiting for the operation to finish is tolerated (idefineiatelly)
1086 public void testTerminationOperationIsOutwaitedWithErrors() throws Exception {
1088 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1089 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1090 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1091 vnfInfo.setOperationExecutions(operationExecutions);
1092 VnfProperty vnfdId = new VnfProperty();
1093 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1094 vnfdId.setValue(ONAP_CSAR_ID);
1095 vnfInfo.getExtensions().add(vnfdId);
1096 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1097 OperationExecution terminationOperation = new OperationExecution();
1098 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1100 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1101 terminationOperation.setId("terminationId");
1102 operationExecutions.add(terminationOperation);
1103 terminationOperation.setStatus(OperationStatus.STARTED);
1104 return buildObservable(terminationOperation);
1107 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1108 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1109 Set<Integer> calls = new HashSet<>();
1110 List<RuntimeException> expectedExceptions = new ArrayList<>();
1111 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
1113 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
1114 if (calls.size() >= 100) {
1115 terminationOperation.setStatus(OperationStatus.FINISHED);
1116 return buildObservable(operationExecutions);
1118 calls.add(calls.size());
1119 RuntimeException RuntimeException = new RuntimeException();
1120 expectedExceptions.add(RuntimeException);
1121 throw RuntimeException;
1125 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1127 waitForJobToFinishInJobManager(finished);
1128 verify(vnfApi, times(101)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
1129 verify(systemFunctions, times(100)).sleep(5000);
1130 for (RuntimeException expectedException : expectedExceptions) {
1131 verify(logger).warn("Unable to retrieve operations details", expectedException);
1136 * test gracefull termination
1139 public void testGracefullTermination() throws Exception {
1141 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1142 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1143 terminationRequest.setTerminationType(VnfTerminationType.GRACEFUL);
1144 terminationRequest.setGracefulTerminationTimeout("1234");
1145 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1146 vnfInfo.setOperationExecutions(operationExecutions);
1147 VnfProperty vnfdId = new VnfProperty();
1148 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1149 vnfdId.setValue(ONAP_CSAR_ID);
1150 vnfInfo.getExtensions().add(vnfdId);
1151 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1152 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1154 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1155 OperationExecution terminationOperation = new OperationExecution();
1156 terminationOperation.setId("terminationId");
1157 operationExecutions.add(terminationOperation);
1158 terminationOperation.setStatus(OperationStatus.FINISHED);
1159 return buildObservable(terminationOperation);
1162 doAnswer(invocation -> {
1163 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
1165 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1166 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1167 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1169 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1171 waitForJobToFinishInJobManager(finished);
1172 assertEquals(1, actualTerminationRequest.getAllValues().size());
1173 assertEquals(TerminationType.GRACEFUL, actualTerminationRequest.getValue().getTerminationType());
1174 assertEquals(Integer.valueOf(1234), actualTerminationRequest.getValue().getGracefulTerminationTimeout());
1175 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
1176 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1177 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
1178 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1182 * instantiation with missing ONAP csarId to instantiation extra param result in failure
1185 public void testMissingVnfParameters() throws Exception {
1187 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1188 String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "invalid" + "\" : {}}}, \"vimId\" : \"" + VIM_ID + "\"}";
1189 instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
1192 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
1194 } catch (Exception e) {
1195 assertEquals("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id", e.getMessage());
1196 verify(logger).error("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id");
1201 * test explicit forceful termination
1204 public void testExplicitForcefulTermination() throws Exception {
1206 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1207 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1208 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1209 terminationRequest.setGracefulTerminationTimeout("1234");
1210 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1211 vnfInfo.setOperationExecutions(operationExecutions);
1212 VnfProperty vnfdId = new VnfProperty();
1213 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1214 vnfdId.setValue(ONAP_CSAR_ID);
1215 vnfInfo.getExtensions().add(vnfdId);
1216 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1217 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
1218 OperationExecution terminationOperation = new OperationExecution();
1219 terminationOperation.setId("terminationId");
1220 operationExecutions.add(terminationOperation);
1221 terminationOperation.setStatus(OperationStatus.FINISHED);
1222 return buildObservable(terminationOperation);
1224 doAnswer(invocation -> {
1225 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
1227 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1228 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1229 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1231 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1233 waitForJobToFinishInJobManager(finished);
1234 assertEquals(1, actualTerminationRequest.getAllValues().size());
1235 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1236 assertNull(actualTerminationRequest.getValue().getGracefulTerminationTimeout());
1237 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
1238 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1239 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
1240 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1244 * test failure in the termination workflow finishes the job
1247 public void testFailureInTheTerminationFinishesTheManagedJob() throws Exception {
1249 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1250 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1251 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1252 terminationRequest.setGracefulTerminationTimeout("1234");
1253 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1254 vnfInfo.setOperationExecutions(operationExecutions);
1255 VnfProperty vnfdId = new VnfProperty();
1256 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1257 vnfdId.setValue(ONAP_CSAR_ID);
1258 vnfInfo.getExtensions().add(vnfdId);
1259 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1260 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
1262 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
1263 OperationExecution terminationOperation = new OperationExecution();
1264 terminationOperation.setId("terminationId");
1265 operationExecutions.add(terminationOperation);
1266 terminationOperation.setStatus(OperationStatus.FINISHED);
1267 return terminationOperation;
1270 RuntimeException expectedException = new RuntimeException();
1271 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1272 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1273 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1275 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1277 waitForJobToFinishInJobManager(finished);
1278 assertEquals(0, actualTerminationRequest.getAllValues().size());
1279 Mockito.verifyZeroInteractions(vfcGrantManager);
1283 * if termination fails the VNF is not deleted
1286 public void testFailedTerminationAbortsTerminationWorkflow() throws Exception {
1288 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1289 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1290 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1291 vnfInfo.setOperationExecutions(operationExecutions);
1292 VnfProperty vnfdId = new VnfProperty();
1293 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1294 vnfdId.setValue(ONAP_CSAR_ID);
1295 vnfInfo.getExtensions().add(vnfdId);
1296 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1297 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1299 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1300 OperationExecution terminationOperation = new OperationExecution();
1301 terminationOperation.setId("terminationId");
1302 operationExecutions.add(terminationOperation);
1303 terminationOperation.setStatus(OperationStatus.FAILED);
1304 return buildObservable(terminationOperation);
1307 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1308 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1310 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1312 waitForJobToFinishInJobManager(finished);
1313 assertEquals(1, actualTerminationRequest.getAllValues().size());
1314 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1315 verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1316 verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1317 verify(logger).error("Unable to terminate VNF the operation did not finish with success");
1321 * test VNF query basic success scenario
1324 public void testQuery() throws Exception {
1325 vnfInfo.setDescription("myDescription");
1326 vnfInfo.setName("myName");
1327 vnfInfo.setVnfSoftwareVersion("vnfSoftwareVersion");
1328 vnfInfo.setVnfProvider("myProvider");
1329 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1330 VnfProperty prop = new VnfProperty();
1331 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1332 prop.setValue(ONAP_CSAR_ID);
1333 vnfInfo.getExtensions().add(prop);
1335 org.onap.vnfmdriver.model.VnfInfo vnf = lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1337 assertEquals(VNF_ID, vnf.getVnfInstanceId());
1338 //FIXME ? (do not know what exactly the vnf version mean in core terminology)
1339 assertEquals("vnfSoftwareVersion", vnf.getVersion());
1340 assertEquals(ONAP_CSAR_ID, vnf.getVnfdId());
1341 assertEquals("myDescription", vnf.getVnfInstanceDescription());
1342 assertEquals("myName", vnf.getVnfInstanceName());
1343 assertEquals(ONAP_CSAR_ID, vnf.getVnfPackageId());
1344 assertEquals("myProvider", vnf.getVnfProvider());
1345 //FIXME (in swagger schema )
1346 assertEquals("ACTIVE", vnf.getVnfStatus());
1347 assertEquals("Kuku", vnf.getVnfType());
1351 * error is propagated and logged if the queried VNF does not exist
1354 public void testQueryForNonExistingVnf() throws Exception {
1356 RuntimeException expectedException = new RuntimeException();
1357 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1360 lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1363 } catch (Exception e) {
1364 verify(logger).error("Unable to query VNF (myVnfId)", expectedException);
1365 assertEquals(expectedException, e.getCause());
1370 * test scale basic scenario
1373 public void testScale() throws Exception {
1374 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1375 scaleRequest.setNumberOfSteps("2");
1376 scaleRequest.setAspectId("myAspect");
1377 scaleRequest.setType(ScaleDirection.IN);
1378 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }"));
1379 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1380 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1381 VnfProperty prop = new VnfProperty();
1382 prop.setValue(ONAP_CSAR_ID);
1383 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1384 vnfInfo.getExtensions().add(prop);
1385 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1386 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1387 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1389 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1391 waitForJobToFinishInJobManager(finished);
1392 assertEquals(1, actualScaleRequest.getAllValues().size());
1393 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1394 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1395 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1396 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1397 assertEquals("myAspect", sRequest.getAspectId());
1398 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1399 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1400 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1401 verify(jobManager).spawnJob(VNF_ID, restResponse);
1402 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("scale"), eq(VNF_ID), anyString());
1407 * the VNFM should tolerate that no additional params were supplied
1410 public void testScaleWithoutAddtionalParams() throws Exception {
1411 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1412 scaleRequest.setNumberOfSteps("2");
1413 scaleRequest.setAspectId("myAspect");
1414 scaleRequest.setType(ScaleDirection.IN);
1415 scaleRequest.setAdditionalParam(null);
1416 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1417 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1418 VnfProperty prop = new VnfProperty();
1419 prop.setValue(ONAP_CSAR_ID);
1420 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1421 vnfInfo.getExtensions().add(prop);
1422 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1423 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1424 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1426 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1428 waitForJobToFinishInJobManager(finished);
1429 assertEquals(1, actualScaleRequest.getAllValues().size());
1430 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1431 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1432 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1433 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1434 assertEquals("myAspect", sRequest.getAspectId());
1435 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1436 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1437 assertEquals("{\"jobId\":\"myJobId\"}", new Gson().toJson(sRequest.getAdditionalParams()));
1438 verify(jobManager).spawnJob(VNF_ID, restResponse);
1442 * test scale out basic scenario
1445 public void testScaleOut() throws Exception {
1446 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1447 scaleRequest.setNumberOfSteps("2");
1448 scaleRequest.setAspectId("myAspect");
1449 scaleRequest.setType(ScaleDirection.OUT);
1450 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1451 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1452 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1453 VnfProperty prop = new VnfProperty();
1454 prop.setValue(ONAP_CSAR_ID);
1455 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1456 vnfInfo.getExtensions().add(prop);
1457 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1458 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1459 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1461 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1463 waitForJobToFinishInJobManager(finished);
1464 assertEquals(1, actualScaleRequest.getAllValues().size());
1465 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1466 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1467 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1468 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1469 assertEquals("myAspect", sRequest.getAspectId());
1470 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.OUT, sRequest.getType());
1471 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1472 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1476 * test scale operation is out waited
1479 public void testScaleOutwait() throws Exception {
1480 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1481 scaleRequest.setNumberOfSteps("2");
1482 scaleRequest.setAspectId("myAspect");
1483 scaleRequest.setType(ScaleDirection.IN);
1484 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1485 scaleOperationExecution.setStatus(OperationStatus.STARTED);
1486 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1487 VnfProperty prop = new VnfProperty();
1488 prop.setValue(ONAP_CSAR_ID);
1489 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1490 vnfInfo.getExtensions().add(prop);
1491 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1492 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1493 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1494 List<RuntimeException> expectedExceptions = new ArrayList<>();
1495 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<Observable<List<OperationExecution>>>) invocation -> {
1496 if (expectedExceptions.size() >= 100) {
1497 when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(scaleOperationExecution));
1498 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1499 return buildObservable(operationExecutions);
1501 RuntimeException RuntimeException = new RuntimeException();
1502 expectedExceptions.add(RuntimeException);
1503 throw RuntimeException;
1507 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1509 waitForJobToFinishInJobManager(finished);
1510 assertEquals(100, expectedExceptions.size());
1511 for (RuntimeException expectedException : expectedExceptions) {
1512 verify(logger).warn("Unable to retrieve operations details", expectedException);
1514 verify(systemFunctions, times(100)).sleep(5000);
1518 * test scale failure propagation
1521 public void testScaleFailurePropagation() throws Exception {
1522 RuntimeException expectedException = new RuntimeException();
1523 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1524 scaleRequest.setNumberOfSteps("2");
1525 scaleRequest.setAspectId("myAspect");
1526 scaleRequest.setType(ScaleDirection.IN);
1527 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1529 lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1531 waitForJobToFinishInJobManager(finished);
1532 verify(logger).error("Unable to scale VNF with myVnfId identifier", expectedException);
1536 * test heal basic scenario
1539 public void testHeal() throws Exception {
1540 VnfHealRequest healRequest = new VnfHealRequest();
1541 healRequest.setAction("myAction");
1542 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1543 affectedVm.setVmname("vmName");
1544 healRequest.setAffectedvm(affectedVm);
1545 healOperationExecution.setStatus(OperationStatus.FINISHED);
1546 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1547 VnfProperty prop = new VnfProperty();
1548 prop.setValue(ONAP_CSAR_ID);
1549 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1550 vnfInfo.getExtensions().add(prop);
1551 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1552 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1553 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1555 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1557 waitForJobToFinishInJobManager(finished);
1558 assertEquals(1, actualHealRequest.getAllValues().size());
1559 HealVnfRequest sRequest = actualHealRequest.getValue();
1560 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1561 workflowOrder.verify(vfcGrantManager).requestGrantForHeal(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(healRequest), eq(JOB_ID));
1562 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdHealPost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1563 JsonObject root = new Gson().toJsonTree(sRequest.getAdditionalParams()).getAsJsonObject();
1564 assertEquals("myAction", root.get("action").getAsString());
1565 assertEquals("vmName", root.get("vmName").getAsString());
1566 assertEquals(JOB_ID, root.get("jobId").getAsString());
1567 verify(jobManager).spawnJob(VNF_ID, restResponse);
1568 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("heal"), eq(VNF_ID), anyString());
1572 * test heal operation is out waited
1575 public void testHealOutwait() throws Exception {
1576 VnfHealRequest healRequest = new VnfHealRequest();
1577 healRequest.setAction("myAction");
1578 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1579 affectedVm.setVmname("vmName");
1580 healRequest.setAffectedvm(affectedVm);
1581 healOperationExecution.setStatus(OperationStatus.FINISHED);
1582 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1583 VnfProperty prop = new VnfProperty();
1584 prop.setValue(ONAP_CSAR_ID);
1585 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1586 vnfInfo.getExtensions().add(prop);
1587 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1588 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1589 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1590 List<RuntimeException> expectedExceptions = new ArrayList<>();
1591 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
1593 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
1594 if (expectedExceptions.size() >= 100) {
1595 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1596 return buildObservable(operationExecutions);
1598 RuntimeException RuntimeException = new RuntimeException();
1599 expectedExceptions.add(RuntimeException);
1600 throw RuntimeException;
1604 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1606 waitForJobToFinishInJobManager(finished);
1607 assertEquals(100, expectedExceptions.size());
1608 for (RuntimeException expectedException : expectedExceptions) {
1609 verify(logger).warn("Unable to retrieve operations details", expectedException);
1611 verify(systemFunctions, times(100)).sleep(5000);
1615 * failure in heal propagates in error
1618 public void testHealFailurePropagation() throws Exception {
1619 RuntimeException expectedException = new RuntimeException();
1620 VnfHealRequest healRequest = new VnfHealRequest();
1621 healRequest.setAction("myAction");
1622 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1623 affectedVm.setVmname("vmName");
1624 healRequest.setAffectedvm(affectedVm);
1625 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1627 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1629 waitForJobToFinishInJobManager(finished);
1630 verify(logger).error("Unable to heal VNF with myVnfId identifier", expectedException);
1635 * test custom operation basic scenario
1638 public void testCustomOperation() throws Exception {
1639 String operationId = "operationIdCaptor";
1640 Object additionalParams = new JsonObject();
1642 JobInfo job = lifecycleManager.customOperation(VNFM_ID, VNF_ID, operationId, additionalParams, restResponse);
1644 waitForJobToFinishInJobManager(finished);
1645 assertEquals(operationId, operationIdCaptor.getValue());
1646 assertEquals(additionalParams, customOperationRequestArgumentCaptor.getValue().getAdditionalParams());
1649 private void waitForJobToFinishInJobManager(Set<Boolean> finished) throws InterruptedException {
1650 while (finished.size() == 0) {
1651 systemFunctions().sleep(100);
1655 private VnfInstantiateRequest prepareInstantiationRequest(VimInfo.VimInfoTypeEnum cloudType) {
1656 VnfInstantiateRequest instantiationRequest = new VnfInstantiateRequest();
1657 instantiationRequest.setVnfPackageId(ONAP_CSAR_ID);
1658 instantiationRequest.setVnfDescriptorId(ONAP_CSAR_ID);
1659 instantiationRequest.setVnfInstanceDescription("myDescription");
1660 instantiationRequest.setVnfInstanceName("vnfName");
1661 additionalParam.setInstantiationLevel("level1");
1662 switch (cloudType) {
1663 case OPENSTACK_V2_INFO:
1664 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1666 case OPENSTACK_V3_INFO:
1667 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
1668 vimInfo.setDomain("myDomain");
1670 case VMWARE_VCLOUD_INFO:
1671 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
1674 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
1677 Map<String, List<NetworkAddress>> exteranalConnectionPointAddresses = new HashMap<>();
1678 exteranalConnectionPointAddresses.put("ecp1", new ArrayList<>());
1679 NetworkAddress networkAddress = new NetworkAddress();
1680 networkAddress.setIp("1.2.3.4");
1681 networkAddress.setMac("mac");
1682 networkAddress.setSubnetId("subnetId");
1683 exteranalConnectionPointAddresses.get("ecp1").add(networkAddress);
1684 additionalParam.setExternalConnectionPointAddresses(exteranalConnectionPointAddresses);
1685 VimComputeResourceFlavour flavor = new VimComputeResourceFlavour();
1686 flavor.setResourceId("flavourProviderId");
1687 flavor.setVimId(VIM_ID);
1688 flavor.setVnfdVirtualComputeDescId("virtualComputeDescId");
1689 additionalParam.getComputeResourceFlavours().add(flavor);
1690 ExtVirtualLinkData evl = new ExtVirtualLinkData();
1691 evl.setResourceId("networkProviderId1");
1692 evl.setVimId(VIM_ID);
1693 evl.setExtVirtualLinkId("evlId1");
1694 VnfExtCpData ecp2 = new VnfExtCpData();
1695 ecp2.setCpdId("cpdId3");
1696 ecp2.setAddresses(new ArrayList<>());
1697 ecp2.getAddresses().add(networkAddress);
1698 ecp2.setNumDynamicAddresses(2);
1699 evl.getExtCps().add(ecp2);
1700 additionalParam.getExtVirtualLinks().add(evl);
1701 externalVirtualLink.setCpdId("myCpdId");
1702 externalVirtualLink.setResourceId("myNetworkProviderId");
1703 externalVirtualLink.setVlInstanceId("myEVlId");
1704 externalVirtualLink.setResourceSubnetId("notUsedSubnetId");
1705 instantiationRequest.setExtVirtualLink(new ArrayList<>());
1706 instantiationRequest.getExtVirtualLink().add(externalVirtualLink);
1707 additionalParam.getExtManagedVirtualLinks().add(extManVl);
1708 ZoneInfo zone = new ZoneInfo();
1709 zone.setId("zoneId");
1710 zone.setResourceId("zoneProviderId");
1711 zone.setVimId(VIM_ID);
1712 additionalParam.getZones().add(zone);
1713 VimSoftwareImage image = new VimSoftwareImage();
1714 image.setResourceId("imageProviderId");
1715 image.setVimId(VIM_ID);
1716 image.setVnfdSoftwareImageId("imageId");
1717 additionalParam.getSoftwareImages().add(image);
1718 additionalParam.setAdditionalParams(new JsonParser().parse("{ \"a\" : \"b\" }"));
1719 String params = new Gson().toJson(additionalParam);
1720 String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "\" : " + params + "}}, \"vimId\" : \"" + VIM_ID + "\"}";
1721 instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
1722 return instantiationRequest;
1726 * Test vimId decomposition
1729 public void testVimIdSplitting() {
1730 assertEquals("regionId", LifecycleManager.getRegionName("cloudOwner_regionId"));
1731 assertEquals("cloudOwner", LifecycleManager.getCloudOwner("cloudOwner_regionId"));