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 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;
  40
  41 import static java.util.Optional.empty;
  42 import static java.util.Optional.of;
  43
  44 import static junit.framework.TestCase.*;
  45 import static org.mockito.Mockito.*;
  46 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
  47 import static org.springframework.test.util.ReflectionTestUtils.setField;
  48
  49 public class TestVfcNotificationSender extends TestBase {
  50     private VfcNotificationSender vfcNotificationSender;
  51     private ArgumentCaptor<VNFLCMNotification> sentLcnToVfc = ArgumentCaptor.forClass(VNFLCMNotification.class);
  52     private VnfLifecycleChangeNotification recievedLcn = new VnfLifecycleChangeNotification();
  53     private List<OperationExecution> operationExecutions = new ArrayList<>();
  54     private OperationExecution instantiationOperation = new OperationExecution();
  55     private OperationExecution scaleOperation = new OperationExecution();
  56     private OperationExecution healOperation = new OperationExecution();
  57     private OperationExecution terminationOperation = new OperationExecution();
  58     private ReportedAffectedConnectionPoints affectedCp;
  59
  60
  61     @Before
  62     public void init() throws Exception {
  63         vfcNotificationSender = new VfcNotificationSender(vfcRestApiProvider);
  64         setField(VfcNotificationSender.class, "logger", logger);
  65         when(nsLcmApi.vNFLCMNotification(eq(VNFM_ID), eq(VNF_ID), sentLcnToVfc.capture())).thenReturn(VOID_OBSERVABLE.value());
  66         instantiationOperation.setId("instantiationOperationExecutionId");
  67         instantiationOperation.setStartTime(OffsetDateTime.now());
  68         instantiationOperation.setOperationType(OperationType.INSTANTIATE);
  69         scaleOperation.setId("scaleOperationExecutionId");
  70         scaleOperation.setStartTime(OffsetDateTime.now().plusDays(1));
  71         scaleOperation.setOperationType(OperationType.SCALE);
  72         terminationOperation.setId("terminationExecutionId");
  73         terminationOperation.setStartTime(OffsetDateTime.now().plusDays(1));
  74         terminationOperation.setOperationType(OperationType.TERMINATE);
  75         healOperation.setId("healOperaitonExecutionId");
  76         healOperation.setOperationType(OperationType.HEAL);
  77         healOperation.setStartTime(OffsetDateTime.now().plusDays(1));
  78         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecutions));
  79         prepOperation(instantiationOperation);
  80         prepOperation(scaleOperation);
  81         prepOperation(healOperation);
  82         prepOperation(terminationOperation);
  83         recievedLcn.setVnfInstanceId(VNF_ID);
  84     }
  85
  86     private void prepOperation(OperationExecution operationExecution) {
  87         addEmptyModifiedConnectionPoints(operationExecution);
  88         JsonElement root = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + JOB_ID + "\"}}");
  89         operationExecution.setOperationParams(root);
  90         switch (operationExecution.getOperationType()) {
  91             case TERMINATE:
  92                 root.getAsJsonObject().addProperty("terminationType", "GRACEFULL");
  93         }
  94         when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(operationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecution));
  95         operationExecutions.add(operationExecution);
  96     }
  97
  98     private void addEmptyModifiedConnectionPoints(OperationExecution operationExecution) {
  99         OperationResult operationResult = new OperationResult();
 100         operationResult.operationResult = new ReportedAffectedConnectionPoints();
 101         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 102         operationExecution.setAdditionalData(additionalData);
 103     }
 104
 105     /**
 106      * test start notification success scenario
 107      * - the affected resources are not processed even if present
 108      * - LCN is sent to VF-C
 109      */
 110     @Test
 111     public void testStartLcn() {
 112         recievedLcn.setStatus(OperationStatus.STARTED);
 113         recievedLcn.setOperation(OperationType.INSTANTIATE);
 114         //when
 115         vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, empty(), VIM_ID, VNFM_ID);
 116         //verify
 117         assertEquals(1, sentLcnToVfc.getAllValues().size());
 118         assertEquals(0, sentLcnToVfc.getValue().getAffectedVl().size());
 119         assertEquals(0, sentLcnToVfc.getValue().getAffectedVnfc().size());
 120         assertEquals(0, sentLcnToVfc.getValue().getAffectedCp().size());
 121         assertEquals(0, sentLcnToVfc.getValue().getAffectedVirtualStorage().size());
 122
 123         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 124         assertEquals(org.onap.vnfmdriver.model.OperationType.INSTANTIATE, sentLcnToVfc.getValue().getOperation());
 125         assertEquals(VnfLcmNotificationStatus.START, sentLcnToVfc.getValue().getStatus());
 126         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 127         VOID_OBSERVABLE.assertCalled();
 128     }
 129
 130     /**
 131      * test end notification success scenario
 132      * - LCN is sent to VF-C
 133      */
 134     @Test
 135     public void testFinishLcn() {
 136         //given
 137         recievedLcn.setOperation(OperationType.INSTANTIATE);
 138         recievedLcn.setStatus(OperationStatus.FINISHED);
 139         AffectedVnfc affectedVnfc = new AffectedVnfc();
 140         affectedVnfc.setChangeType(ChangeType.ADDED);
 141         affectedVnfc.setId("myVnfcId");
 142         affectedVnfc.setVduId("myVduId");
 143         affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
 144         affectedVnfc.setComputeResource(new ResourceHandle());
 145         affectedVnfc.getComputeResource().setResourceId("serverProviderId");
 146         affectedVnfc.getComputeResource().setVimId(VIM_ID);
 147         affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
 148         recievedLcn.setAffectedVnfcs(new ArrayList<>());
 149         recievedLcn.getAffectedVnfcs().add(affectedVnfc);
 150
 151         AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
 152         affectedVirtualLink.setChangeType(ChangeType.ADDED);
 153         affectedVirtualLink.setId("vlId");
 154         affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
 155         affectedVirtualLink.setResource(new ResourceHandle());
 156         affectedVirtualLink.getResource().setVimId(VIM_ID);
 157         affectedVirtualLink.getResource().setResourceId("networkProviderId");
 158         recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
 159         recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
 160
 161         AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
 162         affectedStorage.setChangeType(ChangeType.ADDED);
 163         affectedStorage.setId("storageId");
 164         affectedStorage.setVirtualStorageDescId("storageVnfdId");
 165         affectedStorage.setResource(new ResourceHandle());
 166         affectedStorage.getResource().setVimId(VIM_ID);
 167         affectedStorage.getResource().setResourceId("storageProviderId");
 168         recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
 169         recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
 170
 171         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 172         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 173         affectedCp.setCpdId("cpVnfdId");
 174         affectedCp.setIpAddress("1.2.3.4");
 175         affectedCp.setMacAddress("myMac");
 176         affectedCp.setName("myPortName");
 177         affectedCp.setCpId("cpId");
 178
 179         affectedCp.setNetworkProviderId("networkProviderId");
 180         affectedCp.setProviderId("portProviderId");
 181         affectedCp.setServerProviderId("serverProviderId");
 182         affectedCp.setTenantId("tenantId");
 183         affectedConnectionPoints.getPost().add(affectedCp);
 184
 185         OperationResult operationResult = new OperationResult();
 186         operationResult.operationResult = affectedConnectionPoints;
 187         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 188         instantiationOperation.setAdditionalData(additionalData);
 189         //when
 190         vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, of(affectedConnectionPoints), VIM_ID, VNFM_ID);
 191         //verify
 192         assertEquals(1, sentLcnToVfc.getAllValues().size());
 193
 194         assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
 195         org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
 196         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectedVl.getChangeType());
 197         assertEquals("vlVnfdId", actualAffectedVl.getVldid());
 198         assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
 199         assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
 200         assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
 201
 202         assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
 203         org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
 204         assertEquals("myVduId", actualAffectdVnfc.getVduId());
 205         assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
 206         assertEquals("myVmName", actualAffectdVnfc.getVmname());
 207         assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
 208         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectdVnfc.getChangeType());
 209         assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
 210
 211         assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
 212         AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
 213         assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
 214         assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
 215         assertEquals(null, actualAffectedCp.getOwnerId());
 216         assertEquals(null, actualAffectedCp.getOwnerType());
 217         assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
 218         assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
 219         assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
 220         assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
 221         assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
 222         assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
 223         assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
 224         assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
 225         assertEquals(VnfCpNotificationType.ADDED, actualAffectedCp.getChangeType());
 226
 227         assertEquals(0, sentLcnToVfc.getValue().getAffectedVirtualStorage().size());
 228         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 229         assertEquals(org.onap.vnfmdriver.model.OperationType.INSTANTIATE, sentLcnToVfc.getValue().getOperation());
 230         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 231         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 232         VOID_OBSERVABLE.assertCalled();
 233     }
 234
 235     /**
 236      * test end notification success scenario for ECP
 237      */
 238     @Test
 239     public void testFinishLcnForEcp() {
 240         //given
 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);
 254
 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);
 268
 269         OperationResult operationResult = new OperationResult();
 270         operationResult.operationResult = affectedConnectionPoints;
 271         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 272         instantiationOperation.setAdditionalData(additionalData);
 273         //when
 274         vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, of(affectedConnectionPoints), VIM_ID, VNFM_ID);
 275         //verify
 276         assertEquals(1, sentLcnToVfc.getAllValues().size());
 277
 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());
 293         VOID_OBSERVABLE.assertCalled();
 294     }
 295
 296     /**
 297      * test end notification success scenario with termination
 298      */
 299     @Test
 300     public void testFinishLcnWithTerminate() {
 301         //given
 302         recievedLcn.setOperation(OperationType.TERMINATE);
 303         recievedLcn.setStatus(OperationStatus.FINISHED);
 304         AffectedVnfc affectedVnfc = new AffectedVnfc();
 305         affectedVnfc.setChangeType(ChangeType.REMOVED);
 306         affectedVnfc.setId("myVnfcId");
 307         affectedVnfc.setVduId("myVduId");
 308         affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
 309         affectedVnfc.setComputeResource(new ResourceHandle());
 310         affectedVnfc.getComputeResource().setResourceId("serverProviderId");
 311         affectedVnfc.getComputeResource().setVimId(VIM_ID);
 312         affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
 313         recievedLcn.setAffectedVnfcs(new ArrayList<>());
 314         recievedLcn.getAffectedVnfcs().add(affectedVnfc);
 315
 316         AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
 317         affectedVirtualLink.setChangeType(ChangeType.REMOVED);
 318         affectedVirtualLink.setId("vlId");
 319         affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
 320         affectedVirtualLink.setResource(new ResourceHandle());
 321         affectedVirtualLink.getResource().setVimId(VIM_ID);
 322         affectedVirtualLink.getResource().setResourceId("networkProviderId");
 323         recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
 324         recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
 325
 326         AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
 327         affectedStorage.setChangeType(ChangeType.REMOVED);
 328         affectedStorage.setId("storageId");
 329         affectedStorage.setVirtualStorageDescId("storageVnfdId");
 330         affectedStorage.setResource(new ResourceHandle());
 331         affectedStorage.getResource().setVimId(VIM_ID);
 332         affectedStorage.getResource().setResourceId("storageProviderId");
 333         recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
 334         recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
 335
 336         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 337         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 338         affectedCp.setCpdId("cpVnfdId");
 339         affectedCp.setIpAddress("1.2.3.4");
 340         affectedCp.setMacAddress("myMac");
 341         affectedCp.setName("myPortName");
 342         affectedCp.setCpId("cpId");
 343
 344         // affectedCp.setEcpdId("ecpdId");
 345         affectedCp.setNetworkProviderId("networkProviderId");
 346         affectedCp.setProviderId("portProviderId");
 347         affectedCp.setServerProviderId("serverProviderId");
 348         affectedCp.setTenantId("tenantId");
 349         affectedConnectionPoints.getPre().add(affectedCp);
 350
 351         OperationResult operationResult = new OperationResult();
 352         operationResult.operationResult = affectedConnectionPoints;
 353         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 354         instantiationOperation.setAdditionalData(additionalData);
 355         //when
 356         vfcNotificationSender.processNotification(recievedLcn, terminationOperation, of(affectedConnectionPoints), VIM_ID, VNFM_ID);
 357         //verify
 358         assertEquals(1, sentLcnToVfc.getAllValues().size());
 359
 360         assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
 361         org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
 362         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectedVl.getChangeType());
 363         assertEquals("vlVnfdId", actualAffectedVl.getVldid());
 364         assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
 365         assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
 366         assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
 367
 368         assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
 369         org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
 370         assertEquals("myVduId", actualAffectdVnfc.getVduId());
 371         assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
 372         assertEquals("myVmName", actualAffectdVnfc.getVmname());
 373         assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
 374         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectdVnfc.getChangeType());
 375         assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
 376
 377         assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
 378         AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
 379         assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
 380         assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
 381         assertEquals(null, actualAffectedCp.getOwnerId());
 382         assertEquals(null, actualAffectedCp.getOwnerType());
 383         assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
 384         assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
 385         assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
 386         assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
 387         assertEquals(VnfCpNotificationType.REMOVED, actualAffectedCp.getChangeType());
 388         assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
 389         assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
 390         assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
 391         assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
 392
 393         assertEquals(0, sentLcnToVfc.getValue().getAffectedVirtualStorage().size());
 394         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 395         assertEquals(org.onap.vnfmdriver.model.OperationType.TERMINAL, sentLcnToVfc.getValue().getOperation());
 396         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 397         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 398         VOID_OBSERVABLE.assertCalled();
 399     }
 400
 401     /**
 402      * test end notification success scenario for modifiction (heal)
 403      * - LCN is sent to VF-C
 404      */
 405     @Test
 406     public void testFinishLcnForModification() {
 407         //given
 408         recievedLcn.setOperation(OperationType.HEAL);
 409         recievedLcn.setStatus(OperationStatus.FINISHED);
 410         AffectedVnfc affectedVnfc = new AffectedVnfc();
 411         affectedVnfc.setChangeType(ChangeType.MODIFIED);
 412         affectedVnfc.setId("myVnfcId");
 413         affectedVnfc.setVduId("myVduId");
 414         affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
 415         affectedVnfc.setComputeResource(new ResourceHandle());
 416         affectedVnfc.getComputeResource().setResourceId("serverProviderId");
 417         affectedVnfc.getComputeResource().setVimId(VIM_ID);
 418         affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
 419         recievedLcn.setAffectedVnfcs(new ArrayList<>());
 420         recievedLcn.getAffectedVnfcs().add(affectedVnfc);
 421
 422         AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
 423         affectedVirtualLink.setChangeType(ChangeType.MODIFIED);
 424         affectedVirtualLink.setId("vlId");
 425         affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
 426         affectedVirtualLink.setResource(new ResourceHandle());
 427         affectedVirtualLink.getResource().setVimId(VIM_ID);
 428         affectedVirtualLink.getResource().setResourceId("networkProviderId");
 429         recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
 430         recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
 431
 432
 433         AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
 434         affectedStorage.setChangeType(ChangeType.MODIFIED);
 435         affectedStorage.setId("storageId");
 436         affectedStorage.setVirtualStorageDescId("storageVnfdId");
 437         affectedStorage.setResource(new ResourceHandle());
 438         affectedStorage.getResource().setVimId(VIM_ID);
 439         affectedStorage.getResource().setResourceId("storageProviderId");
 440         recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
 441         recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
 442
 443         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 444         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 445         affectedCp.setCpdId("cpVnfdId");
 446         affectedCp.setIpAddress("1.2.3.4");
 447         affectedCp.setMacAddress("myMac");
 448         affectedCp.setName("myPortName");
 449         affectedCp.setCpId("cpId");
 450
 451         // affectedCp.setEcpdId("ecpdId");
 452         affectedCp.setNetworkProviderId("networkProviderId");
 453         affectedCp.setProviderId("portProviderId");
 454         affectedCp.setServerProviderId("serverProviderId");
 455         affectedCp.setTenantId("tenantId");
 456         affectedConnectionPoints.getPre().add(affectedCp);
 457
 458         ReportedAffectedCp after = new ReportedAffectedCp();
 459         after.setCpdId("cpVnfdId");
 460         after.setIpAddress("1.2.3.5");
 461         after.setMacAddress("myMac");
 462         after.setName("myPortName");
 463         after.setCpId("cpId");
 464
 465         // affectedCp.setEcpdId("ecpdId");
 466         after.setNetworkProviderId("networkProviderId");
 467         after.setProviderId("portProviderId");
 468         after.setServerProviderId("serverProviderId");
 469         after.setTenantId("tenantId");
 470         affectedConnectionPoints.getPost().add(after);
 471
 472
 473         OperationResult operationResult = new OperationResult();
 474         operationResult.operationResult = affectedConnectionPoints;
 475         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 476         instantiationOperation.setAdditionalData(additionalData);
 477         //when
 478         vfcNotificationSender.processNotification(recievedLcn, healOperation, of(affectedConnectionPoints), VIM_ID, VNFM_ID);
 479         //verify
 480         assertEquals(1, sentLcnToVfc.getAllValues().size());
 481
 482         assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
 483         org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
 484         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.MODIFIED, actualAffectedVl.getChangeType());
 485         assertEquals("vlVnfdId", actualAffectedVl.getVldid());
 486         assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
 487         assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
 488         assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
 489
 490         assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
 491         org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
 492         assertEquals("myVduId", actualAffectdVnfc.getVduId());
 493         assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
 494         assertEquals("myVmName", actualAffectdVnfc.getVmname());
 495         assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
 496         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.MODIFIED, actualAffectdVnfc.getChangeType());
 497         assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
 498
 499         assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
 500         AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
 501         assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
 502         assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
 503         assertEquals(null, actualAffectedCp.getOwnerId());
 504         assertEquals(null, actualAffectedCp.getOwnerType());
 505         assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
 506         assertEquals("1.2.3.5", actualAffectedCp.getPortResource().getIpAddress());
 507         assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
 508         assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
 509         assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
 510         assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
 511         assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
 512         assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
 513         assertEquals(VnfCpNotificationType.CHANGED, actualAffectedCp.getChangeType());
 514
 515         assertEquals(0, sentLcnToVfc.getValue().getAffectedVirtualStorage().size());
 516         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 517         assertEquals(org.onap.vnfmdriver.model.OperationType.HEAL, sentLcnToVfc.getValue().getOperation());
 518         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 519         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 520         VOID_OBSERVABLE.assertCalled();
 521     }
 522
 523     /**
 524      * test end notification success scenario for scale-out
 525      * - LCN is sent to VF-C
 526      */
 527     @Test
 528     public void testFinishLcnForScaleout() {
 529         //given
 530         recievedLcn.setOperation(OperationType.SCALE);
 531         recievedLcn.setStatus(OperationStatus.FINISHED);
 532         recievedLcn.setLifecycleOperationOccurrenceId(scaleOperation.getId());
 533         ScaleVnfRequest request = new ScaleVnfRequest();
 534         request.setAdditionalParams(new JsonParser().parse("{ \"jobId\" : \"" + JOB_ID + "\" }"));
 535         request.setType(ScaleDirection.OUT);
 536         scaleOperation.setOperationParams(request);
 537         scaleOperation.setOperationType(OperationType.SCALE);
 538         AffectedVnfc affectedVnfc = new AffectedVnfc();
 539         affectedVnfc.setChangeType(ChangeType.ADDED);
 540         affectedVnfc.setId("myVnfcId");
 541         affectedVnfc.setVduId("myVduId");
 542         affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
 543         affectedVnfc.setComputeResource(new ResourceHandle());
 544         affectedVnfc.getComputeResource().setResourceId("serverProviderId");
 545         affectedVnfc.getComputeResource().setVimId(VIM_ID);
 546         affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
 547         recievedLcn.setAffectedVnfcs(new ArrayList<>());
 548         recievedLcn.getAffectedVnfcs().add(affectedVnfc);
 549
 550         AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
 551         affectedVirtualLink.setChangeType(ChangeType.ADDED);
 552         affectedVirtualLink.setId("vlId");
 553         affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
 554         affectedVirtualLink.setResource(new ResourceHandle());
 555         affectedVirtualLink.getResource().setVimId(VIM_ID);
 556         affectedVirtualLink.getResource().setResourceId("networkProviderId");
 557         recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
 558         recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
 559
 560
 561         AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
 562         affectedStorage.setChangeType(ChangeType.ADDED);
 563         affectedStorage.setId("storageId");
 564         affectedStorage.setVirtualStorageDescId("storageVnfdId");
 565         affectedStorage.setResource(new ResourceHandle());
 566         affectedStorage.getResource().setVimId(VIM_ID);
 567         affectedStorage.getResource().setResourceId("storageProviderId");
 568         recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
 569         recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
 570
 571         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 572         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 573         affectedCp.setCpdId("cpVnfdId");
 574         affectedCp.setIpAddress("1.2.3.4");
 575         affectedCp.setMacAddress("myMac");
 576         affectedCp.setName("myPortName");
 577         affectedCp.setCpId("cpId");
 578
 579         // affectedCp.setEcpdId("ecpdId");
 580         affectedCp.setNetworkProviderId("networkProviderId");
 581         affectedCp.setProviderId("portProviderId");
 582         affectedCp.setServerProviderId("serverProviderId");
 583         affectedCp.setTenantId("tenantId");
 584         affectedConnectionPoints.getPost().add(affectedCp);
 585
 586         OperationResult operationResult = new OperationResult();
 587         operationResult.operationResult = affectedConnectionPoints;
 588         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 589         scaleOperation.setAdditionalData(additionalData);
 590         //when
 591         vfcNotificationSender.processNotification(recievedLcn, scaleOperation, of(affectedConnectionPoints), VIM_ID, VNFM_ID);
 592         //verify
 593         assertEquals(1, sentLcnToVfc.getAllValues().size());
 594
 595         assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
 596         org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
 597         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectedVl.getChangeType());
 598         assertEquals("vlVnfdId", actualAffectedVl.getVldid());
 599         assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
 600         assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
 601         assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
 602
 603         assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
 604         org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
 605         assertEquals("myVduId", actualAffectdVnfc.getVduId());
 606         assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
 607         assertEquals("myVmName", actualAffectdVnfc.getVmname());
 608         assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
 609         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectdVnfc.getChangeType());
 610         assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
 611
 612         assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
 613         AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
 614         assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
 615         assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
 616         assertEquals(null, actualAffectedCp.getOwnerId());
 617         assertEquals(null, actualAffectedCp.getOwnerType());
 618         assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
 619         assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
 620         assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
 621         assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
 622         assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
 623         assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
 624         assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
 625         assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
 626         assertEquals(VnfCpNotificationType.ADDED, actualAffectedCp.getChangeType());
 627
 628         assertEquals(0, sentLcnToVfc.getValue().getAffectedVirtualStorage().size());
 629         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 630         assertEquals(org.onap.vnfmdriver.model.OperationType.SCALEOUT, sentLcnToVfc.getValue().getOperation());
 631         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 632         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 633         VOID_OBSERVABLE.assertCalled();
 634     }
 635
 636     /**
 637      * test end notification success scenario for scale-out
 638      * - LCN is sent to VF-C
 639      */
 640     @Test
 641     public void testFinishLcnForScaleIn() {
 642         //given
 643         recievedLcn.setOperation(OperationType.SCALE);
 644         recievedLcn.setStatus(OperationStatus.FINISHED);
 645         recievedLcn.setLifecycleOperationOccurrenceId(scaleOperation.getId());
 646         ScaleVnfRequest request = new ScaleVnfRequest();
 647         request.setAdditionalParams(new JsonParser().parse("{ \"jobId\" : \"" + JOB_ID + "\" }"));
 648         request.setType(ScaleDirection.IN);
 649         scaleOperation.setOperationParams(request);
 650         AffectedVnfc affectedVnfc = new AffectedVnfc();
 651         affectedVnfc.setChangeType(ChangeType.REMOVED);
 652         affectedVnfc.setId("myVnfcId");
 653         affectedVnfc.setVduId("myVduId");
 654         affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
 655         affectedVnfc.setComputeResource(new ResourceHandle());
 656         affectedVnfc.getComputeResource().setResourceId("serverProviderId");
 657         affectedVnfc.getComputeResource().setVimId(VIM_ID);
 658         affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
 659         recievedLcn.setAffectedVnfcs(new ArrayList<>());
 660         recievedLcn.getAffectedVnfcs().add(affectedVnfc);
 661
 662         AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
 663         affectedVirtualLink.setChangeType(ChangeType.REMOVED);
 664         affectedVirtualLink.setId("vlId");
 665         affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
 666         affectedVirtualLink.setResource(new ResourceHandle());
 667         affectedVirtualLink.getResource().setVimId(VIM_ID);
 668         affectedVirtualLink.getResource().setResourceId("networkProviderId");
 669         recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
 670         recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
 671
 672
 673         AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
 674         affectedStorage.setChangeType(ChangeType.REMOVED);
 675         affectedStorage.setId("storageId");
 676         affectedStorage.setVirtualStorageDescId("storageVnfdId");
 677         affectedStorage.setResource(new ResourceHandle());
 678         affectedStorage.getResource().setVimId(VIM_ID);
 679         affectedStorage.getResource().setResourceId("storageProviderId");
 680         recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
 681         recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
 682
 683         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 684         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 685         affectedCp.setCpdId("cpVnfdId");
 686         affectedCp.setIpAddress("1.2.3.4");
 687         affectedCp.setMacAddress("myMac");
 688         affectedCp.setName("myPortName");
 689         affectedCp.setCpId("cpId");
 690
 691         // affectedCp.setEcpdId("ecpdId");
 692         affectedCp.setNetworkProviderId("networkProviderId");
 693         affectedCp.setProviderId("portProviderId");
 694         affectedCp.setServerProviderId("serverProviderId");
 695         affectedCp.setTenantId("tenantId");
 696         affectedConnectionPoints.getPre().add(affectedCp);
 697
 698
 699         OperationResult operationResult = new OperationResult();
 700         operationResult.operationResult = affectedConnectionPoints;
 701         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 702         scaleOperation.setAdditionalData(additionalData);
 703         scaleOperation.setOperationType(OperationType.SCALE);
 704         //when
 705         vfcNotificationSender.processNotification(recievedLcn, scaleOperation, of(affectedConnectionPoints), VIM_ID, VNFM_ID);
 706         //verify
 707         assertEquals(1, sentLcnToVfc.getAllValues().size());
 708
 709         assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
 710         org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
 711         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectedVl.getChangeType());
 712         assertEquals("vlVnfdId", actualAffectedVl.getVldid());
 713         assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
 714         assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
 715         assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
 716
 717         assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
 718         org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
 719         assertEquals("myVduId", actualAffectdVnfc.getVduId());
 720         assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
 721         assertEquals("myVmName", actualAffectdVnfc.getVmname());
 722         assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
 723         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectdVnfc.getChangeType());
 724         assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
 725
 726         assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
 727         AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
 728         assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
 729         assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
 730         assertEquals(null, actualAffectedCp.getOwnerId());
 731         assertEquals(null, actualAffectedCp.getOwnerType());
 732         assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
 733         assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
 734         assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
 735         assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
 736         assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
 737         assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
 738         assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
 739         assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
 740         assertEquals(VnfCpNotificationType.REMOVED, actualAffectedCp.getChangeType());
 741
 742         assertEquals(0, sentLcnToVfc.getValue().getAffectedVirtualStorage().size());
 743         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 744         assertEquals(org.onap.vnfmdriver.model.OperationType.SCALEIN, sentLcnToVfc.getValue().getOperation());
 745         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 746         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 747         VOID_OBSERVABLE.assertCalled();
 748     }
 749
 750
 751     /**
 752      * en empty LCN is sent even if nothing has changed
 753      */
 754     @Test
 755     public void testNothingChanged() {
 756         //given
 757         recievedLcn.setOperation(OperationType.SCALE);
 758         recievedLcn.setStatus(OperationStatus.FINISHED);
 759         recievedLcn.setLifecycleOperationOccurrenceId(scaleOperation.getId());
 760         ScaleVnfRequest request = new ScaleVnfRequest();
 761         request.setAdditionalParams(new JsonParser().parse("{ \"jobId\" : \"" + JOB_ID + "\" }"));
 762         request.setType(ScaleDirection.IN);
 763         scaleOperation.setOperationParams(request);
 764         OperationResult operationResult = new OperationResult();
 765         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 766         scaleOperation.setAdditionalData(additionalData);
 767         scaleOperation.setOperationType(OperationType.SCALE);
 768         when(logger.isInfoEnabled()).thenReturn(false);
 769         //when
 770         vfcNotificationSender.processNotification(recievedLcn, scaleOperation, empty(), VIM_ID, VNFM_ID);
 771         //verify
 772         assertEquals(1, sentLcnToVfc.getAllValues().size());
 773
 774         assertEquals(0, sentLcnToVfc.getValue().getAffectedVl().size());
 775         assertEquals(0, sentLcnToVfc.getValue().getAffectedVnfc().size());
 776         assertEquals(0, sentLcnToVfc.getValue().getAffectedCp().size());
 777         assertEquals(0, sentLcnToVfc.getValue().getAffectedVirtualStorage().size());
 778         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 779         assertEquals(org.onap.vnfmdriver.model.OperationType.SCALEIN, sentLcnToVfc.getValue().getOperation());
 780         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 781         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 782         verify(logger, never()).info(eq("Sending LCN: {}"), anyString());
 783         VOID_OBSERVABLE.assertCalled();
 784     }
 785
 786     /**
 787      * If a connection point is not modified it is not contained in the LCN
 788      */
 789     @Test
 790     public void testNonModifiedCP() {
 791         //given
 792         recievedLcn.setOperation(OperationType.HEAL);
 793         recievedLcn.setStatus(OperationStatus.FINISHED);
 794
 795         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 796         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 797         affectedCp.setCpdId("cpVnfdId");
 798         affectedCp.setIpAddress("1.2.3.4");
 799         affectedCp.setMacAddress("myMac");
 800         affectedCp.setName("myPortName");
 801         affectedCp.setCpId("cpId");
 802
 803         // affectedCp.setEcpdId("ecpdId");
 804         affectedCp.setNetworkProviderId("networkProviderId");
 805         affectedCp.setProviderId("portProviderId");
 806         affectedCp.setServerProviderId("serverProviderId");
 807         affectedCp.setTenantId("tenantId");
 808         affectedConnectionPoints.getPre().add(affectedCp);
 809
 810         ReportedAffectedCp after = new ReportedAffectedCp();
 811         after.setCpdId("cpVnfdId");
 812         after.setIpAddress("1.2.3.4");
 813         after.setMacAddress("myMac");
 814         after.setName("myPortName");
 815         after.setCpId("cpId");
 816
 817         // affectedCp.setEcpdId("ecpdId");
 818         after.setNetworkProviderId("networkProviderId");
 819         after.setProviderId("portProviderId");
 820         after.setServerProviderId("serverProviderId");
 821         after.setTenantId("tenantId");
 822         affectedConnectionPoints.getPost().add(after);
 823
 824
 825         OperationResult operationResult = new OperationResult();
 826         operationResult.operationResult = affectedConnectionPoints;
 827         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 828         instantiationOperation.setAdditionalData(additionalData);
 829         //when
 830         vfcNotificationSender.processNotification(recievedLcn, healOperation, of(affectedConnectionPoints), VIM_ID, VNFM_ID);
 831         //verify
 832         assertEquals(1, sentLcnToVfc.getAllValues().size());
 833
 834         assertEquals(0, sentLcnToVfc.getValue().getAffectedVl().size());
 835         assertEquals(0, sentLcnToVfc.getValue().getAffectedVnfc().size());
 836         assertEquals(0, sentLcnToVfc.getValue().getAffectedCp().size());
 837         assertEquals(0, sentLcnToVfc.getValue().getAffectedVirtualStorage().size());
 838         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 839         assertEquals(org.onap.vnfmdriver.model.OperationType.HEAL, sentLcnToVfc.getValue().getOperation());
 840         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 841         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 842     }
 843
 844     /**
 845      * Unable to send notification to VF-C results in error
 846      */
 847     @Test
 848     public void testUnableToSendNotificationToVfc() throws Exception {
 849         RuntimeException expectedException = new RuntimeException();
 850         doThrow(expectedException).when(nsLcmApi).vNFLCMNotification(any(), any(), any());
 851         recievedLcn.setStatus(OperationStatus.STARTED);
 852         recievedLcn.setOperation(OperationType.INSTANTIATE);
 853         //when
 854         try {
 855             vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, empty(), VIM_ID, VNFM_ID);
 856             //verify
 857             fail();
 858         } catch (Exception e) {
 859             verify(logger).error("Unable to send LCN to VF-C", expectedException);
 860             assertEquals(expectedException, e.getCause());
 861         }
 862     }
 863
 864     class OperationResult {
 865         ReportedAffectedConnectionPoints operationResult;
 866     }
 867 }