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.
17 package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc;
19 import com.google.common.collect.Lists;
20 import com.google.gson.Gson;
21 import com.google.gson.JsonElement;
22 import com.google.gson.JsonParser;
23 import com.nokia.cbam.lcm.v32.model.AffectedVirtualLink;
24 import com.nokia.cbam.lcm.v32.model.AffectedVirtualStorage;
25 import com.nokia.cbam.lcm.v32.model.AffectedVnfc;
26 import com.nokia.cbam.lcm.v32.model.ChangeType;
27 import com.nokia.cbam.lcm.v32.model.*;
28 import com.nokia.cbam.lcm.v32.model.OperationType;
29 import com.nokia.cbam.lcm.v32.model.ScaleDirection;
30 import java.util.ArrayList;
31 import java.util.List;
32 import org.junit.Before;
33 import org.junit.Test;
34 import org.mockito.ArgumentCaptor;
35 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase;
36 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedConnectionPoints;
37 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedCp;
38 import org.onap.vnfmdriver.model.*;
39 import org.threeten.bp.OffsetDateTime;
41 import static java.util.Optional.empty;
42 import static java.util.Optional.of;
44 import static junit.framework.TestCase.*;
45 import static org.mockito.Mockito.any;
46 import static org.mockito.Mockito.eq;
47 import static org.mockito.Mockito.*;
48 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
49 import static org.springframework.test.util.ReflectionTestUtils.setField;
51 public class TestVfcNotificationSender extends TestBase {
52 private VfcNotificationSender vfcNotificationSender;
53 private ArgumentCaptor<VNFLCMNotification> sentLcnToVfc = ArgumentCaptor.forClass(VNFLCMNotification.class);
54 private VnfLifecycleChangeNotification recievedLcn = new VnfLifecycleChangeNotification();
55 private List<OperationExecution> operationExecutions = new ArrayList<>();
56 private OperationExecution instantiationOperation = new OperationExecution();
57 private OperationExecution scaleOperation = new OperationExecution();
58 private OperationExecution healOperation = new OperationExecution();
59 private OperationExecution terminationOperation = new OperationExecution();
60 private ReportedAffectedConnectionPoints affectedCp;
64 public void init() throws Exception {
65 vfcNotificationSender = new VfcNotificationSender(driverProperties, vfcRestApiProvider);
66 setField(VfcNotificationSender.class, "logger", logger);
67 when(nsLcmApi.vNFLCMNotification(eq(VNFM_ID), eq(VNF_ID), sentLcnToVfc.capture())).thenReturn(null);
68 instantiationOperation.setId("instantiationOperationExecutionId");
69 instantiationOperation.setStartTime(OffsetDateTime.now());
70 instantiationOperation.setOperationType(OperationType.INSTANTIATE);
71 scaleOperation.setId("scaleOperationExecutionId");
72 scaleOperation.setStartTime(OffsetDateTime.now().plusDays(1));
73 scaleOperation.setOperationType(OperationType.SCALE);
74 terminationOperation.setId("terminationExecutionId");
75 terminationOperation.setStartTime(OffsetDateTime.now().plusDays(1));
76 terminationOperation.setOperationType(OperationType.TERMINATE);
77 healOperation.setId("healOperaitonExecutionId");
78 healOperation.setOperationType(OperationType.HEAL);
79 healOperation.setStartTime(OffsetDateTime.now().plusDays(1));
80 when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecutions));
81 prepOperation(instantiationOperation);
82 prepOperation(scaleOperation);
83 prepOperation(healOperation);
84 prepOperation(terminationOperation);
85 recievedLcn.setVnfInstanceId(VNF_ID);
88 private void prepOperation(OperationExecution operationExecution) {
89 addEmptyModifiedConnectionPoints(operationExecution);
90 JsonElement root = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + JOB_ID + "\"}}");
91 operationExecution.setOperationParams(root);
92 switch (operationExecution.getOperationType()) {
94 root.getAsJsonObject().addProperty("terminationType", "GRACEFULL");
96 when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(operationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecution));
97 operationExecutions.add(operationExecution);
100 private void addEmptyModifiedConnectionPoints(OperationExecution operationExecution) {
101 OperationResult operationResult = new OperationResult();
102 operationResult.operationResult = new ReportedAffectedConnectionPoints();
103 JsonElement additionalData = new Gson().toJsonTree(operationResult);
104 operationExecution.setAdditionalData(additionalData);
108 * test start notification success scenario
109 * - the affected resources are not processed even if present
110 * - LCN is sent to VF-C
113 public void testStartLcn() {
114 recievedLcn.setStatus(OperationStatus.STARTED);
115 recievedLcn.setOperation(OperationType.INSTANTIATE);
117 vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, empty(), VIM_ID);
119 assertEquals(1, sentLcnToVfc.getAllValues().size());
120 assertNull(sentLcnToVfc.getValue().getAffectedVl());
121 assertNull(sentLcnToVfc.getValue().getAffectedVnfc());
122 assertNull(sentLcnToVfc.getValue().getAffectedCp());
123 assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage());
125 assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
126 assertEquals(org.onap.vnfmdriver.model.OperationType.INSTANTIATE, sentLcnToVfc.getValue().getOperation());
127 assertEquals(VnfLcmNotificationStatus.START, sentLcnToVfc.getValue().getStatus());
128 assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
132 * test end notification success scenario
133 * - LCN is sent to VF-C
136 public void testFinishLcn() {
138 recievedLcn.setOperation(OperationType.INSTANTIATE);
139 recievedLcn.setStatus(OperationStatus.FINISHED);
140 AffectedVnfc affectedVnfc = new AffectedVnfc();
141 affectedVnfc.setChangeType(ChangeType.ADDED);
142 affectedVnfc.setId("myVnfcId");
143 affectedVnfc.setVduId("myVduId");
144 affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
145 affectedVnfc.setComputeResource(new ResourceHandle());
146 affectedVnfc.getComputeResource().setResourceId("serverProviderId");
147 affectedVnfc.getComputeResource().setVimId(VIM_ID);
148 affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
149 recievedLcn.setAffectedVnfcs(new ArrayList<>());
150 recievedLcn.getAffectedVnfcs().add(affectedVnfc);
152 AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
153 affectedVirtualLink.setChangeType(ChangeType.ADDED);
154 affectedVirtualLink.setId("vlId");
155 affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
156 affectedVirtualLink.setResource(new ResourceHandle());
157 affectedVirtualLink.getResource().setVimId(VIM_ID);
158 affectedVirtualLink.getResource().setResourceId("networkProviderId");
159 recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
160 recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
162 AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
163 affectedStorage.setChangeType(ChangeType.ADDED);
164 affectedStorage.setId("storageId");
165 affectedStorage.setVirtualStorageDescId("storageVnfdId");
166 affectedStorage.setResource(new ResourceHandle());
167 affectedStorage.getResource().setVimId(VIM_ID);
168 affectedStorage.getResource().setResourceId("storageProviderId");
169 recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
170 recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
172 ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
173 ReportedAffectedCp affectedCp = new ReportedAffectedCp();
174 affectedCp.setCpdId("cpVnfdId");
175 affectedCp.setIpAddress("1.2.3.4");
176 affectedCp.setMacAddress("myMac");
177 affectedCp.setName("myPortName");
178 affectedCp.setCpId("cpId");
180 affectedCp.setNetworkProviderId("networkProviderId");
181 affectedCp.setProviderId("portProviderId");
182 affectedCp.setServerProviderId("serverProviderId");
183 affectedCp.setTenantId("tenantId");
184 affectedConnectionPoints.getPost().add(affectedCp);
186 OperationResult operationResult = new OperationResult();
187 operationResult.operationResult = affectedConnectionPoints;
188 JsonElement additionalData = new Gson().toJsonTree(operationResult);
189 instantiationOperation.setAdditionalData(additionalData);
191 vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, of(affectedConnectionPoints), VIM_ID);
193 assertEquals(1, sentLcnToVfc.getAllValues().size());
195 assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
196 org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
197 assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectedVl.getChangeType());
198 assertEquals("vlVnfdId", actualAffectedVl.getVldid());
199 assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
200 assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
201 assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
203 assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
204 org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
205 assertEquals("myVduId", actualAffectdVnfc.getVduId());
206 assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
207 assertEquals("myVmName", actualAffectdVnfc.getVmname());
208 assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
209 assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectdVnfc.getChangeType());
210 assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
212 assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
213 AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
214 assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
215 assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
216 assertEquals(null, actualAffectedCp.getOwnerId());
217 assertEquals(null, actualAffectedCp.getOwnerType());
218 assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
219 assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
220 assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
221 assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
222 assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
223 assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
224 assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
225 assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
226 assertEquals(VnfCpNotificationType.ADDED, actualAffectedCp.getChangeType());
228 assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage());
229 assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
230 assertEquals(org.onap.vnfmdriver.model.OperationType.INSTANTIATE, sentLcnToVfc.getValue().getOperation());
231 assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
232 assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
236 * test end notification success scenario for ECP
239 public void testFinishLcnForEcp() {
241 recievedLcn.setOperation(OperationType.INSTANTIATE);
242 recievedLcn.setStatus(OperationStatus.FINISHED);
243 AffectedVnfc affectedVnfc = new AffectedVnfc();
244 affectedVnfc.setChangeType(ChangeType.ADDED);
245 affectedVnfc.setId("myVnfcId");
246 affectedVnfc.setVduId("myVduId");
247 affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
248 affectedVnfc.setComputeResource(new ResourceHandle());
249 affectedVnfc.getComputeResource().setResourceId("serverProviderId");
250 affectedVnfc.getComputeResource().setVimId(VIM_ID);
251 affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
252 recievedLcn.setAffectedVnfcs(new ArrayList<>());
253 recievedLcn.getAffectedVnfcs().add(affectedVnfc);
255 ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
256 ReportedAffectedCp affectedCp = new ReportedAffectedCp();
257 //affectedCp.setCpdId("cpVnfdId");
258 affectedCp.setIpAddress("1.2.3.4");
259 affectedCp.setMacAddress("myMac");
260 affectedCp.setName("myPortName");
261 affectedCp.setCpId("cpId");
262 affectedCp.setEcpdId("ecpdId");
263 affectedCp.setNetworkProviderId("networkProviderId");
264 affectedCp.setProviderId("portProviderId");
265 affectedCp.setServerProviderId("serverProviderId");
266 affectedCp.setTenantId("tenantId");
267 affectedConnectionPoints.getPost().add(affectedCp);
269 OperationResult operationResult = new OperationResult();
270 operationResult.operationResult = affectedConnectionPoints;
271 JsonElement additionalData = new Gson().toJsonTree(operationResult);
272 instantiationOperation.setAdditionalData(additionalData);
274 vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, of(affectedConnectionPoints), VIM_ID);
276 assertEquals(1, sentLcnToVfc.getAllValues().size());
278 assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
279 AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
280 assertEquals("ecpdId", actualAffectedCp.getCpdid());
281 assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
282 assertEquals(null, actualAffectedCp.getOwnerId());
283 assertEquals(null, actualAffectedCp.getOwnerType());
284 assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
285 assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
286 assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
287 assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
288 assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
289 assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
290 assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
291 assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
292 assertEquals(VnfCpNotificationType.ADDED, actualAffectedCp.getChangeType());
296 * test end notification success scenario with termination
299 public void testFinishLcnWithTerminate() {
301 recievedLcn.setOperation(OperationType.TERMINATE);
302 recievedLcn.setStatus(OperationStatus.FINISHED);
303 AffectedVnfc affectedVnfc = new AffectedVnfc();
304 affectedVnfc.setChangeType(ChangeType.REMOVED);
305 affectedVnfc.setId("myVnfcId");
306 affectedVnfc.setVduId("myVduId");
307 affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
308 affectedVnfc.setComputeResource(new ResourceHandle());
309 affectedVnfc.getComputeResource().setResourceId("serverProviderId");
310 affectedVnfc.getComputeResource().setVimId(VIM_ID);
311 affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
312 recievedLcn.setAffectedVnfcs(new ArrayList<>());
313 recievedLcn.getAffectedVnfcs().add(affectedVnfc);
315 AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
316 affectedVirtualLink.setChangeType(ChangeType.REMOVED);
317 affectedVirtualLink.setId("vlId");
318 affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
319 affectedVirtualLink.setResource(new ResourceHandle());
320 affectedVirtualLink.getResource().setVimId(VIM_ID);
321 affectedVirtualLink.getResource().setResourceId("networkProviderId");
322 recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
323 recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
325 AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
326 affectedStorage.setChangeType(ChangeType.REMOVED);
327 affectedStorage.setId("storageId");
328 affectedStorage.setVirtualStorageDescId("storageVnfdId");
329 affectedStorage.setResource(new ResourceHandle());
330 affectedStorage.getResource().setVimId(VIM_ID);
331 affectedStorage.getResource().setResourceId("storageProviderId");
332 recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
333 recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
335 ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
336 ReportedAffectedCp affectedCp = new ReportedAffectedCp();
337 affectedCp.setCpdId("cpVnfdId");
338 affectedCp.setIpAddress("1.2.3.4");
339 affectedCp.setMacAddress("myMac");
340 affectedCp.setName("myPortName");
341 affectedCp.setCpId("cpId");
343 // affectedCp.setEcpdId("ecpdId");
344 affectedCp.setNetworkProviderId("networkProviderId");
345 affectedCp.setProviderId("portProviderId");
346 affectedCp.setServerProviderId("serverProviderId");
347 affectedCp.setTenantId("tenantId");
348 affectedConnectionPoints.getPre().add(affectedCp);
350 OperationResult operationResult = new OperationResult();
351 operationResult.operationResult = affectedConnectionPoints;
352 JsonElement additionalData = new Gson().toJsonTree(operationResult);
353 instantiationOperation.setAdditionalData(additionalData);
355 vfcNotificationSender.processNotification(recievedLcn, terminationOperation, of(affectedConnectionPoints), VIM_ID);
357 assertEquals(1, sentLcnToVfc.getAllValues().size());
359 assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
360 org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
361 assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectedVl.getChangeType());
362 assertEquals("vlVnfdId", actualAffectedVl.getVldid());
363 assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
364 assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
365 assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
367 assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
368 org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
369 assertEquals("myVduId", actualAffectdVnfc.getVduId());
370 assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
371 assertEquals("myVmName", actualAffectdVnfc.getVmname());
372 assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
373 assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectdVnfc.getChangeType());
374 assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
376 assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
377 AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
378 assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
379 assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
380 assertEquals(null, actualAffectedCp.getOwnerId());
381 assertEquals(null, actualAffectedCp.getOwnerType());
382 assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
383 assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
384 assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
385 assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
386 assertEquals(VnfCpNotificationType.REMOVED, actualAffectedCp.getChangeType());
387 assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
388 assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
389 assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
390 assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
392 assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage());
393 assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
394 assertEquals(org.onap.vnfmdriver.model.OperationType.TERMINAL, sentLcnToVfc.getValue().getOperation());
395 assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
396 assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
400 * test end notification success scenario for modifiction (heal)
401 * - LCN is sent to VF-C
404 public void testFinishLcnForModification() {
406 recievedLcn.setOperation(OperationType.HEAL);
407 recievedLcn.setStatus(OperationStatus.FINISHED);
408 AffectedVnfc affectedVnfc = new AffectedVnfc();
409 affectedVnfc.setChangeType(ChangeType.MODIFIED);
410 affectedVnfc.setId("myVnfcId");
411 affectedVnfc.setVduId("myVduId");
412 affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
413 affectedVnfc.setComputeResource(new ResourceHandle());
414 affectedVnfc.getComputeResource().setResourceId("serverProviderId");
415 affectedVnfc.getComputeResource().setVimId(VIM_ID);
416 affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
417 recievedLcn.setAffectedVnfcs(new ArrayList<>());
418 recievedLcn.getAffectedVnfcs().add(affectedVnfc);
420 AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
421 affectedVirtualLink.setChangeType(ChangeType.MODIFIED);
422 affectedVirtualLink.setId("vlId");
423 affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
424 affectedVirtualLink.setResource(new ResourceHandle());
425 affectedVirtualLink.getResource().setVimId(VIM_ID);
426 affectedVirtualLink.getResource().setResourceId("networkProviderId");
427 recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
428 recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
431 AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
432 affectedStorage.setChangeType(ChangeType.MODIFIED);
433 affectedStorage.setId("storageId");
434 affectedStorage.setVirtualStorageDescId("storageVnfdId");
435 affectedStorage.setResource(new ResourceHandle());
436 affectedStorage.getResource().setVimId(VIM_ID);
437 affectedStorage.getResource().setResourceId("storageProviderId");
438 recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
439 recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
441 ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
442 ReportedAffectedCp affectedCp = new ReportedAffectedCp();
443 affectedCp.setCpdId("cpVnfdId");
444 affectedCp.setIpAddress("1.2.3.4");
445 affectedCp.setMacAddress("myMac");
446 affectedCp.setName("myPortName");
447 affectedCp.setCpId("cpId");
449 // affectedCp.setEcpdId("ecpdId");
450 affectedCp.setNetworkProviderId("networkProviderId");
451 affectedCp.setProviderId("portProviderId");
452 affectedCp.setServerProviderId("serverProviderId");
453 affectedCp.setTenantId("tenantId");
454 affectedConnectionPoints.getPre().add(affectedCp);
456 ReportedAffectedCp after = new ReportedAffectedCp();
457 after.setCpdId("cpVnfdId");
458 after.setIpAddress("1.2.3.5");
459 after.setMacAddress("myMac");
460 after.setName("myPortName");
461 after.setCpId("cpId");
463 // affectedCp.setEcpdId("ecpdId");
464 after.setNetworkProviderId("networkProviderId");
465 after.setProviderId("portProviderId");
466 after.setServerProviderId("serverProviderId");
467 after.setTenantId("tenantId");
468 affectedConnectionPoints.getPost().add(after);
471 OperationResult operationResult = new OperationResult();
472 operationResult.operationResult = affectedConnectionPoints;
473 JsonElement additionalData = new Gson().toJsonTree(operationResult);
474 instantiationOperation.setAdditionalData(additionalData);
476 vfcNotificationSender.processNotification(recievedLcn, healOperation, of(affectedConnectionPoints), VIM_ID);
478 assertEquals(1, sentLcnToVfc.getAllValues().size());
480 assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
481 org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
482 assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.MODIFIED, actualAffectedVl.getChangeType());
483 assertEquals("vlVnfdId", actualAffectedVl.getVldid());
484 assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
485 assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
486 assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
488 assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
489 org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
490 assertEquals("myVduId", actualAffectdVnfc.getVduId());
491 assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
492 assertEquals("myVmName", actualAffectdVnfc.getVmname());
493 assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
494 assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.MODIFIED, actualAffectdVnfc.getChangeType());
495 assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
497 assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
498 AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
499 assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
500 assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
501 assertEquals(null, actualAffectedCp.getOwnerId());
502 assertEquals(null, actualAffectedCp.getOwnerType());
503 assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
504 assertEquals("1.2.3.5", actualAffectedCp.getPortResource().getIpAddress());
505 assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
506 assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
507 assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
508 assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
509 assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
510 assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
511 assertEquals(VnfCpNotificationType.CHANGED, actualAffectedCp.getChangeType());
513 assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage());
514 assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
515 assertEquals(org.onap.vnfmdriver.model.OperationType.HEAL, sentLcnToVfc.getValue().getOperation());
516 assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
517 assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
521 * test end notification success scenario for scale-out
522 * - LCN is sent to VF-C
525 public void testFinishLcnForScaleout() {
527 recievedLcn.setOperation(OperationType.SCALE);
528 recievedLcn.setStatus(OperationStatus.FINISHED);
529 recievedLcn.setLifecycleOperationOccurrenceId(scaleOperation.getId());
530 ScaleVnfRequest request = new ScaleVnfRequest();
531 request.setAdditionalParams(new JsonParser().parse("{ \"jobId\" : \"" + JOB_ID + "\" }"));
532 request.setType(ScaleDirection.OUT);
533 scaleOperation.setOperationParams(request);
534 scaleOperation.setOperationType(OperationType.SCALE);
535 AffectedVnfc affectedVnfc = new AffectedVnfc();
536 affectedVnfc.setChangeType(ChangeType.ADDED);
537 affectedVnfc.setId("myVnfcId");
538 affectedVnfc.setVduId("myVduId");
539 affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
540 affectedVnfc.setComputeResource(new ResourceHandle());
541 affectedVnfc.getComputeResource().setResourceId("serverProviderId");
542 affectedVnfc.getComputeResource().setVimId(VIM_ID);
543 affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
544 recievedLcn.setAffectedVnfcs(new ArrayList<>());
545 recievedLcn.getAffectedVnfcs().add(affectedVnfc);
547 AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
548 affectedVirtualLink.setChangeType(ChangeType.ADDED);
549 affectedVirtualLink.setId("vlId");
550 affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
551 affectedVirtualLink.setResource(new ResourceHandle());
552 affectedVirtualLink.getResource().setVimId(VIM_ID);
553 affectedVirtualLink.getResource().setResourceId("networkProviderId");
554 recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
555 recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
558 AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
559 affectedStorage.setChangeType(ChangeType.ADDED);
560 affectedStorage.setId("storageId");
561 affectedStorage.setVirtualStorageDescId("storageVnfdId");
562 affectedStorage.setResource(new ResourceHandle());
563 affectedStorage.getResource().setVimId(VIM_ID);
564 affectedStorage.getResource().setResourceId("storageProviderId");
565 recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
566 recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
568 ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
569 ReportedAffectedCp affectedCp = new ReportedAffectedCp();
570 affectedCp.setCpdId("cpVnfdId");
571 affectedCp.setIpAddress("1.2.3.4");
572 affectedCp.setMacAddress("myMac");
573 affectedCp.setName("myPortName");
574 affectedCp.setCpId("cpId");
576 // affectedCp.setEcpdId("ecpdId");
577 affectedCp.setNetworkProviderId("networkProviderId");
578 affectedCp.setProviderId("portProviderId");
579 affectedCp.setServerProviderId("serverProviderId");
580 affectedCp.setTenantId("tenantId");
581 affectedConnectionPoints.getPost().add(affectedCp);
583 OperationResult operationResult = new OperationResult();
584 operationResult.operationResult = affectedConnectionPoints;
585 JsonElement additionalData = new Gson().toJsonTree(operationResult);
586 scaleOperation.setAdditionalData(additionalData);
588 vfcNotificationSender.processNotification(recievedLcn, scaleOperation, of(affectedConnectionPoints), VIM_ID);
590 assertEquals(1, sentLcnToVfc.getAllValues().size());
592 assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
593 org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
594 assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectedVl.getChangeType());
595 assertEquals("vlVnfdId", actualAffectedVl.getVldid());
596 assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
597 assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
598 assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
600 assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
601 org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
602 assertEquals("myVduId", actualAffectdVnfc.getVduId());
603 assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
604 assertEquals("myVmName", actualAffectdVnfc.getVmname());
605 assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
606 assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectdVnfc.getChangeType());
607 assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
609 assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
610 AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
611 assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
612 assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
613 assertEquals(null, actualAffectedCp.getOwnerId());
614 assertEquals(null, actualAffectedCp.getOwnerType());
615 assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
616 assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
617 assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
618 assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
619 assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
620 assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
621 assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
622 assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
623 assertEquals(VnfCpNotificationType.ADDED, actualAffectedCp.getChangeType());
625 assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage());
626 assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
627 assertEquals(org.onap.vnfmdriver.model.OperationType.SCALEOUT, sentLcnToVfc.getValue().getOperation());
628 assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
629 assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
633 * test end notification success scenario for scale-out
634 * - LCN is sent to VF-C
637 public void testFinishLcnForScaleIn() {
639 recievedLcn.setOperation(OperationType.SCALE);
640 recievedLcn.setStatus(OperationStatus.FINISHED);
641 recievedLcn.setLifecycleOperationOccurrenceId(scaleOperation.getId());
642 ScaleVnfRequest request = new ScaleVnfRequest();
643 request.setAdditionalParams(new JsonParser().parse("{ \"jobId\" : \"" + JOB_ID + "\" }"));
644 request.setType(ScaleDirection.IN);
645 scaleOperation.setOperationParams(request);
646 AffectedVnfc affectedVnfc = new AffectedVnfc();
647 affectedVnfc.setChangeType(ChangeType.REMOVED);
648 affectedVnfc.setId("myVnfcId");
649 affectedVnfc.setVduId("myVduId");
650 affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
651 affectedVnfc.setComputeResource(new ResourceHandle());
652 affectedVnfc.getComputeResource().setResourceId("serverProviderId");
653 affectedVnfc.getComputeResource().setVimId(VIM_ID);
654 affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
655 recievedLcn.setAffectedVnfcs(new ArrayList<>());
656 recievedLcn.getAffectedVnfcs().add(affectedVnfc);
658 AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
659 affectedVirtualLink.setChangeType(ChangeType.REMOVED);
660 affectedVirtualLink.setId("vlId");
661 affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
662 affectedVirtualLink.setResource(new ResourceHandle());
663 affectedVirtualLink.getResource().setVimId(VIM_ID);
664 affectedVirtualLink.getResource().setResourceId("networkProviderId");
665 recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
666 recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
669 AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
670 affectedStorage.setChangeType(ChangeType.REMOVED);
671 affectedStorage.setId("storageId");
672 affectedStorage.setVirtualStorageDescId("storageVnfdId");
673 affectedStorage.setResource(new ResourceHandle());
674 affectedStorage.getResource().setVimId(VIM_ID);
675 affectedStorage.getResource().setResourceId("storageProviderId");
676 recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
677 recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
679 ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
680 ReportedAffectedCp affectedCp = new ReportedAffectedCp();
681 affectedCp.setCpdId("cpVnfdId");
682 affectedCp.setIpAddress("1.2.3.4");
683 affectedCp.setMacAddress("myMac");
684 affectedCp.setName("myPortName");
685 affectedCp.setCpId("cpId");
687 // affectedCp.setEcpdId("ecpdId");
688 affectedCp.setNetworkProviderId("networkProviderId");
689 affectedCp.setProviderId("portProviderId");
690 affectedCp.setServerProviderId("serverProviderId");
691 affectedCp.setTenantId("tenantId");
692 affectedConnectionPoints.getPre().add(affectedCp);
695 OperationResult operationResult = new OperationResult();
696 operationResult.operationResult = affectedConnectionPoints;
697 JsonElement additionalData = new Gson().toJsonTree(operationResult);
698 scaleOperation.setAdditionalData(additionalData);
699 scaleOperation.setOperationType(OperationType.SCALE);
701 vfcNotificationSender.processNotification(recievedLcn, scaleOperation, of(affectedConnectionPoints), VIM_ID);
703 assertEquals(1, sentLcnToVfc.getAllValues().size());
705 assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
706 org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
707 assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectedVl.getChangeType());
708 assertEquals("vlVnfdId", actualAffectedVl.getVldid());
709 assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
710 assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
711 assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
713 assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
714 org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
715 assertEquals("myVduId", actualAffectdVnfc.getVduId());
716 assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
717 assertEquals("myVmName", actualAffectdVnfc.getVmname());
718 assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
719 assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectdVnfc.getChangeType());
720 assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
722 assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
723 AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
724 assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
725 assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
726 assertEquals(null, actualAffectedCp.getOwnerId());
727 assertEquals(null, actualAffectedCp.getOwnerType());
728 assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
729 assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
730 assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
731 assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
732 assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
733 assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
734 assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
735 assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
736 assertEquals(VnfCpNotificationType.REMOVED, actualAffectedCp.getChangeType());
738 assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage());
739 assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
740 assertEquals(org.onap.vnfmdriver.model.OperationType.SCALEIN, sentLcnToVfc.getValue().getOperation());
741 assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
742 assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
747 * en empty LCN is sent even if nothing has changed
750 public void testNothingChanged() {
752 recievedLcn.setOperation(OperationType.SCALE);
753 recievedLcn.setStatus(OperationStatus.FINISHED);
754 recievedLcn.setLifecycleOperationOccurrenceId(scaleOperation.getId());
755 ScaleVnfRequest request = new ScaleVnfRequest();
756 request.setAdditionalParams(new JsonParser().parse("{ \"jobId\" : \"" + JOB_ID + "\" }"));
757 request.setType(ScaleDirection.IN);
758 scaleOperation.setOperationParams(request);
759 OperationResult operationResult = new OperationResult();
760 JsonElement additionalData = new Gson().toJsonTree(operationResult);
761 scaleOperation.setAdditionalData(additionalData);
762 scaleOperation.setOperationType(OperationType.SCALE);
763 when(logger.isInfoEnabled()).thenReturn(false);
765 vfcNotificationSender.processNotification(recievedLcn, scaleOperation, empty(), VIM_ID);
767 assertEquals(1, sentLcnToVfc.getAllValues().size());
769 assertNull(sentLcnToVfc.getValue().getAffectedVl());
770 assertNull(sentLcnToVfc.getValue().getAffectedVnfc());
771 assertNull(sentLcnToVfc.getValue().getAffectedCp());
772 assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage());
773 assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
774 assertEquals(org.onap.vnfmdriver.model.OperationType.SCALEIN, sentLcnToVfc.getValue().getOperation());
775 assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
776 assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
777 verify(logger, never()).info(eq("Sending LCN: {}"), anyString());
781 * If a connection point is not modified it is not contained in the LCN
784 public void testNonModifiedCP() {
786 recievedLcn.setOperation(OperationType.HEAL);
787 recievedLcn.setStatus(OperationStatus.FINISHED);
789 ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
790 ReportedAffectedCp affectedCp = new ReportedAffectedCp();
791 affectedCp.setCpdId("cpVnfdId");
792 affectedCp.setIpAddress("1.2.3.4");
793 affectedCp.setMacAddress("myMac");
794 affectedCp.setName("myPortName");
795 affectedCp.setCpId("cpId");
797 // affectedCp.setEcpdId("ecpdId");
798 affectedCp.setNetworkProviderId("networkProviderId");
799 affectedCp.setProviderId("portProviderId");
800 affectedCp.setServerProviderId("serverProviderId");
801 affectedCp.setTenantId("tenantId");
802 affectedConnectionPoints.getPre().add(affectedCp);
804 ReportedAffectedCp after = new ReportedAffectedCp();
805 after.setCpdId("cpVnfdId");
806 after.setIpAddress("1.2.3.4");
807 after.setMacAddress("myMac");
808 after.setName("myPortName");
809 after.setCpId("cpId");
811 // affectedCp.setEcpdId("ecpdId");
812 after.setNetworkProviderId("networkProviderId");
813 after.setProviderId("portProviderId");
814 after.setServerProviderId("serverProviderId");
815 after.setTenantId("tenantId");
816 affectedConnectionPoints.getPost().add(after);
819 OperationResult operationResult = new OperationResult();
820 operationResult.operationResult = affectedConnectionPoints;
821 JsonElement additionalData = new Gson().toJsonTree(operationResult);
822 instantiationOperation.setAdditionalData(additionalData);
824 vfcNotificationSender.processNotification(recievedLcn, healOperation, of(affectedConnectionPoints), VIM_ID);
826 assertEquals(1, sentLcnToVfc.getAllValues().size());
828 assertNull(sentLcnToVfc.getValue().getAffectedVl());
829 assertNull(sentLcnToVfc.getValue().getAffectedVnfc());
830 assertEquals(0, sentLcnToVfc.getValue().getAffectedCp().size());
831 assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage());
832 assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
833 assertEquals(org.onap.vnfmdriver.model.OperationType.HEAL, sentLcnToVfc.getValue().getOperation());
834 assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
835 assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
839 * Unable to send notification to VF-C results in error
842 public void testUnableToSendNotificationToVfc() throws Exception {
843 RuntimeException expectedException = new RuntimeException();
844 doThrow(expectedException).when(nsLcmApi).vNFLCMNotification(any(), any(), any());
845 recievedLcn.setStatus(OperationStatus.STARTED);
846 recievedLcn.setOperation(OperationType.INSTANTIATE);
849 vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, empty(), VIM_ID);
852 } catch (Exception e) {
853 verify(logger).error("Unable to send LCN to VF-C", expectedException);
854 assertEquals(expectedException, e.getCause());
858 class OperationResult {
859 ReportedAffectedConnectionPoints operationResult;