2 * Copyright 2016-2017, Nokia Corporation
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
16 package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
18 import com.google.gson.Gson;
19 import com.google.gson.JsonElement;
20 import com.google.gson.JsonObject;
21 import com.google.gson.JsonParser;
22 import com.nokia.cbam.catalog.v1.model.CatalogAdapterVnfpackage;
23 import com.nokia.cbam.lcm.v32.model.*;
24 import com.nokia.cbam.lcm.v32.model.OperationType;
25 import com.nokia.cbam.lcm.v32.model.VimInfo;
26 import com.nokia.cbam.lcm.v32.model.VnfInfo;
27 import io.reactivex.Observable;
28 import java.nio.file.Paths;
30 import javax.servlet.http.HttpServletResponse;
31 import org.junit.Before;
32 import org.junit.Test;
33 import org.mockito.ArgumentCaptor;
34 import org.mockito.InOrder;
35 import org.mockito.Mock;
36 import org.mockito.Mockito;
37 import org.mockito.invocation.InvocationOnMock;
38 import org.mockito.stubbing.Answer;
39 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VimInfoProvider;
40 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.TestVfcGrantManager;
41 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.VfcGrantManager;
42 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.StoreLoader;
43 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.LifecycleChangeNotificationManager;
44 import org.onap.vnfmdriver.model.ExtVirtualLinkInfo;
45 import org.onap.vnfmdriver.model.*;
46 import org.onap.vnfmdriver.model.ScaleDirection;
47 import org.threeten.bp.OffsetDateTime;
49 import static java.lang.Boolean.parseBoolean;
50 import static java.nio.file.Files.readAllBytes;
51 import static java.util.Optional.empty;
53 import static junit.framework.TestCase.*;
54 import static org.mockito.Matchers.eq;
55 import static org.mockito.Mockito.*;
56 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.child;
57 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions.systemFunctions;
58 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
59 import static org.springframework.test.util.ReflectionTestUtils.setField;
61 public class TestLifecycleManager extends TestBase {
62 public static final String JOB_ID = "myJobId";
63 public static final String CBAM_VNFD_ID = "cbamVnfdId";
64 public static final String TENANT = "myTenant";
65 public static final String OPERATION_EXECUTION_ID = "operationExecutionId";
66 private static final String ONAP_CSAR_ID = "myOnapCsarId";
67 private static final String VIM_ID = "ownerId_regionId";
68 private GrantVNFResponseVim vim = new GrantVNFResponseVim();
70 private CatalogManager catalogManager;
72 private VfcGrantManager vfcGrantManager;
74 private CbamTokenProvider tokenProvider;
76 private JobManager jobManager;
78 private LifecycleChangeNotificationManager notificationManager;
80 private HttpServletResponse restResponse;
82 private VimInfoProvider vimInfoProvider;
84 private ArgumentCaptor<CreateVnfRequest> createRequest = ArgumentCaptor.forClass(CreateVnfRequest.class);
85 private AdditionalParameters additionalParam = new AdditionalParameters();
86 private String INSTANTIATION_LEVEL = "level1";
87 private GrantVNFResponseVim grantResponse = new GrantVNFResponseVim();
88 private String cbamVnfdContent;
89 private OperationExecution instantiationOperationExecution = new OperationExecution();
90 private OperationExecution modifyPropertyoperationExecution = new OperationExecution();
91 private OperationExecution scaleOperationExecution = new OperationExecution();
92 private OperationExecution healOperationExecution = new OperationExecution();
93 private OperationExecution customOperationExecution = new OperationExecution();
96 private VnfInfo vnfInfo = new VnfInfo();
97 private List<OperationExecution> operationExecutions = new ArrayList<>();
98 private org.onap.vnfmdriver.model.VimInfo vimInfo = new org.onap.vnfmdriver.model.VimInfo();
99 private ExtVirtualLinkInfo externalVirtualLink = new ExtVirtualLinkInfo();
100 private ExtManagedVirtualLinkData extManVl = new ExtManagedVirtualLinkData();
101 private ArgumentCaptor<ModifyVnfInfoRequest> actualVnfModifyRequest = ArgumentCaptor.forClass(ModifyVnfInfoRequest.class);
102 private Set<Boolean> finished = new HashSet<>();
103 private ArgumentCaptor<ScaleVnfRequest> actualScaleRequest = ArgumentCaptor.forClass(ScaleVnfRequest.class);
104 private ArgumentCaptor<HealVnfRequest> actualHealRequest = ArgumentCaptor.forClass(HealVnfRequest.class);
105 private ArgumentCaptor<CustomOperationRequest> customOperationRequestArgumentCaptor = ArgumentCaptor.forClass(CustomOperationRequest.class);
106 private ArgumentCaptor<String> operationIdCaptor = ArgumentCaptor.forClass(String.class);
108 private LifecycleManager lifecycleManager;
111 public void initMocks() throws Exception {
112 vnfInfo.setExtensions(new ArrayList<>());
113 vnfInfo.setOperationExecutions(new ArrayList<>());
114 lifecycleManager = new LifecycleManager(catalogManager, vfcGrantManager, cbamRestApiProvider, vimInfoProvider, jobManager, notificationManager);
115 cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.full.yaml").toURI())));
116 setField(LifecycleManager.class, "logger", logger);
117 CatalogAdapterVnfpackage cbamPackage = new CatalogAdapterVnfpackage();
118 when(catalogManager.preparePackageInCbam(VNFM_ID, ONAP_CSAR_ID)).thenReturn(cbamPackage);
119 cbamPackage.setVnfdId(CBAM_VNFD_ID);
120 vnfInfo.setVnfdId(CBAM_VNFD_ID);
121 vnfInfo.setId(VNF_ID);
122 when(jobManager.spawnJob(VNF_ID, restResponse)).thenReturn(JOB_ID);
123 when(catalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent);
124 cbamPackage.setId(CBAM_VNFD_ID);
125 vimInfo.setUrl("cloudUrl");
126 vimInfo.setPassword("vimPassword");
127 vimInfo.setUserName("vimUsername");
128 vimInfo.setSslInsecure("true");
129 vimInfo.setVimId(VIM_ID);
130 vimInfo.setName("vimName");
131 when(vimInfoProvider.getVimInfo((VIM_ID))).thenReturn(vimInfo);
132 instantiationOperationExecution.setId(OPERATION_EXECUTION_ID);
133 instantiationOperationExecution.setOperationType(OperationType.INSTANTIATE);
134 instantiationOperationExecution.setStartTime(OffsetDateTime.now());
135 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecutions));
136 operationExecutions.add(modifyPropertyoperationExecution);
137 modifyPropertyoperationExecution.setStartTime(OffsetDateTime.now());
138 modifyPropertyoperationExecution.setOperationType(OperationType.MODIFY_INFO);
139 operationExecutions.add(instantiationOperationExecution);
140 instantiationOperationExecution.setStatus(OperationStatus.FINISHED);
141 modifyPropertyoperationExecution.setStatus(OperationStatus.FINISHED);
142 customOperationExecution.setStatus(OperationStatus.FINISHED);
143 modifyPropertyoperationExecution.setId(UUID.randomUUID().toString());
144 scaleOperationExecution.setId(UUID.randomUUID().toString());
145 healOperationExecution.setId(UUID.randomUUID().toString());
146 customOperationExecution.setId(UUID.randomUUID().toString());
148 when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(modifyPropertyoperationExecution));
149 doAnswer(new Answer() {
151 public Object answer(InvocationOnMock invocation) throws Throwable {
152 finished.add(Boolean.TRUE);
155 }).when(jobManager).jobFinished(JOB_ID);
156 when(vnfApi.vnfsVnfInstanceIdScalePost(eq(VNF_ID), actualScaleRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
158 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
159 operationExecutions.add(scaleOperationExecution);
160 return buildObservable(scaleOperationExecution);
163 when(vnfApi.vnfsVnfInstanceIdHealPost(eq(VNF_ID), actualHealRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
165 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
166 operationExecutions.add(healOperationExecution);
167 return buildObservable(healOperationExecution);
170 when(vnfApi.vnfsVnfInstanceIdCustomCustomOperationNamePost(eq(VNF_ID), operationIdCaptor.capture(), customOperationRequestArgumentCaptor.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
172 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
173 operationExecutions.add(customOperationExecution);
174 return buildObservable(customOperationExecution);
183 public void testInstantiation() throws Exception {
185 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
187 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
188 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
189 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
190 grantResponse.setVimId(VIM_ID);
191 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
192 accessInfo.setTenant(TENANT);
193 grantResponse.setAccessInfo(accessInfo);
194 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
195 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
197 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
198 waitForJobToFinishInJobManager(finished);
200 assertEquals(VNF_ID, response.getVnfInstanceId());
201 assertEquals(JOB_ID, response.getJobId());
202 assertEquals(createRequest.getAllValues().size(), 1);
203 assertEquals("myDescription", createRequest.getValue().getDescription());
204 assertEquals("vnfName", createRequest.getValue().getName());
205 assertEquals(CBAM_VNFD_ID, createRequest.getValue().getVnfdId());
206 assertEquals(1, actualInstantiationRequest.getAllValues().size());
207 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
208 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
209 assertEquals(VIM_ID, actualVim.getId());
210 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, actualVim.getVimInfoType());
211 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
212 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
213 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
214 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
215 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
216 assertEquals("myTenant", actualVim.getAccessInfo().getTenant());
217 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
218 assertEquals(1, actualInstantiationRequest.getValue().getComputeResourceFlavours().size());
219 assertEquals("flavourProviderId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getResourceId());
220 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVimId());
221 assertEquals("virtualComputeDescId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVnfdVirtualComputeDescId());
222 assertEquals(1, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().size());
223 assertEquals(extManVl, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().get(0));
224 assertEquals(2, actualInstantiationRequest.getValue().getExtVirtualLinks().size());
226 assertEquals("myNetworkProviderId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getResourceId());
227 assertEquals("myEVlId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtVirtualLinkId());
228 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().size());
229 assertEquals("myCpdId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().get(0).getCpdId());
231 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getVimId());
232 assertEquals("evlId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtVirtualLinkId());
233 assertEquals("networkProviderId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getResourceId());
234 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().size());
237 assertEquals(Integer.valueOf(2), actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getNumDynamicAddresses());
238 assertEquals("cpdId3", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getCpdId());
239 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().size());
240 assertEquals("1.2.3.4", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getIp());
241 assertEquals("mac", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getMac());
242 assertEquals("subnetId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getSubnetId());
244 assertEquals("myFlavorId", actualInstantiationRequest.getValue().getFlavourId());
245 assertEquals(Boolean.TRUE, actualInstantiationRequest.getValue().isGrantlessMode());
246 assertEquals("level1", actualInstantiationRequest.getValue().getInstantiationLevelId());
247 assertEquals(1, actualInstantiationRequest.getValue().getZones().size());
248 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getZones().get(0).getVimId());
249 assertEquals("zoneProviderId", actualInstantiationRequest.getValue().getZones().get(0).getResourceId());
250 assertEquals("zoneId", actualInstantiationRequest.getValue().getZones().get(0).getId());
251 assertEquals(1, actualInstantiationRequest.getValue().getSoftwareImages().size());
252 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVimId());
253 assertEquals("imageProviderId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getResourceId());
254 assertEquals("imageId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVnfdSoftwareImageId());
255 String actualEmbeddedAdditionParams = new Gson().toJson(actualInstantiationRequest.getValue().getAdditionalParams());
256 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(actualEmbeddedAdditionParams) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(actualEmbeddedAdditionParams));
257 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
258 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
260 assertEquals(1, actualVnfModifyRequest.getAllValues().size());
261 assertEquals(2, actualVnfModifyRequest.getValue().getExtensions().size());
262 assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getName());
263 assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getValue());
264 assertEquals(LifecycleManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName());
265 assertEquals(VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getValue());
267 //the 3.2 API does not accept empty array
268 assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties());
269 verify(jobManager).spawnJob(VNF_ID, restResponse);
270 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
271 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
275 * invalid VIM type results in failure
278 public void testInstantiationWithInvalidVimType() throws Exception {
280 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
281 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
282 when(logger.isInfoEnabled()).thenReturn(false);
285 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
288 } catch (Exception e) {
289 assertEquals("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types", e.getMessage());
291 verify(vnfApi, never()).vnfsPost(Mockito.any(), Mockito.any());
292 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
293 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
294 verify(logger).error("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types");
298 * test instantiation with KeyStone V2 based with SSL
301 public void testInstantiationV2WithSsl() throws Exception {
302 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
303 when(logger.isInfoEnabled()).thenReturn(false);
304 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
305 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
306 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
307 grantResponse.setVimId(VIM_ID);
308 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
309 accessInfo.setTenant(TENANT);
310 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
311 vimInfo.setSslInsecure("false");
312 vimInfo.setSslCacert(caCert);
313 grantResponse.setAccessInfo(accessInfo);
314 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
315 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
316 JsonObject inputs = child((JsonObject) instantiationRequest.getAdditionalParam(), "inputs");
317 JsonObject vnfs = child(child(inputs, "vnfs"), ONAP_CSAR_ID);
318 vnfs.remove("additionalParams");
320 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
321 waitForJobToFinishInJobManager(finished);
322 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
324 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
325 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
326 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
327 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
328 verify(logger).warn("No additional parameters were specified for the operation");
329 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), anyString(), anyString(), anyString());
333 * non specified SSL verification means not verified
336 public void testInstantiationV2WithoutSsl() throws Exception {
337 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
339 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
340 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
341 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
342 grantResponse.setVimId(VIM_ID);
343 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
344 accessInfo.setTenant(TENANT);
345 vimInfo.setSslInsecure(null);
346 grantResponse.setAccessInfo(accessInfo);
347 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
348 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
350 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
351 waitForJobToFinishInJobManager(finished);
352 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
354 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
355 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
356 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
360 * test instantiation with KeyStone V3 based
363 public void testInstantiationV3() throws Exception {
364 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
366 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
367 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
368 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
369 grantResponse.setVimId(VIM_ID);
370 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
371 accessInfo.setTenant(TENANT);
372 grantResponse.setAccessInfo(accessInfo);
373 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
374 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
376 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
377 waitForJobToFinishInJobManager(finished);
378 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
380 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
381 assertEquals(VIM_ID, actualVim.getId());
382 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
383 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
384 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
385 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
386 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
387 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
388 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
389 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
390 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
391 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
392 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
396 * test instantiation with KeyStone V3 based with SSL
399 public void testInstantiationV3WithSsl() throws Exception {
400 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
402 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
403 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
404 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
405 grantResponse.setVimId(VIM_ID);
406 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
407 accessInfo.setTenant(TENANT);
408 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
409 vimInfo.setSslInsecure("false");
410 vimInfo.setSslCacert(caCert);
411 grantResponse.setAccessInfo(accessInfo);
412 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
413 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
415 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
416 waitForJobToFinishInJobManager(finished);
417 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
419 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
420 assertEquals(VIM_ID, actualVim.getId());
421 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
422 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
423 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
424 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
425 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
426 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
427 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
428 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
429 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
430 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
431 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
432 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
436 * non specified SSL verification meams not verified for KeyStone V3 based
439 public void testInstantiationV3WithNonSpecifiedSsl() throws Exception {
440 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
442 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
443 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
444 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
445 grantResponse.setVimId(VIM_ID);
446 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
447 accessInfo.setTenant(TENANT);
448 vimInfo.setSslInsecure(null);
449 grantResponse.setAccessInfo(accessInfo);
450 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
451 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
453 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
454 waitForJobToFinishInJobManager(finished);
455 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
457 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
458 assertEquals(VIM_ID, actualVim.getId());
459 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
460 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
461 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
462 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
463 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
464 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
465 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
466 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
467 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
468 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
472 * test instantiation with vcloud
475 public void testInstantiationVcloud() throws Exception {
476 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
478 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
479 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
480 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
481 grantResponse.setVimId(VIM_ID);
482 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
483 accessInfo.setTenant(TENANT);
484 grantResponse.setAccessInfo(accessInfo);
485 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
486 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
488 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
489 waitForJobToFinishInJobManager(finished);
490 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
492 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
493 assertEquals(VIM_ID, actualVim.getId());
494 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
495 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
496 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
497 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
498 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
499 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
500 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
501 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
502 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
506 * test instantiation with vCloud with SSL
509 public void testInstantiationVcloudWithSsl() throws Exception {
510 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
512 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
513 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
514 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
515 grantResponse.setVimId(VIM_ID);
516 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
517 accessInfo.setTenant(TENANT);
518 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
519 vimInfo.setSslInsecure("false");
520 vimInfo.setSslCacert(caCert);
521 grantResponse.setAccessInfo(accessInfo);
522 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
523 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
525 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
526 waitForJobToFinishInJobManager(finished);
527 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
529 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
530 assertEquals(VIM_ID, actualVim.getId());
531 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
532 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
533 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
534 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
535 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
536 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
537 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
538 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
539 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
540 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
544 * test instantiation with vCloud with SSL
547 public void testInstantiationVcloudWithNonSecifedSSl() throws Exception {
548 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
550 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
551 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
552 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
553 grantResponse.setVimId(VIM_ID);
554 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
555 accessInfo.setTenant(TENANT);
556 vimInfo.setSslInsecure(null);
557 grantResponse.setAccessInfo(accessInfo);
558 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
559 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
561 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
562 waitForJobToFinishInJobManager(finished);
563 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
565 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
566 assertEquals(VIM_ID, actualVim.getId());
567 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
568 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
569 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
570 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
571 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
572 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
573 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
574 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
578 * test failure in the instantiation request marks the job to be finished in job manager
581 public void testFailureInTheInstantiationRequest() throws Exception {
582 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
583 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
584 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
585 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
586 grantResponse.setVimId(VIM_ID);
587 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
588 accessInfo.setTenant(TENANT);
589 grantResponse.setAccessInfo(accessInfo);
590 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
591 RuntimeException expectedException = new RuntimeException();
592 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
595 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
597 waitForJobToFinishInJobManager(finished);
598 assertEquals(VNF_ID, response.getVnfInstanceId());
599 assertEquals(JOB_ID, response.getJobId());
600 verify(logger).error("Unable to instantiate VNF with myVnfId identifier", expectedException);
604 * instantiation fails if VF-C does not send vim identifier in grant response
607 public void testVfcFailsToSendVimId() throws Exception {
608 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
610 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
611 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
612 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
613 //grantResponse.setVimId(VIM_ID);
614 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
615 accessInfo.setTenant(TENANT);
616 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
617 vimInfo.setSslInsecure("false");
618 vimInfo.setSslCacert(caCert);
619 grantResponse.setAccessInfo(accessInfo);
620 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
621 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
623 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
624 waitForJobToFinishInJobManager(finished);
625 assertEquals(0, actualInstantiationRequest.getAllValues().size());
627 verify(logger).error("VF-C did not send VIM identifier in grant response");
632 * test operation execution polling is retried in case of failures
635 public void testFailureInTheOperationExecutionPollingDuringInstantiationRequest() throws Exception {
636 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
637 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
638 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
639 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
640 grantResponse.setVimId(VIM_ID);
641 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
642 accessInfo.setTenant(TENANT);
643 grantResponse.setAccessInfo(accessInfo);
644 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
645 List<RuntimeException> polling = new ArrayList<>();
646 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
647 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).then(new Answer<Observable<List<OperationExecution>>>() {
649 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
650 if (polling.size() > 2) {
651 return buildObservable(operationExecutions);
653 RuntimeException runtimeException = new RuntimeException();
654 polling.add(runtimeException);
655 throw runtimeException;
659 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
661 waitForJobToFinishInJobManager(finished);
662 assertEquals(VNF_ID, response.getVnfInstanceId());
663 assertEquals(JOB_ID, response.getJobId());
664 assertEquals(3, polling.size());
665 for (RuntimeException e : polling) {
666 verify(logger).warn("Unable to retrieve operations details", e);
668 verify(systemFunctions, Mockito.times(3)).sleep(5000);
672 * failure in VNF creation is logged an proagated
675 public void failureInVnfCreationIsPropagated() throws Exception {
677 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
679 RuntimeException expectedException = new RuntimeException();
680 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
683 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
686 } catch (RuntimeException e) {
687 assertEquals(expectedException, e.getCause());
688 verify(logger).error("Unable to create the VNF", expectedException);
693 * failure in updating the modifyable attributes of the VNF is logged an proagated
696 public void failureInVnfModificationIsPropagated() throws Exception {
698 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
700 RuntimeException expectedException = new RuntimeException();
701 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
702 when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
706 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
709 } catch (RuntimeException e) {
710 assertEquals(expectedException, e.getCause().getCause());
711 verify(logger).error("Unable to set the onapCsarId property on the VNF", expectedException);
716 * if the VIM info can not be queried the VNF is not instantiated and
717 * error propagated through job
720 public void testFailureInQueryVimInfo() throws Exception {
721 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
722 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
723 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
724 grantResponse.setVimId(VIM_ID);
725 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
726 accessInfo.setTenant(TENANT);
727 grantResponse.setAccessInfo(accessInfo);
729 when(vimInfoProvider.getVimInfo(VIM_ID)).thenThrow(new RuntimeException());
731 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
733 waitForJobToFinishInJobManager(finished);
734 verify(vnfApi, never()).vnfsVnfInstanceIdInstantiatePost(Mockito.any(), Mockito.any(), Mockito.any());
738 * test termination basic success scenario
739 * - the VNF is not deleted before the notifications are processed
742 public void testTerminationAndDeletion() throws Exception {
744 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
745 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
746 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
747 vnfInfo.setOperationExecutions(operationExecutions);
748 VnfProperty vnfdId = new VnfProperty();
749 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
750 vnfdId.setValue(ONAP_CSAR_ID);
751 vnfInfo.getExtensions().add(vnfdId);
752 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
753 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
755 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
756 OperationExecution terminationOperation = new OperationExecution();
757 terminationOperation.setId("terminationId");
758 operationExecutions.add(terminationOperation);
759 terminationOperation.setStatus(OperationStatus.FINISHED);
760 return buildObservable(terminationOperation);
763 when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
764 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
765 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
767 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
769 waitForJobToFinishInJobManager(finished);
770 assertEquals(1, actualTerminationRequest.getAllValues().size());
771 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
772 assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
773 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
774 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
775 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
776 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
777 VOID_OBSERVABLE.assertCalled();
778 verify(jobManager).spawnJob(VNF_ID, restResponse);
779 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
783 * test termination basic success scenario
784 * - the VNF is not deleted before the notifications are processed
787 public void testTermination() throws Exception {
789 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
790 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
791 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
792 vnfInfo.setOperationExecutions(operationExecutions);
793 VnfProperty vnfdId = new VnfProperty();
794 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
795 vnfdId.setValue(ONAP_CSAR_ID);
796 vnfInfo.getExtensions().add(vnfdId);
797 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
798 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
800 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
801 OperationExecution terminationOperation = new OperationExecution();
802 terminationOperation.setId("terminationId");
803 operationExecutions.add(terminationOperation);
804 terminationOperation.setStatus(OperationStatus.FINISHED);
805 return buildObservable(terminationOperation);
808 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
809 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
811 JobInfo jobInfo = lifecycleManager.terminate(VNFM_ID, VNF_ID, terminationRequest, restResponse);
813 waitForJobToFinishInJobManager(finished);
814 assertEquals(1, actualTerminationRequest.getAllValues().size());
815 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
816 assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
817 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
818 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
819 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
820 verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
821 verify(jobManager).spawnJob(VNF_ID, restResponse);
822 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
826 * test termination of a non instantiated VNF
827 * - the VNF is not terminated (only deleted)
830 public void testTerminationOfNonInstantiated() throws Exception {
832 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
833 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
834 vnfInfo.setInstantiationState(InstantiationState.NOT_INSTANTIATED);
835 vnfInfo.setOperationExecutions(operationExecutions);
836 VnfProperty vnfdId = new VnfProperty();
837 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
838 vnfdId.setValue(ONAP_CSAR_ID);
839 vnfInfo.getExtensions().add(vnfdId);
840 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
841 when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
842 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
844 lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
846 boolean deleted = false;
849 verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
854 verify(vfcGrantManager, never()).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
855 verify(notificationManager, never()).waitForTerminationToBeProcessed("terminationId");
856 verify(logger).warn("The VNF with {} identifier is not instantiated no termination is required", VNF_ID);
857 verify(logger).info("Deleting VNF with {} identifier", VNF_ID);
858 verify(logger).info("The VNF with {} identifier has been deleted", VNF_ID);
859 VOID_OBSERVABLE.assertCalled();
863 * test that the VNF deletion is not started before the termination finishes
866 public void testTerminationOperationIsOutwaited() throws Exception {
868 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
869 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
870 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
871 vnfInfo.setOperationExecutions(operationExecutions);
872 VnfProperty vnfdId = new VnfProperty();
873 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
874 vnfdId.setValue(ONAP_CSAR_ID);
875 vnfInfo.getExtensions().add(vnfdId);
876 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
877 OperationExecution terminationOperation = new OperationExecution();
878 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
879 terminationOperation.setId("terminationId");
880 operationExecutions.add(terminationOperation);
881 terminationOperation.setStatus(OperationStatus.STARTED);
882 return buildObservable(terminationOperation);
884 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
885 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
886 Set<Integer> calls = new HashSet<>();
887 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(invocation -> {
888 if (calls.size() == 1000) {
889 terminationOperation.setStatus(OperationStatus.FINISHED);
891 calls.add(calls.size());
892 return buildObservable(operationExecutions);
895 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
897 waitForJobToFinishInJobManager(finished);
898 verify(vnfApi, times(1001)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
899 verify(systemFunctions, times(1000)).sleep(5000);
904 * test that failured during waiting for the operation to finish is tolerated (idefineiatelly)
907 public void testTerminationOperationIsOutwaitedWithErrors() throws Exception {
909 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
910 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
911 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
912 vnfInfo.setOperationExecutions(operationExecutions);
913 VnfProperty vnfdId = new VnfProperty();
914 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
915 vnfdId.setValue(ONAP_CSAR_ID);
916 vnfInfo.getExtensions().add(vnfdId);
917 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
918 OperationExecution terminationOperation = new OperationExecution();
919 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
921 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
922 terminationOperation.setId("terminationId");
923 operationExecutions.add(terminationOperation);
924 terminationOperation.setStatus(OperationStatus.STARTED);
925 return buildObservable(terminationOperation);
928 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
929 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
930 Set<Integer> calls = new HashSet<>();
931 List<RuntimeException> expectedExceptions = new ArrayList<>();
932 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
934 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
935 if (calls.size() >= 100) {
936 terminationOperation.setStatus(OperationStatus.FINISHED);
937 return buildObservable(operationExecutions);
939 calls.add(calls.size());
940 RuntimeException RuntimeException = new RuntimeException();
941 expectedExceptions.add(RuntimeException);
942 throw RuntimeException;
946 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
948 waitForJobToFinishInJobManager(finished);
949 verify(vnfApi, times(101)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
950 verify(systemFunctions, times(100)).sleep(5000);
951 for (RuntimeException expectedException : expectedExceptions) {
952 verify(logger).warn("Unable to retrieve operations details", expectedException);
957 * test gracefull termination
960 public void testGracefullTermination() throws Exception {
962 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
963 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
964 terminationRequest.setTerminationType(VnfTerminationType.GRACEFUL);
965 terminationRequest.setGracefulTerminationTimeout("1234");
966 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
967 vnfInfo.setOperationExecutions(operationExecutions);
968 VnfProperty vnfdId = new VnfProperty();
969 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
970 vnfdId.setValue(ONAP_CSAR_ID);
971 vnfInfo.getExtensions().add(vnfdId);
972 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
973 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
975 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
976 OperationExecution terminationOperation = new OperationExecution();
977 terminationOperation.setId("terminationId");
978 operationExecutions.add(terminationOperation);
979 terminationOperation.setStatus(OperationStatus.FINISHED);
980 return buildObservable(terminationOperation);
983 doAnswer(invocation -> {
984 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
986 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
987 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
988 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
990 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
992 waitForJobToFinishInJobManager(finished);
993 assertEquals(1, actualTerminationRequest.getAllValues().size());
994 assertEquals(TerminationType.GRACEFUL, actualTerminationRequest.getValue().getTerminationType());
995 assertEquals(Integer.valueOf(1234), actualTerminationRequest.getValue().getGracefulTerminationTimeout());
996 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
997 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
998 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
999 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1003 * instantiation with missing ONAP csarId to instantiation extra param result in failure
1006 public void testMissingVnfParameters() throws Exception {
1008 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1009 String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "invalid" + "\" : {}}}, \"vimId\" : \"" + VIM_ID + "\"}";
1010 instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
1013 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
1015 } catch (Exception e) {
1016 assertEquals("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id", e.getMessage());
1017 verify(logger).error("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id");
1022 * test explicit forceful termination
1025 public void testExplicitForcefulTermination() throws Exception {
1027 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1028 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1029 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1030 terminationRequest.setGracefulTerminationTimeout("1234");
1031 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1032 vnfInfo.setOperationExecutions(operationExecutions);
1033 VnfProperty vnfdId = new VnfProperty();
1034 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1035 vnfdId.setValue(ONAP_CSAR_ID);
1036 vnfInfo.getExtensions().add(vnfdId);
1037 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1038 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
1039 OperationExecution terminationOperation = new OperationExecution();
1040 terminationOperation.setId("terminationId");
1041 operationExecutions.add(terminationOperation);
1042 terminationOperation.setStatus(OperationStatus.FINISHED);
1043 return buildObservable(terminationOperation);
1045 doAnswer(invocation -> {
1046 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
1048 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1049 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1050 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1052 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1054 waitForJobToFinishInJobManager(finished);
1055 assertEquals(1, actualTerminationRequest.getAllValues().size());
1056 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1057 assertNull(actualTerminationRequest.getValue().getGracefulTerminationTimeout());
1058 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
1059 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1060 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
1061 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1065 * test failure in the termination workflow finishes the job
1068 public void testFailureInTheTerminationFinishesTheManagedJob() throws Exception {
1070 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1071 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1072 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1073 terminationRequest.setGracefulTerminationTimeout("1234");
1074 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1075 vnfInfo.setOperationExecutions(operationExecutions);
1076 VnfProperty vnfdId = new VnfProperty();
1077 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1078 vnfdId.setValue(ONAP_CSAR_ID);
1079 vnfInfo.getExtensions().add(vnfdId);
1080 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1081 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
1083 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
1084 OperationExecution terminationOperation = new OperationExecution();
1085 terminationOperation.setId("terminationId");
1086 operationExecutions.add(terminationOperation);
1087 terminationOperation.setStatus(OperationStatus.FINISHED);
1088 return terminationOperation;
1091 RuntimeException expectedException = new RuntimeException();
1092 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1093 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1094 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1096 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1098 waitForJobToFinishInJobManager(finished);
1099 assertEquals(0, actualTerminationRequest.getAllValues().size());
1100 Mockito.verifyZeroInteractions(vfcGrantManager);
1104 * if termination fails the VNF is not deleted
1107 public void testFailedTerminationAbortsTerminationWorkflow() throws Exception {
1109 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1110 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1111 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1112 vnfInfo.setOperationExecutions(operationExecutions);
1113 VnfProperty vnfdId = new VnfProperty();
1114 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1115 vnfdId.setValue(ONAP_CSAR_ID);
1116 vnfInfo.getExtensions().add(vnfdId);
1117 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1118 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1120 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1121 OperationExecution terminationOperation = new OperationExecution();
1122 terminationOperation.setId("terminationId");
1123 operationExecutions.add(terminationOperation);
1124 terminationOperation.setStatus(OperationStatus.FAILED);
1125 return buildObservable(terminationOperation);
1128 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1129 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1131 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1133 waitForJobToFinishInJobManager(finished);
1134 assertEquals(1, actualTerminationRequest.getAllValues().size());
1135 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1136 verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1137 verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1138 verify(logger).error("Unable to terminate VNF the operation did not finish with success");
1142 * test VNF query basic success scenario
1145 public void testQuery() throws Exception {
1146 vnfInfo.setDescription("myDescription");
1147 vnfInfo.setName("myName");
1148 vnfInfo.setVnfSoftwareVersion("vnfSoftwareVersion");
1149 vnfInfo.setVnfProvider("myProvider");
1150 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1151 VnfProperty prop = new VnfProperty();
1152 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1153 prop.setValue(ONAP_CSAR_ID);
1154 vnfInfo.getExtensions().add(prop);
1156 org.onap.vnfmdriver.model.VnfInfo vnf = lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1158 assertEquals(VNF_ID, vnf.getVnfInstanceId());
1159 //FIXME ? (do not know what exactly the vnf version mean in core terminology)
1160 assertEquals("vnfSoftwareVersion", vnf.getVersion());
1161 assertEquals(ONAP_CSAR_ID, vnf.getVnfdId());
1162 assertEquals("myDescription", vnf.getVnfInstanceDescription());
1163 assertEquals("myName", vnf.getVnfInstanceName());
1164 assertEquals(ONAP_CSAR_ID, vnf.getVnfPackageId());
1165 assertEquals("myProvider", vnf.getVnfProvider());
1166 //FIXME (in swagger schema )
1167 assertEquals("ACTIVE", vnf.getVnfStatus());
1168 assertEquals("Kuku", vnf.getVnfType());
1172 * error is propagated and logged if the queried VNF does not exist
1175 public void testQueryForNonExistingVnf() throws Exception {
1177 RuntimeException expectedException = new RuntimeException();
1178 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1181 lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1184 } catch (Exception e) {
1185 verify(logger).error("Unable to query VNF (myVnfId)", expectedException);
1186 assertEquals(expectedException, e.getCause());
1191 * test scale basic scenario
1194 public void testScale() throws Exception {
1195 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1196 scaleRequest.setNumberOfSteps("2");
1197 scaleRequest.setAspectId("myAspect");
1198 scaleRequest.setType(ScaleDirection.IN);
1199 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }"));
1200 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1201 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1202 VnfProperty prop = new VnfProperty();
1203 prop.setValue(ONAP_CSAR_ID);
1204 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1205 vnfInfo.getExtensions().add(prop);
1206 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1207 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1208 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1210 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1212 waitForJobToFinishInJobManager(finished);
1213 assertEquals(1, actualScaleRequest.getAllValues().size());
1214 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1215 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1216 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1217 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1218 assertEquals("myAspect", sRequest.getAspectId());
1219 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1220 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1221 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1222 verify(jobManager).spawnJob(VNF_ID, restResponse);
1223 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("scale"), eq(VNF_ID), anyString());
1228 * the VNFM should tolerate that no additional params were supplied
1231 public void testScaleWithoutAddtionalParams() throws Exception {
1232 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1233 scaleRequest.setNumberOfSteps("2");
1234 scaleRequest.setAspectId("myAspect");
1235 scaleRequest.setType(ScaleDirection.IN);
1236 scaleRequest.setAdditionalParam(null);
1237 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1238 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1239 VnfProperty prop = new VnfProperty();
1240 prop.setValue(ONAP_CSAR_ID);
1241 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1242 vnfInfo.getExtensions().add(prop);
1243 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1244 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1245 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1247 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1249 waitForJobToFinishInJobManager(finished);
1250 assertEquals(1, actualScaleRequest.getAllValues().size());
1251 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1252 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1253 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1254 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1255 assertEquals("myAspect", sRequest.getAspectId());
1256 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1257 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1258 assertEquals("{\"jobId\":\"myJobId\"}", new Gson().toJson(sRequest.getAdditionalParams()));
1259 verify(jobManager).spawnJob(VNF_ID, restResponse);
1263 * test scale out basic scenario
1266 public void testScaleOut() throws Exception {
1267 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1268 scaleRequest.setNumberOfSteps("2");
1269 scaleRequest.setAspectId("myAspect");
1270 scaleRequest.setType(ScaleDirection.OUT);
1271 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1272 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1273 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1274 VnfProperty prop = new VnfProperty();
1275 prop.setValue(ONAP_CSAR_ID);
1276 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1277 vnfInfo.getExtensions().add(prop);
1278 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1279 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1280 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1282 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1284 waitForJobToFinishInJobManager(finished);
1285 assertEquals(1, actualScaleRequest.getAllValues().size());
1286 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1287 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1288 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1289 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1290 assertEquals("myAspect", sRequest.getAspectId());
1291 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.OUT, sRequest.getType());
1292 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1293 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1297 * test scale operation is out waited
1300 public void testScaleOutwait() throws Exception {
1301 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1302 scaleRequest.setNumberOfSteps("2");
1303 scaleRequest.setAspectId("myAspect");
1304 scaleRequest.setType(ScaleDirection.IN);
1305 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1306 scaleOperationExecution.setStatus(OperationStatus.STARTED);
1307 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1308 VnfProperty prop = new VnfProperty();
1309 prop.setValue(ONAP_CSAR_ID);
1310 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1311 vnfInfo.getExtensions().add(prop);
1312 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1313 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1314 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1315 List<RuntimeException> expectedExceptions = new ArrayList<>();
1316 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<Observable<List<OperationExecution>>>) invocation -> {
1317 if (expectedExceptions.size() >= 100) {
1318 when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(scaleOperationExecution));
1319 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1320 return buildObservable(operationExecutions);
1322 RuntimeException RuntimeException = new RuntimeException();
1323 expectedExceptions.add(RuntimeException);
1324 throw RuntimeException;
1328 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1330 waitForJobToFinishInJobManager(finished);
1331 assertEquals(100, expectedExceptions.size());
1332 for (RuntimeException expectedException : expectedExceptions) {
1333 verify(logger).warn("Unable to retrieve operations details", expectedException);
1335 verify(systemFunctions, times(100)).sleep(5000);
1339 * test scale failure propagation
1342 public void testScaleFailurePropagation() throws Exception {
1343 RuntimeException expectedException = new RuntimeException();
1344 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1345 scaleRequest.setNumberOfSteps("2");
1346 scaleRequest.setAspectId("myAspect");
1347 scaleRequest.setType(ScaleDirection.IN);
1348 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1350 lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1352 waitForJobToFinishInJobManager(finished);
1353 verify(logger).error("Unable to scale VNF with myVnfId identifier", expectedException);
1357 * test heal basic scenario
1360 public void testHeal() throws Exception {
1361 VnfHealRequest healRequest = new VnfHealRequest();
1362 healRequest.setAction("myAction");
1363 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1364 affectedVm.setVmname("vmName");
1365 healRequest.setAffectedvm(affectedVm);
1366 healOperationExecution.setStatus(OperationStatus.FINISHED);
1367 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1368 VnfProperty prop = new VnfProperty();
1369 prop.setValue(ONAP_CSAR_ID);
1370 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1371 vnfInfo.getExtensions().add(prop);
1372 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1373 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1374 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1376 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1378 waitForJobToFinishInJobManager(finished);
1379 assertEquals(1, actualHealRequest.getAllValues().size());
1380 HealVnfRequest sRequest = actualHealRequest.getValue();
1381 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1382 workflowOrder.verify(vfcGrantManager).requestGrantForHeal(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(healRequest), eq(JOB_ID));
1383 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdHealPost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1384 JsonObject root = new Gson().toJsonTree(sRequest.getAdditionalParams()).getAsJsonObject();
1385 assertEquals("myAction", root.get("action").getAsString());
1386 assertEquals("vmName", root.get("vmName").getAsString());
1387 assertEquals(JOB_ID, root.get("jobId").getAsString());
1388 verify(jobManager).spawnJob(VNF_ID, restResponse);
1389 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("heal"), eq(VNF_ID), anyString());
1393 * test heal operation is out waited
1396 public void testHealOutwait() throws Exception {
1397 VnfHealRequest healRequest = new VnfHealRequest();
1398 healRequest.setAction("myAction");
1399 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1400 affectedVm.setVmname("vmName");
1401 healRequest.setAffectedvm(affectedVm);
1402 healOperationExecution.setStatus(OperationStatus.FINISHED);
1403 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1404 VnfProperty prop = new VnfProperty();
1405 prop.setValue(ONAP_CSAR_ID);
1406 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1407 vnfInfo.getExtensions().add(prop);
1408 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1409 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1410 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1411 List<RuntimeException> expectedExceptions = new ArrayList<>();
1412 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
1414 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
1415 if (expectedExceptions.size() >= 100) {
1416 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1417 return buildObservable(operationExecutions);
1419 RuntimeException RuntimeException = new RuntimeException();
1420 expectedExceptions.add(RuntimeException);
1421 throw RuntimeException;
1425 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1427 waitForJobToFinishInJobManager(finished);
1428 assertEquals(100, expectedExceptions.size());
1429 for (RuntimeException expectedException : expectedExceptions) {
1430 verify(logger).warn("Unable to retrieve operations details", expectedException);
1432 verify(systemFunctions, times(100)).sleep(5000);
1436 * failure in heal propagates in error
1439 public void testHealFailurePropagation() throws Exception {
1440 RuntimeException expectedException = new RuntimeException();
1441 VnfHealRequest healRequest = new VnfHealRequest();
1442 healRequest.setAction("myAction");
1443 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1444 affectedVm.setVmname("vmName");
1445 healRequest.setAffectedvm(affectedVm);
1446 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1448 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1450 waitForJobToFinishInJobManager(finished);
1451 verify(logger).error("Unable to heal VNF with myVnfId identifier", expectedException);
1456 * test custom operation basic scenario
1459 public void testCustomOperation() throws Exception {
1460 String operationId = "operationIdCaptor";
1461 Object additionalParams = new JsonObject();
1463 JobInfo job = lifecycleManager.customOperation(VNFM_ID, VNF_ID, operationId, additionalParams, restResponse);
1465 waitForJobToFinishInJobManager(finished);
1466 assertEquals(operationId, operationIdCaptor.getValue());
1467 assertEquals(additionalParams, customOperationRequestArgumentCaptor.getValue().getAdditionalParams());
1470 private void waitForJobToFinishInJobManager(Set<Boolean> finished) throws InterruptedException {
1471 while (finished.size() == 0) {
1472 systemFunctions().sleep(100);
1476 private VnfInstantiateRequest prepareInstantiationRequest(VimInfo.VimInfoTypeEnum cloudType) {
1477 VnfInstantiateRequest instantiationRequest = new VnfInstantiateRequest();
1478 instantiationRequest.setVnfPackageId(ONAP_CSAR_ID);
1479 instantiationRequest.setVnfDescriptorId(ONAP_CSAR_ID);
1480 instantiationRequest.setVnfInstanceDescription("myDescription");
1481 instantiationRequest.setVnfInstanceName("vnfName");
1482 additionalParam.setInstantiationLevel("level1");
1483 switch (cloudType) {
1484 case OPENSTACK_V2_INFO:
1485 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1487 case OPENSTACK_V3_INFO:
1488 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
1489 vimInfo.setDomain("myDomain");
1491 case VMWARE_VCLOUD_INFO:
1492 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
1495 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
1498 Map<String, List<NetworkAddress>> exteranalConnectionPointAddresses = new HashMap<>();
1499 exteranalConnectionPointAddresses.put("ecp1", new ArrayList<>());
1500 NetworkAddress networkAddress = new NetworkAddress();
1501 networkAddress.setIp("1.2.3.4");
1502 networkAddress.setMac("mac");
1503 networkAddress.setSubnetId("subnetId");
1504 exteranalConnectionPointAddresses.get("ecp1").add(networkAddress);
1505 additionalParam.setExternalConnectionPointAddresses(exteranalConnectionPointAddresses);
1506 VimComputeResourceFlavour flavor = new VimComputeResourceFlavour();
1507 flavor.setResourceId("flavourProviderId");
1508 flavor.setVimId(VIM_ID);
1509 flavor.setVnfdVirtualComputeDescId("virtualComputeDescId");
1510 additionalParam.getComputeResourceFlavours().add(flavor);
1511 ExtVirtualLinkData evl = new ExtVirtualLinkData();
1512 evl.setResourceId("networkProviderId1");
1513 evl.setVimId(VIM_ID);
1514 evl.setExtVirtualLinkId("evlId1");
1515 VnfExtCpData ecp2 = new VnfExtCpData();
1516 ecp2.setCpdId("cpdId3");
1517 ecp2.setAddresses(new ArrayList<>());
1518 ecp2.getAddresses().add(networkAddress);
1519 ecp2.setNumDynamicAddresses(2);
1520 evl.getExtCps().add(ecp2);
1521 additionalParam.getExtVirtualLinks().add(evl);
1522 externalVirtualLink.setCpdId("myCpdId");
1523 externalVirtualLink.setResourceId("myNetworkProviderId");
1524 externalVirtualLink.setVlInstanceId("myEVlId");
1525 externalVirtualLink.setResourceSubnetId("notUsedSubnetId");
1526 instantiationRequest.setExtVirtualLink(new ArrayList<>());
1527 instantiationRequest.getExtVirtualLink().add(externalVirtualLink);
1528 additionalParam.getExtManagedVirtualLinks().add(extManVl);
1529 ZoneInfo zone = new ZoneInfo();
1530 zone.setId("zoneId");
1531 zone.setResourceId("zoneProviderId");
1532 zone.setVimId(VIM_ID);
1533 additionalParam.getZones().add(zone);
1534 VimSoftwareImage image = new VimSoftwareImage();
1535 image.setResourceId("imageProviderId");
1536 image.setVimId(VIM_ID);
1537 image.setVnfdSoftwareImageId("imageId");
1538 additionalParam.getSoftwareImages().add(image);
1539 additionalParam.setAdditionalParams(new JsonParser().parse("{ \"a\" : \"b\" }"));
1540 String params = new Gson().toJson(additionalParam);
1541 String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "\" : " + params + "}}, \"vimId\" : \"" + VIM_ID + "\"}";
1542 instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
1543 return instantiationRequest;
1547 * Test vimId decomposition
1550 public void testVimIdSplitting() {
1551 assertEquals("regionId", LifecycleManager.getRegionName("cloudOwner_regionId"));
1552 assertEquals("cloudOwner", LifecycleManager.getCloudOwner("cloudOwner_regionId"));