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

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