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 org.junit.Before;
29 import org.junit.Test;
30 import org.mockito.ArgumentCaptor;
31 import org.mockito.InOrder;
32 import org.mockito.Mock;
33 import org.mockito.Mockito;
34 import org.mockito.invocation.InvocationOnMock;
35 import org.mockito.stubbing.Answer;
36 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VimInfoProvider;
37 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.TestVfcGrantManager;
38 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.VfcGrantManager;
39 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.StoreLoader;
40 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.LifecycleChangeNotificationManager;
41 import org.onap.vnfmdriver.model.ExtVirtualLinkInfo;
42 import org.onap.vnfmdriver.model.*;
43 import org.onap.vnfmdriver.model.ScaleDirection;
44 import org.threeten.bp.OffsetDateTime;
46 import javax.servlet.http.HttpServletResponse;
47 import java.nio.file.Paths;
50 import static java.lang.Boolean.parseBoolean;
51 import static java.nio.file.Files.readAllBytes;
52 import static 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);
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");
318 * non specified SSL verification means not verified
321 public void testInstantiationV2WithoutSsl() throws Exception {
322 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
324 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
325 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
326 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
327 grantResponse.setVimId(VIM_ID);
328 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
329 accessInfo.setTenant(TENANT);
330 vimInfo.setSslInsecure(null);
331 grantResponse.setAccessInfo(accessInfo);
332 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
333 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
335 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
336 waitForJobToFinishInJobManager(finished);
337 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
339 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
340 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
341 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
345 * test instantiation with KeyStone V3 based
348 public void testInstantiationV3() throws Exception {
349 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
351 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
352 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
353 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
354 grantResponse.setVimId(VIM_ID);
355 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
356 accessInfo.setTenant(TENANT);
357 grantResponse.setAccessInfo(accessInfo);
358 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
359 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
361 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
362 waitForJobToFinishInJobManager(finished);
363 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
365 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
366 assertEquals(VIM_ID, actualVim.getId());
367 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
368 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
369 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
370 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
371 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
372 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
373 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
374 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
375 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
376 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
377 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
381 * test instantiation with KeyStone V3 based with SSL
384 public void testInstantiationV3WithSsl() throws Exception {
385 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
387 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
388 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
389 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
390 grantResponse.setVimId(VIM_ID);
391 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
392 accessInfo.setTenant(TENANT);
393 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
394 vimInfo.setSslInsecure("false");
395 vimInfo.setSslCacert(caCert);
396 grantResponse.setAccessInfo(accessInfo);
397 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
398 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
400 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
401 waitForJobToFinishInJobManager(finished);
402 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
404 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
405 assertEquals(VIM_ID, actualVim.getId());
406 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
407 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
408 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
409 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
410 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
411 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
412 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
413 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
414 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
415 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
416 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
417 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
421 * non specified SSL verification meams not verified for KeyStone V3 based
424 public void testInstantiationV3WithNonSpecifiedSsl() throws Exception {
425 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
427 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
428 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
429 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
430 grantResponse.setVimId(VIM_ID);
431 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
432 accessInfo.setTenant(TENANT);
433 vimInfo.setSslInsecure(null);
434 grantResponse.setAccessInfo(accessInfo);
435 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
436 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
438 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
439 waitForJobToFinishInJobManager(finished);
440 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
442 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
443 assertEquals(VIM_ID, actualVim.getId());
444 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
445 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
446 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
447 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
448 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
449 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
450 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
451 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
452 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
453 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
457 * test instantiation with vcloud
460 public void testInstantiationVcloud() throws Exception {
461 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
463 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
464 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
465 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
466 grantResponse.setVimId(VIM_ID);
467 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
468 accessInfo.setTenant(TENANT);
469 grantResponse.setAccessInfo(accessInfo);
470 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
471 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
473 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
474 waitForJobToFinishInJobManager(finished);
475 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
477 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
478 assertEquals(VIM_ID, actualVim.getId());
479 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
480 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
481 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
482 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
483 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
484 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
485 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
486 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
487 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
491 * test instantiation with vCloud with SSL
494 public void testInstantiationVcloudWithSsl() throws Exception {
495 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
497 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
498 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
499 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
500 grantResponse.setVimId(VIM_ID);
501 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
502 accessInfo.setTenant(TENANT);
503 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
504 vimInfo.setSslInsecure("false");
505 vimInfo.setSslCacert(caCert);
506 grantResponse.setAccessInfo(accessInfo);
507 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
508 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
510 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
511 waitForJobToFinishInJobManager(finished);
512 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
514 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
515 assertEquals(VIM_ID, actualVim.getId());
516 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
517 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
518 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
519 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
520 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
521 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
522 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
523 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
524 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
525 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
529 * test instantiation with vCloud with SSL
532 public void testInstantiationVcloudWithNonSecifedSSl() throws Exception {
533 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
535 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
536 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
537 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
538 grantResponse.setVimId(VIM_ID);
539 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
540 accessInfo.setTenant(TENANT);
541 vimInfo.setSslInsecure(null);
542 grantResponse.setAccessInfo(accessInfo);
543 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
544 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
546 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
547 waitForJobToFinishInJobManager(finished);
548 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
550 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
551 assertEquals(VIM_ID, actualVim.getId());
552 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
553 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
554 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
555 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
556 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
557 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
558 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
559 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
563 * test failure in the instantiation request marks the job to be finished in job manager
566 public void testFailureInTheInstantiationRequest() throws Exception {
567 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
568 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
569 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
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 grantResponse.setAccessInfo(accessInfo);
575 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
576 RuntimeException expectedException = new RuntimeException();
577 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
580 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
582 waitForJobToFinishInJobManager(finished);
583 assertEquals(VNF_ID, response.getVnfInstanceId());
584 assertEquals(JOB_ID, response.getJobId());
585 verify(logger).error("Unable to instantiate VNF with myVnfId identifier", expectedException);
589 * instantiation fails if VF-C does not send vim identifier in grant response
592 public void testVfcFailsToSendVimId() throws Exception {
593 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
595 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
596 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
597 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
598 //grantResponse.setVimId(VIM_ID);
599 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
600 accessInfo.setTenant(TENANT);
601 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
602 vimInfo.setSslInsecure("false");
603 vimInfo.setSslCacert(caCert);
604 grantResponse.setAccessInfo(accessInfo);
605 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
606 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
608 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
609 waitForJobToFinishInJobManager(finished);
610 assertEquals(0, actualInstantiationRequest.getAllValues().size());
612 verify(logger).error("VF-C did not send VIM identifier in grant response");
617 * test operation execution polling is retried in case of failures
620 public void testFailureInTheOperationExecutionPollingDuringInstantiationRequest() throws Exception {
621 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
622 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
623 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
624 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
625 grantResponse.setVimId(VIM_ID);
626 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
627 accessInfo.setTenant(TENANT);
628 grantResponse.setAccessInfo(accessInfo);
629 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
630 List<RuntimeException> polling = new ArrayList<>();
631 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
632 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).then(new Answer<Observable<List<OperationExecution>>>() {
634 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
635 if (polling.size() > 2) {
636 return buildObservable(operationExecutions);
638 RuntimeException runtimeException = new RuntimeException();
639 polling.add(runtimeException);
640 throw runtimeException;
644 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
646 waitForJobToFinishInJobManager(finished);
647 assertEquals(VNF_ID, response.getVnfInstanceId());
648 assertEquals(JOB_ID, response.getJobId());
649 assertEquals(3, polling.size());
650 for (RuntimeException e : polling) {
651 verify(logger).warn("Unable to retrieve operations details", e);
653 verify(systemFunctions, Mockito.times(3)).sleep(5000);
657 * failure in VNF creation is logged an proagated
660 public void failureInVnfCreationIsPropagated() throws Exception {
662 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
664 RuntimeException expectedException = new RuntimeException();
665 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
668 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
671 } catch (RuntimeException e) {
672 assertEquals(expectedException, e.getCause());
673 verify(logger).error("Unable to create the VNF", expectedException);
678 * failure in updating the modifyable attributes of the VNF is logged an proagated
681 public void failureInVnfModificationIsPropagated() throws Exception {
683 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
685 RuntimeException expectedException = new RuntimeException();
686 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
687 when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
691 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
694 } catch (RuntimeException e) {
695 assertEquals(expectedException, e.getCause().getCause());
696 verify(logger).error("Unable to set the onapCsarId property on the VNF", expectedException);
701 * if the VIM info can not be queried the VNF is not instantiated and
702 * error propagated through job
705 public void testFailureInQueryVimInfo() throws Exception {
706 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
707 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
708 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
709 grantResponse.setVimId(VIM_ID);
710 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
711 accessInfo.setTenant(TENANT);
712 grantResponse.setAccessInfo(accessInfo);
714 when(vimInfoProvider.getVimInfo(VIM_ID)).thenThrow(new RuntimeException());
716 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
718 waitForJobToFinishInJobManager(finished);
719 verify(vnfApi, never()).vnfsVnfInstanceIdInstantiatePost(Mockito.any(), Mockito.any(), Mockito.any());
723 * test termination basic success scenario
724 * - the VNF is not deleted before the notifications are processed
727 public void testTermination() throws Exception {
729 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
730 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
731 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
732 vnfInfo.setOperationExecutions(operationExecutions);
733 VnfProperty vnfdId = new VnfProperty();
734 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
735 vnfdId.setValue(ONAP_CSAR_ID);
736 vnfInfo.getExtensions().add(vnfdId);
737 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
738 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
740 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
741 OperationExecution terminationOperation = new OperationExecution();
742 terminationOperation.setId("terminationId");
743 operationExecutions.add(terminationOperation);
744 terminationOperation.setStatus(OperationStatus.FINISHED);
745 return buildObservable(terminationOperation);
748 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
749 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
751 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
753 waitForJobToFinishInJobManager(finished);
754 assertEquals(1, actualTerminationRequest.getAllValues().size());
755 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
756 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
757 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
758 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
759 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
760 verify(jobManager).spawnJob(VNF_ID, restResponse);
761 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
765 * test termination of a non instantiated VNF
766 * - the VNF is not terminated (only deleted)
769 public void testTerminationOfNonInstantiated() throws Exception {
771 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
772 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
773 vnfInfo.setInstantiationState(InstantiationState.NOT_INSTANTIATED);
774 vnfInfo.setOperationExecutions(operationExecutions);
775 VnfProperty vnfdId = new VnfProperty();
776 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
777 vnfdId.setValue(ONAP_CSAR_ID);
778 vnfInfo.getExtensions().add(vnfdId);
779 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
780 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
782 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
784 boolean deleted = false;
788 verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
793 verify(vfcGrantManager, never()).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
794 verify(notificationManager, never()).waitForTerminationToBeProcessed("terminationId");
798 * test that the VNF deletion is not started before the termination finishes
801 public void testTerminationOperationIsOutwaited() throws Exception {
803 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
804 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
805 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
806 vnfInfo.setOperationExecutions(operationExecutions);
807 VnfProperty vnfdId = new VnfProperty();
808 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
809 vnfdId.setValue(ONAP_CSAR_ID);
810 vnfInfo.getExtensions().add(vnfdId);
811 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
812 OperationExecution terminationOperation = new OperationExecution();
813 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
814 terminationOperation.setId("terminationId");
815 operationExecutions.add(terminationOperation);
816 terminationOperation.setStatus(OperationStatus.STARTED);
817 return buildObservable(terminationOperation);
819 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
820 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
821 Set<Integer> calls = new HashSet<>();
822 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(invocation -> {
823 if (calls.size() == 1000) {
824 terminationOperation.setStatus(OperationStatus.FINISHED);
826 calls.add(calls.size());
827 return buildObservable(operationExecutions);
830 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
832 waitForJobToFinishInJobManager(finished);
833 verify(vnfApi, times(1001)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
834 verify(systemFunctions, times(1000)).sleep(5000);
839 * test that failured during waiting for the operation to finish is tolerated (idefineiatelly)
842 public void testTerminationOperationIsOutwaitedWithErrors() throws Exception {
844 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
845 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
846 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
847 vnfInfo.setOperationExecutions(operationExecutions);
848 VnfProperty vnfdId = new VnfProperty();
849 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
850 vnfdId.setValue(ONAP_CSAR_ID);
851 vnfInfo.getExtensions().add(vnfdId);
852 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
853 OperationExecution terminationOperation = new OperationExecution();
854 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
856 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
857 terminationOperation.setId("terminationId");
858 operationExecutions.add(terminationOperation);
859 terminationOperation.setStatus(OperationStatus.STARTED);
860 return buildObservable(terminationOperation);
863 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
864 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
865 Set<Integer> calls = new HashSet<>();
866 List<RuntimeException> expectedExceptions = new ArrayList<>();
867 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
869 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
870 if (calls.size() >= 100) {
871 terminationOperation.setStatus(OperationStatus.FINISHED);
872 return buildObservable(operationExecutions);
874 calls.add(calls.size());
875 RuntimeException RuntimeException = new RuntimeException();
876 expectedExceptions.add(RuntimeException);
877 throw RuntimeException;
881 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
883 waitForJobToFinishInJobManager(finished);
884 verify(vnfApi, times(101)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
885 verify(systemFunctions, times(100)).sleep(5000);
886 for (RuntimeException expectedException : expectedExceptions) {
887 verify(logger).warn("Unable to retrieve operations details", expectedException);
892 * test gracefull termination
895 public void testGracefullTermination() throws Exception {
897 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
898 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
899 terminationRequest.setTerminationType(VnfTerminationType.GRACEFUL);
900 terminationRequest.setGracefulTerminationTimeout("1234");
901 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
902 vnfInfo.setOperationExecutions(operationExecutions);
903 VnfProperty vnfdId = new VnfProperty();
904 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
905 vnfdId.setValue(ONAP_CSAR_ID);
906 vnfInfo.getExtensions().add(vnfdId);
907 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
908 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
910 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
911 OperationExecution terminationOperation = new OperationExecution();
912 terminationOperation.setId("terminationId");
913 operationExecutions.add(terminationOperation);
914 terminationOperation.setStatus(OperationStatus.FINISHED);
915 return buildObservable(terminationOperation);
918 doAnswer(invocation -> {
919 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
921 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
922 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
923 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
925 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
927 waitForJobToFinishInJobManager(finished);
928 assertEquals(1, actualTerminationRequest.getAllValues().size());
929 assertEquals(TerminationType.GRACEFUL, actualTerminationRequest.getValue().getTerminationType());
930 assertEquals(Integer.valueOf(1234), actualTerminationRequest.getValue().getGracefulTerminationTimeout());
931 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
932 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
933 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
934 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
938 * instantiation with missing ONAP csarId to instantiation extra param result in failure
941 public void testMissingVnfParameters() throws Exception {
943 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
944 String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "invalid" + "\" : {}}}, \"vimId\" : \"" + VIM_ID + "\"}";
945 instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
948 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
950 } catch (Exception e) {
951 assertEquals("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id", e.getMessage());
952 verify(logger).error("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id");
957 * test explicit forceful termination
960 public void testExplicitForcefulTermination() throws Exception {
962 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
963 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
964 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
965 terminationRequest.setGracefulTerminationTimeout("1234");
966 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
967 vnfInfo.setOperationExecutions(operationExecutions);
968 VnfProperty vnfdId = new VnfProperty();
969 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
970 vnfdId.setValue(ONAP_CSAR_ID);
971 vnfInfo.getExtensions().add(vnfdId);
972 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
973 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
974 OperationExecution terminationOperation = new OperationExecution();
975 terminationOperation.setId("terminationId");
976 operationExecutions.add(terminationOperation);
977 terminationOperation.setStatus(OperationStatus.FINISHED);
978 return buildObservable(terminationOperation);
980 doAnswer(invocation -> {
981 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
983 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
984 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
985 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
987 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
989 waitForJobToFinishInJobManager(finished);
990 assertEquals(1, actualTerminationRequest.getAllValues().size());
991 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
992 assertNull(actualTerminationRequest.getValue().getGracefulTerminationTimeout());
993 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
994 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
995 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
996 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1000 * test failure in the termination workflow finishes the job
1003 public void testFailureInTheTerminationFinishesTheManagedJob() throws Exception {
1005 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1006 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1007 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1008 terminationRequest.setGracefulTerminationTimeout("1234");
1009 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1010 vnfInfo.setOperationExecutions(operationExecutions);
1011 VnfProperty vnfdId = new VnfProperty();
1012 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1013 vnfdId.setValue(ONAP_CSAR_ID);
1014 vnfInfo.getExtensions().add(vnfdId);
1015 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1016 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
1018 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
1019 OperationExecution terminationOperation = new OperationExecution();
1020 terminationOperation.setId("terminationId");
1021 operationExecutions.add(terminationOperation);
1022 terminationOperation.setStatus(OperationStatus.FINISHED);
1023 return terminationOperation;
1026 RuntimeException expectedException = new RuntimeException();
1027 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1028 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1029 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1031 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1033 waitForJobToFinishInJobManager(finished);
1034 assertEquals(0, actualTerminationRequest.getAllValues().size());
1035 Mockito.verifyZeroInteractions(vfcGrantManager);
1039 * if termination fails the VNF is not deleted
1042 public void testFailedTerminationAbortsTerminationWorkflow() throws Exception {
1044 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1045 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1046 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1047 vnfInfo.setOperationExecutions(operationExecutions);
1048 VnfProperty vnfdId = new VnfProperty();
1049 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1050 vnfdId.setValue(ONAP_CSAR_ID);
1051 vnfInfo.getExtensions().add(vnfdId);
1052 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1053 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1055 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1056 OperationExecution terminationOperation = new OperationExecution();
1057 terminationOperation.setId("terminationId");
1058 operationExecutions.add(terminationOperation);
1059 terminationOperation.setStatus(OperationStatus.FAILED);
1060 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));
1066 JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1068 waitForJobToFinishInJobManager(finished);
1069 assertEquals(1, actualTerminationRequest.getAllValues().size());
1070 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1071 verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1072 verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1073 verify(logger).error("Unable to terminate VNF the operation did not finish with success");
1077 * test VNF query basic success scenario
1080 public void testQuery() throws Exception {
1081 vnfInfo.setDescription("myDescription");
1082 vnfInfo.setName("myName");
1083 vnfInfo.setVnfSoftwareVersion("vnfSoftwareVersion");
1084 vnfInfo.setVnfProvider("myProvider");
1085 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1086 VnfProperty prop = new VnfProperty();
1087 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1088 prop.setValue(ONAP_CSAR_ID);
1089 vnfInfo.getExtensions().add(prop);
1091 org.onap.vnfmdriver.model.VnfInfo vnf = lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1093 assertEquals(VNF_ID, vnf.getVnfInstanceId());
1094 //FIXME ? (do not know what exactly the vnf version mean in core terminology)
1095 assertEquals("vnfSoftwareVersion", vnf.getVersion());
1096 assertEquals(ONAP_CSAR_ID, vnf.getVnfdId());
1097 assertEquals("myDescription", vnf.getVnfInstanceDescription());
1098 assertEquals("myName", vnf.getVnfInstanceName());
1099 assertEquals(ONAP_CSAR_ID, vnf.getVnfPackageId());
1100 assertEquals("myProvider", vnf.getVnfProvider());
1101 //FIXME (in swagger schema )
1102 assertEquals("ACTIVE", vnf.getVnfStatus());
1103 assertEquals("Kuku", vnf.getVnfType());
1107 * error is propagated and logged if the queried VNF does not exist
1110 public void testQueryForNonExistingVnf() throws Exception {
1112 RuntimeException expectedException = new RuntimeException();
1113 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1116 lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1119 } catch (Exception e) {
1120 verify(logger).error("Unable to query VNF (myVnfId)", expectedException);
1121 assertEquals(expectedException, e.getCause());
1126 * test scale basic scenario
1129 public void testScale() throws Exception {
1130 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1131 scaleRequest.setNumberOfSteps("2");
1132 scaleRequest.setAspectId("myAspect");
1133 scaleRequest.setType(ScaleDirection.IN);
1134 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }"));
1135 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1136 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1137 VnfProperty prop = new VnfProperty();
1138 prop.setValue(ONAP_CSAR_ID);
1139 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1140 vnfInfo.getExtensions().add(prop);
1141 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1142 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1143 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1145 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1147 waitForJobToFinishInJobManager(finished);
1148 assertEquals(1, actualScaleRequest.getAllValues().size());
1149 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1150 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1151 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1152 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1153 assertEquals("myAspect", sRequest.getAspectId());
1154 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1155 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1156 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1157 verify(jobManager).spawnJob(VNF_ID, restResponse);
1158 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("scale"), eq(VNF_ID), anyString());
1163 * the VNFM should tolerate that no additional params were supplied
1166 public void testScaleWithoutAddtionalParams() throws Exception {
1167 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1168 scaleRequest.setNumberOfSteps("2");
1169 scaleRequest.setAspectId("myAspect");
1170 scaleRequest.setType(ScaleDirection.IN);
1171 scaleRequest.setAdditionalParam(null);
1172 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1173 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1174 VnfProperty prop = new VnfProperty();
1175 prop.setValue(ONAP_CSAR_ID);
1176 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1177 vnfInfo.getExtensions().add(prop);
1178 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1179 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1180 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1182 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1184 waitForJobToFinishInJobManager(finished);
1185 assertEquals(1, actualScaleRequest.getAllValues().size());
1186 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1187 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1188 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1189 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1190 assertEquals("myAspect", sRequest.getAspectId());
1191 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1192 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1193 assertEquals("{\"jobId\":\"myJobId\"}", new Gson().toJson(sRequest.getAdditionalParams()));
1194 verify(jobManager).spawnJob(VNF_ID, restResponse);
1198 * test scale out basic scenario
1201 public void testScaleOut() throws Exception {
1202 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1203 scaleRequest.setNumberOfSteps("2");
1204 scaleRequest.setAspectId("myAspect");
1205 scaleRequest.setType(ScaleDirection.OUT);
1206 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1207 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1208 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1209 VnfProperty prop = new VnfProperty();
1210 prop.setValue(ONAP_CSAR_ID);
1211 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1212 vnfInfo.getExtensions().add(prop);
1213 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1214 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1215 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1217 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1219 waitForJobToFinishInJobManager(finished);
1220 assertEquals(1, actualScaleRequest.getAllValues().size());
1221 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1222 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1223 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1224 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1225 assertEquals("myAspect", sRequest.getAspectId());
1226 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.OUT, sRequest.getType());
1227 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1228 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1232 * test scale operation is out waited
1235 public void testScaleOutwait() throws Exception {
1236 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1237 scaleRequest.setNumberOfSteps("2");
1238 scaleRequest.setAspectId("myAspect");
1239 scaleRequest.setType(ScaleDirection.IN);
1240 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1241 scaleOperationExecution.setStatus(OperationStatus.STARTED);
1242 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1243 VnfProperty prop = new VnfProperty();
1244 prop.setValue(ONAP_CSAR_ID);
1245 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1246 vnfInfo.getExtensions().add(prop);
1247 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1248 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1249 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1250 List<RuntimeException> expectedExceptions = new ArrayList<>();
1251 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<Observable<List<OperationExecution>>>) invocation -> {
1252 if (expectedExceptions.size() >= 100) {
1253 when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(scaleOperationExecution));
1254 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1255 return buildObservable(operationExecutions);
1257 RuntimeException RuntimeException = new RuntimeException();
1258 expectedExceptions.add(RuntimeException);
1259 throw RuntimeException;
1263 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1265 waitForJobToFinishInJobManager(finished);
1266 assertEquals(100, expectedExceptions.size());
1267 for (RuntimeException expectedException : expectedExceptions) {
1268 verify(logger).warn("Unable to retrieve operations details", expectedException);
1270 verify(systemFunctions, times(100)).sleep(5000);
1274 * test scale failure propagation
1277 public void testScaleFailurePropagation() throws Exception {
1278 RuntimeException expectedException = new RuntimeException();
1279 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1280 scaleRequest.setNumberOfSteps("2");
1281 scaleRequest.setAspectId("myAspect");
1282 scaleRequest.setType(ScaleDirection.IN);
1283 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1285 lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1287 waitForJobToFinishInJobManager(finished);
1288 verify(logger).error("Unable to scale VNF with myVnfId identifier", expectedException);
1292 * test heal basic scenario
1295 public void testHeal() throws Exception {
1296 VnfHealRequest healRequest = new VnfHealRequest();
1297 healRequest.setAction("myAction");
1298 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1299 affectedVm.setVmname("vmName");
1300 healRequest.setAffectedvm(affectedVm);
1301 healOperationExecution.setStatus(OperationStatus.FINISHED);
1302 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1303 VnfProperty prop = new VnfProperty();
1304 prop.setValue(ONAP_CSAR_ID);
1305 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1306 vnfInfo.getExtensions().add(prop);
1307 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1308 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1309 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1311 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1313 waitForJobToFinishInJobManager(finished);
1314 assertEquals(1, actualHealRequest.getAllValues().size());
1315 HealVnfRequest sRequest = actualHealRequest.getValue();
1316 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1317 workflowOrder.verify(vfcGrantManager).requestGrantForHeal(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(healRequest), eq(JOB_ID));
1318 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdHealPost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1319 JsonObject root = new Gson().toJsonTree(sRequest.getAdditionalParams()).getAsJsonObject();
1320 assertEquals("myAction", root.get("action").getAsString());
1321 assertEquals("vmName", root.get("vmName").getAsString());
1322 assertEquals(JOB_ID, root.get("jobId").getAsString());
1323 verify(jobManager).spawnJob(VNF_ID, restResponse);
1324 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("heal"), eq(VNF_ID), anyString());
1328 * test heal operation is out waited
1331 public void testHealOutwait() throws Exception {
1332 VnfHealRequest healRequest = new VnfHealRequest();
1333 healRequest.setAction("myAction");
1334 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1335 affectedVm.setVmname("vmName");
1336 healRequest.setAffectedvm(affectedVm);
1337 healOperationExecution.setStatus(OperationStatus.FINISHED);
1338 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1339 VnfProperty prop = new VnfProperty();
1340 prop.setValue(ONAP_CSAR_ID);
1341 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1342 vnfInfo.getExtensions().add(prop);
1343 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1344 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1345 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1346 List<RuntimeException> expectedExceptions = new ArrayList<>();
1347 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
1349 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
1350 if (expectedExceptions.size() >= 100) {
1351 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1352 return buildObservable(operationExecutions);
1354 RuntimeException RuntimeException = new RuntimeException();
1355 expectedExceptions.add(RuntimeException);
1356 throw RuntimeException;
1360 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1362 waitForJobToFinishInJobManager(finished);
1363 assertEquals(100, expectedExceptions.size());
1364 for (RuntimeException expectedException : expectedExceptions) {
1365 verify(logger).warn("Unable to retrieve operations details", expectedException);
1367 verify(systemFunctions, times(100)).sleep(5000);
1371 * failure in heal propagates in error
1374 public void testHealFailurePropagation() throws Exception {
1375 RuntimeException expectedException = new RuntimeException();
1376 VnfHealRequest healRequest = new VnfHealRequest();
1377 healRequest.setAction("myAction");
1378 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1379 affectedVm.setVmname("vmName");
1380 healRequest.setAffectedvm(affectedVm);
1381 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1383 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1385 waitForJobToFinishInJobManager(finished);
1386 verify(logger).error("Unable to heal VNF with myVnfId identifier", expectedException);
1389 private void waitForJobToFinishInJobManager(Set<Boolean> finished) throws InterruptedException {
1390 while (finished.size() == 0) {
1391 systemFunctions().sleep(100);
1395 private VnfInstantiateRequest prepareInstantiationRequest(VimInfo.VimInfoTypeEnum cloudType) {
1396 VnfInstantiateRequest instantiationRequest = new VnfInstantiateRequest();
1397 instantiationRequest.setVnfPackageId(ONAP_CSAR_ID);
1398 instantiationRequest.setVnfDescriptorId(ONAP_CSAR_ID);
1399 instantiationRequest.setVnfInstanceDescription("myDescription");
1400 instantiationRequest.setVnfInstanceName("vnfName");
1401 additionalParam.setInstantiationLevel("level1");
1402 switch (cloudType) {
1403 case OPENSTACK_V2_INFO:
1404 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1406 case OPENSTACK_V3_INFO:
1407 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
1408 additionalParam.setDomain("myDomain");
1410 case VMWARE_VCLOUD_INFO:
1411 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
1414 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
1417 Map<String, List<NetworkAddress>> exteranalConnectionPointAddresses = new HashMap<>();
1418 exteranalConnectionPointAddresses.put("ecp1", new ArrayList<>());
1419 NetworkAddress networkAddress = new NetworkAddress();
1420 networkAddress.setIp("1.2.3.4");
1421 networkAddress.setMac("mac");
1422 networkAddress.setSubnetId("subnetId");
1423 exteranalConnectionPointAddresses.get("ecp1").add(networkAddress);
1424 additionalParam.setExternalConnectionPointAddresses(exteranalConnectionPointAddresses);
1425 VimComputeResourceFlavour flavor = new VimComputeResourceFlavour();
1426 flavor.setResourceId("flavourProviderId");
1427 flavor.setVimId(VIM_ID);
1428 flavor.setVnfdVirtualComputeDescId("virtualComputeDescId");
1429 additionalParam.getComputeResourceFlavours().add(flavor);
1430 ExtVirtualLinkData evl = new ExtVirtualLinkData();
1431 evl.setResourceId("networkProviderId1");
1432 evl.setVimId(VIM_ID);
1433 evl.setExtVirtualLinkId("evlId1");
1434 VnfExtCpData ecp2 = new VnfExtCpData();
1435 ecp2.setCpdId("cpdId3");
1436 ecp2.setAddresses(new ArrayList<>());
1437 ecp2.getAddresses().add(networkAddress);
1438 ecp2.setNumDynamicAddresses(2);
1439 evl.getExtCps().add(ecp2);
1440 additionalParam.getExtVirtualLinks().add(evl);
1441 externalVirtualLink.setCpdId("myCpdId");
1442 externalVirtualLink.setResourceId("myNetworkProviderId");
1443 externalVirtualLink.setVlInstanceId("myEVlId");
1444 externalVirtualLink.setResourceSubnetId("notUsedSubnetId");
1445 instantiationRequest.setExtVirtualLink(new ArrayList<>());
1446 instantiationRequest.getExtVirtualLink().add(externalVirtualLink);
1447 additionalParam.getExtManagedVirtualLinks().add(extManVl);
1448 ZoneInfo zone = new ZoneInfo();
1449 zone.setId("zoneId");
1450 zone.setResourceId("zoneProviderId");
1451 zone.setVimId(VIM_ID);
1452 additionalParam.getZones().add(zone);
1453 VimSoftwareImage image = new VimSoftwareImage();
1454 image.setResourceId("imageProviderId");
1455 image.setVimId(VIM_ID);
1456 image.setVnfdSoftwareImageId("imageId");
1457 additionalParam.getSoftwareImages().add(image);
1458 additionalParam.setAdditionalParams(new JsonParser().parse("{ \"a\" : \"b\" }"));
1459 String params = new Gson().toJson(additionalParam);
1460 String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "\" : " + params + "}}, \"vimId\" : \"" + VIM_ID + "\"}";
1461 instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
1462 return instantiationRequest;
1466 * Test vimId decomposition
1469 public void testVimIdSplitting() {
1470 assertEquals("regionId", LifecycleManager.getRegionName("cloudOwner_regionId"));
1471 assertEquals("cloudOwner", LifecycleManager.getCloudOwner("cloudOwner_regionId"));