nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/vfc/TestVfcNotificationSender.java

   1 /*
   2  * Copyright 2016-2017, Nokia Corporation
   3  *
   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
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16
  17 package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc;
  18
  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 org.junit.Before;
  31 import org.junit.Test;
  32 import org.mockito.ArgumentCaptor;
  33 import org.mockito.Mockito;
  34 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase;
  35 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedConnectionPoints;
  36 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedCp;
  37 import org.onap.vnfmdriver.ApiException;
  38 import org.onap.vnfmdriver.model.*;
  39 import org.threeten.bp.OffsetDateTime;
  40
  41 import java.util.ArrayList;
  42 import java.util.List;
  43
  44 import static junit.framework.TestCase.*;
  45 import static org.mockito.Matchers.any;
  46 import static org.mockito.Matchers.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;
  50
  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;
  61
  62
  63     @Before
  64     public void init() throws Exception {
  65         vfcNotificationSender = new VfcNotificationSender(driverProperties, vfcRestApiProvider);
  66         setField(VfcNotificationSender.class, "logger", logger);
  67         Mockito.doNothing().when(nsLcmApi).vNFLCMNotification(eq(VNFM_ID), eq(VNF_ID), sentLcnToVfc.capture());
  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(operationExecutions);
  81         prepOperation(instantiationOperation);
  82         prepOperation(scaleOperation);
  83         prepOperation(healOperation);
  84         prepOperation(terminationOperation);
  85         recievedLcn.setVnfInstanceId(VNF_ID);
  86     }
  87
  88     private void prepOperation(OperationExecution operationExecution) throws com.nokia.cbam.lcm.v32.ApiException {
  89         addEmptyModifiedConnectionPoints(operationExecution);
  90         JsonElement root = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + JOB_ID + "\"}}");
  91         operationExecution.setOperationParams(root);
  92         switch (operationExecution.getOperationType()) {
  93             case TERMINATE:
  94                 root.getAsJsonObject().addProperty("terminationType", "GRACEFULL");
  95         }
  96         when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(operationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(operationExecution);
  97         operationExecutions.add(operationExecution);
  98     }
  99
 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);
 105     }
 106
 107     /**
 108      * test start notification success scenario
 109      * - the affected resources are not processed even if present
 110      * - LCN is sent to VF-C
 111      */
 112     @Test
 113     public void testStartLcn() {
 114         recievedLcn.setStatus(OperationStatus.STARTED);
 115         recievedLcn.setOperation(OperationType.INSTANTIATE);
 116         //when
 117         vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, affectedCp, VIM_ID);
 118         //verify
 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());
 124
 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());
 129     }
 130
 131     /**
 132      * test end notification success scenario
 133      * - LCN is sent to VF-C
 134      */
 135     @Test
 136     public void testFinishLcn() {
 137         //given
 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);
 151
 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);
 161
 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);
 171
 172         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 173         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 174         affectedCp.setChangeType(ChangeType.ADDED);
 175         affectedCp.setCpdId("cpVnfdId");
 176         affectedCp.setIpAddress("1.2.3.4");
 177         affectedCp.setMacAddress("myMac");
 178         affectedCp.setName("myPortName");
 179         affectedCp.setCpId("cpId");
 180
 181         affectedCp.setNetworkProviderId("networkProviderId");
 182         affectedCp.setProviderId("portProviderId");
 183         affectedCp.setServerProviderId("serverProviderId");
 184         affectedCp.setTenantId("tenantId");
 185         affectedConnectionPoints.getPost().add(affectedCp);
 186
 187         OperationResult operationResult = new OperationResult();
 188         operationResult.operationResult = affectedConnectionPoints;
 189         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 190         instantiationOperation.setAdditionalData(additionalData);
 191         //when
 192         vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, affectedConnectionPoints, VIM_ID);
 193         //verify
 194         assertEquals(1, sentLcnToVfc.getAllValues().size());
 195
 196         assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
 197         org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
 198         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectedVl.getChangeType());
 199         assertEquals("vlVnfdId", actualAffectedVl.getVldid());
 200         assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
 201         assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
 202         assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
 203
 204         assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
 205         org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
 206         assertEquals("myVduId", actualAffectdVnfc.getVduId());
 207         assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
 208         assertEquals("myVmName", actualAffectdVnfc.getVmname());
 209         assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
 210         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectdVnfc.getChangeType());
 211         assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
 212
 213         assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
 214         AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
 215         assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
 216         assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
 217         assertEquals(null, actualAffectedCp.getOwnerId());
 218         assertEquals(null, actualAffectedCp.getOwnerType());
 219         assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
 220         assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
 221         assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
 222         assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
 223         assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
 224         assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
 225         assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
 226         assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
 227         assertEquals(VnfCpNotificationType.ADDED, actualAffectedCp.getChangeType());
 228
 229         assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage());
 230         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 231         assertEquals(org.onap.vnfmdriver.model.OperationType.INSTANTIATE, sentLcnToVfc.getValue().getOperation());
 232         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 233         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 234     }
 235
 236     /**
 237      * test end notification success scenario for ECP
 238      */
 239     @Test
 240     public void testFinishLcnForEcp() {
 241         //given
 242         recievedLcn.setOperation(OperationType.INSTANTIATE);
 243         recievedLcn.setStatus(OperationStatus.FINISHED);
 244         AffectedVnfc affectedVnfc = new AffectedVnfc();
 245         affectedVnfc.setChangeType(ChangeType.ADDED);
 246         affectedVnfc.setId("myVnfcId");
 247         affectedVnfc.setVduId("myVduId");
 248         affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
 249         affectedVnfc.setComputeResource(new ResourceHandle());
 250         affectedVnfc.getComputeResource().setResourceId("serverProviderId");
 251         affectedVnfc.getComputeResource().setVimId(VIM_ID);
 252         affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
 253         recievedLcn.setAffectedVnfcs(new ArrayList<>());
 254         recievedLcn.getAffectedVnfcs().add(affectedVnfc);
 255
 256         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 257         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 258         affectedCp.setChangeType(ChangeType.ADDED);
 259         //affectedCp.setCpdId("cpVnfdId");
 260         affectedCp.setIpAddress("1.2.3.4");
 261         affectedCp.setMacAddress("myMac");
 262         affectedCp.setName("myPortName");
 263         affectedCp.setCpId("cpId");
 264         affectedCp.setEcpdId("ecpdId");
 265         affectedCp.setNetworkProviderId("networkProviderId");
 266         affectedCp.setProviderId("portProviderId");
 267         affectedCp.setServerProviderId("serverProviderId");
 268         affectedCp.setTenantId("tenantId");
 269         affectedConnectionPoints.getPost().add(affectedCp);
 270
 271         OperationResult operationResult = new OperationResult();
 272         operationResult.operationResult = affectedConnectionPoints;
 273         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 274         instantiationOperation.setAdditionalData(additionalData);
 275         //when
 276         vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, affectedConnectionPoints, VIM_ID);
 277         //verify
 278         assertEquals(1, sentLcnToVfc.getAllValues().size());
 279
 280         assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
 281         AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
 282         assertEquals("ecpdId", actualAffectedCp.getCpdid());
 283         assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
 284         assertEquals(null, actualAffectedCp.getOwnerId());
 285         assertEquals(null, actualAffectedCp.getOwnerType());
 286         assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
 287         assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
 288         assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
 289         assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
 290         assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
 291         assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
 292         assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
 293         assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
 294         assertEquals(VnfCpNotificationType.ADDED, actualAffectedCp.getChangeType());
 295     }
 296
 297     /**
 298      * test end notification success scenario with termination
 299      */
 300     @Test
 301     public void testFinishLcnWithTerminate() {
 302         //given
 303         recievedLcn.setOperation(OperationType.TERMINATE);
 304         recievedLcn.setStatus(OperationStatus.FINISHED);
 305         AffectedVnfc affectedVnfc = new AffectedVnfc();
 306         affectedVnfc.setChangeType(ChangeType.REMOVED);
 307         affectedVnfc.setId("myVnfcId");
 308         affectedVnfc.setVduId("myVduId");
 309         affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
 310         affectedVnfc.setComputeResource(new ResourceHandle());
 311         affectedVnfc.getComputeResource().setResourceId("serverProviderId");
 312         affectedVnfc.getComputeResource().setVimId(VIM_ID);
 313         affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
 314         recievedLcn.setAffectedVnfcs(new ArrayList<>());
 315         recievedLcn.getAffectedVnfcs().add(affectedVnfc);
 316
 317         AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
 318         affectedVirtualLink.setChangeType(ChangeType.REMOVED);
 319         affectedVirtualLink.setId("vlId");
 320         affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
 321         affectedVirtualLink.setResource(new ResourceHandle());
 322         affectedVirtualLink.getResource().setVimId(VIM_ID);
 323         affectedVirtualLink.getResource().setResourceId("networkProviderId");
 324         recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
 325         recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
 326
 327         AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
 328         affectedStorage.setChangeType(ChangeType.REMOVED);
 329         affectedStorage.setId("storageId");
 330         affectedStorage.setVirtualStorageDescId("storageVnfdId");
 331         affectedStorage.setResource(new ResourceHandle());
 332         affectedStorage.getResource().setVimId(VIM_ID);
 333         affectedStorage.getResource().setResourceId("storageProviderId");
 334         recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
 335         recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
 336
 337         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 338         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 339         affectedCp.setChangeType(ChangeType.REMOVED);
 340         affectedCp.setCpdId("cpVnfdId");
 341         affectedCp.setIpAddress("1.2.3.4");
 342         affectedCp.setMacAddress("myMac");
 343         affectedCp.setName("myPortName");
 344         affectedCp.setCpId("cpId");
 345
 346         // affectedCp.setEcpdId("ecpdId");
 347         affectedCp.setNetworkProviderId("networkProviderId");
 348         affectedCp.setProviderId("portProviderId");
 349         affectedCp.setServerProviderId("serverProviderId");
 350         affectedCp.setTenantId("tenantId");
 351         affectedConnectionPoints.getPost().add(affectedCp);
 352
 353         OperationResult operationResult = new OperationResult();
 354         operationResult.operationResult = affectedConnectionPoints;
 355         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 356         instantiationOperation.setAdditionalData(additionalData);
 357         //when
 358         vfcNotificationSender.processNotification(recievedLcn, terminationOperation, affectedConnectionPoints, VIM_ID);
 359         //verify
 360         assertEquals(1, sentLcnToVfc.getAllValues().size());
 361
 362         assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
 363         org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
 364         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectedVl.getChangeType());
 365         assertEquals("vlVnfdId", actualAffectedVl.getVldid());
 366         assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
 367         assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
 368         assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
 369
 370         assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
 371         org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
 372         assertEquals("myVduId", actualAffectdVnfc.getVduId());
 373         assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
 374         assertEquals("myVmName", actualAffectdVnfc.getVmname());
 375         assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
 376         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectdVnfc.getChangeType());
 377         assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
 378
 379         assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
 380         AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
 381         assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
 382         assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
 383         assertEquals(null, actualAffectedCp.getOwnerId());
 384         assertEquals(null, actualAffectedCp.getOwnerType());
 385         assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
 386         assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
 387         assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
 388         assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
 389         assertEquals(VnfCpNotificationType.REMOVED, actualAffectedCp.getChangeType());
 390         assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
 391         assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
 392         assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
 393         assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
 394
 395         assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage());
 396         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 397         assertEquals(org.onap.vnfmdriver.model.OperationType.TERMINAL, sentLcnToVfc.getValue().getOperation());
 398         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 399         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 400     }
 401
 402     /**
 403      * test end notification success scenario for modifiction (heal)
 404      * - LCN is sent to VF-C
 405      */
 406     @Test
 407     public void testFinishLcnForModification() {
 408         //given
 409         recievedLcn.setOperation(OperationType.HEAL);
 410         recievedLcn.setStatus(OperationStatus.FINISHED);
 411         AffectedVnfc affectedVnfc = new AffectedVnfc();
 412         affectedVnfc.setChangeType(ChangeType.MODIFIED);
 413         affectedVnfc.setId("myVnfcId");
 414         affectedVnfc.setVduId("myVduId");
 415         affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
 416         affectedVnfc.setComputeResource(new ResourceHandle());
 417         affectedVnfc.getComputeResource().setResourceId("serverProviderId");
 418         affectedVnfc.getComputeResource().setVimId(VIM_ID);
 419         affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
 420         recievedLcn.setAffectedVnfcs(new ArrayList<>());
 421         recievedLcn.getAffectedVnfcs().add(affectedVnfc);
 422
 423         AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
 424         affectedVirtualLink.setChangeType(ChangeType.MODIFIED);
 425         affectedVirtualLink.setId("vlId");
 426         affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
 427         affectedVirtualLink.setResource(new ResourceHandle());
 428         affectedVirtualLink.getResource().setVimId(VIM_ID);
 429         affectedVirtualLink.getResource().setResourceId("networkProviderId");
 430         recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
 431         recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
 432
 433
 434         AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
 435         affectedStorage.setChangeType(ChangeType.MODIFIED);
 436         affectedStorage.setId("storageId");
 437         affectedStorage.setVirtualStorageDescId("storageVnfdId");
 438         affectedStorage.setResource(new ResourceHandle());
 439         affectedStorage.getResource().setVimId(VIM_ID);
 440         affectedStorage.getResource().setResourceId("storageProviderId");
 441         recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
 442         recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
 443
 444         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 445         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 446         affectedCp.setChangeType(ChangeType.MODIFIED);
 447         affectedCp.setCpdId("cpVnfdId");
 448         affectedCp.setIpAddress("1.2.3.4");
 449         affectedCp.setMacAddress("myMac");
 450         affectedCp.setName("myPortName");
 451         affectedCp.setCpId("cpId");
 452
 453         // affectedCp.setEcpdId("ecpdId");
 454         affectedCp.setNetworkProviderId("networkProviderId");
 455         affectedCp.setProviderId("portProviderId");
 456         affectedCp.setServerProviderId("serverProviderId");
 457         affectedCp.setTenantId("tenantId");
 458         affectedConnectionPoints.getPost().add(affectedCp);
 459
 460
 461         OperationResult operationResult = new OperationResult();
 462         operationResult.operationResult = affectedConnectionPoints;
 463         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 464         instantiationOperation.setAdditionalData(additionalData);
 465         //when
 466         vfcNotificationSender.processNotification(recievedLcn, healOperation, affectedConnectionPoints, VIM_ID);
 467         //verify
 468         assertEquals(1, sentLcnToVfc.getAllValues().size());
 469
 470         assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
 471         org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
 472         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.MODIFIED, actualAffectedVl.getChangeType());
 473         assertEquals("vlVnfdId", actualAffectedVl.getVldid());
 474         assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
 475         assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
 476         assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
 477
 478         assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
 479         org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
 480         assertEquals("myVduId", actualAffectdVnfc.getVduId());
 481         assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
 482         assertEquals("myVmName", actualAffectdVnfc.getVmname());
 483         assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
 484         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.MODIFIED, actualAffectdVnfc.getChangeType());
 485         assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
 486
 487         assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
 488         AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
 489         assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
 490         assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
 491         assertEquals(null, actualAffectedCp.getOwnerId());
 492         assertEquals(null, actualAffectedCp.getOwnerType());
 493         assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
 494         assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
 495         assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
 496         assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
 497         assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
 498         assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
 499         assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
 500         assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
 501         assertEquals(VnfCpNotificationType.CHANGED, actualAffectedCp.getChangeType());
 502
 503         assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage());
 504         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 505         assertEquals(org.onap.vnfmdriver.model.OperationType.HEAL, sentLcnToVfc.getValue().getOperation());
 506         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 507         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 508     }
 509
 510     /**
 511      * test end notification success scenario for scale-out
 512      * - LCN is sent to VF-C
 513      */
 514     @Test
 515     public void testFinishLcnForScaleout() {
 516         //given
 517         recievedLcn.setOperation(OperationType.SCALE);
 518         recievedLcn.setStatus(OperationStatus.FINISHED);
 519         recievedLcn.setLifecycleOperationOccurrenceId(scaleOperation.getId());
 520         ScaleVnfRequest request = new ScaleVnfRequest();
 521         request.setAdditionalParams(new JsonParser().parse("{ \"jobId\" : \"" + JOB_ID + "\" }"));
 522         request.setType(ScaleDirection.OUT);
 523         scaleOperation.setOperationParams(request);
 524         scaleOperation.setOperationType(OperationType.SCALE);
 525         AffectedVnfc affectedVnfc = new AffectedVnfc();
 526         affectedVnfc.setChangeType(ChangeType.ADDED);
 527         affectedVnfc.setId("myVnfcId");
 528         affectedVnfc.setVduId("myVduId");
 529         affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
 530         affectedVnfc.setComputeResource(new ResourceHandle());
 531         affectedVnfc.getComputeResource().setResourceId("serverProviderId");
 532         affectedVnfc.getComputeResource().setVimId(VIM_ID);
 533         affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
 534         recievedLcn.setAffectedVnfcs(new ArrayList<>());
 535         recievedLcn.getAffectedVnfcs().add(affectedVnfc);
 536
 537         AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
 538         affectedVirtualLink.setChangeType(ChangeType.ADDED);
 539         affectedVirtualLink.setId("vlId");
 540         affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
 541         affectedVirtualLink.setResource(new ResourceHandle());
 542         affectedVirtualLink.getResource().setVimId(VIM_ID);
 543         affectedVirtualLink.getResource().setResourceId("networkProviderId");
 544         recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
 545         recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
 546
 547
 548         AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
 549         affectedStorage.setChangeType(ChangeType.ADDED);
 550         affectedStorage.setId("storageId");
 551         affectedStorage.setVirtualStorageDescId("storageVnfdId");
 552         affectedStorage.setResource(new ResourceHandle());
 553         affectedStorage.getResource().setVimId(VIM_ID);
 554         affectedStorage.getResource().setResourceId("storageProviderId");
 555         recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
 556         recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
 557
 558         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 559         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 560         affectedCp.setChangeType(ChangeType.ADDED);
 561         affectedCp.setCpdId("cpVnfdId");
 562         affectedCp.setIpAddress("1.2.3.4");
 563         affectedCp.setMacAddress("myMac");
 564         affectedCp.setName("myPortName");
 565         affectedCp.setCpId("cpId");
 566
 567         // affectedCp.setEcpdId("ecpdId");
 568         affectedCp.setNetworkProviderId("networkProviderId");
 569         affectedCp.setProviderId("portProviderId");
 570         affectedCp.setServerProviderId("serverProviderId");
 571         affectedCp.setTenantId("tenantId");
 572         affectedConnectionPoints.getPost().add(affectedCp);
 573
 574         OperationResult operationResult = new OperationResult();
 575         operationResult.operationResult = affectedConnectionPoints;
 576         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 577         scaleOperation.setAdditionalData(additionalData);
 578         //when
 579         vfcNotificationSender.processNotification(recievedLcn, scaleOperation, affectedConnectionPoints, VIM_ID);
 580         //verify
 581         assertEquals(1, sentLcnToVfc.getAllValues().size());
 582
 583         assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
 584         org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
 585         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectedVl.getChangeType());
 586         assertEquals("vlVnfdId", actualAffectedVl.getVldid());
 587         assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
 588         assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
 589         assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
 590
 591         assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
 592         org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
 593         assertEquals("myVduId", actualAffectdVnfc.getVduId());
 594         assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
 595         assertEquals("myVmName", actualAffectdVnfc.getVmname());
 596         assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
 597         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectdVnfc.getChangeType());
 598         assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
 599
 600         assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
 601         AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
 602         assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
 603         assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
 604         assertEquals(null, actualAffectedCp.getOwnerId());
 605         assertEquals(null, actualAffectedCp.getOwnerType());
 606         assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
 607         assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
 608         assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
 609         assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
 610         assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
 611         assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
 612         assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
 613         assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
 614         assertEquals(VnfCpNotificationType.ADDED, actualAffectedCp.getChangeType());
 615
 616         assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage());
 617         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 618         assertEquals(org.onap.vnfmdriver.model.OperationType.SCALEOUT, sentLcnToVfc.getValue().getOperation());
 619         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 620         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 621     }
 622
 623     /**
 624      * test end notification success scenario for scale-out
 625      * - LCN is sent to VF-C
 626      */
 627     @Test
 628     public void testFinishLcnForScaleIn() {
 629         //given
 630         recievedLcn.setOperation(OperationType.SCALE);
 631         recievedLcn.setStatus(OperationStatus.FINISHED);
 632         recievedLcn.setLifecycleOperationOccurrenceId(scaleOperation.getId());
 633         ScaleVnfRequest request = new ScaleVnfRequest();
 634         request.setAdditionalParams(new JsonParser().parse("{ \"jobId\" : \"" + JOB_ID + "\" }"));
 635         request.setType(ScaleDirection.IN);
 636         scaleOperation.setOperationParams(request);
 637         AffectedVnfc affectedVnfc = new AffectedVnfc();
 638         affectedVnfc.setChangeType(ChangeType.REMOVED);
 639         affectedVnfc.setId("myVnfcId");
 640         affectedVnfc.setVduId("myVduId");
 641         affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
 642         affectedVnfc.setComputeResource(new ResourceHandle());
 643         affectedVnfc.getComputeResource().setResourceId("serverProviderId");
 644         affectedVnfc.getComputeResource().setVimId(VIM_ID);
 645         affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
 646         recievedLcn.setAffectedVnfcs(new ArrayList<>());
 647         recievedLcn.getAffectedVnfcs().add(affectedVnfc);
 648
 649         AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
 650         affectedVirtualLink.setChangeType(ChangeType.REMOVED);
 651         affectedVirtualLink.setId("vlId");
 652         affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
 653         affectedVirtualLink.setResource(new ResourceHandle());
 654         affectedVirtualLink.getResource().setVimId(VIM_ID);
 655         affectedVirtualLink.getResource().setResourceId("networkProviderId");
 656         recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
 657         recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
 658
 659
 660         AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
 661         affectedStorage.setChangeType(ChangeType.REMOVED);
 662         affectedStorage.setId("storageId");
 663         affectedStorage.setVirtualStorageDescId("storageVnfdId");
 664         affectedStorage.setResource(new ResourceHandle());
 665         affectedStorage.getResource().setVimId(VIM_ID);
 666         affectedStorage.getResource().setResourceId("storageProviderId");
 667         recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
 668         recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
 669
 670         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 671         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 672         affectedCp.setChangeType(ChangeType.REMOVED);
 673         affectedCp.setCpdId("cpVnfdId");
 674         affectedCp.setIpAddress("1.2.3.4");
 675         affectedCp.setMacAddress("myMac");
 676         affectedCp.setName("myPortName");
 677         affectedCp.setCpId("cpId");
 678
 679         // affectedCp.setEcpdId("ecpdId");
 680         affectedCp.setNetworkProviderId("networkProviderId");
 681         affectedCp.setProviderId("portProviderId");
 682         affectedCp.setServerProviderId("serverProviderId");
 683         affectedCp.setTenantId("tenantId");
 684         affectedConnectionPoints.getPost().add(affectedCp);
 685
 686
 687         OperationResult operationResult = new OperationResult();
 688         operationResult.operationResult = affectedConnectionPoints;
 689         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 690         scaleOperation.setAdditionalData(additionalData);
 691         scaleOperation.setOperationType(OperationType.SCALE);
 692         //when
 693         vfcNotificationSender.processNotification(recievedLcn, scaleOperation, affectedConnectionPoints, VIM_ID);
 694         //verify
 695         assertEquals(1, sentLcnToVfc.getAllValues().size());
 696
 697         assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
 698         org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
 699         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectedVl.getChangeType());
 700         assertEquals("vlVnfdId", actualAffectedVl.getVldid());
 701         assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
 702         assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
 703         assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
 704
 705         assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
 706         org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
 707         assertEquals("myVduId", actualAffectdVnfc.getVduId());
 708         assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
 709         assertEquals("myVmName", actualAffectdVnfc.getVmname());
 710         assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
 711         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectdVnfc.getChangeType());
 712         assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
 713
 714         assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
 715         AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
 716         assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
 717         assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
 718         assertEquals(null, actualAffectedCp.getOwnerId());
 719         assertEquals(null, actualAffectedCp.getOwnerType());
 720         assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
 721         assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
 722         assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
 723         assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
 724         assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
 725         assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
 726         assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
 727         assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
 728         assertEquals(VnfCpNotificationType.REMOVED, actualAffectedCp.getChangeType());
 729
 730         assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage());
 731         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 732         assertEquals(org.onap.vnfmdriver.model.OperationType.SCALEIN, sentLcnToVfc.getValue().getOperation());
 733         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 734         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 735     }
 736
 737     /**
 738      * Unable to send notification to VF-C results in error
 739      */
 740     @Test
 741     public void testUnableToSendNotificationToVfc() throws Exception {
 742         ApiException expectedException = new ApiException();
 743         doThrow(expectedException).when(nsLcmApi).vNFLCMNotification(any(), any(), any());
 744         recievedLcn.setStatus(OperationStatus.STARTED);
 745         recievedLcn.setOperation(OperationType.INSTANTIATE);
 746         //when
 747         try {
 748             vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, affectedCp, VIM_ID);
 749             //verify
 750             fail();
 751         } catch (Exception e) {
 752             verify(logger).error("Unable to send LCN to VF-C", expectedException);
 753             assertEquals(expectedException, e.getCause());
 754         }
 755     }
 756
 757     class OperationResult {
 758         ReportedAffectedConnectionPoints operationResult;
 759     }
 760 }