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 * invalid VIM type results in failure
294 public void testInstantiationWithInvalidVimType() throws Exception {
296 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO, false);
297 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
298 when(logger.isInfoEnabled()).thenReturn(false);
301 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
304 } catch (Exception e) {
305 assertEquals("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types", e.getMessage());
307 verify(vnfApi, never()).vnfsPost(Mockito.any(), Mockito.any());
308 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
309 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
310 verify(logger).error("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types");
314 * test instantiation with KeyStone V2 based with SSL
317 public void testInstantiationV2WithSsl() throws Exception {
318 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
319 when(logger.isInfoEnabled()).thenReturn(false);
320 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
321 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
322 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
323 grantResponse.setVimId(VIM_ID);
324 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
325 accessInfo.setTenant(TENANT);
326 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
327 vimInfo.setSslInsecure("false");
328 vimInfo.setSslCacert(caCert);
329 grantResponse.setAccessInfo(accessInfo);
330 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
331 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
332 JsonObject inputs = child((JsonObject) instantiationRequest.getAdditionalParam(), "inputs");
333 JsonObject vnf = new JsonParser().parse(childElement(inputs, ONAP_CSAR_ID).getAsString()).getAsJsonObject();
334 vnf.remove("additionalParams");
335 inputs.add(ONAP_CSAR_ID, new JsonPrimitive(new Gson().toJson(vnf)));
337 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
338 waitForJobToFinishInJobManager(finished);
339 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
341 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
342 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
343 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
344 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
345 verify(logger).warn("No additional parameters were specified for the operation");
346 verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), anyString(), anyString(), anyString());
350 * non specified SSL verification means not verified
353 public void testInstantiationV2WithoutSsl() throws Exception {
354 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
356 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
357 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
358 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
359 grantResponse.setVimId(VIM_ID);
360 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
361 accessInfo.setTenant(TENANT);
362 vimInfo.setSslInsecure(null);
363 grantResponse.setAccessInfo(accessInfo);
364 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
365 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
367 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
368 waitForJobToFinishInJobManager(finished);
369 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
371 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
372 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
373 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
377 * test instantiation with KeyStone V3 based
380 public void testInstantiationV3() throws Exception {
381 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, false);
382 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
383 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
384 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
385 grantResponse.setVimId(VIM_ID);
386 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
387 accessInfo.setTenant(TENANT);
388 grantResponse.setAccessInfo(accessInfo);
389 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
390 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
392 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
393 waitForJobToFinishInJobManager(finished);
394 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
396 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
397 assertEquals(VIM_ID, actualVim.getId());
398 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
399 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
400 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
401 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
402 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
403 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
404 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
405 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
406 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
407 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
408 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
412 * test instantiation with backward compatibility test with Amsterdam release
413 * - the vim identifier is supplied as vimid with not camel case
414 * - the access info is supplied as accessinfo with not camel case
417 public void testInstantiationNoVimId() throws Exception {
419 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
420 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
421 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
422 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
423 grantResponse.setVimid(VIM_ID);
424 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
425 accessInfo.setTenant(TENANT);
426 grantResponse.setAccessinfo(accessInfo);
427 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
428 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
430 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
431 waitForJobToFinishInJobManager(finished);
433 assertEquals(VNF_ID, response.getVnfInstanceId());
434 assertEquals(JOB_ID, response.getJobId());
435 assertEquals(createRequest.getAllValues().size(), 1);
436 assertEquals("myDescription", createRequest.getValue().getDescription());
437 assertEquals("vnfName", createRequest.getValue().getName());
438 assertEquals(CBAM_VNFD_ID, createRequest.getValue().getVnfdId());
439 assertEquals(1, actualInstantiationRequest.getAllValues().size());
440 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
441 OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
442 assertEquals(VIM_ID, actualVim.getId());
443 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, actualVim.getVimInfoType());
444 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
445 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
446 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
447 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
448 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
449 assertEquals("myTenant", actualVim.getAccessInfo().getTenant());
450 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
451 assertEquals(1, actualInstantiationRequest.getValue().getComputeResourceFlavours().size());
452 assertEquals("flavourProviderId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getResourceId());
453 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVimId());
454 assertEquals("virtualComputeDescId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVnfdVirtualComputeDescId());
455 assertEquals(1, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().size());
456 assertEquals(extManVl, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().get(0));
457 assertEquals(2, actualInstantiationRequest.getValue().getExtVirtualLinks().size());
459 assertEquals("myNetworkProviderId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getResourceId());
460 assertEquals("myEVlId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtVirtualLinkId());
461 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().size());
462 assertEquals("myCpdId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().get(0).getCpdId());
464 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getVimId());
465 assertEquals("evlId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtVirtualLinkId());
466 assertEquals("networkProviderId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getResourceId());
467 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().size());
470 assertEquals(Integer.valueOf(2), actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getNumDynamicAddresses());
471 assertEquals("cpdId3", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getCpdId());
472 assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().size());
473 assertEquals("1.2.3.4", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getIp());
474 assertEquals("mac", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getMac());
475 assertEquals("subnetId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getSubnetId());
477 assertEquals("myFlavorId", actualInstantiationRequest.getValue().getFlavourId());
478 assertEquals(Boolean.TRUE, actualInstantiationRequest.getValue().isGrantlessMode());
479 assertEquals("level1", actualInstantiationRequest.getValue().getInstantiationLevelId());
480 assertEquals(1, actualInstantiationRequest.getValue().getZones().size());
481 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getZones().get(0).getVimId());
482 assertEquals("zoneProviderId", actualInstantiationRequest.getValue().getZones().get(0).getResourceId());
483 assertEquals("zoneId", actualInstantiationRequest.getValue().getZones().get(0).getId());
484 assertEquals(1, actualInstantiationRequest.getValue().getSoftwareImages().size());
485 assertEquals(VIM_ID, actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVimId());
486 assertEquals("imageProviderId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getResourceId());
487 assertEquals("imageId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVnfdSoftwareImageId());
488 String actualEmbeddedAdditionParams = new Gson().toJson(actualInstantiationRequest.getValue().getAdditionalParams());
489 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(actualEmbeddedAdditionParams) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(actualEmbeddedAdditionParams));
490 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
491 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
493 assertEquals(1, actualVnfModifyRequest.getAllValues().size());
494 assertEquals(2, actualVnfModifyRequest.getValue().getExtensions().size());
495 assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getName());
496 assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getValue());
497 assertEquals(LifecycleManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName());
498 assertEquals(VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getValue());
500 //the 3.2 API does not accept empty array
501 assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties());
502 verify(jobManager).spawnJob(VNF_ID, restResponse);
503 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
504 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
508 * test instantiation with KeyStone V3 based with SSL
511 public void testInstantiationV3WithSsl() throws Exception {
512 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, false);
513 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
514 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
515 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
516 grantResponse.setVimId(VIM_ID);
517 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
518 accessInfo.setTenant(TENANT);
519 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
520 vimInfo.setSslInsecure("false");
521 vimInfo.setSslCacert(caCert);
522 grantResponse.setAccessInfo(accessInfo);
523 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
524 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
526 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
527 waitForJobToFinishInJobManager(finished);
528 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
530 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
531 assertEquals(VIM_ID, actualVim.getId());
532 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
533 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
534 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
535 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
536 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
537 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
538 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
539 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
540 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
541 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
542 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
543 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
547 * non specified SSL verification meams not verified for KeyStone V3 based
550 public void testInstantiationV3WithNonSpecifiedSsl() throws Exception {
551 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, false);
552 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
553 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
554 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
555 grantResponse.setVimId(VIM_ID);
556 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
557 accessInfo.setTenant(TENANT);
558 vimInfo.setSslInsecure(null);
559 grantResponse.setAccessInfo(accessInfo);
560 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
561 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
563 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
564 waitForJobToFinishInJobManager(finished);
565 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
567 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
568 assertEquals(VIM_ID, actualVim.getId());
569 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
570 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
571 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
572 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
573 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
574 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
575 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
576 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
577 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
578 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
582 * verify backward compatibility with Amsterdam release
585 public void testInstantiationV3WithNoDomain() throws Exception {
586 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
587 additionalParam.setDomain("myDomain");
588 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, false);
589 vimInfo.setDomain(null);
590 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
591 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
592 grantResponse.setVimId(VIM_ID);
593 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
594 accessInfo.setTenant(TENANT);
595 vimInfo.setSslInsecure(null);
596 grantResponse.setAccessInfo(accessInfo);
597 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
598 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
600 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
601 waitForJobToFinishInJobManager(finished);
602 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
604 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
605 assertEquals(VIM_ID, actualVim.getId());
606 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
607 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
608 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
609 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
610 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
611 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
612 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
613 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
614 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
615 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
616 verify(logger).warn("Setting domain from additional parameters");
620 * verify backward compatibility with Amsterdam release
621 * if no domain is specified error is propagated
624 public void testInstantiationV3WithNoDomainFail() throws Exception {
625 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, false);
626 vimInfo.setDomain(null);
627 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
628 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
629 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
630 grantResponse.setVimId(VIM_ID);
631 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
632 accessInfo.setTenant(TENANT);
633 vimInfo.setSslInsecure(null);
634 grantResponse.setAccessInfo(accessInfo);
635 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
636 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
638 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
639 waitForJobToFinishInJobManager(finished);
640 assertEquals(0, actualInstantiationRequest.getAllValues().size());
642 verify(logger).error("The cloud did not supply the cloud domain (Amsterdam release) and was not supplied as additional data");
646 * test instantiation with vcloud
649 public void testInstantiationVcloud() throws Exception {
650 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, false);
652 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
653 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
654 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
655 grantResponse.setVimId(VIM_ID);
656 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
657 accessInfo.setTenant(TENANT);
658 grantResponse.setAccessInfo(accessInfo);
659 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
660 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
662 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
663 waitForJobToFinishInJobManager(finished);
664 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
666 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
667 assertEquals(VIM_ID, actualVim.getId());
668 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
669 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
670 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
671 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
672 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
673 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
674 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
675 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
676 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
680 * test instantiation with vCloud with SSL
683 public void testInstantiationVcloudWithSsl() throws Exception {
684 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, false);
686 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
687 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
688 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
689 grantResponse.setVimId(VIM_ID);
690 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
691 accessInfo.setTenant(TENANT);
692 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
693 vimInfo.setSslInsecure("false");
694 vimInfo.setSslCacert(caCert);
695 grantResponse.setAccessInfo(accessInfo);
696 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
697 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
699 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
700 waitForJobToFinishInJobManager(finished);
701 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
703 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
704 assertEquals(VIM_ID, actualVim.getId());
705 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
706 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
707 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
708 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
709 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
710 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
711 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
712 assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
713 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
714 assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
718 * test instantiation with vCloud with SSL
721 public void testInstantiationVcloudWithNonSecifedSSl() throws Exception {
722 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_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 vimInfo.setSslInsecure(null);
731 grantResponse.setAccessInfo(accessInfo);
732 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
733 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
735 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
736 waitForJobToFinishInJobManager(finished);
737 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
739 VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
740 assertEquals(VIM_ID, actualVim.getId());
741 assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
742 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
743 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
744 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
745 assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
746 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
747 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
748 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
752 * test failure in the instantiation request marks the job to be finished in job manager
755 public void testFailureInTheInstantiationRequest() throws Exception {
756 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
757 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
758 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
759 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
760 grantResponse.setVimId(VIM_ID);
761 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
762 accessInfo.setTenant(TENANT);
763 grantResponse.setAccessInfo(accessInfo);
764 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
765 RuntimeException expectedException = new RuntimeException();
766 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
769 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
771 waitForJobToFinishInJobManager(finished);
772 assertEquals(VNF_ID, response.getVnfInstanceId());
773 assertEquals(JOB_ID, response.getJobId());
774 verify(logger).error("Unable to instantiate VNF with myVnfId identifier", expectedException);
778 * instantiation fails if VF-C does not send vim identifier in grant response
781 public void testVfcFailsToSendVimId() throws Exception {
782 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
784 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
785 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
786 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
787 //grantResponse.setVimId(VIM_ID);
788 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
789 accessInfo.setTenant(TENANT);
790 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
791 vimInfo.setSslInsecure("false");
792 vimInfo.setSslCacert(caCert);
793 grantResponse.setAccessInfo(accessInfo);
794 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
795 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
797 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
798 waitForJobToFinishInJobManager(finished);
799 assertEquals(0, actualInstantiationRequest.getAllValues().size());
801 verify(logger).error("VF-C did not send VIM identifier in grant response");
805 * instantiation fails if VF-C does not send access info in grant response
808 public void testVfcFailsToSendAccessInfo() throws Exception {
809 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
811 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
812 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
813 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
814 grantResponse.setVimId(VIM_ID);
815 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
816 accessInfo.setTenant(TENANT);
817 String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
818 vimInfo.setSslInsecure("false");
819 vimInfo.setSslCacert(caCert);
820 //grantResponse.setAccessInfo(accessInfo);
821 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
822 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
824 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
825 waitForJobToFinishInJobManager(finished);
826 assertEquals(0, actualInstantiationRequest.getAllValues().size());
828 verify(logger).error("VF-C did not send access info in grant response");
832 * test operation execution polling is retried in case of failures
835 public void testFailureInTheOperationExecutionPollingDuringInstantiationRequest() throws Exception {
836 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
837 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
838 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
839 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
840 grantResponse.setVimId(VIM_ID);
841 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
842 accessInfo.setTenant(TENANT);
843 grantResponse.setAccessInfo(accessInfo);
844 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
845 List<RuntimeException> polling = new ArrayList<>();
846 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
847 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).then(new Answer<Observable<List<OperationExecution>>>() {
849 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
850 if (polling.size() > 2) {
851 return buildObservable(operationExecutions);
853 RuntimeException runtimeException = new RuntimeException();
854 polling.add(runtimeException);
855 throw runtimeException;
859 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
861 waitForJobToFinishInJobManager(finished);
862 assertEquals(VNF_ID, response.getVnfInstanceId());
863 assertEquals(JOB_ID, response.getJobId());
864 assertEquals(3, polling.size());
865 for (RuntimeException e : polling) {
866 verify(logger).warn("Unable to retrieve operations details", e);
868 verify(systemFunctions, Mockito.times(3)).sleep(5000);
872 * failure in VNF creation is logged an proagated
875 public void failureInVnfCreationIsPropagated() throws Exception {
877 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
879 RuntimeException expectedException = new RuntimeException();
880 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
883 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
886 } catch (RuntimeException e) {
887 assertEquals(expectedException, e.getCause());
888 verify(logger).error("Unable to create the VNF", expectedException);
893 * failure in updating the modifyable attributes of the VNF is logged an proagated
896 public void failureInVnfModificationIsPropagated() throws Exception {
898 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
900 RuntimeException expectedException = new RuntimeException();
901 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
902 when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
906 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
909 } catch (RuntimeException e) {
910 assertEquals(expectedException, e.getCause().getCause());
911 verify(logger).error("Unable to set the externalVnfmId,onapCsarId properties on the VNF with " + VNF_ID +" identifier", expectedException);
916 * if the VIM info can not be queried the VNF is not instantiated and
917 * error propagated through job
920 public void testFailureInQueryVimInfo() throws Exception {
921 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, false);
922 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
923 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
924 grantResponse.setVimId(VIM_ID);
925 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
926 accessInfo.setTenant(TENANT);
927 grantResponse.setAccessInfo(accessInfo);
929 when(vimInfoProvider.getVimInfo(VIM_ID)).thenThrow(new RuntimeException());
931 lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
933 waitForJobToFinishInJobManager(finished);
934 verify(vnfApi, never()).vnfsVnfInstanceIdInstantiatePost(Mockito.any(), Mockito.any(), Mockito.any());
938 * test termination basic success scenario
939 * - the VNF is not deleted before the notifications are processed
942 public void testTerminationAndDeletion() throws Exception {
944 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
945 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
946 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
947 vnfInfo.setOperationExecutions(operationExecutions);
948 VnfProperty vnfdId = new VnfProperty();
949 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
950 vnfdId.setValue(ONAP_CSAR_ID);
951 vnfInfo.getExtensions().add(vnfdId);
952 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
953 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
955 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
956 OperationExecution terminationOperation = new OperationExecution();
957 terminationOperation.setId("terminationId");
958 operationExecutions.add(terminationOperation);
959 terminationOperation.setStatus(OperationStatus.FINISHED);
960 return buildObservable(terminationOperation);
963 when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
964 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
965 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
967 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
969 waitForJobToFinishInJobManager(finished);
970 assertEquals(1, actualTerminationRequest.getAllValues().size());
971 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
972 assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
973 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
974 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
975 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
976 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
977 VOID_OBSERVABLE.assertCalled();
978 verify(jobManager).spawnJob(VNF_ID, restResponse);
979 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
983 * test termination basic success scenario
984 * - the VNF is not deleted before the notifications are processed
987 public void testTermination() throws Exception {
989 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
990 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
991 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
992 vnfInfo.setOperationExecutions(operationExecutions);
993 VnfProperty vnfdId = new VnfProperty();
994 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
995 vnfdId.setValue(ONAP_CSAR_ID);
996 vnfInfo.getExtensions().add(vnfdId);
997 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
998 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1000 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1001 OperationExecution terminationOperation = new OperationExecution();
1002 terminationOperation.setId("terminationId");
1003 operationExecutions.add(terminationOperation);
1004 terminationOperation.setStatus(OperationStatus.FINISHED);
1005 return buildObservable(terminationOperation);
1008 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1009 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1011 JobInfo jobInfo = lifecycleManager.terminate(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1013 waitForJobToFinishInJobManager(finished);
1014 assertEquals(1, actualTerminationRequest.getAllValues().size());
1015 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1016 assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
1017 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
1018 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1019 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
1020 verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1021 verify(jobManager).spawnJob(VNF_ID, restResponse);
1022 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
1026 * test termination of a non instantiated VNF
1027 * - the VNF is not terminated (only deleted)
1030 public void testTerminationOfNonInstantiated() throws Exception {
1032 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1033 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1034 vnfInfo.setInstantiationState(InstantiationState.NOT_INSTANTIATED);
1035 vnfInfo.setOperationExecutions(operationExecutions);
1036 VnfProperty vnfdId = new VnfProperty();
1037 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1038 vnfdId.setValue(ONAP_CSAR_ID);
1039 vnfInfo.getExtensions().add(vnfdId);
1040 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1041 when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
1042 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1044 lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1046 boolean deleted = false;
1049 verify(logger).info("The VNF with {} identifier has been deleted", VNF_ID);
1054 verify(vfcGrantManager, never()).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1055 verify(notificationManager, never()).waitForTerminationToBeProcessed("terminationId");
1056 verify(logger).warn("The VNF with {} identifier is not instantiated no termination is required", VNF_ID);
1057 verify(logger).info("Deleting VNF with {} identifier", VNF_ID);
1058 verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1059 VOID_OBSERVABLE.assertCalled();
1063 * test that the VNF deletion is not started before the termination finishes
1066 public void testTerminationOperationIsOutwaited() throws Exception {
1068 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1069 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1070 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1071 vnfInfo.setOperationExecutions(operationExecutions);
1072 VnfProperty vnfdId = new VnfProperty();
1073 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1074 vnfdId.setValue(ONAP_CSAR_ID);
1075 vnfInfo.getExtensions().add(vnfdId);
1076 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1077 OperationExecution terminationOperation = new OperationExecution();
1078 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
1079 terminationOperation.setId("terminationId");
1080 operationExecutions.add(terminationOperation);
1081 terminationOperation.setStatus(OperationStatus.STARTED);
1082 return buildObservable(terminationOperation);
1084 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1085 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1086 Set<Integer> calls = new HashSet<>();
1087 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(invocation -> {
1088 if (calls.size() == 1000) {
1089 terminationOperation.setStatus(OperationStatus.FINISHED);
1091 calls.add(calls.size());
1092 return buildObservable(operationExecutions);
1095 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1097 waitForJobToFinishInJobManager(finished);
1098 verify(vnfApi, times(1001)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
1099 verify(systemFunctions, times(1000)).sleep(5000);
1104 * test that failured during waiting for the operation to finish is tolerated (idefineiatelly)
1107 public void testTerminationOperationIsOutwaitedWithErrors() throws Exception {
1109 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1110 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1111 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1112 vnfInfo.setOperationExecutions(operationExecutions);
1113 VnfProperty vnfdId = new VnfProperty();
1114 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1115 vnfdId.setValue(ONAP_CSAR_ID);
1116 vnfInfo.getExtensions().add(vnfdId);
1117 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1118 OperationExecution terminationOperation = new OperationExecution();
1119 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1121 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1122 terminationOperation.setId("terminationId");
1123 operationExecutions.add(terminationOperation);
1124 terminationOperation.setStatus(OperationStatus.STARTED);
1125 return buildObservable(terminationOperation);
1128 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1129 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1130 Set<Integer> calls = new HashSet<>();
1131 List<RuntimeException> expectedExceptions = new ArrayList<>();
1132 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
1134 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
1135 if (calls.size() >= 100) {
1136 terminationOperation.setStatus(OperationStatus.FINISHED);
1137 return buildObservable(operationExecutions);
1139 calls.add(calls.size());
1140 RuntimeException RuntimeException = new RuntimeException();
1141 expectedExceptions.add(RuntimeException);
1142 throw RuntimeException;
1146 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1148 waitForJobToFinishInJobManager(finished);
1149 verify(vnfApi, times(101)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
1150 verify(systemFunctions, times(100)).sleep(5000);
1151 for (RuntimeException expectedException : expectedExceptions) {
1152 verify(logger).warn("Unable to retrieve operations details", expectedException);
1157 * test gracefull termination
1160 public void testGracefullTermination() throws Exception {
1162 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1163 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1164 terminationRequest.setTerminationType(VnfTerminationType.GRACEFUL);
1165 terminationRequest.setGracefulTerminationTimeout("1234");
1166 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1167 vnfInfo.setOperationExecutions(operationExecutions);
1168 VnfProperty vnfdId = new VnfProperty();
1169 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1170 vnfdId.setValue(ONAP_CSAR_ID);
1171 vnfInfo.getExtensions().add(vnfdId);
1172 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1173 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1175 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1176 OperationExecution terminationOperation = new OperationExecution();
1177 terminationOperation.setId("terminationId");
1178 operationExecutions.add(terminationOperation);
1179 terminationOperation.setStatus(OperationStatus.FINISHED);
1180 return buildObservable(terminationOperation);
1183 doAnswer(invocation -> {
1184 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
1186 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
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(1, actualTerminationRequest.getAllValues().size());
1194 assertEquals(TerminationType.GRACEFUL, actualTerminationRequest.getValue().getTerminationType());
1195 assertEquals(Integer.valueOf(1234), actualTerminationRequest.getValue().getGracefulTerminationTimeout());
1196 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
1197 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1198 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
1199 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1203 * test explicit forceful termination
1206 public void testExplicitForcefulTermination() throws Exception {
1208 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1209 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1210 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1211 terminationRequest.setGracefulTerminationTimeout("1234");
1212 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1213 vnfInfo.setOperationExecutions(operationExecutions);
1214 VnfProperty vnfdId = new VnfProperty();
1215 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1216 vnfdId.setValue(ONAP_CSAR_ID);
1217 vnfInfo.getExtensions().add(vnfdId);
1218 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1219 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
1220 OperationExecution terminationOperation = new OperationExecution();
1221 terminationOperation.setId("terminationId");
1222 operationExecutions.add(terminationOperation);
1223 terminationOperation.setStatus(OperationStatus.FINISHED);
1224 return buildObservable(terminationOperation);
1226 doAnswer(invocation -> {
1227 verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
1229 }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1230 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1231 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1233 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1235 waitForJobToFinishInJobManager(finished);
1236 assertEquals(1, actualTerminationRequest.getAllValues().size());
1237 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1238 assertNull(actualTerminationRequest.getValue().getGracefulTerminationTimeout());
1239 InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
1240 notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1241 notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
1242 notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1246 * test failure in the termination workflow finishes the job
1249 public void testFailureInTheTerminationFinishesTheManagedJob() throws Exception {
1251 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1252 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1253 terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1254 terminationRequest.setGracefulTerminationTimeout("1234");
1255 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1256 vnfInfo.setOperationExecutions(operationExecutions);
1257 VnfProperty vnfdId = new VnfProperty();
1258 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1259 vnfdId.setValue(ONAP_CSAR_ID);
1260 vnfInfo.getExtensions().add(vnfdId);
1261 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1262 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
1264 public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
1265 OperationExecution terminationOperation = new OperationExecution();
1266 terminationOperation.setId("terminationId");
1267 operationExecutions.add(terminationOperation);
1268 terminationOperation.setStatus(OperationStatus.FINISHED);
1269 return terminationOperation;
1272 RuntimeException expectedException = new RuntimeException();
1273 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1274 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1275 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1277 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1279 waitForJobToFinishInJobManager(finished);
1280 assertEquals(0, actualTerminationRequest.getAllValues().size());
1281 Mockito.verifyZeroInteractions(vfcGrantManager);
1285 * if termination fails the VNF is not deleted
1288 public void testFailedTerminationAbortsTerminationWorkflow() throws Exception {
1290 VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1291 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1292 vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1293 vnfInfo.setOperationExecutions(operationExecutions);
1294 VnfProperty vnfdId = new VnfProperty();
1295 vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1296 vnfdId.setValue(ONAP_CSAR_ID);
1297 vnfInfo.getExtensions().add(vnfdId);
1298 ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1299 when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1301 public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1302 OperationExecution terminationOperation = new OperationExecution();
1303 terminationOperation.setId("terminationId");
1304 operationExecutions.add(terminationOperation);
1305 terminationOperation.setStatus(OperationStatus.FAILED);
1306 return buildObservable(terminationOperation);
1309 JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1310 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1312 JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1314 waitForJobToFinishInJobManager(finished);
1315 assertEquals(1, actualTerminationRequest.getAllValues().size());
1316 assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1317 verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1318 verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1319 verify(logger).error("Unable to terminate VNF the operation did not finish with success");
1323 * test VNF query basic success scenario
1326 public void testQuery() throws Exception {
1327 vnfInfo.setDescription("myDescription");
1328 vnfInfo.setName("myName");
1329 vnfInfo.setVnfSoftwareVersion("vnfSoftwareVersion");
1330 vnfInfo.setVnfProvider("myProvider");
1331 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1332 VnfProperty prop = new VnfProperty();
1333 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1334 prop.setValue(ONAP_CSAR_ID);
1335 vnfInfo.getExtensions().add(prop);
1337 org.onap.vnfmdriver.model.VnfInfo vnf = lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1339 assertEquals(VNF_ID, vnf.getVnfInstanceId());
1340 //FIXME ? (do not know what exactly the vnf version mean in core terminology)
1341 assertEquals("vnfSoftwareVersion", vnf.getVersion());
1342 assertEquals(ONAP_CSAR_ID, vnf.getVnfdId());
1343 assertEquals("myDescription", vnf.getVnfInstanceDescription());
1344 assertEquals("myName", vnf.getVnfInstanceName());
1345 assertEquals(ONAP_CSAR_ID, vnf.getVnfPackageId());
1346 assertEquals("myProvider", vnf.getVnfProvider());
1347 //FIXME (in swagger schema )
1348 assertEquals("ACTIVE", vnf.getVnfStatus());
1349 assertEquals("Kuku", vnf.getVnfType());
1353 * error is propagated and logged if the queried VNF does not exist
1356 public void testQueryForNonExistingVnf() throws Exception {
1358 RuntimeException expectedException = new RuntimeException();
1359 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1362 lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1365 } catch (Exception e) {
1366 verify(logger).error("Unable to query VNF (myVnfId)", expectedException);
1367 assertEquals(expectedException, e.getCause());
1372 * test scale basic scenario
1375 public void testScale() throws Exception {
1376 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1377 scaleRequest.setNumberOfSteps("2");
1378 scaleRequest.setAspectId("myAspect");
1379 scaleRequest.setType(ScaleDirection.IN);
1380 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }"));
1381 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1382 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1383 VnfProperty prop = new VnfProperty();
1384 prop.setValue(ONAP_CSAR_ID);
1385 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1386 vnfInfo.getExtensions().add(prop);
1387 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1388 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1389 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1391 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1393 waitForJobToFinishInJobManager(finished);
1394 assertEquals(1, actualScaleRequest.getAllValues().size());
1395 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1396 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1397 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1398 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1399 assertEquals("myAspect", sRequest.getAspectId());
1400 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1401 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1402 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1403 verify(jobManager).spawnJob(VNF_ID, restResponse);
1404 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("scale"), eq(VNF_ID), anyString());
1408 * test scale a non scalable VNF
1411 public void testScaleNonScalableVnf() throws Exception {
1412 cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.instantiation.yaml").toURI())));
1413 when(catalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent);
1414 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1415 scaleRequest.setNumberOfSteps("2");
1416 scaleRequest.setAspectId("myAspect");
1417 scaleRequest.setType(ScaleDirection.IN);
1418 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }"));
1419 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1420 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1421 VnfProperty prop = new VnfProperty();
1422 prop.setValue(ONAP_CSAR_ID);
1423 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1424 vnfInfo.getExtensions().add(prop);
1425 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1426 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1427 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1429 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1431 waitForJobToFinishInJobManager(finished);
1432 assertEquals(0, actualScaleRequest.getAllValues().size());
1433 verify(logger).error("Unable to find operation named scale");
1437 * the VNFM should tolerate that no additional params were supplied
1440 public void testScaleWithoutAdditionalParams() throws Exception {
1441 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1442 scaleRequest.setNumberOfSteps("2");
1443 scaleRequest.setAspectId("myAspect");
1444 scaleRequest.setType(ScaleDirection.IN);
1445 scaleRequest.setAdditionalParam(null);
1446 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1448 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1449 VnfProperty prop = new VnfProperty();
1450 prop.setValue(ONAP_CSAR_ID);
1451 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1452 vnfInfo.getExtensions().add(prop);
1453 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1454 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1455 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1457 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1459 waitForJobToFinishInJobManager(finished);
1460 assertEquals(1, actualScaleRequest.getAllValues().size());
1461 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1462 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1463 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1464 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1465 assertEquals("myAspect", sRequest.getAspectId());
1466 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1467 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1468 assertEquals("{\"jobId\":\"myJobId\"}", new Gson().toJson(sRequest.getAdditionalParams()));
1469 verify(jobManager).spawnJob(VNF_ID, restResponse);
1473 * test scale out basic scenario
1476 public void testScaleOut() throws Exception {
1477 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1478 scaleRequest.setNumberOfSteps("2");
1479 scaleRequest.setAspectId("myAspect");
1480 scaleRequest.setType(ScaleDirection.OUT);
1481 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1482 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1483 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1484 VnfProperty prop = new VnfProperty();
1485 prop.setValue(ONAP_CSAR_ID);
1486 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1487 vnfInfo.getExtensions().add(prop);
1488 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1489 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1490 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1492 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1494 waitForJobToFinishInJobManager(finished);
1495 assertEquals(1, actualScaleRequest.getAllValues().size());
1496 ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1497 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1498 workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1499 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1500 assertEquals("myAspect", sRequest.getAspectId());
1501 assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.OUT, sRequest.getType());
1502 assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1503 assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1507 * test scale operation is out waited
1510 public void testScaleOutwait() throws Exception {
1511 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1512 scaleRequest.setNumberOfSteps("2");
1513 scaleRequest.setAspectId("myAspect");
1514 scaleRequest.setType(ScaleDirection.IN);
1515 scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1516 scaleOperationExecution.setStatus(OperationStatus.STARTED);
1517 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1518 VnfProperty prop = new VnfProperty();
1519 prop.setValue(ONAP_CSAR_ID);
1520 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1521 vnfInfo.getExtensions().add(prop);
1522 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1523 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1524 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1525 List<RuntimeException> expectedExceptions = new ArrayList<>();
1526 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<Observable<List<OperationExecution>>>) invocation -> {
1527 if (expectedExceptions.size() >= 100) {
1528 when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(scaleOperationExecution));
1529 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1530 return buildObservable(operationExecutions);
1532 RuntimeException RuntimeException = new RuntimeException();
1533 expectedExceptions.add(RuntimeException);
1534 throw RuntimeException;
1538 JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1540 waitForJobToFinishInJobManager(finished);
1541 assertEquals(100, expectedExceptions.size());
1542 for (RuntimeException expectedException : expectedExceptions) {
1543 verify(logger).warn("Unable to retrieve operations details", expectedException);
1545 verify(systemFunctions, times(100)).sleep(5000);
1549 * test scale failure propagation
1552 public void testScaleFailurePropagation() throws Exception {
1553 RuntimeException expectedException = new RuntimeException();
1554 VnfScaleRequest scaleRequest = new VnfScaleRequest();
1555 scaleRequest.setNumberOfSteps("2");
1556 scaleRequest.setAspectId("myAspect");
1557 scaleRequest.setType(ScaleDirection.IN);
1558 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1560 lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1562 waitForJobToFinishInJobManager(finished);
1563 verify(logger).error("Unable to scale VNF with myVnfId identifier", expectedException);
1567 * test heal basic scenario
1570 public void testHeal() throws Exception {
1571 VnfHealRequest healRequest = new VnfHealRequest();
1572 healRequest.setAction("myAction");
1573 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1574 affectedVm.setVmname("vmName");
1575 healRequest.setAffectedvm(affectedVm);
1576 healOperationExecution.setStatus(OperationStatus.FINISHED);
1577 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1578 VnfProperty prop = new VnfProperty();
1579 prop.setValue(ONAP_CSAR_ID);
1580 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1581 vnfInfo.getExtensions().add(prop);
1582 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1583 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1584 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1586 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1588 waitForJobToFinishInJobManager(finished);
1589 assertEquals(1, actualHealRequest.getAllValues().size());
1590 HealVnfRequest sRequest = actualHealRequest.getValue();
1591 InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1592 workflowOrder.verify(vfcGrantManager).requestGrantForHeal(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(healRequest), eq(JOB_ID));
1593 workflowOrder.verify(vnfApi).vnfsVnfInstanceIdHealPost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1594 JsonObject root = new Gson().toJsonTree(sRequest.getAdditionalParams()).getAsJsonObject();
1595 assertEquals("myAction", root.get("action").getAsString());
1596 assertEquals("vmName", root.get("vmName").getAsString());
1597 assertEquals(JOB_ID, root.get("jobId").getAsString());
1598 verify(jobManager).spawnJob(VNF_ID, restResponse);
1599 verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("heal"), eq(VNF_ID), anyString());
1603 * test heal operation is out waited
1606 public void testHealOutwait() throws Exception {
1607 VnfHealRequest healRequest = new VnfHealRequest();
1608 healRequest.setAction("myAction");
1609 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1610 affectedVm.setVmname("vmName");
1611 healRequest.setAffectedvm(affectedVm);
1612 healOperationExecution.setStatus(OperationStatus.FINISHED);
1613 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1614 VnfProperty prop = new VnfProperty();
1615 prop.setValue(ONAP_CSAR_ID);
1616 prop.setName(LifecycleManager.ONAP_CSAR_ID);
1617 vnfInfo.getExtensions().add(prop);
1618 vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1619 String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1620 when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1621 List<RuntimeException> expectedExceptions = new ArrayList<>();
1622 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
1624 public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
1625 if (expectedExceptions.size() >= 100) {
1626 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1627 return buildObservable(operationExecutions);
1629 RuntimeException RuntimeException = new RuntimeException();
1630 expectedExceptions.add(RuntimeException);
1631 throw RuntimeException;
1635 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1637 waitForJobToFinishInJobManager(finished);
1638 assertEquals(100, expectedExceptions.size());
1639 for (RuntimeException expectedException : expectedExceptions) {
1640 verify(logger).warn("Unable to retrieve operations details", expectedException);
1642 verify(systemFunctions, times(100)).sleep(5000);
1646 * failure in heal propagates in error
1649 public void testHealFailurePropagation() throws Exception {
1650 RuntimeException expectedException = new RuntimeException();
1651 VnfHealRequest healRequest = new VnfHealRequest();
1652 healRequest.setAction("myAction");
1653 VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1654 affectedVm.setVmname("vmName");
1655 healRequest.setAffectedvm(affectedVm);
1656 when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1658 JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1660 waitForJobToFinishInJobManager(finished);
1661 verify(logger).error("Unable to heal VNF with myVnfId identifier", expectedException);
1666 * test custom operation basic scenario
1669 public void testCustomOperation() throws Exception {
1670 String operationId = "operationIdCaptor";
1671 Object additionalParams = new JsonObject();
1673 JobInfo job = lifecycleManager.customOperation(VNFM_ID, VNF_ID, operationId, additionalParams, restResponse);
1675 waitForJobToFinishInJobManager(finished);
1676 assertEquals(operationId, operationIdCaptor.getValue());
1677 assertEquals(additionalParams, customOperationRequestArgumentCaptor.getValue().getAdditionalParams());
1680 private void waitForJobToFinishInJobManager(Set<Boolean> finished) throws InterruptedException {
1681 while (finished.size() == 0) {
1682 systemFunctions().sleep(100);
1686 public static class X{
1687 public Map<String, String> getInputs() {
1691 public void setInputs(Map<String, String> inputs) {
1692 this.inputs = inputs;
1695 @SerializedName("inputs")
1696 public Map<String,String> inputs = new HashMap<String,String>();
1698 public String vimId;
1700 public String properties;
1703 private VnfInstantiateRequest prepareInstantiationRequest(VimInfo.VimInfoTypeEnum cloudType, boolean addExtension) {
1704 VnfInstantiateRequest instantiationRequest = new VnfInstantiateRequest();
1705 instantiationRequest.setVnfPackageId(ONAP_CSAR_ID);
1706 instantiationRequest.setVnfDescriptorId(ONAP_CSAR_ID);
1707 instantiationRequest.setVnfInstanceDescription("myDescription");
1708 instantiationRequest.setVnfInstanceName("vnfName");
1709 externalVirtualLink.setCpdId("myCpdId");
1710 externalVirtualLink.setResourceId("myNetworkProviderId");
1711 externalVirtualLink.setVlInstanceId("myEVlId");
1712 externalVirtualLink.setResourceSubnetId("notUsedSubnetId");
1713 instantiationRequest.setExtVirtualLink(new ArrayList<>());
1714 instantiationRequest.getExtVirtualLink().add(externalVirtualLink);
1715 buildAdditionalParams(cloudType, addExtension);
1716 String params = new Gson().toJson(additionalParam);
1718 x.inputs.put(ONAP_CSAR_ID, params);
1720 JsonElement additionalParam = new Gson().toJsonTree(x);
1721 instantiationRequest.setAdditionalParam(additionalParam);
1722 return instantiationRequest;
1725 private void buildAdditionalParams(VimInfo.VimInfoTypeEnum cloudType, boolean addExtensions) {
1726 additionalParam.setInstantiationLevel("level1");
1727 switch (cloudType) {
1728 case OPENSTACK_V2_INFO:
1729 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1731 case OPENSTACK_V3_INFO:
1732 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
1733 vimInfo.setDomain("myDomain");
1735 case VMWARE_VCLOUD_INFO:
1736 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
1739 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
1742 Map<String, List<NetworkAddress>> exteranalConnectionPointAddresses = new HashMap<>();
1743 exteranalConnectionPointAddresses.put("ecp1", new ArrayList<>());
1744 NetworkAddress networkAddress = new NetworkAddress();
1745 networkAddress.setIp("1.2.3.4");
1746 networkAddress.setMac("mac");
1747 networkAddress.setSubnetId("subnetId");
1748 exteranalConnectionPointAddresses.get("ecp1").add(networkAddress);
1749 additionalParam.setExternalConnectionPointAddresses(exteranalConnectionPointAddresses);
1750 VimComputeResourceFlavour flavor = new VimComputeResourceFlavour();
1751 flavor.setResourceId("flavourProviderId");
1752 flavor.setVimId(VIM_ID);
1753 flavor.setVnfdVirtualComputeDescId("virtualComputeDescId");
1754 additionalParam.getComputeResourceFlavours().add(flavor);
1755 ExtVirtualLinkData evl = new ExtVirtualLinkData();
1756 evl.setResourceId("networkProviderId1");
1757 evl.setVimId(VIM_ID);
1758 evl.setExtVirtualLinkId("evlId1");
1759 VnfExtCpData ecp2 = new VnfExtCpData();
1760 ecp2.setCpdId("cpdId3");
1761 ecp2.setAddresses(new ArrayList<>());
1762 ecp2.getAddresses().add(networkAddress);
1763 ecp2.setNumDynamicAddresses(2);
1764 evl.getExtCps().add(ecp2);
1765 additionalParam.getExtVirtualLinks().add(evl);
1766 additionalParam.getExtManagedVirtualLinks().add(extManVl);
1767 ZoneInfo zone = new ZoneInfo();
1768 zone.setId("zoneId");
1769 zone.setResourceId("zoneProviderId");
1770 zone.setVimId(VIM_ID);
1771 additionalParam.getZones().add(zone);
1772 VimSoftwareImage image = new VimSoftwareImage();
1773 image.setResourceId("imageProviderId");
1774 image.setVimId(VIM_ID);
1775 image.setVnfdSoftwareImageId("imageId");
1776 additionalParam.getSoftwareImages().add(image);
1777 additionalParam.setAdditionalParams(new JsonParser().parse("{ \"a\" : \"b\" }"));
1779 VnfProperty p1 = new VnfProperty();
1781 p1.setValue(Lists.newArrayList("a", "b"));
1782 VnfProperty p2 = new VnfProperty();
1785 VnfProperty p3 = new VnfProperty();
1787 JsonObject o = new JsonObject();
1789 o.addProperty("a", "b");
1790 additionalParam.getExtensions().add(p1);
1791 additionalParam.getExtensions().add(p2);
1792 additionalParam.getExtensions().add(p3);
1797 * Test vimId decomposition
1800 public void testVimIdSplitting() {
1801 assertEquals("regionId", LifecycleManager.getRegionName("cloudOwner_regionId"));
1802 assertEquals("cloudOwner", LifecycleManager.getCloudOwner("cloudOwner_regionId"));
1806 * additional params of instantiation may be passed as VNF property
1809 public void testVnfConfigurationBasedOnPackageParameters() throws Exception {
1810 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, false);
1811 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
1812 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
1813 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
1814 grantResponse.setVimId(VIM_ID);
1815 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
1816 accessInfo.setTenant(TENANT);
1817 grantResponse.setAccessInfo(accessInfo);
1818 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
1819 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
1821 JsonObject root = new JsonObject();
1822 root.addProperty(LifecycleManager.ETSI_CONFIG, new Gson().toJson(additionalParam));
1823 x.properties = new Gson().toJson(root);
1825 JsonElement additionalParam = new Gson().toJsonTree(x);
1826 instantiationRequest.setAdditionalParam(additionalParam);
1828 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
1829 waitForJobToFinishInJobManager(finished);
1830 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
1832 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
1833 assertEquals(VIM_ID, actualVim.getId());
1834 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
1835 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
1836 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
1837 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
1838 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
1839 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
1840 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
1841 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
1842 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
1843 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
1844 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
1849 * additional params of instantiation may be passed as directly attached artifact
1852 public void testVnfConfigurationBasedOnArtifactParameters() throws Exception {
1853 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, false);
1854 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
1855 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
1856 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
1857 grantResponse.setVimId(VIM_ID);
1858 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
1859 accessInfo.setTenant(TENANT);
1860 grantResponse.setAccessInfo(accessInfo);
1861 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
1862 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
1863 when(catalogManager.getEtsiConfiguration(ONAP_CSAR_ID)).thenReturn(new Gson().toJson(additionalParam));
1866 JsonElement additionalParam = new Gson().toJsonTree(x);
1867 instantiationRequest.setAdditionalParam(additionalParam);
1869 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
1870 waitForJobToFinishInJobManager(finished);
1871 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
1873 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
1874 assertEquals(VIM_ID, actualVim.getId());
1875 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
1876 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
1877 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
1878 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
1879 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
1880 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
1881 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
1882 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
1883 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
1884 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
1885 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
1889 * additional params of instantiation may be passed as VNF property
1892 public void testVnfConfigurationBasedOnPackageParametersMissingPropertiesEtsiConfig() throws Exception {
1893 VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, false);
1894 when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
1895 additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
1896 when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
1897 grantResponse.setVimId(VIM_ID);
1898 GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
1899 accessInfo.setTenant(TENANT);
1900 grantResponse.setAccessInfo(accessInfo);
1901 ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
1902 when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
1904 JsonObject root = new JsonObject();
1905 root.addProperty(LifecycleManager.ETSI_CONFIG, new Gson().toJson(additionalParam));
1906 x.properties = "{ }";
1907 new Gson().toJson(root);
1908 x.inputs.put(ONAP_CSAR_ID, new Gson().toJson(additionalParam));
1910 JsonElement additionalParam = new Gson().toJsonTree(x);
1911 instantiationRequest.setAdditionalParam(additionalParam);
1913 VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
1914 waitForJobToFinishInJobManager(finished);
1915 assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
1917 OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
1918 assertEquals(VIM_ID, actualVim.getId());
1919 assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
1920 assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
1921 assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
1922 //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
1923 assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
1924 assertEquals("regionId", actualVim.getAccessInfo().getRegion());
1925 assertEquals("myTenant", actualVim.getAccessInfo().getProject());
1926 assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
1927 assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
1928 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
1929 assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
1930 verify(logger).info("The instantiation input for VNF with {} CSAR id does not have an " + LifecycleManager.ETSI_CONFIG + " section", ONAP_CSAR_ID);