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.*;
19 import com.google.gson.annotations.SerializedName;
20 import com.nokia.cbam.catalog.v1.model.CatalogAdapterVnfpackage;
21 import com.nokia.cbam.lcm.v32.model.*;
22 import com.nokia.cbam.lcm.v32.model.OperationType;
23 import com.nokia.cbam.lcm.v32.model.VimInfo;
24 import com.nokia.cbam.lcm.v32.model.VnfInfo;
25 import io.reactivex.Observable;
26 import java.nio.file.Paths;
28 import javax.servlet.http.HttpServletResponse;
29 import org.junit.Before;
30 import org.junit.Test;
31 import org.mockito.ArgumentCaptor;
32 import org.mockito.InOrder;
33 import org.mockito.Mock;
34 import org.mockito.Mockito;
35 import org.mockito.invocation.InvocationOnMock;
36 import org.mockito.stubbing.Answer;
37 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VimInfoProvider;
38 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.TestVfcGrantManager;
39 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.VfcGrantManager;
40 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.StoreLoader;
41 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.LifecycleChangeNotificationManager;
42 import org.onap.vnfmdriver.model.ExtVirtualLinkInfo;
43 import org.onap.vnfmdriver.model.*;
44 import org.onap.vnfmdriver.model.ScaleDirection;
45 import org.threeten.bp.OffsetDateTime;
47 import static java.lang.Boolean.parseBoolean;
48 import static java.nio.file.Files.readAllBytes;
49 import static java.util.Optional.empty;
51 import static junit.framework.TestCase.*;
52 import static org.mockito.Mockito.*;
53 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.child;
54 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.childElement;
55 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions.systemFunctions;
56 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
57 import static org.springframework.test.util.ReflectionTestUtils.setField;
59 public class TestLifecycleManager extends TestBase {
60 public static final String JOB_ID = "myJobId";
61 public static final String CBAM_VNFD_ID = "cbamVnfdId";
62 public static final String TENANT = "myTenant";
63 public static final String OPERATION_EXECUTION_ID = "operationExecutionId";
64 private static final String ONAP_CSAR_ID = "myOnapCsarId";
65 private static final String VIM_ID = "ownerId_regionId";
67 private CatalogManager catalogManager;
69 private VfcGrantManager vfcGrantManager;
71 private JobManager jobManager;
73 private LifecycleChangeNotificationManager notificationManager;
75 private HttpServletResponse restResponse;
77 private VimInfoProvider vimInfoProvider;
79 private ArgumentCaptor<CreateVnfRequest> createRequest = ArgumentCaptor.forClass(CreateVnfRequest.class);
80 private AdditionalParameters additionalParam = new AdditionalParameters();
81 private String INSTANTIATION_LEVEL = "level1";
82 private GrantVNFResponseVim grantResponse = new GrantVNFResponseVim();
83 private String cbamVnfdContent;
84 private OperationExecution instantiationOperationExecution = new OperationExecution();
85 private OperationExecution modifyPropertyoperationExecution = new OperationExecution();
86 private OperationExecution scaleOperationExecution = new OperationExecution();
87 private OperationExecution healOperationExecution = new OperationExecution();
88 private OperationExecution customOperationExecution = new OperationExecution();
91 private VnfInfo vnfInfo = new VnfInfo();
92 private List<OperationExecution> operationExecutions = new ArrayList<>();
93 private org.onap.vnfmdriver.model.VimInfo vimInfo = new org.onap.vnfmdriver.model.VimInfo();
94 private ExtVirtualLinkInfo externalVirtualLink = new ExtVirtualLinkInfo();
95 private ExtManagedVirtualLinkData extManVl = new ExtManagedVirtualLinkData();
96 private ArgumentCaptor<ModifyVnfInfoRequest> actualVnfModifyRequest = ArgumentCaptor.forClass(ModifyVnfInfoRequest.class);
97 private Set<Boolean> finished = new HashSet<>();
98 private ArgumentCaptor<ScaleVnfRequest> actualScaleRequest = ArgumentCaptor.forClass(ScaleVnfRequest.class);
99 private ArgumentCaptor<HealVnfRequest> actualHealRequest = ArgumentCaptor.forClass(HealVnfRequest.class);
100 private ArgumentCaptor<CustomOperationRequest> customOperationRequestArgumentCaptor = ArgumentCaptor.forClass(CustomOperationRequest.class);
101 private ArgumentCaptor<String> operationIdCaptor = ArgumentCaptor.forClass(String.class);
103 private LifecycleManager lifecycleManager;
106 public void initMocks() throws Exception {
107 vnfInfo.setExtensions(new ArrayList<>());
108 vnfInfo.setOperationExecutions(new ArrayList<>());
109 lifecycleManager = new LifecycleManager(catalogManager, vfcGrantManager, cbamRestApiProvider, vimInfoProvider, jobManager, notificationManager);
110 cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.full.yaml").toURI())));
111 setField(LifecycleManager.class, "logger", logger);
112 CatalogAdapterVnfpackage cbamPackage = new CatalogAdapterVnfpackage();
113 when(catalogManager.preparePackageInCbam(VNFM_ID, ONAP_CSAR_ID)).thenReturn(cbamPackage);
114 cbamPackage.setVnfdId(CBAM_VNFD_ID);
115 vnfInfo.setVnfdId(CBAM_VNFD_ID);
116 vnfInfo.setId(VNF_ID);
117 when(jobManager.spawnJob(VNF_ID, restResponse)).thenReturn(JOB_ID);
118 when(catalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent);
119 cbamPackage.setId(CBAM_VNFD_ID);
120 vimInfo.setUrl("cloudUrl");
121 vimInfo.setPassword("vimPassword");
122 vimInfo.setUserName("vimUsername");
123 vimInfo.setSslInsecure("true");
124 vimInfo.setVimId(VIM_ID);
125 vimInfo.setName("vimName");
126 when(vimInfoProvider.getVimInfo((VIM_ID))).thenReturn(vimInfo);
127 instantiationOperationExecution.setId(OPERATION_EXECUTION_ID);
128 instantiationOperationExecution.setOperationType(OperationType.INSTANTIATE);
129 instantiationOperationExecution.setStartTime(OffsetDateTime.now());
130 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecutions));
131 operationExecutions.add(modifyPropertyoperationExecution);
132 modifyPropertyoperationExecution.setStartTime(OffsetDateTime.now());
133 modifyPropertyoperationExecution.setOperationType(OperationType.MODIFY_INFO);
134 operationExecutions.add(instantiationOperationExecution);
135 instantiationOperationExecution.setStatus(OperationStatus.FINISHED);
136 modifyPropertyoperationExecution.setStatus(OperationStatus.FINISHED);
137 customOperationExecution.setStatus(OperationStatus.FINISHED);
138 modifyPropertyoperationExecution.setId(UUID.randomUUID().toString());
139 scaleOperationExecution.setId(UUID.randomUUID().toString());
140 healOperationExecution.setId(UUID.randomUUID().toString());
141 customOperationExecution.setId(UUID.randomUUID().toString());
143 when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(modifyPropertyoperationExecution));
144 doAnswer(new Answer() {
146 public Object answer(InvocationOnMock invocation) throws Throwable {
147 finished.add(Boolean.TRUE);
150 }).when(jobManager).jobFinished(JOB_ID);
151 when(vnfApi.vnfsVnfInstanceIdScalePost(eq(VNF_ID), actualScaleRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
153 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
154 operationExecutions.add(scaleOperationExecution);
155 return buildObservable(scaleOperationExecution);
158 when(vnfApi.vnfsVnfInstanceIdHealPost(eq(VNF_ID), actualHealRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
160 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
161 operationExecutions.add(healOperationExecution);
162 return buildObservable(healOperationExecution);
165 when(vnfApi.vnfsVnfInstanceIdCustomCustomOperationNamePost(eq(VNF_ID), operationIdCaptor.capture(), customOperationRequestArgumentCaptor.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
167 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
168 operationExecutions.add(customOperationExecution);
169 return buildObservable(customOperationExecution);
178 public void testInstantiation() throws Exception {
180 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
182 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
183 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
184 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
185 grantResponse.setVimId(VIM_ID);
186 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
187 accessInfo.setTenant(TENANT);
188 grantResponse.setAccessInfo(accessInfo);
189 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
190 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
192 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
193 waitForJobToFinishInJobManager(finished);
195 assertEquals(VNF_ID, response.getVnfInstanceId());
196 assertEquals(JOB_ID, response.getJobId());
197 assertEquals(createRequest.getAllValues().size(), 1);
198 assertEquals("myDescription", createRequest.getValue().getDescription());
199 assertEquals("vnfName", createRequest.getValue().getName());
200 assertEquals(CBAM_VNFD_ID, createRequest.getValue().getVnfdId());
201 assertEquals(1, actualInstantiationRequest.getAllValues().size());
202 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
203 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
204 assertEquals(VIM_ID, actualVim.getId());
205 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, actualVim.getVimInfoType());
206 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
207 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
208 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
209 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
210 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
211 assertEquals("myTenant", actualVim.getAccessInfo().getTenant());
212 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
213 assertEquals(1, actualInstantiationRequest.getValue().getComputeResourceFlavours().size());
214 assertEquals("flavourProviderId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getResourceId());
215 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVimId());
216 assertEquals("virtualComputeDescId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVnfdVirtualComputeDescId());
217 assertEquals(1, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().size());
218 assertEquals(extManVl, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().get(0));
219 assertEquals(2, actualInstantiationRequest.getValue().getExtVirtualLinks().size());
221 assertEquals("myNetworkProviderId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getResourceId());
222 assertEquals("myEVlId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtVirtualLinkId());
223 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().size());
224 assertEquals("myCpdId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().get(0).getCpdId());
226 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getVimId());
227 assertEquals("evlId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtVirtualLinkId());
228 assertEquals("networkProviderId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getResourceId());
229 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().size());
232 assertEquals(Integer.valueOf(2), actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getNumDynamicAddresses());
233 assertEquals("cpdId3", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getCpdId());
234 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().size());
235 assertEquals("1.2.3.4", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getIp());
236 assertEquals("mac", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getMac());
237 assertEquals("subnetId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getSubnetId());
239 assertEquals("myFlavorId", actualInstantiationRequest.getValue().getFlavourId());
240 assertEquals(Boolean.TRUE, actualInstantiationRequest.getValue().isGrantlessMode());
241 assertEquals("level1", actualInstantiationRequest.getValue().getInstantiationLevelId());
242 assertEquals(1, actualInstantiationRequest.getValue().getZones().size());
243 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getZones().get(0).getVimId());
244 assertEquals("zoneProviderId", actualInstantiationRequest.getValue().getZones().get(0).getResourceId());
245 assertEquals("zoneId", actualInstantiationRequest.getValue().getZones().get(0).getId());
246 assertEquals(1, actualInstantiationRequest.getValue().getSoftwareImages().size());
247 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVimId());
248 assertEquals("imageProviderId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getResourceId());
249 assertEquals("imageId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVnfdSoftwareImageId());
250 String actualEmbeddedAdditionParams = new Gson().toJson(actualInstantiationRequest.getValue().getAdditionalParams());
251 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(actualEmbeddedAdditionParams) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(actualEmbeddedAdditionParams));
252 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
253 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
255 assertEquals(1, actualVnfModifyRequest.getAllValues().size());
256 assertEquals(2, actualVnfModifyRequest.getValue().getExtensions().size());
257 assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getName());
258 assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getValue());
259 assertEquals(LifecycleManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName());
260 assertEquals(VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getValue());
262 //the 3.2 API does not accept empty array
263 assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties());
264 verify(jobManager).spawnJob(VNF_ID, restResponse);
265 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
266 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
270 * invalid VIM type results in failure
273 public void testInstantiationWithInvalidVimType() throws Exception {
275 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
276 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
277 when(logger.isInfoEnabled()).thenReturn(false);
280 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
283 } catch (Exception e) {
284 assertEquals("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types", e.getMessage());
286 verify(vnfApi, never()).vnfsPost(Mockito.any(), Mockito.any());
287 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
288 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
289 verify(logger).error("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types");
293 * test instantiation with KeyStone V2 based with SSL
296 public void testInstantiationV2WithSsl() throws Exception {
297 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
298 when(logger.isInfoEnabled()).thenReturn(false);
299 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
300 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
301 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
302 grantResponse.setVimId(VIM_ID);
303 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
304 accessInfo.setTenant(TENANT);
305 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
306 vimInfo.setSslInsecure("false");
307 vimInfo.setSslCacert(caCert);
308 grantResponse.setAccessInfo(accessInfo);
309 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
310 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
311 JsonObject inputs = child((JsonObject) instantiationRequest.getAdditionalParam(), "inputs");
312 JsonObject vnf = new JsonParser().parse(childElement(inputs, ONAP_CSAR_ID).getAsString()).getAsJsonObject();
313 vnf.remove("additionalParams");
314 inputs.add(ONAP_CSAR_ID, new JsonPrimitive(new Gson().toJson(vnf)));
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 public static class X{
1656 public Map<String, String> getInputs() {
1660 public void setInputs(Map<String, String> inputs) {
1661 this.inputs = inputs;
1664 @SerializedName("inputs")
1665 public Map<String,String> inputs = new HashMap<String,String>();
1667 public String vimId;
1670 private VnfInstantiateRequest prepareInstantiationRequest(VimInfo.VimInfoTypeEnum cloudType) {
1671 VnfInstantiateRequest instantiationRequest = new VnfInstantiateRequest();
1672 instantiationRequest.setVnfPackageId(ONAP_CSAR_ID);
1673 instantiationRequest.setVnfDescriptorId(ONAP_CSAR_ID);
1674 instantiationRequest.setVnfInstanceDescription("myDescription");
1675 instantiationRequest.setVnfInstanceName("vnfName");
1676 additionalParam.setInstantiationLevel("level1");
1677 switch (cloudType) {
1678 case OPENSTACK_V2_INFO:
1679 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1681 case OPENSTACK_V3_INFO:
1682 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
1683 vimInfo.setDomain("myDomain");
1685 case VMWARE_VCLOUD_INFO:
1686 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
1689 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
1692 Map<String, List<NetworkAddress>> exteranalConnectionPointAddresses = new HashMap<>();
1693 exteranalConnectionPointAddresses.put("ecp1", new ArrayList<>());
1694 NetworkAddress networkAddress = new NetworkAddress();
1695 networkAddress.setIp("1.2.3.4");
1696 networkAddress.setMac("mac");
1697 networkAddress.setSubnetId("subnetId");
1698 exteranalConnectionPointAddresses.get("ecp1").add(networkAddress);
1699 additionalParam.setExternalConnectionPointAddresses(exteranalConnectionPointAddresses);
1700 VimComputeResourceFlavour flavor = new VimComputeResourceFlavour();
1701 flavor.setResourceId("flavourProviderId");
1702 flavor.setVimId(VIM_ID);
1703 flavor.setVnfdVirtualComputeDescId("virtualComputeDescId");
1704 additionalParam.getComputeResourceFlavours().add(flavor);
1705 ExtVirtualLinkData evl = new ExtVirtualLinkData();
1706 evl.setResourceId("networkProviderId1");
1707 evl.setVimId(VIM_ID);
1708 evl.setExtVirtualLinkId("evlId1");
1709 VnfExtCpData ecp2 = new VnfExtCpData();
1710 ecp2.setCpdId("cpdId3");
1711 ecp2.setAddresses(new ArrayList<>());
1712 ecp2.getAddresses().add(networkAddress);
1713 ecp2.setNumDynamicAddresses(2);
1714 evl.getExtCps().add(ecp2);
1715 additionalParam.getExtVirtualLinks().add(evl);
1716 externalVirtualLink.setCpdId("myCpdId");
1717 externalVirtualLink.setResourceId("myNetworkProviderId");
1718 externalVirtualLink.setVlInstanceId("myEVlId");
1719 externalVirtualLink.setResourceSubnetId("notUsedSubnetId");
1720 instantiationRequest.setExtVirtualLink(new ArrayList<>());
1721 instantiationRequest.getExtVirtualLink().add(externalVirtualLink);
1722 additionalParam.getExtManagedVirtualLinks().add(extManVl);
1723 ZoneInfo zone = new ZoneInfo();
1724 zone.setId("zoneId");
1725 zone.setResourceId("zoneProviderId");
1726 zone.setVimId(VIM_ID);
1727 additionalParam.getZones().add(zone);
1728 VimSoftwareImage image = new VimSoftwareImage();
1729 image.setResourceId("imageProviderId");
1730 image.setVimId(VIM_ID);
1731 image.setVnfdSoftwareImageId("imageId");
1732 additionalParam.getSoftwareImages().add(image);
1733 additionalParam.setAdditionalParams(new JsonParser().parse("{ \"a\" : \"b\" }"));
1734 String params = new Gson().toJson(additionalParam);
1736 x.inputs.put(ONAP_CSAR_ID, params);
1738 JsonElement additionalParam = new Gson().toJsonTree(x);
1739 instantiationRequest.setAdditionalParam(additionalParam);
1740 return instantiationRequest;
1744 * Test vimId decomposition
1747 public void testVimIdSplitting() {
1748 assertEquals("regionId", LifecycleManager.getRegionName("cloudOwner_regionId"));
1749 assertEquals("cloudOwner", LifecycleManager.getCloudOwner("cloudOwner_regionId"));