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