2 * Copyright 2016-2017, Nokia Corporation
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
16 package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
18 import com.google.gson.Gson;
19 import com.google.gson.JsonElement;
20 import com.google.gson.JsonObject;
21 import com.google.gson.JsonParser;
22 import com.nokia.cbam.catalog.v1.model.CatalogAdapterVnfpackage;
23 import com.nokia.cbam.lcm.v32.model.*;
24 import com.nokia.cbam.lcm.v32.model.OperationType;
25 import com.nokia.cbam.lcm.v32.model.VimInfo;
26 import com.nokia.cbam.lcm.v32.model.VnfInfo;
27 import io.reactivex.Observable;
28 import java.nio.file.Paths;
30 import javax.servlet.http.HttpServletResponse;
31 import org.junit.Before;
32 import org.junit.Test;
33 import org.mockito.ArgumentCaptor;
34 import org.mockito.InOrder;
35 import org.mockito.Mock;
36 import org.mockito.Mockito;
37 import org.mockito.invocation.InvocationOnMock;
38 import org.mockito.stubbing.Answer;
39 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VimInfoProvider;
40 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.TestVfcGrantManager;
41 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.VfcGrantManager;
42 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.StoreLoader;
43 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.LifecycleChangeNotificationManager;
44 import org.onap.vnfmdriver.model.ExtVirtualLinkInfo;
45 import org.onap.vnfmdriver.model.*;
46 import org.onap.vnfmdriver.model.ScaleDirection;
47 import org.threeten.bp.OffsetDateTime;
49 import static java.lang.Boolean.parseBoolean;
50 import static java.nio.file.Files.readAllBytes;
51 import static java.util.Optional.empty;
53 import static junit.framework.TestCase.*;
54 import static org.mockito.Matchers.eq;
55 import static org.mockito.Mockito.*;
56 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.child;
57 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions.systemFunctions;
58 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
59 import static org.springframework.test.util.ReflectionTestUtils.setField;
61 public class TestLifecycleManager extends TestBase {
62 public static final String JOB_ID = "myJobId";
63 public static final String CBAM_VNFD_ID = "cbamVnfdId";
64 public static final String TENANT = "myTenant";
65 public static final String OPERATION_EXECUTION_ID = "operationExecutionId";
66 private static final String ONAP_CSAR_ID = "myOnapCsarId";
67 private static final String VIM_ID = "ownerId_regionId";
68 private GrantVNFResponseVim vim = new GrantVNFResponseVim();
70 private CatalogManager catalogManager;
72 private VfcGrantManager vfcGrantManager;
74 private CbamTokenProvider tokenProvider;
76 private JobManager jobManager;
78 private LifecycleChangeNotificationManager notificationManager;
80 private HttpServletResponse restResponse;
82 private VimInfoProvider vimInfoProvider;
84 private ArgumentCaptor<CreateVnfRequest> createRequest = ArgumentCaptor.forClass(CreateVnfRequest.class);
85 private AdditionalParameters additionalParam = new AdditionalParameters();
86 private String INSTANTIATION_LEVEL = "level1";
87 private GrantVNFResponseVim grantResponse = new GrantVNFResponseVim();
88 private String cbamVnfdContent;
89 private OperationExecution instantiationOperationExecution = new OperationExecution();
90 private OperationExecution modifyPropertyoperationExecution = new OperationExecution();
91 private OperationExecution scaleOperationExecution = new OperationExecution();
92 private OperationExecution healOperationExecution = new OperationExecution();
94 private VnfInfo vnfInfo = new VnfInfo();
95 private List<OperationExecution> operationExecutions = new ArrayList<>();
96 private org.onap.vnfmdriver.model.VimInfo vimInfo = new org.onap.vnfmdriver.model.VimInfo();
97 private ExtVirtualLinkInfo externalVirtualLink = new ExtVirtualLinkInfo();
98 private ExtManagedVirtualLinkData extManVl = new ExtManagedVirtualLinkData();
99 private ArgumentCaptor<ModifyVnfInfoRequest> actualVnfModifyRequest = ArgumentCaptor.forClass(ModifyVnfInfoRequest.class);
100 private Set<Boolean> finished = new HashSet<>();
101 private ArgumentCaptor<ScaleVnfRequest> actualScaleRequest = ArgumentCaptor.forClass(ScaleVnfRequest.class);
102 private ArgumentCaptor<HealVnfRequest> actualHealRequest = ArgumentCaptor.forClass(HealVnfRequest.class);
104 private LifecycleManager lifecycleManager;
107 public void initMocks() throws Exception {
108 vnfInfo.setExtensions(new ArrayList<>());
109 vnfInfo.setOperationExecutions(new ArrayList<>());
110 lifecycleManager = new LifecycleManager(catalogManager, vfcGrantManager, cbamRestApiProvider, vimInfoProvider, jobManager, notificationManager);
111 cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.full.yaml").toURI())));
112 setField(LifecycleManager.class, "logger", logger);
113 CatalogAdapterVnfpackage cbamPackage = new CatalogAdapterVnfpackage();
114 when(catalogManager.preparePackageInCbam(VNFM_ID, ONAP_CSAR_ID)).thenReturn(cbamPackage);
115 cbamPackage.setVnfdId(CBAM_VNFD_ID);
116 vnfInfo.setVnfdId(CBAM_VNFD_ID);
117 vnfInfo.setId(VNF_ID);
118 when(jobManager.spawnJob(VNF_ID, restResponse)).thenReturn(JOB_ID);
119 when(catalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent);
120 cbamPackage.setId(CBAM_VNFD_ID);
121 vimInfo.setUrl("cloudUrl");
122 vimInfo.setPassword("vimPassword");
123 vimInfo.setUserName("vimUsername");
124 vimInfo.setSslInsecure("true");
125 vimInfo.setVimId(VIM_ID);
126 vimInfo.setName("vimName");
127 when(vimInfoProvider.getVimInfo((VIM_ID))).thenReturn(vimInfo);
128 instantiationOperationExecution.setId(OPERATION_EXECUTION_ID);
129 instantiationOperationExecution.setOperationType(OperationType.INSTANTIATE);
130 instantiationOperationExecution.setStartTime(OffsetDateTime.now());
131 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecutions));
132 operationExecutions.add(modifyPropertyoperationExecution);
133 modifyPropertyoperationExecution.setStartTime(OffsetDateTime.now());
134 modifyPropertyoperationExecution.setOperationType(OperationType.MODIFY_INFO);
135 operationExecutions.add(instantiationOperationExecution);
136 instantiationOperationExecution.setStatus(OperationStatus.FINISHED);
137 modifyPropertyoperationExecution.setStatus(OperationStatus.FINISHED);
138 modifyPropertyoperationExecution.setId(UUID.randomUUID().toString());
139 scaleOperationExecution.setId(UUID.randomUUID().toString());
140 healOperationExecution.setId(UUID.randomUUID().toString());
141 when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(modifyPropertyoperationExecution));
142 doAnswer(new Answer() {
144 public Object answer(InvocationOnMock invocation) throws Throwable {
145 finished.add(Boolean.TRUE);
148 }).when(jobManager).jobFinished(JOB_ID);
149 when(vnfApi.vnfsVnfInstanceIdScalePost(eq(VNF_ID), actualScaleRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
151 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
152 operationExecutions.add(scaleOperationExecution);
153 return buildObservable(scaleOperationExecution);
156 when(vnfApi.vnfsVnfInstanceIdHealPost(eq(VNF_ID), actualHealRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
158 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
159 operationExecutions.add(healOperationExecution);
160 return buildObservable(healOperationExecution);
169 public void testInstantiation() throws Exception {
171 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
173 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
174 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
175 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
176 grantResponse.setVimId(VIM_ID);
177 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
178 accessInfo.setTenant(TENANT);
179 grantResponse.setAccessInfo(accessInfo);
180 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
181 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
183 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
184 waitForJobToFinishInJobManager(finished);
186 assertEquals(VNF_ID, response.getVnfInstanceId());
187 assertEquals(JOB_ID, response.getJobId());
188 assertEquals(createRequest.getAllValues().size(), 1);
189 assertEquals("myDescription", createRequest.getValue().getDescription());
190 assertEquals("vnfName", createRequest.getValue().getName());
191 assertEquals(CBAM_VNFD_ID, createRequest.getValue().getVnfdId());
192 assertEquals(1, actualInstantiationRequest.getAllValues().size());
193 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
194 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
195 assertEquals(VIM_ID, actualVim.getId());
196 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, actualVim.getVimInfoType());
197 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
198 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
199 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
200 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
201 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
202 assertEquals("myTenant", actualVim.getAccessInfo().getTenant());
203 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
204 assertEquals(1, actualInstantiationRequest.getValue().getComputeResourceFlavours().size());
205 assertEquals("flavourProviderId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getResourceId());
206 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVimId());
207 assertEquals("virtualComputeDescId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVnfdVirtualComputeDescId());
208 assertEquals(1, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().size());
209 assertEquals(extManVl, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().get(0));
210 assertEquals(2, actualInstantiationRequest.getValue().getExtVirtualLinks().size());
212 assertEquals("myNetworkProviderId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getResourceId());
213 assertEquals("myEVlId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtVirtualLinkId());
214 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().size());
215 assertEquals("myCpdId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().get(0).getCpdId());
217 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getVimId());
218 assertEquals("evlId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtVirtualLinkId());
219 assertEquals("networkProviderId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getResourceId());
220 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().size());
223 assertEquals(Integer.valueOf(2), actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getNumDynamicAddresses());
224 assertEquals("cpdId3", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getCpdId());
225 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().size());
226 assertEquals("1.2.3.4", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getIp());
227 assertEquals("mac", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getMac());
228 assertEquals("subnetId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getSubnetId());
230 assertEquals("myFlavorId", actualInstantiationRequest.getValue().getFlavourId());
231 assertEquals(Boolean.TRUE, actualInstantiationRequest.getValue().isGrantlessMode());
232 assertEquals("level1", actualInstantiationRequest.getValue().getInstantiationLevelId());
233 assertEquals(1, actualInstantiationRequest.getValue().getZones().size());
234 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getZones().get(0).getVimId());
235 assertEquals("zoneProviderId", actualInstantiationRequest.getValue().getZones().get(0).getResourceId());
236 assertEquals("zoneId", actualInstantiationRequest.getValue().getZones().get(0).getId());
237 assertEquals(1, actualInstantiationRequest.getValue().getSoftwareImages().size());
238 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVimId());
239 assertEquals("imageProviderId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getResourceId());
240 assertEquals("imageId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVnfdSoftwareImageId());
241 String actualEmbeddedAdditionParams = new Gson().toJson(actualInstantiationRequest.getValue().getAdditionalParams());
242 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(actualEmbeddedAdditionParams) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(actualEmbeddedAdditionParams));
243 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
244 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
246 assertEquals(1, actualVnfModifyRequest.getAllValues().size());
247 assertEquals(2, actualVnfModifyRequest.getValue().getExtensions().size());
248 assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getName());
249 assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getValue());
250 assertEquals(LifecycleManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName());
251 assertEquals(VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getValue());
253 //the 3.2 API does not accept empty array
254 assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties());
255 verify(jobManager).spawnJob(VNF_ID, restResponse);
256 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
257 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
261 * invalid VIM type results in failure
264 public void testInstantiationWithInvalidVimType() throws Exception {
266 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
267 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
268 when(logger.isInfoEnabled()).thenReturn(false);
271 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
274 } catch (Exception e) {
275 assertEquals("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types", e.getMessage());
277 verify(vnfApi, never()).vnfsPost(Mockito.any(), Mockito.any());
278 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
279 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
280 verify(logger).error("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types");
284 * test instantiation with KeyStone V2 based with SSL
287 public void testInstantiationV2WithSsl() throws Exception {
288 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
289 when(logger.isInfoEnabled()).thenReturn(false);
290 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
291 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
292 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
293 grantResponse.setVimId(VIM_ID);
294 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
295 accessInfo.setTenant(TENANT);
296 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
297 vimInfo.setSslInsecure("false");
298 vimInfo.setSslCacert(caCert);
299 grantResponse.setAccessInfo(accessInfo);
300 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
301 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
302 JsonObject inputs = child((JsonObject) instantiationRequest.getAdditionalParam(), "inputs");
303 JsonObject vnfs = child(child(inputs, "vnfs"), ONAP_CSAR_ID);
304 vnfs.remove("additionalParams");
306 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
307 waitForJobToFinishInJobManager(finished);
308 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
310 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
311 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
312 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
313 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
314 verify(logger).warn("No additional parameters were specified for the operation");
315 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), anyString(), anyString(), anyString());
319 * non specified SSL verification means not verified
322 public void testInstantiationV2WithoutSsl() throws Exception {
323 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
325 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
326 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
327 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
328 grantResponse.setVimId(VIM_ID);
329 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
330 accessInfo.setTenant(TENANT);
331 vimInfo.setSslInsecure(null);
332 grantResponse.setAccessInfo(accessInfo);
333 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
334 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
336 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
337 waitForJobToFinishInJobManager(finished);
338 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
340 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
341 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
342 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
346 * test instantiation with KeyStone V3 based
349 public void testInstantiationV3() throws Exception {
350 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
352 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
353 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
354 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
355 grantResponse.setVimId(VIM_ID);
356 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
357 accessInfo.setTenant(TENANT);
358 grantResponse.setAccessInfo(accessInfo);
359 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
360 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
362 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
363 waitForJobToFinishInJobManager(finished);
364 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
366 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
367 assertEquals(VIM_ID, actualVim.getId());
368 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
369 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
370 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
371 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
372 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
373 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
374 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
375 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
376 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
377 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
378 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
382 * test instantiation with KeyStone V3 based with SSL
385 public void testInstantiationV3WithSsl() throws Exception {
386 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
388 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
389 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
390 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
391 grantResponse.setVimId(VIM_ID);
392 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
393 accessInfo.setTenant(TENANT);
394 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
395 vimInfo.setSslInsecure("false");
396 vimInfo.setSslCacert(caCert);
397 grantResponse.setAccessInfo(accessInfo);
398 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
399 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
401 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
402 waitForJobToFinishInJobManager(finished);
403 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
405 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
406 assertEquals(VIM_ID, actualVim.getId());
407 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
408 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
409 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
410 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
411 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
412 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
413 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
414 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
415 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
416 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
417 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
418 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
422 * non specified SSL verification meams not verified for KeyStone V3 based
425 public void testInstantiationV3WithNonSpecifiedSsl() throws Exception {
426 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
428 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
429 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
430 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
431 grantResponse.setVimId(VIM_ID);
432 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
433 accessInfo.setTenant(TENANT);
434 vimInfo.setSslInsecure(null);
435 grantResponse.setAccessInfo(accessInfo);
436 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
437 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
439 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
440 waitForJobToFinishInJobManager(finished);
441 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
443 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
444 assertEquals(VIM_ID, actualVim.getId());
445 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
446 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
447 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
448 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
449 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
450 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
451 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
452 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
453 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
454 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
458 * test instantiation with vcloud
461 public void testInstantiationVcloud() throws Exception {
462 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
464 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
465 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
466 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
467 grantResponse.setVimId(VIM_ID);
468 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
469 accessInfo.setTenant(TENANT);
470 grantResponse.setAccessInfo(accessInfo);
471 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
472 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
474 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
475 waitForJobToFinishInJobManager(finished);
476 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
478 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
479 assertEquals(VIM_ID, actualVim.getId());
480 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
481 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
482 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
483 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
484 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
485 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
486 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
487 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
488 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
492 * test instantiation with vCloud with SSL
495 public void testInstantiationVcloudWithSsl() throws Exception {
496 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
498 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
499 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
500 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
501 grantResponse.setVimId(VIM_ID);
502 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
503 accessInfo.setTenant(TENANT);
504 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
505 vimInfo.setSslInsecure("false");
506 vimInfo.setSslCacert(caCert);
507 grantResponse.setAccessInfo(accessInfo);
508 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
509 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
511 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
512 waitForJobToFinishInJobManager(finished);
513 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
515 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
516 assertEquals(VIM_ID, actualVim.getId());
517 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
518 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
519 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
520 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
521 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
522 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
523 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
524 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
525 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
526 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
530 * test instantiation with vCloud with SSL
533 public void testInstantiationVcloudWithNonSecifedSSl() throws Exception {
534 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
536 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
537 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
538 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
539 grantResponse.setVimId(VIM_ID);
540 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
541 accessInfo.setTenant(TENANT);
542 vimInfo.setSslInsecure(null);
543 grantResponse.setAccessInfo(accessInfo);
544 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
545 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
547 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
548 waitForJobToFinishInJobManager(finished);
549 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
551 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
552 assertEquals(VIM_ID, actualVim.getId());
553 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
554 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
555 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
556 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
557 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
558 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
559 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
560 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
564 * test failure in the instantiation request marks the job to be finished in job manager
567 public void testFailureInTheInstantiationRequest() throws Exception {
568 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
569 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
570 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
571 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
572 grantResponse.setVimId(VIM_ID);
573 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
574 accessInfo.setTenant(TENANT);
575 grantResponse.setAccessInfo(accessInfo);
576 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
577 RuntimeException expectedException = new RuntimeException();
578 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
581 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
583 waitForJobToFinishInJobManager(finished);
584 assertEquals(VNF_ID, response.getVnfInstanceId());
585 assertEquals(JOB_ID, response.getJobId());
586 verify(logger).error("Unable to instantiate VNF with myVnfId identifier", expectedException);
590 * instantiation fails if VF-C does not send vim identifier in grant response
593 public void testVfcFailsToSendVimId() throws Exception {
594 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
596 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
597 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
598 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
599 //grantResponse.setVimId(VIM_ID);
600 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
601 accessInfo.setTenant(TENANT);
602 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
603 vimInfo.setSslInsecure("false");
604 vimInfo.setSslCacert(caCert);
605 grantResponse.setAccessInfo(accessInfo);
606 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
607 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
609 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
610 waitForJobToFinishInJobManager(finished);
611 assertEquals(0, actualInstantiationRequest.getAllValues().size());
613 verify(logger).error("VF-C did not send VIM identifier in grant response");
618 * test operation execution polling is retried in case of failures
621 public void testFailureInTheOperationExecutionPollingDuringInstantiationRequest() throws Exception {
622 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
623 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
624 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
625 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
626 grantResponse.setVimId(VIM_ID);
627 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
628 accessInfo.setTenant(TENANT);
629 grantResponse.setAccessInfo(accessInfo);
630 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
631 List<RuntimeException> polling = new ArrayList<>();
632 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
633 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).then(new Answer<Observable<List<OperationExecution>>>() {
635 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
636 if (polling.size() > 2) {
637 return buildObservable(operationExecutions);
639 RuntimeException runtimeException = new RuntimeException();
640 polling.add(runtimeException);
641 throw runtimeException;
645 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
647 waitForJobToFinishInJobManager(finished);
648 assertEquals(VNF_ID, response.getVnfInstanceId());
649 assertEquals(JOB_ID, response.getJobId());
650 assertEquals(3, polling.size());
651 for (RuntimeException e : polling) {
652 verify(logger).warn("Unable to retrieve operations details", e);
654 verify(systemFunctions, Mockito.times(3)).sleep(5000);
658 * failure in VNF creation is logged an proagated
661 public void failureInVnfCreationIsPropagated() throws Exception {
663 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
665 RuntimeException expectedException = new RuntimeException();
666 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
669 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
672 } catch (RuntimeException e) {
673 assertEquals(expectedException, e.getCause());
674 verify(logger).error("Unable to create the VNF", expectedException);
679 * failure in updating the modifyable attributes of the VNF is logged an proagated
682 public void failureInVnfModificationIsPropagated() throws Exception {
684 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
686 RuntimeException expectedException = new RuntimeException();
687 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
688 when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
692 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
695 } catch (RuntimeException e) {
696 assertEquals(expectedException, e.getCause().getCause());
697 verify(logger).error("Unable to set the onapCsarId property on the VNF", expectedException);
702 * if the VIM info can not be queried the VNF is not instantiated and
703 * error propagated through job
706 public void testFailureInQueryVimInfo() throws Exception {
707 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
708 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
709 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
710 grantResponse.setVimId(VIM_ID);
711 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
712 accessInfo.setTenant(TENANT);
713 grantResponse.setAccessInfo(accessInfo);
715 when(vimInfoProvider.getVimInfo(VIM_ID)).thenThrow(new RuntimeException());
717 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
719 waitForJobToFinishInJobManager(finished);
720 verify(vnfApi, never()).vnfsVnfInstanceIdInstantiatePost(Mockito.any(), Mockito.any(), Mockito.any());
724 * test termination basic success scenario
725 * - the VNF is not deleted before the notifications are processed
728 public void testTermination() throws Exception {
730 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
731 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
732 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
733 vnfInfo.setOperationExecutions(operationExecutions);
734 VnfProperty vnfdId = new VnfProperty();
735 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
736 vnfdId.setValue(ONAP_CSAR_ID);
737 vnfInfo.getExtensions().add(vnfdId);
738 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
739 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
741 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
742 OperationExecution terminationOperation = new OperationExecution();
743 terminationOperation.setId("terminationId");
744 operationExecutions.add(terminationOperation);
745 terminationOperation.setStatus(OperationStatus.FINISHED);
746 return buildObservable(terminationOperation);
749 when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
750 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
751 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
753 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
755 waitForJobToFinishInJobManager(finished);
756 assertEquals(1, actualTerminationRequest.getAllValues().size());
757 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
758 assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
759 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
760 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
761 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
762 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
763 VOID_OBSERVABLE.assertCalled();
764 verify(jobManager).spawnJob(VNF_ID, restResponse);
765 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
769 * test termination of a non instantiated VNF
770 * - the VNF is not terminated (only deleted)
773 public void testTerminationOfNonInstantiated() throws Exception {
775 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
776 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
777 vnfInfo.setInstantiationState(InstantiationState.NOT_INSTANTIATED);
778 vnfInfo.setOperationExecutions(operationExecutions);
779 VnfProperty vnfdId = new VnfProperty();
780 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
781 vnfdId.setValue(ONAP_CSAR_ID);
782 vnfInfo.getExtensions().add(vnfdId);
783 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
784 when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
785 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
787 lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
789 boolean deleted = false;
792 verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
797 verify(vfcGrantManager, never()).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
798 verify(notificationManager, never()).waitForTerminationToBeProcessed("terminationId");
799 verify(logger).debug("The VNF {} with identifier is not instantiated no termination required", VNF_ID);
800 verify(logger).info("Deleting VNF with {} identifier", VNF_ID);
801 verify(logger).info("The VNF with {} identifier has been deleted", VNF_ID);
802 VOID_OBSERVABLE.assertCalled();
806 * test that the VNF deletion is not started before the termination finishes
809 public void testTerminationOperationIsOutwaited() throws Exception {
811 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
812 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
813 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
814 vnfInfo.setOperationExecutions(operationExecutions);
815 VnfProperty vnfdId = new VnfProperty();
816 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
817 vnfdId.setValue(ONAP_CSAR_ID);
818 vnfInfo.getExtensions().add(vnfdId);
819 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
820 OperationExecution terminationOperation = new OperationExecution();
821 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
822 terminationOperation.setId("terminationId");
823 operationExecutions.add(terminationOperation);
824 terminationOperation.setStatus(OperationStatus.STARTED);
825 return buildObservable(terminationOperation);
827 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
828 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
829 Set<Integer> calls = new HashSet<>();
830 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(invocation -> {
831 if (calls.size() == 1000) {
832 terminationOperation.setStatus(OperationStatus.FINISHED);
834 calls.add(calls.size());
835 return buildObservable(operationExecutions);
838 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
840 waitForJobToFinishInJobManager(finished);
841 verify(vnfApi, times(1001)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
842 verify(systemFunctions, times(1000)).sleep(5000);
847 * test that failured during waiting for the operation to finish is tolerated (idefineiatelly)
850 public void testTerminationOperationIsOutwaitedWithErrors() throws Exception {
852 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
853 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
854 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
855 vnfInfo.setOperationExecutions(operationExecutions);
856 VnfProperty vnfdId = new VnfProperty();
857 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
858 vnfdId.setValue(ONAP_CSAR_ID);
859 vnfInfo.getExtensions().add(vnfdId);
860 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
861 OperationExecution terminationOperation = new OperationExecution();
862 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
864 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
865 terminationOperation.setId("terminationId");
866 operationExecutions.add(terminationOperation);
867 terminationOperation.setStatus(OperationStatus.STARTED);
868 return buildObservable(terminationOperation);
871 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
872 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
873 Set<Integer> calls = new HashSet<>();
874 List<RuntimeException> expectedExceptions = new ArrayList<>();
875 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
877 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
878 if (calls.size() >= 100) {
879 terminationOperation.setStatus(OperationStatus.FINISHED);
880 return buildObservable(operationExecutions);
882 calls.add(calls.size());
883 RuntimeException RuntimeException = new RuntimeException();
884 expectedExceptions.add(RuntimeException);
885 throw RuntimeException;
889 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
891 waitForJobToFinishInJobManager(finished);
892 verify(vnfApi, times(101)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
893 verify(systemFunctions, times(100)).sleep(5000);
894 for (RuntimeException expectedException : expectedExceptions) {
895 verify(logger).warn("Unable to retrieve operations details", expectedException);
900 * test gracefull termination
903 public void testGracefullTermination() throws Exception {
905 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
906 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
907 terminationRequest.setTerminationType(VnfTerminationType.GRACEFUL);
908 terminationRequest.setGracefulTerminationTimeout("1234");
909 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
910 vnfInfo.setOperationExecutions(operationExecutions);
911 VnfProperty vnfdId = new VnfProperty();
912 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
913 vnfdId.setValue(ONAP_CSAR_ID);
914 vnfInfo.getExtensions().add(vnfdId);
915 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
916 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
918 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
919 OperationExecution terminationOperation = new OperationExecution();
920 terminationOperation.setId("terminationId");
921 operationExecutions.add(terminationOperation);
922 terminationOperation.setStatus(OperationStatus.FINISHED);
923 return buildObservable(terminationOperation);
926 doAnswer(invocation -> {
927 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
929 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
930 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
931 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
933 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
935 waitForJobToFinishInJobManager(finished);
936 assertEquals(1, actualTerminationRequest.getAllValues().size());
937 assertEquals(TerminationType.GRACEFUL, actualTerminationRequest.getValue().getTerminationType());
938 assertEquals(Integer.valueOf(1234), actualTerminationRequest.getValue().getGracefulTerminationTimeout());
939 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
940 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
941 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
942 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
946 * instantiation with missing ONAP csarId to instantiation extra param result in failure
949 public void testMissingVnfParameters() throws Exception {
951 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
952 String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "invalid" + "\" : {}}}, \"vimId\" : \"" + VIM_ID + "\"}";
953 instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
956 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
958 } catch (Exception e) {
959 assertEquals("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id", e.getMessage());
960 verify(logger).error("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id");
965 * test explicit forceful termination
968 public void testExplicitForcefulTermination() throws Exception {
970 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
971 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
972 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
973 terminationRequest.setGracefulTerminationTimeout("1234");
974 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
975 vnfInfo.setOperationExecutions(operationExecutions);
976 VnfProperty vnfdId = new VnfProperty();
977 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
978 vnfdId.setValue(ONAP_CSAR_ID);
979 vnfInfo.getExtensions().add(vnfdId);
980 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
981 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
982 OperationExecution terminationOperation = new OperationExecution();
983 terminationOperation.setId("terminationId");
984 operationExecutions.add(terminationOperation);
985 terminationOperation.setStatus(OperationStatus.FINISHED);
986 return buildObservable(terminationOperation);
988 doAnswer(invocation -> {
989 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
991 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
992 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
993 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
995 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
997 waitForJobToFinishInJobManager(finished);
998 assertEquals(1, actualTerminationRequest.getAllValues().size());
999 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1000 assertNull(actualTerminationRequest.getValue().getGracefulTerminationTimeout());
1001 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
1002 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1003 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
1004 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1008 * test failure in the termination workflow finishes the job
1011 public void testFailureInTheTerminationFinishesTheManagedJob() throws Exception {
1013 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1014 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1015 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1016 terminationRequest.setGracefulTerminationTimeout("1234");
1017 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1018 vnfInfo.setOperationExecutions(operationExecutions);
1019 VnfProperty vnfdId = new VnfProperty();
1020 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1021 vnfdId.setValue(ONAP_CSAR_ID);
1022 vnfInfo.getExtensions().add(vnfdId);
1023 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1024 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
1026 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
1027 OperationExecution terminationOperation = new OperationExecution();
1028 terminationOperation.setId("terminationId");
1029 operationExecutions.add(terminationOperation);
1030 terminationOperation.setStatus(OperationStatus.FINISHED);
1031 return terminationOperation;
1034 RuntimeException expectedException = new RuntimeException();
1035 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1036 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1037 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1039 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1041 waitForJobToFinishInJobManager(finished);
1042 assertEquals(0, actualTerminationRequest.getAllValues().size());
1043 Mockito.verifyZeroInteractions(vfcGrantManager);
1047 * if termination fails the VNF is not deleted
1050 public void testFailedTerminationAbortsTerminationWorkflow() throws Exception {
1052 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1053 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1054 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1055 vnfInfo.setOperationExecutions(operationExecutions);
1056 VnfProperty vnfdId = new VnfProperty();
1057 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1058 vnfdId.setValue(ONAP_CSAR_ID);
1059 vnfInfo.getExtensions().add(vnfdId);
1060 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1061 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1063 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1064 OperationExecution terminationOperation = new OperationExecution();
1065 terminationOperation.setId("terminationId");
1066 operationExecutions.add(terminationOperation);
1067 terminationOperation.setStatus(OperationStatus.FAILED);
1068 return buildObservable(terminationOperation);
1071 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1072 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1074 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1076 waitForJobToFinishInJobManager(finished);
1077 assertEquals(1, actualTerminationRequest.getAllValues().size());
1078 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1079 verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1080 verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1081 verify(logger).error("Unable to terminate VNF the operation did not finish with success");
1085 * test VNF query basic success scenario
1088 public void testQuery() throws Exception {
1089 vnfInfo.setDescription("myDescription");
1090 vnfInfo.setName("myName");
1091 vnfInfo.setVnfSoftwareVersion("vnfSoftwareVersion");
1092 vnfInfo.setVnfProvider("myProvider");
1093 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1094 VnfProperty prop = new VnfProperty();
1095 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1096 prop.setValue(ONAP_CSAR_ID);
1097 vnfInfo.getExtensions().add(prop);
1099 org.onap.vnfmdriver.model.VnfInfo vnf = lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1101 assertEquals(VNF_ID, vnf.getVnfInstanceId());
1102 //FIXME ? (do not know what exactly the vnf version mean in core terminology)
1103 assertEquals("vnfSoftwareVersion", vnf.getVersion());
1104 assertEquals(ONAP_CSAR_ID, vnf.getVnfdId());
1105 assertEquals("myDescription", vnf.getVnfInstanceDescription());
1106 assertEquals("myName", vnf.getVnfInstanceName());
1107 assertEquals(ONAP_CSAR_ID, vnf.getVnfPackageId());
1108 assertEquals("myProvider", vnf.getVnfProvider());
1109 //FIXME (in swagger schema )
1110 assertEquals("ACTIVE", vnf.getVnfStatus());
1111 assertEquals("Kuku", vnf.getVnfType());
1115 * error is propagated and logged if the queried VNF does not exist
1118 public void testQueryForNonExistingVnf() throws Exception {
1120 RuntimeException expectedException = new RuntimeException();
1121 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1124 lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1127 } catch (Exception e) {
1128 verify(logger).error("Unable to query VNF (myVnfId)", expectedException);
1129 assertEquals(expectedException, e.getCause());
1134 * test scale basic scenario
1137 public void testScale() throws Exception {
1138 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1139 scaleRequest.setNumberOfSteps("2");
1140 scaleRequest.setAspectId("myAspect");
1141 scaleRequest.setType(ScaleDirection.IN);
1142 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }"));
1143 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1144 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1145 VnfProperty prop = new VnfProperty();
1146 prop.setValue(ONAP_CSAR_ID);
1147 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1148 vnfInfo.getExtensions().add(prop);
1149 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1150 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1151 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1153 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1155 waitForJobToFinishInJobManager(finished);
1156 assertEquals(1, actualScaleRequest.getAllValues().size());
1157 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1158 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1159 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1160 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1161 assertEquals("myAspect", sRequest.getAspectId());
1162 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1163 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1164 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1165 verify(jobManager).spawnJob(VNF_ID, restResponse);
1166 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("scale"), eq(VNF_ID), anyString());
1171 * the VNFM should tolerate that no additional params were supplied
1174 public void testScaleWithoutAddtionalParams() throws Exception {
1175 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1176 scaleRequest.setNumberOfSteps("2");
1177 scaleRequest.setAspectId("myAspect");
1178 scaleRequest.setType(ScaleDirection.IN);
1179 scaleRequest.setAdditionalParam(null);
1180 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1181 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1182 VnfProperty prop = new VnfProperty();
1183 prop.setValue(ONAP_CSAR_ID);
1184 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1185 vnfInfo.getExtensions().add(prop);
1186 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1187 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1188 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1190 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1192 waitForJobToFinishInJobManager(finished);
1193 assertEquals(1, actualScaleRequest.getAllValues().size());
1194 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1195 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1196 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1197 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1198 assertEquals("myAspect", sRequest.getAspectId());
1199 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1200 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1201 assertEquals("{\"jobId\":\"myJobId\"}", new Gson().toJson(sRequest.getAdditionalParams()));
1202 verify(jobManager).spawnJob(VNF_ID, restResponse);
1206 * test scale out basic scenario
1209 public void testScaleOut() throws Exception {
1210 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1211 scaleRequest.setNumberOfSteps("2");
1212 scaleRequest.setAspectId("myAspect");
1213 scaleRequest.setType(ScaleDirection.OUT);
1214 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1215 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1216 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1217 VnfProperty prop = new VnfProperty();
1218 prop.setValue(ONAP_CSAR_ID);
1219 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1220 vnfInfo.getExtensions().add(prop);
1221 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1222 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1223 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1225 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1227 waitForJobToFinishInJobManager(finished);
1228 assertEquals(1, actualScaleRequest.getAllValues().size());
1229 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1230 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1231 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1232 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1233 assertEquals("myAspect", sRequest.getAspectId());
1234 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.OUT, sRequest.getType());
1235 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1236 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1240 * test scale operation is out waited
1243 public void testScaleOutwait() throws Exception {
1244 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1245 scaleRequest.setNumberOfSteps("2");
1246 scaleRequest.setAspectId("myAspect");
1247 scaleRequest.setType(ScaleDirection.IN);
1248 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1249 scaleOperationExecution.setStatus(OperationStatus.STARTED);
1250 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1251 VnfProperty prop = new VnfProperty();
1252 prop.setValue(ONAP_CSAR_ID);
1253 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1254 vnfInfo.getExtensions().add(prop);
1255 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1256 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1257 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1258 List<RuntimeException> expectedExceptions = new ArrayList<>();
1259 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<Observable<List<OperationExecution>>>) invocation -> {
1260 if (expectedExceptions.size() >= 100) {
1261 when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(scaleOperationExecution));
1262 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1263 return buildObservable(operationExecutions);
1265 RuntimeException RuntimeException = new RuntimeException();
1266 expectedExceptions.add(RuntimeException);
1267 throw RuntimeException;
1271 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1273 waitForJobToFinishInJobManager(finished);
1274 assertEquals(100, expectedExceptions.size());
1275 for (RuntimeException expectedException : expectedExceptions) {
1276 verify(logger).warn("Unable to retrieve operations details", expectedException);
1278 verify(systemFunctions, times(100)).sleep(5000);
1282 * test scale failure propagation
1285 public void testScaleFailurePropagation() throws Exception {
1286 RuntimeException expectedException = new RuntimeException();
1287 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1288 scaleRequest.setNumberOfSteps("2");
1289 scaleRequest.setAspectId("myAspect");
1290 scaleRequest.setType(ScaleDirection.IN);
1291 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1293 lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1295 waitForJobToFinishInJobManager(finished);
1296 verify(logger).error("Unable to scale VNF with myVnfId identifier", expectedException);
1300 * test heal basic scenario
1303 public void testHeal() throws Exception {
1304 VnfHealRequest healRequest = new VnfHealRequest();
1305 healRequest.setAction("myAction");
1306 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1307 affectedVm.setVmname("vmName");
1308 healRequest.setAffectedvm(affectedVm);
1309 healOperationExecution.setStatus(OperationStatus.FINISHED);
1310 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1311 VnfProperty prop = new VnfProperty();
1312 prop.setValue(ONAP_CSAR_ID);
1313 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1314 vnfInfo.getExtensions().add(prop);
1315 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1316 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1317 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1319 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1321 waitForJobToFinishInJobManager(finished);
1322 assertEquals(1, actualHealRequest.getAllValues().size());
1323 HealVnfRequest sRequest = actualHealRequest.getValue();
1324 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1325 workflowOrder.verify(vfcGrantManager).requestGrantForHeal(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(healRequest), eq(JOB_ID));
1326 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdHealPost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1327 JsonObject root = new Gson().toJsonTree(sRequest.getAdditionalParams()).getAsJsonObject();
1328 assertEquals("myAction", root.get("action").getAsString());
1329 assertEquals("vmName", root.get("vmName").getAsString());
1330 assertEquals(JOB_ID, root.get("jobId").getAsString());
1331 verify(jobManager).spawnJob(VNF_ID, restResponse);
1332 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("heal"), eq(VNF_ID), anyString());
1336 * test heal operation is out waited
1339 public void testHealOutwait() throws Exception {
1340 VnfHealRequest healRequest = new VnfHealRequest();
1341 healRequest.setAction("myAction");
1342 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1343 affectedVm.setVmname("vmName");
1344 healRequest.setAffectedvm(affectedVm);
1345 healOperationExecution.setStatus(OperationStatus.FINISHED);
1346 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1347 VnfProperty prop = new VnfProperty();
1348 prop.setValue(ONAP_CSAR_ID);
1349 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1350 vnfInfo.getExtensions().add(prop);
1351 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1352 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1353 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1354 List<RuntimeException> expectedExceptions = new ArrayList<>();
1355 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
1357 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
1358 if (expectedExceptions.size() >= 100) {
1359 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1360 return buildObservable(operationExecutions);
1362 RuntimeException RuntimeException = new RuntimeException();
1363 expectedExceptions.add(RuntimeException);
1364 throw RuntimeException;
1368 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1370 waitForJobToFinishInJobManager(finished);
1371 assertEquals(100, expectedExceptions.size());
1372 for (RuntimeException expectedException : expectedExceptions) {
1373 verify(logger).warn("Unable to retrieve operations details", expectedException);
1375 verify(systemFunctions, times(100)).sleep(5000);
1379 * failure in heal propagates in error
1382 public void testHealFailurePropagation() throws Exception {
1383 RuntimeException expectedException = new RuntimeException();
1384 VnfHealRequest healRequest = new VnfHealRequest();
1385 healRequest.setAction("myAction");
1386 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1387 affectedVm.setVmname("vmName");
1388 healRequest.setAffectedvm(affectedVm);
1389 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1391 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1393 waitForJobToFinishInJobManager(finished);
1394 verify(logger).error("Unable to heal VNF with myVnfId identifier", expectedException);
1397 private void waitForJobToFinishInJobManager(Set<Boolean> finished) throws InterruptedException {
1398 while (finished.size() == 0) {
1399 systemFunctions().sleep(100);
1403 private VnfInstantiateRequest prepareInstantiationRequest(VimInfo.VimInfoTypeEnum cloudType) {
1404 VnfInstantiateRequest instantiationRequest = new VnfInstantiateRequest();
1405 instantiationRequest.setVnfPackageId(ONAP_CSAR_ID);
1406 instantiationRequest.setVnfDescriptorId(ONAP_CSAR_ID);
1407 instantiationRequest.setVnfInstanceDescription("myDescription");
1408 instantiationRequest.setVnfInstanceName("vnfName");
1409 additionalParam.setInstantiationLevel("level1");
1410 switch (cloudType) {
1411 case OPENSTACK_V2_INFO:
1412 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1414 case OPENSTACK_V3_INFO:
1415 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
1416 additionalParam.setDomain("myDomain");
1418 case VMWARE_VCLOUD_INFO:
1419 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
1422 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
1425 Map<String, List<NetworkAddress>> exteranalConnectionPointAddresses = new HashMap<>();
1426 exteranalConnectionPointAddresses.put("ecp1", new ArrayList<>());
1427 NetworkAddress networkAddress = new NetworkAddress();
1428 networkAddress.setIp("1.2.3.4");
1429 networkAddress.setMac("mac");
1430 networkAddress.setSubnetId("subnetId");
1431 exteranalConnectionPointAddresses.get("ecp1").add(networkAddress);
1432 additionalParam.setExternalConnectionPointAddresses(exteranalConnectionPointAddresses);
1433 VimComputeResourceFlavour flavor = new VimComputeResourceFlavour();
1434 flavor.setResourceId("flavourProviderId");
1435 flavor.setVimId(VIM_ID);
1436 flavor.setVnfdVirtualComputeDescId("virtualComputeDescId");
1437 additionalParam.getComputeResourceFlavours().add(flavor);
1438 ExtVirtualLinkData evl = new ExtVirtualLinkData();
1439 evl.setResourceId("networkProviderId1");
1440 evl.setVimId(VIM_ID);
1441 evl.setExtVirtualLinkId("evlId1");
1442 VnfExtCpData ecp2 = new VnfExtCpData();
1443 ecp2.setCpdId("cpdId3");
1444 ecp2.setAddresses(new ArrayList<>());
1445 ecp2.getAddresses().add(networkAddress);
1446 ecp2.setNumDynamicAddresses(2);
1447 evl.getExtCps().add(ecp2);
1448 additionalParam.getExtVirtualLinks().add(evl);
1449 externalVirtualLink.setCpdId("myCpdId");
1450 externalVirtualLink.setResourceId("myNetworkProviderId");
1451 externalVirtualLink.setVlInstanceId("myEVlId");
1452 externalVirtualLink.setResourceSubnetId("notUsedSubnetId");
1453 instantiationRequest.setExtVirtualLink(new ArrayList<>());
1454 instantiationRequest.getExtVirtualLink().add(externalVirtualLink);
1455 additionalParam.getExtManagedVirtualLinks().add(extManVl);
1456 ZoneInfo zone = new ZoneInfo();
1457 zone.setId("zoneId");
1458 zone.setResourceId("zoneProviderId");
1459 zone.setVimId(VIM_ID);
1460 additionalParam.getZones().add(zone);
1461 VimSoftwareImage image = new VimSoftwareImage();
1462 image.setResourceId("imageProviderId");
1463 image.setVimId(VIM_ID);
1464 image.setVnfdSoftwareImageId("imageId");
1465 additionalParam.getSoftwareImages().add(image);
1466 additionalParam.setAdditionalParams(new JsonParser().parse("{ \"a\" : \"b\" }"));
1467 String params = new Gson().toJson(additionalParam);
1468 String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "\" : " + params + "}}, \"vimId\" : \"" + VIM_ID + "\"}";
1469 instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
1470 return instantiationRequest;
1474 * Test vimId decomposition
1477 public void testVimIdSplitting() {
1478 assertEquals("regionId", LifecycleManager.getRegionName("cloudOwner_regionId"));
1479 assertEquals("cloudOwner", LifecycleManager.getCloudOwner("cloudOwner_regionId"));