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

   1 /*
   2  * Copyright 2016-2017, Nokia Corporation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc;
  18
  19 import com.google.common.collect.Lists;
  20 import com.google.gson.Gson;
  21 import com.google.gson.JsonElement;
  22 import com.google.gson.JsonParser;
  23 import com.nokia.cbam.lcm.v32.model.AffectedVirtualLink;
  24 import com.nokia.cbam.lcm.v32.model.AffectedVirtualStorage;
  25 import com.nokia.cbam.lcm.v32.model.AffectedVnfc;
  26 import com.nokia.cbam.lcm.v32.model.ChangeType;
  27 import com.nokia.cbam.lcm.v32.model.*;
  28 import com.nokia.cbam.lcm.v32.model.OperationType;
  29 import com.nokia.cbam.lcm.v32.model.ScaleDirection;
  30 import java.util.ArrayList;
  31 import java.util.List;
  32 import org.junit.Before;
  33 import org.junit.Test;
  34 import org.mockito.ArgumentCaptor;
  35 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase;
  36 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedConnectionPoints;
  37 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedCp;
  38 import org.onap.vnfmdriver.model.*;
  39 import org.threeten.bp.OffsetDateTime;
  40
  41 import static java.util.Optional.empty;
  42 import static java.util.Optional.of;
  43
  44 import static junit.framework.TestCase.assertEquals;
  45 import static junit.framework.TestCase.fail;
  46 import static org.mockito.Mockito.*;
  47 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
  48 import static org.springframework.test.util.ReflectionTestUtils.setField;
  49
  50 public class TestVfcNotificationSender extends TestBase {
  51     private VfcNotificationSender vfcNotificationSender;
  52     private ArgumentCaptor<VNFLCMNotification> sentLcnToVfc = ArgumentCaptor.forClass(VNFLCMNotification.class);
  53     private VnfLifecycleChangeNotification recievedLcn = new VnfLifecycleChangeNotification();
  54     private List<OperationExecution> operationExecutions = new ArrayList<>();
  55     private OperationExecution instantiationOperation = new OperationExecution();
  56     private OperationExecution scaleOperation = new OperationExecution();
  57     private OperationExecution healOperation = new OperationExecution();
  58     private OperationExecution terminationOperation = new OperationExecution();
  59     private ReportedAffectedConnectionPoints affectedCp;
  60
  61
  62     @Before
  63     public void init() throws Exception {
  64         vfcNotificationSender = new VfcNotificationSender(vfcRestApiProvider);
  65         setField(VfcNotificationSender.class, "logger", logger);
  66         when(nsLcmApi.vNFLCMNotification(eq(VNFM_ID), eq(VNF_ID), sentLcnToVfc.capture())).thenReturn(VOID_OBSERVABLE.value());
  67         instantiationOperation.setId("instantiationOperationExecutionId");
  68         instantiationOperation.setStartTime(OffsetDateTime.now());
  69         instantiationOperation.setOperationType(OperationType.INSTANTIATE);
  70         scaleOperation.setId("scaleOperationExecutionId");
  71         scaleOperation.setStartTime(OffsetDateTime.now().plusDays(1));
  72         scaleOperation.setOperationType(OperationType.SCALE);
  73         terminationOperation.setId("terminationExecutionId");
  74         terminationOperation.setStartTime(OffsetDateTime.now().plusDays(1));
  75         terminationOperation.setOperationType(OperationType.TERMINATE);
  76         healOperation.setId("healOperaitonExecutionId");
  77         healOperation.setOperationType(OperationType.HEAL);
  78         healOperation.setStartTime(OffsetDateTime.now().plusDays(1));
  79         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecutions));
  80         prepOperation(instantiationOperation);
  81         prepOperation(scaleOperation);
  82         prepOperation(healOperation);
  83         prepOperation(terminationOperation);
  84         recievedLcn.setVnfInstanceId(VNF_ID);
  85     }
  86
  87     private void prepOperation(OperationExecution operationExecution) {
  88         addEmptyModifiedConnectionPoints(operationExecution);
  89         JsonElement root = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + JOB_ID + "\"}}");
  90         operationExecution.setOperationParams(root);
  91         switch (operationExecution.getOperationType()) {
  92             case TERMINATE:
  93                 root.getAsJsonObject().addProperty("terminationType", "GRACEFULL");
  94         }
  95         when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(operationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecution));
  96         operationExecutions.add(operationExecution);
  97     }
  98
  99     private void addEmptyModifiedConnectionPoints(OperationExecution operationExecution) {
 100         OperationResult operationResult = new OperationResult();
 101         operationResult.operationResult = new ReportedAffectedConnectionPoints();
 102         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 103         operationExecution.setAdditionalData(additionalData);
 104     }
 105
 106     /**
 107      * test start notification success scenario
 108      * - the affected resources are not processed even if present
 109      * - LCN is sent to VF-C
 110      */
 111     @Test
 112     public void testStartLcn() {
 113         recievedLcn.setStatus(OperationStatus.STARTED);
 114         recievedLcn.setOperation(OperationType.INSTANTIATE);
 115         //when
 116         vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, empty(), VIM_ID, VNFM_ID);
 117         //verify
 118         assertEquals(1, sentLcnToVfc.getAllValues().size());
 119         assertEquals(0, sentLcnToVfc.getValue().getAffectedVl().size());
 120         assertEquals(0, sentLcnToVfc.getValue().getAffectedVnfc().size());
 121         assertEquals(0, sentLcnToVfc.getValue().getAffectedCp().size());
 122         assertEquals(0, sentLcnToVfc.getValue().getAffectedVirtualStorage().size());
 123
 124         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 125         assertEquals(org.onap.vnfmdriver.model.OperationType.INSTANTIATE, sentLcnToVfc.getValue().getOperation());
 126         assertEquals(VnfLcmNotificationStatus.START, sentLcnToVfc.getValue().getStatus());
 127         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 128         VOID_OBSERVABLE.assertCalled();
 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, VNFM_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         assertEquals(0, sentLcnToVfc.getValue().getAffectedVirtualStorage().size());
 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         VOID_OBSERVABLE.assertCalled();
 234     }
 235
 236     /**
 237      * test end notification success scenario for ECP
 238      */
 239     @Test
 240     public void testFinishLcnForEcp() {
 241         //given
 242         recievedLcn.setOperation(OperationType.INSTANTIATE);
 243         recievedLcn.setStatus(OperationStatus.FINISHED);
 244         AffectedVnfc affectedVnfc = new AffectedVnfc();
 245         affectedVnfc.setChangeType(ChangeType.ADDED);
 246         affectedVnfc.setId("myVnfcId");
 247         affectedVnfc.setVduId("myVduId");
 248         affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
 249         affectedVnfc.setComputeResource(new ResourceHandle());
 250         affectedVnfc.getComputeResource().setResourceId("serverProviderId");
 251         affectedVnfc.getComputeResource().setVimId(VIM_ID);
 252         affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
 253         recievedLcn.setAffectedVnfcs(new ArrayList<>());
 254         recievedLcn.getAffectedVnfcs().add(affectedVnfc);
 255
 256         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 257         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 258         //affectedCp.setCpdId("cpVnfdId");
 259         affectedCp.setIpAddress("1.2.3.4");
 260         affectedCp.setMacAddress("myMac");
 261         affectedCp.setName("myPortName");
 262         affectedCp.setCpId("cpId");
 263         affectedCp.setEcpdId("ecpdId");
 264         affectedCp.setNetworkProviderId("networkProviderId");
 265         affectedCp.setProviderId("portProviderId");
 266         affectedCp.setServerProviderId("serverProviderId");
 267         affectedCp.setTenantId("tenantId");
 268         affectedConnectionPoints.getPost().add(affectedCp);
 269
 270         OperationResult operationResult = new OperationResult();
 271         operationResult.operationResult = affectedConnectionPoints;
 272         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 273         instantiationOperation.setAdditionalData(additionalData);
 274         //when
 275         vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, of(affectedConnectionPoints), VIM_ID, VNFM_ID);
 276         //verify
 277         assertEquals(1, sentLcnToVfc.getAllValues().size());
 278
 279         assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
 280         AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
 281         assertEquals("ecpdId", actualAffectedCp.getCpdid());
 282         assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
 283         assertEquals(null, actualAffectedCp.getOwnerId());
 284         assertEquals(null, actualAffectedCp.getOwnerType());
 285         assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
 286         assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
 287         assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
 288         assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
 289         assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
 290         assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
 291         assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
 292         assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
 293         assertEquals(VnfCpNotificationType.ADDED, actualAffectedCp.getChangeType());
 294         VOID_OBSERVABLE.assertCalled();
 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, VNFM_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         assertEquals(0, sentLcnToVfc.getValue().getAffectedVirtualStorage().size());
 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         VOID_OBSERVABLE.assertCalled();
 400     }
 401
 402     /**
 403      * test end notification success scenario for modifiction (heal)
 404      * - LCN is sent to VF-C
 405      */
 406     @Test
 407     public void testFinishLcnForModification() {
 408         //given
 409         recievedLcn.setOperation(OperationType.HEAL);
 410         recievedLcn.setStatus(OperationStatus.FINISHED);
 411         AffectedVnfc affectedVnfc = new AffectedVnfc();
 412         affectedVnfc.setChangeType(ChangeType.MODIFIED);
 413         affectedVnfc.setId("myVnfcId");
 414         affectedVnfc.setVduId("myVduId");
 415         affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
 416         affectedVnfc.setComputeResource(new ResourceHandle());
 417         affectedVnfc.getComputeResource().setResourceId("serverProviderId");
 418         affectedVnfc.getComputeResource().setVimId(VIM_ID);
 419         affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
 420         recievedLcn.setAffectedVnfcs(new ArrayList<>());
 421         recievedLcn.getAffectedVnfcs().add(affectedVnfc);
 422
 423         AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
 424         affectedVirtualLink.setChangeType(ChangeType.MODIFIED);
 425         affectedVirtualLink.setId("vlId");
 426         affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
 427         affectedVirtualLink.setResource(new ResourceHandle());
 428         affectedVirtualLink.getResource().setVimId(VIM_ID);
 429         affectedVirtualLink.getResource().setResourceId("networkProviderId");
 430         recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
 431         recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
 432
 433
 434         AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
 435         affectedStorage.setChangeType(ChangeType.MODIFIED);
 436         affectedStorage.setId("storageId");
 437         affectedStorage.setVirtualStorageDescId("storageVnfdId");
 438         affectedStorage.setResource(new ResourceHandle());
 439         affectedStorage.getResource().setVimId(VIM_ID);
 440         affectedStorage.getResource().setResourceId("storageProviderId");
 441         recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
 442         recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
 443
 444         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 445         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 446         affectedCp.setCpdId("cpVnfdId");
 447         affectedCp.setIpAddress("1.2.3.4");
 448         affectedCp.setMacAddress("myMac");
 449         affectedCp.setName("myPortName");
 450         affectedCp.setCpId("cpId");
 451
 452         // affectedCp.setEcpdId("ecpdId");
 453         affectedCp.setNetworkProviderId("networkProviderId");
 454         affectedCp.setProviderId("portProviderId");
 455         affectedCp.setServerProviderId("serverProviderId");
 456         affectedCp.setTenantId("tenantId");
 457         affectedConnectionPoints.getPre().add(affectedCp);
 458
 459         ReportedAffectedCp after = new ReportedAffectedCp();
 460         after.setCpdId("cpVnfdId");
 461         after.setIpAddress("1.2.3.5");
 462         after.setMacAddress("myMac");
 463         after.setName("myPortName");
 464         after.setCpId("cpId");
 465
 466         // affectedCp.setEcpdId("ecpdId");
 467         after.setNetworkProviderId("networkProviderId");
 468         after.setProviderId("portProviderId");
 469         after.setServerProviderId("serverProviderId");
 470         after.setTenantId("tenantId");
 471         affectedConnectionPoints.getPost().add(after);
 472
 473
 474         OperationResult operationResult = new OperationResult();
 475         operationResult.operationResult = affectedConnectionPoints;
 476         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 477         instantiationOperation.setAdditionalData(additionalData);
 478         //when
 479         vfcNotificationSender.processNotification(recievedLcn, healOperation, of(affectedConnectionPoints), VIM_ID, VNFM_ID);
 480         //verify
 481         assertEquals(1, sentLcnToVfc.getAllValues().size());
 482
 483         assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
 484         org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
 485         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.MODIFIED, actualAffectedVl.getChangeType());
 486         assertEquals("vlVnfdId", actualAffectedVl.getVldid());
 487         assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
 488         assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
 489         assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
 490
 491         assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
 492         org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
 493         assertEquals("myVduId", actualAffectdVnfc.getVduId());
 494         assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
 495         assertEquals("myVmName", actualAffectdVnfc.getVmname());
 496         assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
 497         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.MODIFIED, actualAffectdVnfc.getChangeType());
 498         assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
 499
 500         assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
 501         AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
 502         assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
 503         assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
 504         assertEquals(null, actualAffectedCp.getOwnerId());
 505         assertEquals(null, actualAffectedCp.getOwnerType());
 506         assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
 507         assertEquals("1.2.3.5", actualAffectedCp.getPortResource().getIpAddress());
 508         assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
 509         assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
 510         assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
 511         assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
 512         assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
 513         assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
 514         assertEquals(VnfCpNotificationType.CHANGED, actualAffectedCp.getChangeType());
 515
 516         assertEquals(0, sentLcnToVfc.getValue().getAffectedVirtualStorage().size());
 517         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 518         assertEquals(org.onap.vnfmdriver.model.OperationType.HEAL, sentLcnToVfc.getValue().getOperation());
 519         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 520         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 521         VOID_OBSERVABLE.assertCalled();
 522     }
 523
 524     /**
 525      * test end notification success scenario for scale-out
 526      * - LCN is sent to VF-C
 527      */
 528     @Test
 529     public void testFinishLcnForScaleout() {
 530         //given
 531         recievedLcn.setOperation(OperationType.SCALE);
 532         recievedLcn.setStatus(OperationStatus.FINISHED);
 533         recievedLcn.setLifecycleOperationOccurrenceId(scaleOperation.getId());
 534         ScaleVnfRequest request = new ScaleVnfRequest();
 535         request.setAdditionalParams(new JsonParser().parse("{ \"jobId\" : \"" + JOB_ID + "\" }"));
 536         request.setType(ScaleDirection.OUT);
 537         scaleOperation.setOperationParams(request);
 538         scaleOperation.setOperationType(OperationType.SCALE);
 539         AffectedVnfc affectedVnfc = new AffectedVnfc();
 540         affectedVnfc.setChangeType(ChangeType.ADDED);
 541         affectedVnfc.setId("myVnfcId");
 542         affectedVnfc.setVduId("myVduId");
 543         affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
 544         affectedVnfc.setComputeResource(new ResourceHandle());
 545         affectedVnfc.getComputeResource().setResourceId("serverProviderId");
 546         affectedVnfc.getComputeResource().setVimId(VIM_ID);
 547         affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
 548         recievedLcn.setAffectedVnfcs(new ArrayList<>());
 549         recievedLcn.getAffectedVnfcs().add(affectedVnfc);
 550
 551         AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
 552         affectedVirtualLink.setChangeType(ChangeType.ADDED);
 553         affectedVirtualLink.setId("vlId");
 554         affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
 555         affectedVirtualLink.setResource(new ResourceHandle());
 556         affectedVirtualLink.getResource().setVimId(VIM_ID);
 557         affectedVirtualLink.getResource().setResourceId("networkProviderId");
 558         recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
 559         recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
 560
 561
 562         AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
 563         affectedStorage.setChangeType(ChangeType.ADDED);
 564         affectedStorage.setId("storageId");
 565         affectedStorage.setVirtualStorageDescId("storageVnfdId");
 566         affectedStorage.setResource(new ResourceHandle());
 567         affectedStorage.getResource().setVimId(VIM_ID);
 568         affectedStorage.getResource().setResourceId("storageProviderId");
 569         recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
 570         recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
 571
 572         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 573         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 574         affectedCp.setCpdId("cpVnfdId");
 575         affectedCp.setIpAddress("1.2.3.4");
 576         affectedCp.setMacAddress("myMac");
 577         affectedCp.setName("myPortName");
 578         affectedCp.setCpId("cpId");
 579
 580         // affectedCp.setEcpdId("ecpdId");
 581         affectedCp.setNetworkProviderId("networkProviderId");
 582         affectedCp.setProviderId("portProviderId");
 583         affectedCp.setServerProviderId("serverProviderId");
 584         affectedCp.setTenantId("tenantId");
 585         affectedConnectionPoints.getPost().add(affectedCp);
 586
 587         OperationResult operationResult = new OperationResult();
 588         operationResult.operationResult = affectedConnectionPoints;
 589         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 590         scaleOperation.setAdditionalData(additionalData);
 591         //when
 592         vfcNotificationSender.processNotification(recievedLcn, scaleOperation, of(affectedConnectionPoints), VIM_ID, VNFM_ID);
 593         //verify
 594         assertEquals(1, sentLcnToVfc.getAllValues().size());
 595
 596         assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
 597         org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
 598         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectedVl.getChangeType());
 599         assertEquals("vlVnfdId", actualAffectedVl.getVldid());
 600         assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
 601         assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
 602         assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
 603
 604         assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
 605         org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
 606         assertEquals("myVduId", actualAffectdVnfc.getVduId());
 607         assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
 608         assertEquals("myVmName", actualAffectdVnfc.getVmname());
 609         assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
 610         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectdVnfc.getChangeType());
 611         assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
 612
 613         assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
 614         AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
 615         assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
 616         assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
 617         assertEquals(null, actualAffectedCp.getOwnerId());
 618         assertEquals(null, actualAffectedCp.getOwnerType());
 619         assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
 620         assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
 621         assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
 622         assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
 623         assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
 624         assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
 625         assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
 626         assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
 627         assertEquals(VnfCpNotificationType.ADDED, actualAffectedCp.getChangeType());
 628
 629         assertEquals(0, sentLcnToVfc.getValue().getAffectedVirtualStorage().size());
 630         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 631         assertEquals(org.onap.vnfmdriver.model.OperationType.SCALEOUT, sentLcnToVfc.getValue().getOperation());
 632         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 633         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 634         VOID_OBSERVABLE.assertCalled();
 635     }
 636
 637     /**
 638      * test end notification success scenario for scale-out
 639      * - LCN is sent to VF-C
 640      */
 641     @Test
 642     public void testFinishLcnForScaleIn() {
 643         //given
 644         recievedLcn.setOperation(OperationType.SCALE);
 645         recievedLcn.setStatus(OperationStatus.FINISHED);
 646         recievedLcn.setLifecycleOperationOccurrenceId(scaleOperation.getId());
 647         ScaleVnfRequest request = new ScaleVnfRequest();
 648         request.setAdditionalParams(new JsonParser().parse("{ \"jobId\" : \"" + JOB_ID + "\" }"));
 649         request.setType(ScaleDirection.IN);
 650         scaleOperation.setOperationParams(request);
 651         AffectedVnfc affectedVnfc = new AffectedVnfc();
 652         affectedVnfc.setChangeType(ChangeType.REMOVED);
 653         affectedVnfc.setId("myVnfcId");
 654         affectedVnfc.setVduId("myVduId");
 655         affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1"));
 656         affectedVnfc.setComputeResource(new ResourceHandle());
 657         affectedVnfc.getComputeResource().setResourceId("serverProviderId");
 658         affectedVnfc.getComputeResource().setVimId(VIM_ID);
 659         affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } "));
 660         recievedLcn.setAffectedVnfcs(new ArrayList<>());
 661         recievedLcn.getAffectedVnfcs().add(affectedVnfc);
 662
 663         AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink();
 664         affectedVirtualLink.setChangeType(ChangeType.REMOVED);
 665         affectedVirtualLink.setId("vlId");
 666         affectedVirtualLink.setVirtualLinkDescId("vlVnfdId");
 667         affectedVirtualLink.setResource(new ResourceHandle());
 668         affectedVirtualLink.getResource().setVimId(VIM_ID);
 669         affectedVirtualLink.getResource().setResourceId("networkProviderId");
 670         recievedLcn.setAffectedVirtualLinks(new ArrayList<>());
 671         recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink);
 672
 673
 674         AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage();
 675         affectedStorage.setChangeType(ChangeType.REMOVED);
 676         affectedStorage.setId("storageId");
 677         affectedStorage.setVirtualStorageDescId("storageVnfdId");
 678         affectedStorage.setResource(new ResourceHandle());
 679         affectedStorage.getResource().setVimId(VIM_ID);
 680         affectedStorage.getResource().setResourceId("storageProviderId");
 681         recievedLcn.setAffectedVirtualStorages(new ArrayList<>());
 682         recievedLcn.getAffectedVirtualStorages().add(affectedStorage);
 683
 684         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 685         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 686         affectedCp.setCpdId("cpVnfdId");
 687         affectedCp.setIpAddress("1.2.3.4");
 688         affectedCp.setMacAddress("myMac");
 689         affectedCp.setName("myPortName");
 690         affectedCp.setCpId("cpId");
 691
 692         // affectedCp.setEcpdId("ecpdId");
 693         affectedCp.setNetworkProviderId("networkProviderId");
 694         affectedCp.setProviderId("portProviderId");
 695         affectedCp.setServerProviderId("serverProviderId");
 696         affectedCp.setTenantId("tenantId");
 697         affectedConnectionPoints.getPre().add(affectedCp);
 698
 699
 700         OperationResult operationResult = new OperationResult();
 701         operationResult.operationResult = affectedConnectionPoints;
 702         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 703         scaleOperation.setAdditionalData(additionalData);
 704         scaleOperation.setOperationType(OperationType.SCALE);
 705         //when
 706         vfcNotificationSender.processNotification(recievedLcn, scaleOperation, of(affectedConnectionPoints), VIM_ID, VNFM_ID);
 707         //verify
 708         assertEquals(1, sentLcnToVfc.getAllValues().size());
 709
 710         assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size());
 711         org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0);
 712         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectedVl.getChangeType());
 713         assertEquals("vlVnfdId", actualAffectedVl.getVldid());
 714         assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId());
 715         assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId());
 716         assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType());
 717
 718         assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size());
 719         org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0);
 720         assertEquals("myVduId", actualAffectdVnfc.getVduId());
 721         assertEquals(VIM_ID, actualAffectdVnfc.getVimid());
 722         assertEquals("myVmName", actualAffectdVnfc.getVmname());
 723         assertEquals("serverProviderId", actualAffectdVnfc.getVmid());
 724         assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectdVnfc.getChangeType());
 725         assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId());
 726
 727         assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size());
 728         AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0);
 729         assertEquals("cpVnfdId", actualAffectedCp.getCpdid());
 730         assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid());
 731         assertEquals(null, actualAffectedCp.getOwnerId());
 732         assertEquals(null, actualAffectedCp.getOwnerType());
 733         assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId());
 734         assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress());
 735         assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress());
 736         assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant());
 737         assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid());
 738         assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId());
 739         assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid());
 740         assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName());
 741         assertEquals(VnfCpNotificationType.REMOVED, actualAffectedCp.getChangeType());
 742
 743         assertEquals(0, sentLcnToVfc.getValue().getAffectedVirtualStorage().size());
 744         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 745         assertEquals(org.onap.vnfmdriver.model.OperationType.SCALEIN, sentLcnToVfc.getValue().getOperation());
 746         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 747         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 748         VOID_OBSERVABLE.assertCalled();
 749     }
 750
 751
 752     /**
 753      * en empty LCN is sent even if nothing has changed
 754      */
 755     @Test
 756     public void testNothingChanged() {
 757         //given
 758         recievedLcn.setOperation(OperationType.SCALE);
 759         recievedLcn.setStatus(OperationStatus.FINISHED);
 760         recievedLcn.setLifecycleOperationOccurrenceId(scaleOperation.getId());
 761         ScaleVnfRequest request = new ScaleVnfRequest();
 762         request.setAdditionalParams(new JsonParser().parse("{ \"jobId\" : \"" + JOB_ID + "\" }"));
 763         request.setType(ScaleDirection.IN);
 764         scaleOperation.setOperationParams(request);
 765         OperationResult operationResult = new OperationResult();
 766         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 767         scaleOperation.setAdditionalData(additionalData);
 768         scaleOperation.setOperationType(OperationType.SCALE);
 769         when(logger.isInfoEnabled()).thenReturn(false);
 770         //when
 771         vfcNotificationSender.processNotification(recievedLcn, scaleOperation, empty(), VIM_ID, VNFM_ID);
 772         //verify
 773         assertEquals(1, sentLcnToVfc.getAllValues().size());
 774
 775         assertEquals(0, sentLcnToVfc.getValue().getAffectedVl().size());
 776         assertEquals(0, sentLcnToVfc.getValue().getAffectedVnfc().size());
 777         assertEquals(0, sentLcnToVfc.getValue().getAffectedCp().size());
 778         assertEquals(0, sentLcnToVfc.getValue().getAffectedVirtualStorage().size());
 779         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 780         assertEquals(org.onap.vnfmdriver.model.OperationType.SCALEIN, sentLcnToVfc.getValue().getOperation());
 781         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 782         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 783         verify(logger, never()).info(eq("Sending LCN: {}"), anyString());
 784         VOID_OBSERVABLE.assertCalled();
 785     }
 786
 787     /**
 788      * If a connection point is not modified it is not contained in the LCN
 789      */
 790     @Test
 791     public void testNonModifiedCP() {
 792         //given
 793         recievedLcn.setOperation(OperationType.HEAL);
 794         recievedLcn.setStatus(OperationStatus.FINISHED);
 795
 796         ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints();
 797         ReportedAffectedCp affectedCp = new ReportedAffectedCp();
 798         affectedCp.setCpdId("cpVnfdId");
 799         affectedCp.setIpAddress("1.2.3.4");
 800         affectedCp.setMacAddress("myMac");
 801         affectedCp.setName("myPortName");
 802         affectedCp.setCpId("cpId");
 803
 804         // affectedCp.setEcpdId("ecpdId");
 805         affectedCp.setNetworkProviderId("networkProviderId");
 806         affectedCp.setProviderId("portProviderId");
 807         affectedCp.setServerProviderId("serverProviderId");
 808         affectedCp.setTenantId("tenantId");
 809         affectedConnectionPoints.getPre().add(affectedCp);
 810
 811         ReportedAffectedCp after = new ReportedAffectedCp();
 812         after.setCpdId("cpVnfdId");
 813         after.setIpAddress("1.2.3.4");
 814         after.setMacAddress("myMac");
 815         after.setName("myPortName");
 816         after.setCpId("cpId");
 817
 818         // affectedCp.setEcpdId("ecpdId");
 819         after.setNetworkProviderId("networkProviderId");
 820         after.setProviderId("portProviderId");
 821         after.setServerProviderId("serverProviderId");
 822         after.setTenantId("tenantId");
 823         affectedConnectionPoints.getPost().add(after);
 824
 825
 826         OperationResult operationResult = new OperationResult();
 827         operationResult.operationResult = affectedConnectionPoints;
 828         JsonElement additionalData = new Gson().toJsonTree(operationResult);
 829         instantiationOperation.setAdditionalData(additionalData);
 830         //when
 831         vfcNotificationSender.processNotification(recievedLcn, healOperation, of(affectedConnectionPoints), VIM_ID, VNFM_ID);
 832         //verify
 833         assertEquals(1, sentLcnToVfc.getAllValues().size());
 834
 835         assertEquals(0, sentLcnToVfc.getValue().getAffectedVl().size());
 836         assertEquals(0, sentLcnToVfc.getValue().getAffectedVnfc().size());
 837         assertEquals(0, sentLcnToVfc.getValue().getAffectedCp().size());
 838         assertEquals(0, sentLcnToVfc.getValue().getAffectedVirtualStorage().size());
 839         assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId());
 840         assertEquals(org.onap.vnfmdriver.model.OperationType.HEAL, sentLcnToVfc.getValue().getOperation());
 841         assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus());
 842         assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId());
 843     }
 844
 845     /**
 846      * Unable to send notification to VF-C results in error
 847      */
 848     @Test
 849     public void testUnableToSendNotificationToVfc() throws Exception {
 850         RuntimeException expectedException = new RuntimeException();
 851         doThrow(expectedException).when(nsLcmApi).vNFLCMNotification(any(), any(), any());
 852         recievedLcn.setStatus(OperationStatus.STARTED);
 853         recievedLcn.setOperation(OperationType.INSTANTIATE);
 854         //when
 855         try {
 856             vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, empty(), VIM_ID, VNFM_ID);
 857             //verify
 858             fail();
 859         } catch (Exception e) {
 860             verify(logger).error("Unable to send LCN to VF-C", expectedException);
 861             assertEquals(expectedException, e.getCause());
 862         }
 863     }
 864
 865     class OperationResult {
 866         ReportedAffectedConnectionPoints operationResult;
 867     }
 868 }