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