2 * Copyright 2016-2017, Nokia Corporation
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
16 package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
18 import com.google.gson.*;
19 import com.google.gson.annotations.SerializedName;
20 import com.nokia.cbam.catalog.v1.model.CatalogAdapterVnfpackage;
21 import com.nokia.cbam.lcm.v32.model.*;
22 import com.nokia.cbam.lcm.v32.model.OperationType;
23 import com.nokia.cbam.lcm.v32.model.VimInfo;
24 import com.nokia.cbam.lcm.v32.model.VnfInfo;
25 import io.reactivex.Observable;
26 import java.nio.file.Paths;
28 import javax.servlet.http.HttpServletResponse;
29 import org.assertj.core.util.Lists;
30 import org.junit.Before;
31 import org.junit.Test;
32 import org.mockito.ArgumentCaptor;
33 import org.mockito.InOrder;
34 import org.mockito.Mock;
35 import org.mockito.Mockito;
36 import org.mockito.invocation.InvocationOnMock;
37 import org.mockito.stubbing.Answer;
38 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VimInfoProvider;
39 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.TestVfcGrantManager;
40 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.VfcGrantManager;
41 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.StoreLoader;
42 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.LifecycleChangeNotificationManager;
43 import org.onap.vnfmdriver.model.ExtVirtualLinkInfo;
44 import org.onap.vnfmdriver.model.*;
45 import org.onap.vnfmdriver.model.ScaleDirection;
46 import org.threeten.bp.OffsetDateTime;
48 import static java.lang.Boolean.parseBoolean;
49 import static java.nio.file.Files.readAllBytes;
50 import static java.util.Optional.empty;
52 import static junit.framework.TestCase.*;
53 import static org.mockito.Mockito.*;
54 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.child;
55 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.childElement;
56 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions.systemFunctions;
57 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
58 import static org.springframework.test.util.ReflectionTestUtils.setField;
60 public class TestLifecycleManager extends TestBase {
61 public static final String JOB_ID = "myJobId";
62 public static final String CBAM_VNFD_ID = "cbamVnfdId";
63 public static final String TENANT = "myTenant";
64 public static final String OPERATION_EXECUTION_ID = "operationExecutionId";
65 private static final String ONAP_CSAR_ID = "myOnapCsarId";
66 private static final String VIM_ID = "ownerId_regionId";
68 private CatalogManager catalogManager;
70 private VfcGrantManager vfcGrantManager;
72 private JobManager jobManager;
74 private LifecycleChangeNotificationManager notificationManager;
76 private HttpServletResponse restResponse;
78 private VimInfoProvider vimInfoProvider;
80 private ArgumentCaptor<CreateVnfRequest> createRequest = ArgumentCaptor.forClass(CreateVnfRequest.class);
81 private AdditionalParameters additionalParam = new AdditionalParameters();
82 private String INSTANTIATION_LEVEL = "level1";
83 private GrantVNFResponseVim grantResponse = new GrantVNFResponseVim();
84 private String cbamVnfdContent;
85 private OperationExecution instantiationOperationExecution = new OperationExecution();
86 private OperationExecution modifyPropertyoperationExecution = new OperationExecution();
87 private OperationExecution scaleOperationExecution = new OperationExecution();
88 private OperationExecution healOperationExecution = new OperationExecution();
89 private OperationExecution customOperationExecution = new OperationExecution();
92 private VnfInfo vnfInfo = new VnfInfo();
93 private List<OperationExecution> operationExecutions = new ArrayList<>();
94 private org.onap.vnfmdriver.model.VimInfo vimInfo = new org.onap.vnfmdriver.model.VimInfo();
95 private ExtVirtualLinkInfo externalVirtualLink = new ExtVirtualLinkInfo();
96 private ExtManagedVirtualLinkData extManVl = new ExtManagedVirtualLinkData();
97 private ArgumentCaptor<ModifyVnfInfoRequest> actualVnfModifyRequest = ArgumentCaptor.forClass(ModifyVnfInfoRequest.class);
98 private Set<Boolean> finished = new HashSet<>();
99 private ArgumentCaptor<ScaleVnfRequest> actualScaleRequest = ArgumentCaptor.forClass(ScaleVnfRequest.class);
100 private ArgumentCaptor<HealVnfRequest> actualHealRequest = ArgumentCaptor.forClass(HealVnfRequest.class);
101 private ArgumentCaptor<CustomOperationRequest> customOperationRequestArgumentCaptor = ArgumentCaptor.forClass(CustomOperationRequest.class);
102 private ArgumentCaptor<String> operationIdCaptor = ArgumentCaptor.forClass(String.class);
104 private LifecycleManager lifecycleManager;
107 public void initMocks() throws Exception {
108 vnfInfo.setExtensions(new ArrayList<>());
109 vnfInfo.setOperationExecutions(new ArrayList<>());
110 lifecycleManager = new LifecycleManager(catalogManager, vfcGrantManager, cbamRestApiProvider, vimInfoProvider, jobManager, notificationManager);
111 cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.full.yaml").toURI())));
112 setField(LifecycleManager.class, "logger", logger);
113 CatalogAdapterVnfpackage cbamPackage = new CatalogAdapterVnfpackage();
114 when(catalogManager.preparePackageInCbam(VNFM_ID, ONAP_CSAR_ID)).thenReturn(cbamPackage);
115 cbamPackage.setVnfdId(CBAM_VNFD_ID);
116 vnfInfo.setVnfdId(CBAM_VNFD_ID);
117 vnfInfo.setId(VNF_ID);
118 when(jobManager.spawnJob(VNF_ID, restResponse)).thenReturn(JOB_ID);
119 when(catalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent);
120 cbamPackage.setId(CBAM_VNFD_ID);
121 vimInfo.setUrl("cloudUrl");
122 vimInfo.setPassword("vimPassword");
123 vimInfo.setUserName("vimUsername");
124 vimInfo.setSslInsecure("true");
125 vimInfo.setVimId(VIM_ID);
126 vimInfo.setName("vimName");
127 when(vimInfoProvider.getVimInfo((VIM_ID))).thenReturn(vimInfo);
128 instantiationOperationExecution.setId(OPERATION_EXECUTION_ID);
129 instantiationOperationExecution.setOperationType(OperationType.INSTANTIATE);
130 instantiationOperationExecution.setStartTime(OffsetDateTime.now());
131 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecutions));
132 operationExecutions.add(modifyPropertyoperationExecution);
133 modifyPropertyoperationExecution.setStartTime(OffsetDateTime.now());
134 modifyPropertyoperationExecution.setOperationType(OperationType.MODIFY_INFO);
135 operationExecutions.add(instantiationOperationExecution);
136 instantiationOperationExecution.setStatus(OperationStatus.FINISHED);
137 modifyPropertyoperationExecution.setStatus(OperationStatus.FINISHED);
138 customOperationExecution.setStatus(OperationStatus.FINISHED);
139 modifyPropertyoperationExecution.setId(UUID.randomUUID().toString());
140 scaleOperationExecution.setId(UUID.randomUUID().toString());
141 healOperationExecution.setId(UUID.randomUUID().toString());
142 customOperationExecution.setId(UUID.randomUUID().toString());
144 when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(modifyPropertyoperationExecution));
145 doAnswer(new Answer() {
147 public Object answer(InvocationOnMock invocation) throws Throwable {
148 finished.add(Boolean.TRUE);
151 }).when(jobManager).jobFinished(JOB_ID);
152 when(vnfApi.vnfsVnfInstanceIdScalePost(eq(VNF_ID), actualScaleRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
154 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
155 operationExecutions.add(scaleOperationExecution);
156 return buildObservable(scaleOperationExecution);
159 when(vnfApi.vnfsVnfInstanceIdHealPost(eq(VNF_ID), actualHealRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
161 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
162 operationExecutions.add(healOperationExecution);
163 return buildObservable(healOperationExecution);
166 when(vnfApi.vnfsVnfInstanceIdCustomCustomOperationNamePost(eq(VNF_ID), operationIdCaptor.capture(), customOperationRequestArgumentCaptor.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
168 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
169 operationExecutions.add(customOperationExecution);
170 return buildObservable(customOperationExecution);
179 public void testInstantiation() throws Exception {
181 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, true);
182 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
183 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
184 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
185 grantResponse.setVimId(VIM_ID);
186 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
187 accessInfo.setTenant(TENANT);
188 grantResponse.setAccessInfo(accessInfo);
189 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
190 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
192 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
193 waitForJobToFinishInJobManager(finished);
195 assertEquals(VNF_ID, response.getVnfInstanceId());
196 assertEquals(JOB_ID, response.getJobId());
197 assertEquals(createRequest.getAllValues().size(), 1);
198 assertEquals("myDescription", createRequest.getValue().getDescription());
199 assertEquals("vnfName", createRequest.getValue().getName());
200 assertEquals(CBAM_VNFD_ID, createRequest.getValue().getVnfdId());
201 assertEquals(1, actualInstantiationRequest.getAllValues().size());
202 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
203 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
204 assertEquals(VIM_ID, actualVim.getId());
205 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, actualVim.getVimInfoType());
206 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
207 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
208 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
209 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
210 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
211 assertEquals("myTenant", actualVim.getAccessInfo().getTenant());
212 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
213 assertEquals(1, actualInstantiationRequest.getValue().getComputeResourceFlavours().size());
214 assertEquals("flavourProviderId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getResourceId());
215 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVimId());
216 assertEquals("virtualComputeDescId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVnfdVirtualComputeDescId());
217 assertEquals(1, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().size());
218 assertEquals(extManVl, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().get(0));
219 assertEquals(2, actualInstantiationRequest.getValue().getExtVirtualLinks().size());
221 assertEquals("myNetworkProviderId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getResourceId());
222 assertEquals("myEVlId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtVirtualLinkId());
223 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().size());
224 assertEquals("myCpdId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().get(0).getCpdId());
226 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getVimId());
227 assertEquals("evlId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtVirtualLinkId());
228 assertEquals("networkProviderId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getResourceId());
229 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().size());
232 assertEquals(Integer.valueOf(2), actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getNumDynamicAddresses());
233 assertEquals("cpdId3", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getCpdId());
234 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().size());
235 assertEquals("1.2.3.4", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getIp());
236 assertEquals("mac", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getMac());
237 assertEquals("subnetId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getSubnetId());
239 assertEquals("myFlavorId", actualInstantiationRequest.getValue().getFlavourId());
240 assertEquals(Boolean.TRUE, actualInstantiationRequest.getValue().isGrantlessMode());
241 assertEquals("level1", actualInstantiationRequest.getValue().getInstantiationLevelId());
242 assertEquals(1, actualInstantiationRequest.getValue().getZones().size());
243 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getZones().get(0).getVimId());
244 assertEquals("zoneProviderId", actualInstantiationRequest.getValue().getZones().get(0).getResourceId());
245 assertEquals("zoneId", actualInstantiationRequest.getValue().getZones().get(0).getId());
246 assertEquals(1, actualInstantiationRequest.getValue().getSoftwareImages().size());
247 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVimId());
248 assertEquals("imageProviderId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getResourceId());
249 assertEquals("imageId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVnfdSoftwareImageId());
250 String actualEmbeddedAdditionParams = new Gson().toJson(actualInstantiationRequest.getValue().getAdditionalParams());
251 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(actualEmbeddedAdditionParams) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(actualEmbeddedAdditionParams));
252 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
253 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
255 assertEquals(2, actualVnfModifyRequest.getAllValues().size());
256 assertEquals(2, actualVnfModifyRequest.getAllValues().get(0).getExtensions().size());
257 assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getAllValues().get(0).getExtensions().get(0).getName());
258 assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getAllValues().get(0).getExtensions().get(0).getValue());
259 assertEquals(LifecycleManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getAllValues().get(0).getExtensions().get(1).getName());
260 assertEquals(VNFM_ID, actualVnfModifyRequest.getAllValues().get(0).getExtensions().get(1).getValue());
262 assertEquals(3, actualVnfModifyRequest.getAllValues().get(1).getExtensions().size());
264 VnfProperty p1 = new VnfProperty();
266 p1.setValue(Lists.newArrayList("a", "b"));
267 VnfProperty p2 = new VnfProperty();
270 VnfProperty p3 = new VnfProperty();
272 JsonObject o = new JsonObject();
274 o.addProperty("a", "b");
275 assertEquals(p1, actualVnfModifyRequest.getAllValues().get(1).getExtensions().get(0));
276 assertEquals("n2", actualVnfModifyRequest.getAllValues().get(1).getExtensions().get(1).getName());
277 HashMap<String, String> expected = new HashMap<>();
278 expected.put("a", "b");
279 assertEquals(expected, actualVnfModifyRequest.getAllValues().get(1).getExtensions().get(1).getValue());
280 assertEquals(p3, actualVnfModifyRequest.getAllValues().get(1).getExtensions().get(2));
282 //the 3.2 API does not accept empty array
283 assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties());
284 verify(jobManager).spawnJob(VNF_ID, restResponse);
285 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
286 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
287 verify(logger).info("The instantiation input for VNF with {} CSAR id does not have a properties section", ONAP_CSAR_ID);
291 * test instantiation with KeyStone V2TOSCA based with SSL
294 public void testInstantiationV2WithSsl() throws Exception {
295 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
296 when(logger.isInfoEnabled()).thenReturn(false);
297 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
298 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
299 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
300 grantResponse.setVimId(VIM_ID);
301 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
302 accessInfo.setTenant(TENANT);
303 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
304 vimInfo.setSslInsecure("false");
305 vimInfo.setSslCacert(caCert);
306 grantResponse.setAccessInfo(accessInfo);
307 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
308 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
309 JsonObject inputs = child((JsonObject) instantiationRequest.getAdditionalParam(), "inputs");
310 JsonObject vnf = new JsonParser().parse(childElement(inputs, ONAP_CSAR_ID).getAsString()).getAsJsonObject();
311 vnf.remove("additionalParams");
312 inputs.add(ONAP_CSAR_ID, new JsonPrimitive(new Gson().toJson(vnf)));
314 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
315 waitForJobToFinishInJobManager(finished);
316 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
318 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
319 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
320 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
321 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
322 verify(logger).warn("No additional parameters were specified for the operation");
323 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), anyString(), anyString(), anyString());
327 * non specified SSL verification means not verified
330 public void testInstantiationV2WithoutSsl() throws Exception {
331 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
333 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
334 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
335 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
336 grantResponse.setVimId(VIM_ID);
337 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
338 accessInfo.setTenant(TENANT);
339 vimInfo.setSslInsecure(null);
340 grantResponse.setAccessInfo(accessInfo);
341 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
342 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
344 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
345 waitForJobToFinishInJobManager(finished);
346 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
348 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
349 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
350 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
354 * test instantiation with KeyStone V3 based
357 public void testInstantiationV3() throws Exception {
358 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, false);
359 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
360 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
361 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
362 grantResponse.setVimId(VIM_ID);
363 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
364 accessInfo.setTenant(TENANT);
365 grantResponse.setAccessInfo(accessInfo);
366 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
367 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
369 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
370 waitForJobToFinishInJobManager(finished);
371 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
373 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
374 assertEquals(VIM_ID, actualVim.getId());
375 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
376 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
377 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
378 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
379 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
380 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
381 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
382 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
383 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
384 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
385 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
389 * test instantiation with backward compatibility test with Amsterdam release
390 * - the vim identifier is supplied as vimid with not camel case
391 * - the access info is supplied as accessinfo with not camel case
394 public void testInstantiationNoVimId() throws Exception {
396 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
397 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
398 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
399 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
400 grantResponse.setVimid(VIM_ID);
401 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
402 accessInfo.setTenant(TENANT);
403 grantResponse.setAccessinfo(accessInfo);
404 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
405 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
407 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
408 waitForJobToFinishInJobManager(finished);
410 assertEquals(VNF_ID, response.getVnfInstanceId());
411 assertEquals(JOB_ID, response.getJobId());
412 assertEquals(createRequest.getAllValues().size(), 1);
413 assertEquals("myDescription", createRequest.getValue().getDescription());
414 assertEquals("vnfName", createRequest.getValue().getName());
415 assertEquals(CBAM_VNFD_ID, createRequest.getValue().getVnfdId());
416 assertEquals(1, actualInstantiationRequest.getAllValues().size());
417 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
418 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
419 assertEquals(VIM_ID, actualVim.getId());
420 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, actualVim.getVimInfoType());
421 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
422 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
423 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
424 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
425 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
426 assertEquals("myTenant", actualVim.getAccessInfo().getTenant());
427 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
428 assertEquals(1, actualInstantiationRequest.getValue().getComputeResourceFlavours().size());
429 assertEquals("flavourProviderId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getResourceId());
430 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVimId());
431 assertEquals("virtualComputeDescId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVnfdVirtualComputeDescId());
432 assertEquals(1, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().size());
433 assertEquals(extManVl, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().get(0));
434 assertEquals(2, actualInstantiationRequest.getValue().getExtVirtualLinks().size());
436 assertEquals("myNetworkProviderId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getResourceId());
437 assertEquals("myEVlId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtVirtualLinkId());
438 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().size());
439 assertEquals("myCpdId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().get(0).getCpdId());
441 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getVimId());
442 assertEquals("evlId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtVirtualLinkId());
443 assertEquals("networkProviderId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getResourceId());
444 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().size());
447 assertEquals(Integer.valueOf(2), actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getNumDynamicAddresses());
448 assertEquals("cpdId3", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getCpdId());
449 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().size());
450 assertEquals("1.2.3.4", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getIp());
451 assertEquals("mac", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getMac());
452 assertEquals("subnetId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getSubnetId());
454 assertEquals("myFlavorId", actualInstantiationRequest.getValue().getFlavourId());
455 assertEquals(Boolean.TRUE, actualInstantiationRequest.getValue().isGrantlessMode());
456 assertEquals("level1", actualInstantiationRequest.getValue().getInstantiationLevelId());
457 assertEquals(1, actualInstantiationRequest.getValue().getZones().size());
458 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getZones().get(0).getVimId());
459 assertEquals("zoneProviderId", actualInstantiationRequest.getValue().getZones().get(0).getResourceId());
460 assertEquals("zoneId", actualInstantiationRequest.getValue().getZones().get(0).getId());
461 assertEquals(1, actualInstantiationRequest.getValue().getSoftwareImages().size());
462 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVimId());
463 assertEquals("imageProviderId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getResourceId());
464 assertEquals("imageId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVnfdSoftwareImageId());
465 String actualEmbeddedAdditionParams = new Gson().toJson(actualInstantiationRequest.getValue().getAdditionalParams());
466 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(actualEmbeddedAdditionParams) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(actualEmbeddedAdditionParams));
467 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
468 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
470 assertEquals(1, actualVnfModifyRequest.getAllValues().size());
471 assertEquals(2, actualVnfModifyRequest.getValue().getExtensions().size());
472 assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getName());
473 assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getValue());
474 assertEquals(LifecycleManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName());
475 assertEquals(VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getValue());
477 //the 3.2 API does not accept empty array
478 assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties());
479 verify(jobManager).spawnJob(VNF_ID, restResponse);
480 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
481 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
485 * test instantiation with KeyStone V3 based with SSL
488 public void testInstantiationV3WithSsl() throws Exception {
489 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, false);
490 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
491 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
492 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
493 grantResponse.setVimId(VIM_ID);
494 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
495 accessInfo.setTenant(TENANT);
496 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
497 vimInfo.setSslInsecure("false");
498 vimInfo.setSslCacert(caCert);
499 grantResponse.setAccessInfo(accessInfo);
500 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
501 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
503 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
504 waitForJobToFinishInJobManager(finished);
505 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
507 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
508 assertEquals(VIM_ID, actualVim.getId());
509 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
510 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
511 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
512 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
513 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
514 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
515 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
516 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
517 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
518 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
519 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
520 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
524 * non specified SSL verification meams not verified for KeyStone V3 based
527 public void testInstantiationV3WithNonSpecifiedSsl() throws Exception {
528 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, false);
529 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
530 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
531 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
532 grantResponse.setVimId(VIM_ID);
533 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
534 accessInfo.setTenant(TENANT);
535 vimInfo.setSslInsecure(null);
536 grantResponse.setAccessInfo(accessInfo);
537 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
538 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
540 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
541 waitForJobToFinishInJobManager(finished);
542 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
544 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
545 assertEquals(VIM_ID, actualVim.getId());
546 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
547 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
548 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
549 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
550 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
551 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
552 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
553 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
554 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
555 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
559 * test instantiation with vcloud
562 public void testInstantiationVcloud() throws Exception {
563 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, false);
565 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
566 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
567 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
568 grantResponse.setVimId(VIM_ID);
569 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
570 accessInfo.setTenant(TENANT);
571 grantResponse.setAccessInfo(accessInfo);
572 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
573 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
575 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
576 waitForJobToFinishInJobManager(finished);
577 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
579 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
580 assertEquals(VIM_ID, actualVim.getId());
581 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
582 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
583 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
584 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
585 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
586 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
587 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
588 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
589 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
593 * test instantiation with vCloud with SSL
596 public void testInstantiationVcloudWithSsl() throws Exception {
597 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, false);
599 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
600 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
601 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
602 grantResponse.setVimId(VIM_ID);
603 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
604 accessInfo.setTenant(TENANT);
605 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
606 vimInfo.setSslInsecure("false");
607 vimInfo.setSslCacert(caCert);
608 grantResponse.setAccessInfo(accessInfo);
609 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
610 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
612 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
613 waitForJobToFinishInJobManager(finished);
614 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
616 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
617 assertEquals(VIM_ID, actualVim.getId());
618 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
619 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
620 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
621 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
622 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
623 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
624 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
625 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
626 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
627 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
631 * test instantiation with vCloud with SSL
634 public void testInstantiationVcloudWithNonSecifedSSl() throws Exception {
635 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, false);
637 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
638 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
639 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
640 grantResponse.setVimId(VIM_ID);
641 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
642 accessInfo.setTenant(TENANT);
643 vimInfo.setSslInsecure(null);
644 grantResponse.setAccessInfo(accessInfo);
645 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
646 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
648 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
649 waitForJobToFinishInJobManager(finished);
650 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
652 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
653 assertEquals(VIM_ID, actualVim.getId());
654 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
655 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
656 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
657 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
658 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
659 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
660 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
661 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
665 * test failure in the instantiation request marks the job to be finished in job manager
668 public void testFailureInTheInstantiationRequest() throws Exception {
669 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
670 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
671 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
672 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
673 grantResponse.setVimId(VIM_ID);
674 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
675 accessInfo.setTenant(TENANT);
676 grantResponse.setAccessInfo(accessInfo);
677 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
678 RuntimeException expectedException = new RuntimeException();
679 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
682 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
684 waitForJobToFinishInJobManager(finished);
685 assertEquals(VNF_ID, response.getVnfInstanceId());
686 assertEquals(JOB_ID, response.getJobId());
687 verify(logger).error("Unable to instantiate VNF with myVnfId identifier", expectedException);
691 * instantiation fails if VF-C does not send vim identifier in grant response
694 public void testVfcFailsToSendVimId() throws Exception {
695 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
697 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
698 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
699 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
700 //grantResponse.setVimId(VIM_ID);
701 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
702 accessInfo.setTenant(TENANT);
703 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
704 vimInfo.setSslInsecure("false");
705 vimInfo.setSslCacert(caCert);
706 grantResponse.setAccessInfo(accessInfo);
707 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
708 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
710 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
711 waitForJobToFinishInJobManager(finished);
712 assertEquals(0, actualInstantiationRequest.getAllValues().size());
714 verify(logger).error("VF-C did not send VIM identifier in grant response");
718 * instantiation fails if VF-C does not send access info in grant response
721 public void testVfcFailsToSendAccessInfo() throws Exception {
722 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
724 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
725 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
726 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
727 grantResponse.setVimId(VIM_ID);
728 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
729 accessInfo.setTenant(TENANT);
730 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
731 vimInfo.setSslInsecure("false");
732 vimInfo.setSslCacert(caCert);
733 //grantResponse.setAccessInfo(accessInfo);
734 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
735 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
737 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
738 waitForJobToFinishInJobManager(finished);
739 assertEquals(0, actualInstantiationRequest.getAllValues().size());
741 verify(logger).error("VF-C did not send access info in grant response");
745 * test operation execution polling is retried in case of failures
748 public void testFailureInTheOperationExecutionPollingDuringInstantiationRequest() throws Exception {
749 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
750 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
751 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
752 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
753 grantResponse.setVimId(VIM_ID);
754 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
755 accessInfo.setTenant(TENANT);
756 grantResponse.setAccessInfo(accessInfo);
757 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
758 List<RuntimeException> polling = new ArrayList<>();
759 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
760 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).then(new Answer<Observable<List<OperationExecution>>>() {
762 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
763 if (polling.size() > 2) {
764 return buildObservable(operationExecutions);
766 RuntimeException runtimeException = new RuntimeException();
767 polling.add(runtimeException);
768 throw runtimeException;
772 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
774 waitForJobToFinishInJobManager(finished);
775 assertEquals(VNF_ID, response.getVnfInstanceId());
776 assertEquals(JOB_ID, response.getJobId());
777 assertEquals(3, polling.size());
778 for (RuntimeException e : polling) {
779 verify(logger).warn("Unable to retrieve operations details", e);
781 verify(systemFunctions, Mockito.times(3)).sleep(5000);
785 * failure in VNF creation is logged an proagated
788 public void failureInVnfCreationIsPropagated() throws Exception {
790 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
792 RuntimeException expectedException = new RuntimeException();
793 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
796 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
799 } catch (RuntimeException e) {
800 assertEquals(expectedException, e.getCause());
801 verify(logger).error("Unable to create the VNF", expectedException);
806 * failure in updating the modifyable attributes of the VNF is logged an proagated
809 public void failureInVnfModificationIsPropagated() throws Exception {
811 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
813 RuntimeException expectedException = new RuntimeException();
814 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
815 when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
819 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
822 } catch (RuntimeException e) {
823 assertEquals(expectedException, e.getCause().getCause());
824 verify(logger).error("Unable to set the externalVnfmId,onapCsarId properties on the VNF with " + VNF_ID + " identifier", expectedException);
829 * if the VIM info can not be queried the VNF is not instantiated and
830 * error propagated through job
833 public void testFailureInQueryVimInfo() throws Exception {
834 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
835 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
836 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
837 grantResponse.setVimId(VIM_ID);
838 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
839 accessInfo.setTenant(TENANT);
840 grantResponse.setAccessInfo(accessInfo);
842 when(vimInfoProvider.getVimInfo(VIM_ID)).thenThrow(new RuntimeException());
844 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
846 waitForJobToFinishInJobManager(finished);
847 verify(vnfApi, never()).vnfsVnfInstanceIdInstantiatePost(Mockito.any(), Mockito.any(), Mockito.any());
851 * test termination basic success scenario
852 * - the VNF is not deleted before the notifications are processed
855 public void testTerminationAndDeletion() throws Exception {
857 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
858 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
859 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
860 vnfInfo.setOperationExecutions(operationExecutions);
861 VnfProperty vnfdId = new VnfProperty();
862 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
863 vnfdId.setValue(ONAP_CSAR_ID);
864 vnfInfo.getExtensions().add(vnfdId);
865 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
866 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
868 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
869 OperationExecution terminationOperation = new OperationExecution();
870 terminationOperation.setId("terminationId");
871 operationExecutions.add(terminationOperation);
872 terminationOperation.setStatus(OperationStatus.FINISHED);
873 return buildObservable(terminationOperation);
876 when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
877 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
878 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
880 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
882 waitForJobToFinishInJobManager(finished);
883 assertEquals(1, actualTerminationRequest.getAllValues().size());
884 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
885 assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
886 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
887 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
888 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
889 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
890 VOID_OBSERVABLE.assertCalled();
891 verify(jobManager).spawnJob(VNF_ID, restResponse);
892 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
896 * test termination basic success scenario
897 * - the VNF is not deleted before the notifications are processed
900 public void testTermination() throws Exception {
902 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
903 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
904 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
905 vnfInfo.setOperationExecutions(operationExecutions);
906 VnfProperty vnfdId = new VnfProperty();
907 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
908 vnfdId.setValue(ONAP_CSAR_ID);
909 vnfInfo.getExtensions().add(vnfdId);
910 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
911 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
913 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
914 OperationExecution terminationOperation = new OperationExecution();
915 terminationOperation.setId("terminationId");
916 operationExecutions.add(terminationOperation);
917 terminationOperation.setStatus(OperationStatus.FINISHED);
918 return buildObservable(terminationOperation);
921 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
922 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
924 JobInfo jobInfo = lifecycleManager.terminate(VNFM_ID, VNF_ID, terminationRequest, restResponse);
926 waitForJobToFinishInJobManager(finished);
927 assertEquals(1, actualTerminationRequest.getAllValues().size());
928 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
929 assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
930 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
931 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
932 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
933 verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
934 verify(jobManager).spawnJob(VNF_ID, restResponse);
935 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
939 * test termination of a non instantiated VNF
940 * - the VNF is not terminated (only deleted)
943 public void testTerminationOfNonInstantiated() throws Exception {
945 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
946 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
947 vnfInfo.setInstantiationState(InstantiationState.NOT_INSTANTIATED);
948 vnfInfo.setOperationExecutions(operationExecutions);
949 VnfProperty vnfdId = new VnfProperty();
950 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
951 vnfdId.setValue(ONAP_CSAR_ID);
952 vnfInfo.getExtensions().add(vnfdId);
953 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
954 when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
955 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
957 lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
959 boolean deleted = false;
962 verify(logger).info("The VNF with {} identifier has been deleted", VNF_ID);
967 verify(vfcGrantManager, never()).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
968 verify(notificationManager, never()).waitForTerminationToBeProcessed("terminationId");
969 verify(logger).warn("The VNF with {} identifier is not instantiated no termination is required", VNF_ID);
970 verify(logger).info("Deleting VNF with {} identifier", VNF_ID);
971 verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
972 VOID_OBSERVABLE.assertCalled();
976 * test that the VNF deletion is not started before the termination finishes
979 public void testTerminationOperationIsOutwaited() throws Exception {
981 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
982 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
983 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
984 vnfInfo.setOperationExecutions(operationExecutions);
985 VnfProperty vnfdId = new VnfProperty();
986 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
987 vnfdId.setValue(ONAP_CSAR_ID);
988 vnfInfo.getExtensions().add(vnfdId);
989 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
990 OperationExecution terminationOperation = new OperationExecution();
991 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
992 terminationOperation.setId("terminationId");
993 operationExecutions.add(terminationOperation);
994 terminationOperation.setStatus(OperationStatus.STARTED);
995 return buildObservable(terminationOperation);
997 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
998 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
999 Set<Integer> calls = new HashSet<>();
1000 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(invocation -> {
1001 if (calls.size() == 1000) {
1002 terminationOperation.setStatus(OperationStatus.FINISHED);
1004 calls.add(calls.size());
1005 return buildObservable(operationExecutions);
1008 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1010 waitForJobToFinishInJobManager(finished);
1011 verify(vnfApi, times(1001)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
1012 verify(systemFunctions, times(1000)).sleep(5000);
1017 * test that failured during waiting for the operation to finish is tolerated (idefineiatelly)
1020 public void testTerminationOperationIsOutwaitedWithErrors() throws Exception {
1022 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1023 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1024 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1025 vnfInfo.setOperationExecutions(operationExecutions);
1026 VnfProperty vnfdId = new VnfProperty();
1027 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1028 vnfdId.setValue(ONAP_CSAR_ID);
1029 vnfInfo.getExtensions().add(vnfdId);
1030 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1031 OperationExecution terminationOperation = new OperationExecution();
1032 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1034 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1035 terminationOperation.setId("terminationId");
1036 operationExecutions.add(terminationOperation);
1037 terminationOperation.setStatus(OperationStatus.STARTED);
1038 return buildObservable(terminationOperation);
1041 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1042 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1043 Set<Integer> calls = new HashSet<>();
1044 List<RuntimeException> expectedExceptions = new ArrayList<>();
1045 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
1047 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
1048 if (calls.size() >= 100) {
1049 terminationOperation.setStatus(OperationStatus.FINISHED);
1050 return buildObservable(operationExecutions);
1052 calls.add(calls.size());
1053 RuntimeException RuntimeException = new RuntimeException();
1054 expectedExceptions.add(RuntimeException);
1055 throw RuntimeException;
1059 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1061 waitForJobToFinishInJobManager(finished);
1062 verify(vnfApi, times(101)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
1063 verify(systemFunctions, times(100)).sleep(5000);
1064 for (RuntimeException expectedException : expectedExceptions) {
1065 verify(logger).warn("Unable to retrieve operations details", expectedException);
1070 * test gracefull termination
1073 public void testGracefullTermination() throws Exception {
1075 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1076 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1077 terminationRequest.setTerminationType(VnfTerminationType.GRACEFUL);
1078 terminationRequest.setGracefulTerminationTimeout("1234");
1079 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1080 vnfInfo.setOperationExecutions(operationExecutions);
1081 VnfProperty vnfdId = new VnfProperty();
1082 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1083 vnfdId.setValue(ONAP_CSAR_ID);
1084 vnfInfo.getExtensions().add(vnfdId);
1085 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1086 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1088 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1089 OperationExecution terminationOperation = new OperationExecution();
1090 terminationOperation.setId("terminationId");
1091 operationExecutions.add(terminationOperation);
1092 terminationOperation.setStatus(OperationStatus.FINISHED);
1093 return buildObservable(terminationOperation);
1096 doAnswer(invocation -> {
1097 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
1099 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1100 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1101 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1103 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1105 waitForJobToFinishInJobManager(finished);
1106 assertEquals(1, actualTerminationRequest.getAllValues().size());
1107 assertEquals(TerminationType.GRACEFUL, actualTerminationRequest.getValue().getTerminationType());
1108 assertEquals(Integer.valueOf(1234), actualTerminationRequest.getValue().getGracefulTerminationTimeout());
1109 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
1110 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1111 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
1112 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1116 * test explicit forceful termination
1119 public void testExplicitForcefulTermination() throws Exception {
1121 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1122 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1123 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1124 terminationRequest.setGracefulTerminationTimeout("1234");
1125 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1126 vnfInfo.setOperationExecutions(operationExecutions);
1127 VnfProperty vnfdId = new VnfProperty();
1128 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1129 vnfdId.setValue(ONAP_CSAR_ID);
1130 vnfInfo.getExtensions().add(vnfdId);
1131 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1132 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
1133 OperationExecution terminationOperation = new OperationExecution();
1134 terminationOperation.setId("terminationId");
1135 operationExecutions.add(terminationOperation);
1136 terminationOperation.setStatus(OperationStatus.FINISHED);
1137 return buildObservable(terminationOperation);
1139 doAnswer(invocation -> {
1140 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
1142 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1143 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1144 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1146 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1148 waitForJobToFinishInJobManager(finished);
1149 assertEquals(1, actualTerminationRequest.getAllValues().size());
1150 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1151 assertNull(actualTerminationRequest.getValue().getGracefulTerminationTimeout());
1152 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
1153 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1154 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
1155 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1159 * test failure in the termination workflow finishes the job
1162 public void testFailureInTheTerminationFinishesTheManagedJob() throws Exception {
1164 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1165 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1166 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1167 terminationRequest.setGracefulTerminationTimeout("1234");
1168 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1169 vnfInfo.setOperationExecutions(operationExecutions);
1170 VnfProperty vnfdId = new VnfProperty();
1171 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1172 vnfdId.setValue(ONAP_CSAR_ID);
1173 vnfInfo.getExtensions().add(vnfdId);
1174 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1175 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
1177 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
1178 OperationExecution terminationOperation = new OperationExecution();
1179 terminationOperation.setId("terminationId");
1180 operationExecutions.add(terminationOperation);
1181 terminationOperation.setStatus(OperationStatus.FINISHED);
1182 return terminationOperation;
1185 RuntimeException expectedException = new RuntimeException();
1186 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1187 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1188 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1190 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1192 waitForJobToFinishInJobManager(finished);
1193 assertEquals(0, actualTerminationRequest.getAllValues().size());
1194 Mockito.verifyZeroInteractions(vfcGrantManager);
1198 * if termination fails the VNF is not deleted
1201 public void testFailedTerminationAbortsTerminationWorkflow() throws Exception {
1203 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1204 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1205 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1206 vnfInfo.setOperationExecutions(operationExecutions);
1207 VnfProperty vnfdId = new VnfProperty();
1208 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1209 vnfdId.setValue(ONAP_CSAR_ID);
1210 vnfInfo.getExtensions().add(vnfdId);
1211 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1212 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1214 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1215 OperationExecution terminationOperation = new OperationExecution();
1216 terminationOperation.setId("terminationId");
1217 operationExecutions.add(terminationOperation);
1218 terminationOperation.setStatus(OperationStatus.FAILED);
1219 return buildObservable(terminationOperation);
1222 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1223 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1225 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1227 waitForJobToFinishInJobManager(finished);
1228 assertEquals(1, actualTerminationRequest.getAllValues().size());
1229 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1230 verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1231 verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1232 verify(logger).error("Unable to terminate VNF the operation did not finish with success");
1236 * test VNF query basic success scenario
1239 public void testQuery() throws Exception {
1240 vnfInfo.setDescription("myDescription");
1241 vnfInfo.setName("myName");
1242 vnfInfo.setVnfSoftwareVersion("vnfSoftwareVersion");
1243 vnfInfo.setVnfProvider("myProvider");
1244 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1245 VnfProperty prop = new VnfProperty();
1246 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1247 prop.setValue(ONAP_CSAR_ID);
1248 vnfInfo.getExtensions().add(prop);
1250 org.onap.vnfmdriver.model.VnfInfo vnf = lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1252 assertEquals(VNF_ID, vnf.getVnfInstanceId());
1253 //FIXME ? (do not know what exactly the vnf version mean in core terminology)
1254 assertEquals("vnfSoftwareVersion", vnf.getVersion());
1255 assertEquals(ONAP_CSAR_ID, vnf.getVnfdId());
1256 assertEquals("myDescription", vnf.getVnfInstanceDescription());
1257 assertEquals("myName", vnf.getVnfInstanceName());
1258 assertEquals(ONAP_CSAR_ID, vnf.getVnfPackageId());
1259 assertEquals("myProvider", vnf.getVnfProvider());
1260 //FIXME (in swagger schema )
1261 assertEquals("ACTIVE", vnf.getVnfStatus());
1262 assertEquals("Kuku", vnf.getVnfType());
1266 * error is propagated and logged if the queried VNF does not exist
1269 public void testQueryForNonExistingVnf() throws Exception {
1271 RuntimeException expectedException = new RuntimeException();
1272 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1275 lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1278 } catch (Exception e) {
1279 verify(logger).error("Unable to query VNF (myVnfId)", expectedException);
1280 assertEquals(expectedException, e.getCause());
1285 * test scale basic scenario
1288 public void testScale() throws Exception {
1289 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1290 scaleRequest.setNumberOfSteps("2");
1291 scaleRequest.setAspectId("myAspect");
1292 scaleRequest.setType(ScaleDirection.IN);
1293 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }"));
1294 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1295 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1296 VnfProperty prop = new VnfProperty();
1297 prop.setValue(ONAP_CSAR_ID);
1298 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1299 vnfInfo.getExtensions().add(prop);
1300 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1301 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1302 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1304 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1306 waitForJobToFinishInJobManager(finished);
1307 assertEquals(1, actualScaleRequest.getAllValues().size());
1308 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1309 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1310 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1311 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1312 assertEquals("myAspect", sRequest.getAspectId());
1313 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1314 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1315 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1316 verify(jobManager).spawnJob(VNF_ID, restResponse);
1317 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("scale"), eq(VNF_ID), anyString());
1321 * test scale a non scalable VNF
1324 public void testScaleNonScalableVnf() throws Exception {
1325 cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.instantiation.yaml").toURI())));
1326 when(catalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent);
1327 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1328 scaleRequest.setNumberOfSteps("2");
1329 scaleRequest.setAspectId("myAspect");
1330 scaleRequest.setType(ScaleDirection.IN);
1331 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }"));
1332 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1333 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1334 VnfProperty prop = new VnfProperty();
1335 prop.setValue(ONAP_CSAR_ID);
1336 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1337 vnfInfo.getExtensions().add(prop);
1338 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1339 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1340 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1342 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1344 waitForJobToFinishInJobManager(finished);
1345 assertEquals(0, actualScaleRequest.getAllValues().size());
1346 verify(logger).error("Unable to find operation named scale");
1350 * the VNFM should tolerate that no additional params were supplied
1353 public void testScaleWithoutAdditionalParams() throws Exception {
1354 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1355 scaleRequest.setNumberOfSteps("2");
1356 scaleRequest.setAspectId("myAspect");
1357 scaleRequest.setType(ScaleDirection.IN);
1358 scaleRequest.setAdditionalParam(null);
1359 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1361 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1362 VnfProperty prop = new VnfProperty();
1363 prop.setValue(ONAP_CSAR_ID);
1364 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1365 vnfInfo.getExtensions().add(prop);
1366 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1367 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1368 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1370 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1372 waitForJobToFinishInJobManager(finished);
1373 assertEquals(1, actualScaleRequest.getAllValues().size());
1374 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1375 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1376 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1377 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1378 assertEquals("myAspect", sRequest.getAspectId());
1379 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1380 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1381 assertEquals("{\"jobId\":\"myJobId\"}", new Gson().toJson(sRequest.getAdditionalParams()));
1382 verify(jobManager).spawnJob(VNF_ID, restResponse);
1386 * test scale out basic scenario
1389 public void testScaleOut() throws Exception {
1390 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1391 scaleRequest.setNumberOfSteps("2");
1392 scaleRequest.setAspectId("myAspect");
1393 scaleRequest.setType(ScaleDirection.OUT);
1394 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1395 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1396 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1397 VnfProperty prop = new VnfProperty();
1398 prop.setValue(ONAP_CSAR_ID);
1399 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1400 vnfInfo.getExtensions().add(prop);
1401 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1402 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1403 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1405 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1407 waitForJobToFinishInJobManager(finished);
1408 assertEquals(1, actualScaleRequest.getAllValues().size());
1409 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1410 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1411 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1412 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1413 assertEquals("myAspect", sRequest.getAspectId());
1414 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.OUT, sRequest.getType());
1415 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1416 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1420 * test scale operation is out waited
1423 public void testScaleOutwait() throws Exception {
1424 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1425 scaleRequest.setNumberOfSteps("2");
1426 scaleRequest.setAspectId("myAspect");
1427 scaleRequest.setType(ScaleDirection.IN);
1428 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1429 scaleOperationExecution.setStatus(OperationStatus.STARTED);
1430 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1431 VnfProperty prop = new VnfProperty();
1432 prop.setValue(ONAP_CSAR_ID);
1433 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1434 vnfInfo.getExtensions().add(prop);
1435 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1436 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1437 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1438 List<RuntimeException> expectedExceptions = new ArrayList<>();
1439 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<Observable<List<OperationExecution>>>) invocation -> {
1440 if (expectedExceptions.size() >= 100) {
1441 when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(scaleOperationExecution));
1442 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1443 return buildObservable(operationExecutions);
1445 RuntimeException RuntimeException = new RuntimeException();
1446 expectedExceptions.add(RuntimeException);
1447 throw RuntimeException;
1451 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1453 waitForJobToFinishInJobManager(finished);
1454 assertEquals(100, expectedExceptions.size());
1455 for (RuntimeException expectedException : expectedExceptions) {
1456 verify(logger).warn("Unable to retrieve operations details", expectedException);
1458 verify(systemFunctions, times(100)).sleep(5000);
1462 * test scale failure propagation
1465 public void testScaleFailurePropagation() throws Exception {
1466 RuntimeException expectedException = new RuntimeException();
1467 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1468 scaleRequest.setNumberOfSteps("2");
1469 scaleRequest.setAspectId("myAspect");
1470 scaleRequest.setType(ScaleDirection.IN);
1471 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1473 lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1475 waitForJobToFinishInJobManager(finished);
1476 verify(logger).error("Unable to scale VNF with myVnfId identifier", expectedException);
1480 * test heal basic scenario
1483 public void testHeal() throws Exception {
1484 VnfHealRequest healRequest = new VnfHealRequest();
1485 healRequest.setAction("myAction");
1486 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1487 affectedVm.setVmname("vmName");
1488 healRequest.setAffectedvm(affectedVm);
1489 healOperationExecution.setStatus(OperationStatus.FINISHED);
1490 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1491 VnfProperty prop = new VnfProperty();
1492 prop.setValue(ONAP_CSAR_ID);
1493 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1494 vnfInfo.getExtensions().add(prop);
1495 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1496 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1497 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1499 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1501 waitForJobToFinishInJobManager(finished);
1502 assertEquals(1, actualHealRequest.getAllValues().size());
1503 HealVnfRequest sRequest = actualHealRequest.getValue();
1504 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1505 workflowOrder.verify(vfcGrantManager).requestGrantForHeal(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(healRequest), eq(JOB_ID));
1506 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdHealPost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1507 JsonObject root = new Gson().toJsonTree(sRequest.getAdditionalParams()).getAsJsonObject();
1508 assertEquals("myAction", root.get("action").getAsString());
1509 assertEquals("vmName", root.get("vmName").getAsString());
1510 assertEquals(JOB_ID, root.get("jobId").getAsString());
1511 verify(jobManager).spawnJob(VNF_ID, restResponse);
1512 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("heal"), eq(VNF_ID), anyString());
1516 * test heal operation is out waited
1519 public void testHealOutwait() throws Exception {
1520 VnfHealRequest healRequest = new VnfHealRequest();
1521 healRequest.setAction("myAction");
1522 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1523 affectedVm.setVmname("vmName");
1524 healRequest.setAffectedvm(affectedVm);
1525 healOperationExecution.setStatus(OperationStatus.FINISHED);
1526 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1527 VnfProperty prop = new VnfProperty();
1528 prop.setValue(ONAP_CSAR_ID);
1529 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1530 vnfInfo.getExtensions().add(prop);
1531 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1532 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1533 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1534 List<RuntimeException> expectedExceptions = new ArrayList<>();
1535 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
1537 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
1538 if (expectedExceptions.size() >= 100) {
1539 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1540 return buildObservable(operationExecutions);
1542 RuntimeException RuntimeException = new RuntimeException();
1543 expectedExceptions.add(RuntimeException);
1544 throw RuntimeException;
1548 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1550 waitForJobToFinishInJobManager(finished);
1551 assertEquals(100, expectedExceptions.size());
1552 for (RuntimeException expectedException : expectedExceptions) {
1553 verify(logger).warn("Unable to retrieve operations details", expectedException);
1555 verify(systemFunctions, times(100)).sleep(5000);
1559 * failure in heal propagates in error
1562 public void testHealFailurePropagation() throws Exception {
1563 RuntimeException expectedException = new RuntimeException();
1564 VnfHealRequest healRequest = new VnfHealRequest();
1565 healRequest.setAction("myAction");
1566 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1567 affectedVm.setVmname("vmName");
1568 healRequest.setAffectedvm(affectedVm);
1569 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1571 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1573 waitForJobToFinishInJobManager(finished);
1574 verify(logger).error("Unable to heal VNF with myVnfId identifier", expectedException);
1579 * test custom operation basic scenario
1582 public void testCustomOperation() throws Exception {
1583 String operationId = "operationIdCaptor";
1584 Object additionalParams = new JsonObject();
1586 JobInfo job = lifecycleManager.customOperation(VNFM_ID, VNF_ID, operationId, additionalParams, restResponse);
1588 waitForJobToFinishInJobManager(finished);
1589 assertEquals(operationId, operationIdCaptor.getValue());
1590 assertEquals(additionalParams, customOperationRequestArgumentCaptor.getValue().getAdditionalParams());
1593 private void waitForJobToFinishInJobManager(Set<Boolean> finished) throws InterruptedException {
1594 while (finished.size() == 0) {
1595 systemFunctions().sleep(100);
1599 private VnfInstantiateRequest prepareInstantiationRequest(VimInfo.VimInfoTypeEnum cloudType, boolean addExtension) {
1600 VnfInstantiateRequest instantiationRequest = new VnfInstantiateRequest();
1601 instantiationRequest.setVnfPackageId(ONAP_CSAR_ID);
1602 instantiationRequest.setVnfDescriptorId(ONAP_CSAR_ID);
1603 instantiationRequest.setVnfInstanceDescription("myDescription");
1604 instantiationRequest.setVnfInstanceName("vnfName");
1605 externalVirtualLink.setCpdId("myCpdId");
1606 externalVirtualLink.setResourceId("myNetworkProviderId");
1607 externalVirtualLink.setVlInstanceId("myEVlId");
1608 externalVirtualLink.setResourceSubnetId("notUsedSubnetId");
1609 instantiationRequest.setExtVirtualLink(new ArrayList<>());
1610 instantiationRequest.getExtVirtualLink().add(externalVirtualLink);
1611 buildAdditionalParams(cloudType, addExtension);
1612 String params = new Gson().toJson(additionalParam);
1614 x.inputs.put(ONAP_CSAR_ID, params);
1616 JsonElement additionalParam = new Gson().toJsonTree(x);
1617 instantiationRequest.setAdditionalParam(additionalParam);
1618 return instantiationRequest;
1621 private void buildAdditionalParams(VimInfo.VimInfoTypeEnum cloudType, boolean addExtensions) {
1622 additionalParam.setInstantiationLevel("level1");
1623 switch (cloudType) {
1624 case OPENSTACK_V2_INFO:
1625 vimInfo.setType("openstack");
1627 case OPENSTACK_V3_INFO:
1628 vimInfo.setType("openstack");
1629 vimInfo.setDomain("myDomain");
1631 case VMWARE_VCLOUD_INFO:
1632 vimInfo.setType("vmware");
1636 Map<String, List<NetworkAddress>> exteranalConnectionPointAddresses = new HashMap<>();
1637 exteranalConnectionPointAddresses.put("ecp1", new ArrayList<>());
1638 NetworkAddress networkAddress = new NetworkAddress();
1639 networkAddress.setIp("1.2.3.4");
1640 networkAddress.setMac("mac");
1641 networkAddress.setSubnetId("subnetId");
1642 exteranalConnectionPointAddresses.get("ecp1").add(networkAddress);
1643 additionalParam.setExternalConnectionPointAddresses(exteranalConnectionPointAddresses);
1644 VimComputeResourceFlavour flavor = new VimComputeResourceFlavour();
1645 flavor.setResourceId("flavourProviderId");
1646 flavor.setVimId(VIM_ID);
1647 flavor.setVnfdVirtualComputeDescId("virtualComputeDescId");
1648 additionalParam.getComputeResourceFlavours().add(flavor);
1649 ExtVirtualLinkData evl = new ExtVirtualLinkData();
1650 evl.setResourceId("networkProviderId1");
1651 evl.setVimId(VIM_ID);
1652 evl.setExtVirtualLinkId("evlId1");
1653 VnfExtCpData ecp2 = new VnfExtCpData();
1654 ecp2.setCpdId("cpdId3");
1655 ecp2.setAddresses(new ArrayList<>());
1656 ecp2.getAddresses().add(networkAddress);
1657 ecp2.setNumDynamicAddresses(2);
1658 evl.getExtCps().add(ecp2);
1659 additionalParam.getExtVirtualLinks().add(evl);
1660 additionalParam.getExtManagedVirtualLinks().add(extManVl);
1661 ZoneInfo zone = new ZoneInfo();
1662 zone.setId("zoneId");
1663 zone.setResourceId("zoneProviderId");
1664 zone.setVimId(VIM_ID);
1665 additionalParam.getZones().add(zone);
1666 VimSoftwareImage image = new VimSoftwareImage();
1667 image.setResourceId("imageProviderId");
1668 image.setVimId(VIM_ID);
1669 image.setVnfdSoftwareImageId("imageId");
1670 additionalParam.getSoftwareImages().add(image);
1671 additionalParam.setAdditionalParams(new JsonParser().parse("{ \"a\" : \"b\" }"));
1672 if (addExtensions) {
1673 VnfProperty p1 = new VnfProperty();
1675 p1.setValue(Lists.newArrayList("a", "b"));
1676 VnfProperty p2 = new VnfProperty();
1679 VnfProperty p3 = new VnfProperty();
1681 JsonObject o = new JsonObject();
1683 o.addProperty("a", "b");
1684 additionalParam.getExtensions().add(p1);
1685 additionalParam.getExtensions().add(p2);
1686 additionalParam.getExtensions().add(p3);
1691 * Test vimId decomposition
1694 public void testVimIdSplitting() {
1695 assertEquals("regionId", LifecycleManager.getRegionName("cloudOwner_regionId"));
1696 assertEquals("cloudOwner", LifecycleManager.getCloudOwner("cloudOwner_regionId"));
1700 * additional params of instantiation may be passed as VNF property
1703 public void testVnfConfigurationBasedOnPackageParameters() throws Exception {
1704 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, false);
1705 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
1706 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
1707 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
1708 grantResponse.setVimId(VIM_ID);
1709 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
1710 accessInfo.setTenant(TENANT);
1711 grantResponse.setAccessInfo(accessInfo);
1712 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
1713 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
1715 JsonObject root = new JsonObject();
1716 root.addProperty(LifecycleManager.ETSI_CONFIG, new Gson().toJson(additionalParam));
1717 x.properties = new Gson().toJson(root);
1719 JsonElement additionalParam = new Gson().toJsonTree(x);
1720 instantiationRequest.setAdditionalParam(additionalParam);
1722 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
1723 waitForJobToFinishInJobManager(finished);
1724 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
1726 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
1727 assertEquals(VIM_ID, actualVim.getId());
1728 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
1729 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
1730 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
1731 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
1732 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
1733 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
1734 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
1735 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
1736 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
1737 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
1738 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
1742 * additional params of instantiation may be passed as directly attached artifact
1745 public void testVnfConfigurationBasedOnArtifactParameters() throws Exception {
1746 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, false);
1747 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
1748 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
1749 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
1750 grantResponse.setVimId(VIM_ID);
1751 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
1752 accessInfo.setTenant(TENANT);
1753 grantResponse.setAccessInfo(accessInfo);
1754 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
1755 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
1756 when(catalogManager.getEtsiConfiguration(ONAP_CSAR_ID)).thenReturn(new Gson().toJson(additionalParam));
1759 JsonElement additionalParam = new Gson().toJsonTree(x);
1760 instantiationRequest.setAdditionalParam(additionalParam);
1762 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
1763 waitForJobToFinishInJobManager(finished);
1764 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
1766 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
1767 assertEquals(VIM_ID, actualVim.getId());
1768 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
1769 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
1770 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
1771 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
1772 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
1773 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
1774 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
1775 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
1776 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
1777 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
1778 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
1782 * additional params of instantiation may be passed as VNF property
1785 public void testVnfConfigurationBasedOnPackageParametersMissingPropertiesEtsiConfig() throws Exception {
1786 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, false);
1787 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
1788 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
1789 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
1790 grantResponse.setVimId(VIM_ID);
1791 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
1792 accessInfo.setTenant(TENANT);
1793 grantResponse.setAccessInfo(accessInfo);
1794 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
1795 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
1797 JsonObject root = new JsonObject();
1798 root.addProperty(LifecycleManager.ETSI_CONFIG, new Gson().toJson(additionalParam));
1799 x.properties = "{ }";
1800 new Gson().toJson(root);
1801 x.inputs.put(ONAP_CSAR_ID, new Gson().toJson(additionalParam));
1803 JsonElement additionalParam = new Gson().toJsonTree(x);
1804 instantiationRequest.setAdditionalParam(additionalParam);
1806 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
1807 waitForJobToFinishInJobManager(finished);
1808 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
1810 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
1811 assertEquals(VIM_ID, actualVim.getId());
1812 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
1813 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
1814 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
1815 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
1816 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
1817 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
1818 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
1819 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
1820 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
1821 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
1822 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
1823 verify(logger).info("The instantiation input for VNF with {} CSAR id does not have an " + LifecycleManager.ETSI_CONFIG + " section", ONAP_CSAR_ID);
1826 public static class X {
1827 @SerializedName("inputs")
1828 public Map<String, String> inputs = new HashMap<String, String>();
1829 public String vimId;
1830 public String properties;
1832 public Map<String, String> getInputs() {
1836 public void setInputs(Map<String, String> inputs) {
1837 this.inputs = inputs;