vnfapi/provider/src/test/java/org/onap/sdnc/vnfapi/VnfapiProviderTestBase.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * openECOMP : SDN-C
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights
   6  *                             reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21 package org.onap.sdnc.vnfapi;
  22
  23 import com.google.common.base.Optional;
  24 import com.google.common.util.concurrent.CheckedFuture;
  25 import org.junit.After;
  26 import org.junit.Assert;
  27 import org.junit.Before;
  28 import org.junit.Rule;
  29 import org.junit.Test;
  30 import org.mockito.Mock;
  31 import org.mockito.junit.MockitoJUnit;
  32 import org.mockito.junit.MockitoRule;
  33 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  34 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
  35 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  36 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  37 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  38 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  39 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  40 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  41 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  42 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  43 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationInput;
  44 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationOutput;
  45 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationInput;
  46 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationOutput;
  47 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationInput;
  48 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationOutput;
  49 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModules;
  50 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationInput;
  51 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationOutput;
  52 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstances;
  53 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationInput;
  54 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationOutput;
  55 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfs;
  56 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VNFAPIService;
  57 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationInput;
  58 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationOutput;
  59 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModules;
  60 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationInput;
  61 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationOutput;
  62 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstances;
  63 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationInput;
  64 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationOutput;
  65 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.Vnfs;
  66 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.network.request.information.NetworkRequestInformation;
  67 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.network.topology.identifier.NetworkTopologyIdentifier;
  68 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.network.topology.information.NetworkTopologyInformation;
  69 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.data.PreloadData;
  70 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.data.PreloadDataBuilder;
  71 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadList;
  72 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadList;
  73 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadList;
  74 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.request.information.RequestInformation;
  75 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.sdnc.request.header.SdncRequestHeader;
  76 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.data.ServiceData;
  77 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.data.ServiceDataBuilder;
  78 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.information.ServiceInformation;
  79 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus;
  80 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatusBuilder;
  81 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.identifiers.VfModuleIdentifiers;
  82 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleList;
  83 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.preload.data.VfModulePreloadData;
  84 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.preload.data.VfModulePreloadDataBuilder;
  85 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.request.information.VfModuleRequestInformation;
  86 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.service.data.VfModuleServiceData;
  87 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.service.data.VfModuleServiceDataBuilder;
  88 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.topology.information.VfModuleTopologyInformation;
  89 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.identifiers.VnfInstanceIdentifiers;
  90 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceList;
  91 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.preload.data.VnfInstancePreloadData;
  92 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.preload.data.VnfInstancePreloadDataBuilder;
  93 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.request.information.VnfInstanceRequestInformation;
  94 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.service.data.VnfInstanceServiceData;
  95 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.service.data.VnfInstanceServiceDataBuilder;
  96 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.topology.information.VnfInstanceTopologyInformation;
  97 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfList;
  98 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfListKey;
  99 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.request.information.VnfRequestInformation;
 100 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.topology.identifier.VnfTopologyIdentifier;
 101 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.topology.information.VnfTopologyInformation;
 102 import org.opendaylight.yangtools.yang.binding.DataObject;
 103 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 104 import org.opendaylight.yangtools.yang.common.RpcResult;
 105 import org.powermock.reflect.Whitebox;
 106
 107 import java.util.ArrayList;
 108 import java.util.concurrent.ExecutorService;
 109 import java.util.concurrent.Future;
 110
 111 import static org.mockito.Matchers.any;
 112 import static org.mockito.Matchers.eq;
 113 import static org.mockito.Mockito.doReturn;
 114 import static org.mockito.Mockito.mock;
 115 import static org.mockito.Mockito.spy;
 116 import static org.mockito.Mockito.times;
 117 import static org.mockito.Mockito.verify;
 118
 119 public class VnfapiProviderTestBase {
 120     @Rule public MockitoRule rule = MockitoJUnit.rule();
 121
 122     @Mock private DataBroker dataBroker;
 123     @Mock private NotificationPublishService notificationPublishService;
 124     @Mock private RpcProviderRegistry rpcProviderRegistry;
 125     @Mock private VNFSDNSvcLogicServiceClient vnfsdnSvcLogicServiceClient;
 126     @Mock private ReadWriteTransaction readWriteTransactionInCreateContainer;
 127     @Mock private ReadWriteTransaction readWriteTransactionInDataChanged;
 128     @Mock private CheckedFuture<Void, TransactionCommitFailedException> checkedFuture;
 129
 130     private VnfApiProvider vnfapiProvider;
 131     private String vfModuleName;
 132     private String vfModuleModelId;
 133     private String vnfInstanceId;
 134     private String vnfInstanceName;
 135     private String vnfModelId;
 136     private String svcRequestId;
 137     private String serviceInstanceId;
 138     private String vnfName;
 139     private String vnfType;
 140     private String vfModuleId;
 141
 142     @Before public void setUp() throws Exception {
 143         doReturn(readWriteTransactionInCreateContainer).when(dataBroker).newReadWriteTransaction();
 144         doReturn(checkedFuture).when(readWriteTransactionInCreateContainer).submit();
 145         // mock readOnlyTransaction
 146         ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
 147         doReturn(readOnlyTransaction).when(dataBroker).newReadOnlyTransaction();
 148         doReturn(checkedFuture).when(readOnlyTransaction).read(any(), any());
 149         // mock writeTransaction
 150         WriteTransaction writeTransaction = mock(WriteTransaction.class);
 151         doReturn(writeTransaction).when(dataBroker).newWriteOnlyTransaction();
 152         doReturn(checkedFuture).when(writeTransaction).submit();
 153
 154         vnfapiProvider = spy(new VnfApiProvider(dataBroker, notificationPublishService, rpcProviderRegistry,
 155             vnfsdnSvcLogicServiceClient));
 156     }
 157
 158     @After public void tearDown() throws Exception {
 159
 160     }
 161
 162     @Test public void close() throws Exception {
 163         ExecutorService executor = Whitebox.getInternalState(vnfapiProvider, "executor");
 164         BindingAwareBroker.RpcRegistration<VNFAPIService> vnfapiServiceRpcRegistration =
 165             mock(BindingAwareBroker.RpcRegistration.class);
 166         vnfapiProvider.rpcRegistration = vnfapiServiceRpcRegistration;
 167
 168         vnfapiProvider.close();
 169
 170         Assert.assertTrue(executor.isShutdown());
 171         verify(vnfapiServiceRpcRegistration, times(1)).close();
 172     }
 173
 174     @Test public void onDataChanged() throws Exception {
 175         AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> asyncDataChangeEvent = mock(AsyncDataChangeEvent.class);
 176         // instance of Vnfs
 177         Vnfs vnfs = mock(Vnfs.class);
 178         doReturn(vnfs).when(asyncDataChangeEvent).getUpdatedSubtree();
 179         VnfList vnfList = mock(VnfList.class);
 180         ServiceData serviceData = mock(ServiceData.class);
 181         doReturn(serviceData).when(vnfList).getServiceData();
 182         ServiceStatus serviceStatus = mock(ServiceStatus.class);
 183         doReturn("N").when(serviceStatus).getFinalIndicator();
 184         doReturn(ServiceStatus.RequestStatus.Synccomplete).when(serviceStatus).getRequestStatus();
 185         doReturn(serviceStatus).when(vnfList).getServiceStatus();
 186         ArrayList<VnfList> vnfListList = new ArrayList<>();
 187         vnfListList.add(vnfList);
 188         doReturn(vnfListList).when(vnfs).getVnfList();
 189         doReturn(readWriteTransactionInDataChanged).when(dataBroker).newWriteOnlyTransaction();
 190         doReturn(checkedFuture).when(readWriteTransactionInDataChanged).submit();
 191
 192         vnfapiProvider.onDataChanged(asyncDataChangeEvent);
 193
 194         verify(readWriteTransactionInDataChanged, times(1)).submit();
 195
 196         // instance of PreloadVnfs
 197         PreloadVnfs preloadVnfs = mock(PreloadVnfs.class);
 198         doReturn(preloadVnfs).when(asyncDataChangeEvent).getUpdatedSubtree();
 199         ArrayList<VnfPreloadList> vnfPreloadLists = new ArrayList<>();
 200         doReturn(vnfPreloadLists).when(preloadVnfs).getVnfPreloadList();
 201         PreloadData preloadData = mock(PreloadData.class);
 202         VnfPreloadList vnfPreloadList = mock(VnfPreloadList.class);
 203         doReturn(preloadData).when(vnfPreloadList).getPreloadData();
 204         vnfPreloadLists.add(vnfPreloadList);
 205
 206         vnfapiProvider.onDataChanged(asyncDataChangeEvent);
 207
 208         verify(readWriteTransactionInDataChanged, times(2)).submit();
 209
 210         // instance of PreloadVnfInstances
 211         PreloadVnfInstances preloadVnfInstances = mock(PreloadVnfInstances.class);
 212         doReturn(preloadVnfInstances).when(asyncDataChangeEvent).getUpdatedSubtree();
 213         ArrayList<VnfInstancePreloadList> vnfInstancePreloadLists = new ArrayList<>();
 214         doReturn(vnfInstancePreloadLists).when(preloadVnfInstances).getVnfInstancePreloadList();
 215         VnfInstancePreloadList vnfInstancePreloadList = mock(VnfInstancePreloadList.class);
 216         VnfInstancePreloadData vnfInstancePreloadData = mock(VnfInstancePreloadData.class);
 217         doReturn(vnfInstancePreloadData).when(vnfInstancePreloadList).getVnfInstancePreloadData();
 218         vnfInstancePreloadLists.add(vnfInstancePreloadList);
 219
 220         vnfapiProvider.onDataChanged(asyncDataChangeEvent);
 221
 222         verify(readWriteTransactionInDataChanged, times(3)).submit();
 223
 224         // instance of VnfInstances
 225         VnfInstances vnfInstances = mock(VnfInstances.class);
 226         doReturn(vnfInstances).when(asyncDataChangeEvent).getUpdatedSubtree();
 227         ArrayList<VnfInstanceList> vnfInstanceLists = new ArrayList<>();
 228         doReturn(vnfInstanceLists).when(vnfInstances).getVnfInstanceList();
 229         VnfInstanceList vnfInstanceList = mock(VnfInstanceList.class);
 230         vnfInstanceLists.add(vnfInstanceList);
 231         VnfInstanceServiceData vnfInstanceServiceData = mock(VnfInstanceServiceData.class);
 232         doReturn(vnfInstanceServiceData).when(vnfInstanceList).getVnfInstanceServiceData();
 233         doReturn(serviceStatus).when(vnfInstanceList).getServiceStatus();
 234
 235         vnfapiProvider.onDataChanged(asyncDataChangeEvent);
 236
 237         verify(readWriteTransactionInDataChanged, times(4)).submit();
 238
 239         // instance of PreloadVfModules
 240         PreloadVfModules preloadVfModules = mock(PreloadVfModules.class);
 241         doReturn(preloadVfModules).when(asyncDataChangeEvent).getUpdatedSubtree();
 242         ArrayList<VfModulePreloadList> vfModulePreloadLists = new ArrayList<>();
 243         doReturn(vfModulePreloadLists).when(preloadVfModules).getVfModulePreloadList();
 244         VfModulePreloadList vfModulePreloadList = mock(VfModulePreloadList.class);
 245         vfModulePreloadLists.add(vfModulePreloadList);
 246         VfModulePreloadData vfModulePreloadData = mock(VfModulePreloadData.class);
 247         doReturn(vfModulePreloadData).when(vfModulePreloadList).getVfModulePreloadData();
 248
 249         vnfapiProvider.onDataChanged(asyncDataChangeEvent);
 250
 251         verify(readWriteTransactionInDataChanged, times(5)).submit();
 252
 253         // instance of VfModules
 254         VfModules vfModules = mock(VfModules.class);
 255         doReturn(preloadVfModules).when(asyncDataChangeEvent).getUpdatedSubtree();
 256         ArrayList<VfModuleList> vfModuleLists = new ArrayList<>();
 257         doReturn(vfModuleLists).when(vfModules).getVfModuleList();
 258         VfModuleList vfModuleList = mock(VfModuleList.class);
 259         vfModuleLists.add(vfModuleList);
 260         VfModuleServiceData vfModuleServiceData = mock(VfModuleServiceData.class);
 261         doReturn(vfModuleServiceData).when(vfModuleList).getVfModuleServiceData();
 262         doReturn(serviceStatus).when(vfModuleList).getServiceStatus();
 263
 264         vnfapiProvider.onDataChanged(asyncDataChangeEvent);
 265
 266         verify(readWriteTransactionInDataChanged, times(6)).submit();
 267     }
 268
 269     /**
 270      * Test Error case:
 271      * <p>
 272      * <code>input.getVnfInstanceRequestInformation() == null</code>
 273      *
 274      * @throws Exception
 275      */
 276     @Test public void vnfInstanceTopologyOperationErrorOne() throws Exception {
 277         VnfInstanceTopologyOperationInput vnfInstanceTopologyOperationInput =
 278             mock(VnfInstanceTopologyOperationInput.class);
 279         doReturn(null).when(vnfInstanceTopologyOperationInput).getVnfInstanceRequestInformation();
 280
 281         Future<RpcResult<VnfInstanceTopologyOperationOutput>> rpcResultFuture =
 282             vnfapiProvider.vnfInstanceTopologyOperation(vnfInstanceTopologyOperationInput);
 283
 284         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
 285         Assert.assertEquals("invalid input, null or empty vnf-instance-id",
 286             rpcResultFuture.get().getResult().getResponseMessage());
 287         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 288     }
 289
 290     /**
 291      * Test Error case:
 292      * <p>
 293      * <code>viid == null</code>
 294      *
 295      * @throws Exception
 296      */
 297     @Test public void vnfInstanceTopologyOperationErrorTwo() throws Exception {
 298         vnfInstanceId = "";
 299         vnfInstanceName = "vnf-instance-name";
 300         vnfModelId = "vnf-model-id";
 301         VnfInstanceTopologyOperationInput vnfInstanceTopologyOperationInput =
 302             mock(VnfInstanceTopologyOperationInput.class);
 303         VnfInstanceRequestInformation vnfInstanceRequestInformation = mock(VnfInstanceRequestInformation.class);
 304         doReturn(vnfInstanceName).when(vnfInstanceRequestInformation).getVnfInstanceName();
 305         doReturn(vnfModelId).when(vnfInstanceRequestInformation).getVnfModelId();
 306         doReturn(vnfInstanceId).when(vnfInstanceRequestInformation).getVnfInstanceId();
 307         doReturn(vnfInstanceRequestInformation).when(vnfInstanceTopologyOperationInput)
 308             .getVnfInstanceRequestInformation();
 309
 310         Future<RpcResult<VnfInstanceTopologyOperationOutput>> rpcResultFuture =
 311             vnfapiProvider.vnfInstanceTopologyOperation(vnfInstanceTopologyOperationInput);
 312
 313         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
 314         Assert.assertEquals("invalid input, null or empty vnf-instance-id",
 315             rpcResultFuture.get().getResult().getResponseMessage());
 316         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 317     }
 318
 319     /**
 320      * Test Error case:
 321      * <p>
 322      * <code>svcLogicClient.hasGraph("VNF-API",SVC_OPERATION,null,"sync" = false</code>
 323      *
 324      * @throws Exception
 325      */
 326     @Test public void vnfInstanceTopologyOperationErrorThree() throws Exception {
 327         vnfInstanceId = "vnf-instance-id";
 328         vnfInstanceName = "vnf-instance-name";
 329         vnfModelId = "vnf-model-id";
 330         svcRequestId = "svc-request-id";
 331
 332         VnfInstanceTopologyOperationInput vnfInstanceTopologyOperationInput =
 333             mock(VnfInstanceTopologyOperationInput.class);
 334         VnfInstanceRequestInformation vnfInstanceRequestInformation = mock(VnfInstanceRequestInformation.class);
 335         doReturn(vnfInstanceId).when(vnfInstanceRequestInformation).getVnfInstanceId();
 336         doReturn(vnfInstanceName).when(vnfInstanceRequestInformation).getVnfInstanceName();
 337         doReturn(vnfModelId).when(vnfInstanceRequestInformation).getVnfModelId();
 338         doReturn(vnfInstanceRequestInformation).when(vnfInstanceTopologyOperationInput)
 339             .getVnfInstanceRequestInformation();
 340
 341         SdncRequestHeader sdncRequestHeader = mock(SdncRequestHeader.class);
 342         doReturn(sdncRequestHeader).when(vnfInstanceTopologyOperationInput).getSdncRequestHeader();
 343         doReturn(svcRequestId).when(sdncRequestHeader).getSvcRequestId();
 344
 345         Future<RpcResult<VnfInstanceTopologyOperationOutput>> rpcResultFuture =
 346             vnfapiProvider.vnfInstanceTopologyOperation(vnfInstanceTopologyOperationInput);
 347
 348         Assert.assertEquals("503", rpcResultFuture.get().getResult().getResponseCode());
 349         Assert.assertTrue(
 350             rpcResultFuture.get().getResult().getResponseMessage().contains("No service logic active for VNF-API"));
 351         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 352     }
 353
 354     /**
 355      * Test Success case
 356      *
 357      * @throws Exception
 358      */
 359     @Test public void vnfInstanceTopologyOperationSuccess() throws Exception {
 360         vnfInstanceId = "vnf-instance-id";
 361         vnfInstanceName = "vnf-instance-name";
 362         vnfModelId = "vnf-model-id";
 363         svcRequestId = "svc-request-id";
 364
 365         VnfInstanceTopologyOperationInput vnfInstanceTopologyOperationInput =
 366             mock(VnfInstanceTopologyOperationInput.class);
 367         VnfInstanceRequestInformation vnfInstanceRequestInformation = mock(VnfInstanceRequestInformation.class);
 368         doReturn(vnfInstanceId).when(vnfInstanceRequestInformation).getVnfInstanceId();
 369         doReturn(vnfInstanceName).when(vnfInstanceRequestInformation).getVnfInstanceName();
 370         doReturn(vnfModelId).when(vnfInstanceRequestInformation).getVnfModelId();
 371         doReturn(vnfInstanceRequestInformation).when(vnfInstanceTopologyOperationInput)
 372             .getVnfInstanceRequestInformation();
 373
 374         SdncRequestHeader sdncRequestHeader = mock(SdncRequestHeader.class);
 375         doReturn(sdncRequestHeader).when(vnfInstanceTopologyOperationInput).getSdncRequestHeader();
 376         doReturn(svcRequestId).when(sdncRequestHeader).getSvcRequestId();
 377         doReturn(SdncRequestHeader.SvcAction.Activate).when(sdncRequestHeader).getSvcAction();
 378         ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
 379         doReturn(readOnlyTransaction).when(dataBroker).newReadOnlyTransaction();
 380         doReturn(checkedFuture).when(readOnlyTransaction).read(any(), any());
 381         WriteTransaction writeTransaction = mock(WriteTransaction.class);
 382         doReturn(writeTransaction).when(dataBroker).newWriteOnlyTransaction();
 383         doReturn(checkedFuture).when(writeTransaction).submit();
 384         doReturn(true).when(vnfsdnSvcLogicServiceClient).hasGraph(any(), any(), any(), any());
 385
 386         Future<RpcResult<VnfInstanceTopologyOperationOutput>> rpcResultFuture =
 387             vnfapiProvider.vnfInstanceTopologyOperation(vnfInstanceTopologyOperationInput);
 388
 389         Assert.assertEquals("200", rpcResultFuture.get().getResult().getResponseCode());
 390         Assert.assertEquals(null, rpcResultFuture.get().getResult().getResponseMessage());
 391         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 392     }
 393
 394     /**
 395      * Test Error case:
 396      * <p>
 397      * <code>input.getVfModuleTopologyInformation() == null</code>
 398      *
 399      * @throws Exception
 400      */
 401     @Test public void vfModuleTopologyOperationErrorOne() throws Exception {
 402         VfModuleTopologyOperationInput vfModuleTopologyOperationInput = mock(VfModuleTopologyOperationInput.class);
 403         doReturn(null).when(vfModuleTopologyOperationInput).getVfModuleRequestInformation();
 404         Future<RpcResult<VfModuleTopologyOperationOutput>> rpcResultFuture =
 405             vnfapiProvider.vfModuleTopologyOperation(vfModuleTopologyOperationInput);
 406
 407         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
 408         Assert.assertEquals("invalid input, null or empty vf-module-id",
 409             rpcResultFuture.get().getResult().getResponseMessage());
 410         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 411     }
 412
 413     /**
 414      * Test Error case:
 415      * <p>
 416      * <code>vfid = ""</code>
 417      * And
 418      * <p>
 419      * <code>viid = ""</code>
 420      *
 421      * @throws Exception
 422      */
 423     @Test public void vfModuleTopologyOperationErrorTwo() throws Exception {
 424         // vifd = ""
 425         vfModuleName = "vfModuleName";
 426         vfModuleModelId = "vfModuleModelId";
 427         vfModuleId = "";
 428         vnfInstanceId = "";
 429         VfModuleTopologyOperationInput vfModuleTopologyOperationInput = mock(VfModuleTopologyOperationInput.class);
 430         VfModuleRequestInformation vfModuleRequestInformation = mock(VfModuleRequestInformation.class);
 431         doReturn(vfModuleRequestInformation).when(vfModuleTopologyOperationInput).getVfModuleRequestInformation();
 432         VfModuleIdentifiers vfModuleIdentifiers = mock(VfModuleIdentifiers.class);
 433         doReturn(vfModuleName).when(vfModuleIdentifiers).getVfModuleName();
 434         doReturn(vfModuleModelId).when(vfModuleIdentifiers).getVfModuleModelId();
 435         doReturn(vfModuleId).when(vfModuleRequestInformation).getVfModuleId();
 436
 437         Future<RpcResult<VfModuleTopologyOperationOutput>> rpcResultFuture =
 438             vnfapiProvider.vfModuleTopologyOperation(vfModuleTopologyOperationInput);
 439
 440         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
 441         Assert.assertEquals("invalid input, null or empty vf-module-id",
 442             rpcResultFuture.get().getResult().getResponseMessage());
 443         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 444
 445         // viid = ""
 446         vfModuleId = "vfModuleId";
 447         doReturn(vfModuleId).when(vfModuleRequestInformation).getVfModuleId();
 448         doReturn(vnfInstanceId).when(vfModuleRequestInformation).getVnfInstanceId();
 449         rpcResultFuture = vnfapiProvider.vfModuleTopologyOperation(vfModuleTopologyOperationInput);
 450
 451         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
 452         Assert.assertEquals("invalid input, null or empty vnf-instance-id",
 453             rpcResultFuture.get().getResult().getResponseMessage());
 454         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 455     }
 456
 457     /**
 458      * Test Error case:
 459      * <p>
 460      * <code>svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync") = false</code>
 461      *
 462      * @throws Exception
 463      */
 464     @Test public void vfModuleTopologyOperationErrorThree() throws Exception {
 465         // vifd = ""
 466         vfModuleName = "vfModuleName";
 467         vfModuleModelId = "vfModuleModelId";
 468         vfModuleId = "vfModuleId";
 469         vnfInstanceId = "vnfInstanceId";
 470         VfModuleTopologyOperationInput vfModuleTopologyOperationInput = mock(VfModuleTopologyOperationInput.class);
 471         VfModuleRequestInformation vfModuleRequestInformation = mock(VfModuleRequestInformation.class);
 472         doReturn(vfModuleRequestInformation).when(vfModuleTopologyOperationInput).getVfModuleRequestInformation();
 473         VfModuleIdentifiers vfModuleIdentifiers = mock(VfModuleIdentifiers.class);
 474         doReturn(vfModuleName).when(vfModuleIdentifiers).getVfModuleName();
 475         doReturn(vfModuleModelId).when(vfModuleIdentifiers).getVfModuleModelId();
 476         doReturn(vfModuleId).when(vfModuleRequestInformation).getVfModuleId();
 477         doReturn(vnfInstanceId).when(vfModuleRequestInformation).getVnfInstanceId();
 478         // mock sdncRequestHeader
 479         SdncRequestHeader sdncRequestHeader = mock(SdncRequestHeader.class);
 480         doReturn(sdncRequestHeader).when(vfModuleTopologyOperationInput).getSdncRequestHeader();
 481         doReturn(svcRequestId).when(sdncRequestHeader).getSvcRequestId();
 482
 483         Future<RpcResult<VfModuleTopologyOperationOutput>> rpcResultFuture =
 484             vnfapiProvider.vfModuleTopologyOperation(vfModuleTopologyOperationInput);
 485
 486         Assert.assertEquals("503", rpcResultFuture.get().getResult().getResponseCode());
 487         Assert.assertTrue(
 488             rpcResultFuture.get().getResult().getResponseMessage().contains("No service logic active for VNF-API"));
 489         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 490     }
 491
 492     /**
 493      * Test Success case
 494      *
 495      * @throws Exception
 496      */
 497     @Test public void vfModuleTopologyOperationSuccess() throws Exception {
 498         vfModuleName = "vfModuleName";
 499         vfModuleModelId = "vfModuleModelId";
 500         vfModuleId = "vfModuleId";
 501         vnfInstanceId = "vnfInstanceId";
 502         VfModuleTopologyOperationInput vfModuleTopologyOperationInput = mock(VfModuleTopologyOperationInput.class);
 503         VfModuleRequestInformation vfModuleRequestInformation = mock(VfModuleRequestInformation.class);
 504         doReturn(vfModuleRequestInformation).when(vfModuleTopologyOperationInput).getVfModuleRequestInformation();
 505         VfModuleIdentifiers vfModuleIdentifiers = mock(VfModuleIdentifiers.class);
 506         doReturn(vfModuleName).when(vfModuleIdentifiers).getVfModuleName();
 507         doReturn(vfModuleModelId).when(vfModuleIdentifiers).getVfModuleModelId();
 508         doReturn(vfModuleId).when(vfModuleRequestInformation).getVfModuleId();
 509         doReturn(vnfInstanceId).when(vfModuleRequestInformation).getVnfInstanceId();
 510         // mock sdncRequestHeader
 511         SdncRequestHeader sdncRequestHeader = mock(SdncRequestHeader.class);
 512         doReturn(sdncRequestHeader).when(vfModuleTopologyOperationInput).getSdncRequestHeader();
 513         doReturn(svcRequestId).when(sdncRequestHeader).getSvcRequestId();
 514         doReturn(true).when(vnfsdnSvcLogicServiceClient).hasGraph(any(), any(), any(), any());
 515
 516         Future<RpcResult<VfModuleTopologyOperationOutput>> rpcResultFuture =
 517             vnfapiProvider.vfModuleTopologyOperation(vfModuleTopologyOperationInput);
 518
 519         Assert.assertEquals("200", rpcResultFuture.get().getResult().getResponseCode());
 520         Assert.assertEquals(null, rpcResultFuture.get().getResult().getResponseMessage());
 521         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 522     }
 523
 524     /**
 525      * Test Error case:
 526      * <p>
 527      * <code>input.getServiceInformation() == null</code>
 528      *
 529      * @throws Exception
 530      */
 531     @Test public void vnfTopologyOperationErrorOne() throws Exception {
 532         VnfTopologyOperationInput vnfTopologyOperationInput = mock(VnfTopologyOperationInput.class);
 533         doReturn(null).when(vnfTopologyOperationInput).getServiceInformation();
 534
 535         Future<RpcResult<VnfTopologyOperationOutput>> rpcResultFuture =
 536             vnfapiProvider.vnfTopologyOperation(vnfTopologyOperationInput);
 537
 538         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
 539         Assert.assertEquals("invalid input, null or empty service-instance-id",
 540             rpcResultFuture.get().getResult().getResponseMessage());
 541         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 542     }
 543
 544     /**
 545      * Test Error case:
 546      * <p>
 547      * <code>input.getVnfRequestInformation() == null</code>
 548      *
 549      * @throws Exception
 550      */
 551     @Test public void vnfTopologyOperationErrorTwo() throws Exception {
 552         serviceInstanceId = "serviceInstanceId";
 553         VnfTopologyOperationInput vnfTopologyOperationInput = mock(VnfTopologyOperationInput.class);
 554         ServiceInformation serviceInformation = mock(ServiceInformation.class);
 555         doReturn(serviceInformation).when(vnfTopologyOperationInput).getServiceInformation();
 556         doReturn(serviceInstanceId).when(serviceInformation).getServiceInstanceId();
 557
 558         Future<RpcResult<VnfTopologyOperationOutput>> rpcResultFuture =
 559             vnfapiProvider.vnfTopologyOperation(vnfTopologyOperationInput);
 560
 561         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
 562         Assert.assertEquals("invalid input, null or empty vf-module-id",
 563             rpcResultFuture.get().getResult().getResponseMessage());
 564         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 565     }
 566
 567     /**
 568      * Test Error case:
 569      * <p>
 570      * <code>svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync") == false</code>
 571      *
 572      * @throws Exception
 573      */
 574     @Test public void vnfTopologyOperationErrorThree() throws Exception {
 575         serviceInstanceId = "serviceInstanceId";
 576         String vnfId = "vnfId";
 577         VnfTopologyOperationInput vnfTopologyOperationInput = mock(VnfTopologyOperationInput.class);
 578         ServiceInformation serviceInformation = mock(ServiceInformation.class);
 579         doReturn(serviceInformation).when(vnfTopologyOperationInput).getServiceInformation();
 580         doReturn(serviceInstanceId).when(serviceInformation).getServiceInstanceId();
 581
 582         VnfRequestInformation vnfRequestInformation = mock(VnfRequestInformation.class);
 583         doReturn(vnfRequestInformation).when(vnfTopologyOperationInput).getVnfRequestInformation();
 584         doReturn(vnfId).when(vnfRequestInformation).getVnfId();
 585
 586         Future<RpcResult<VnfTopologyOperationOutput>> rpcResultFuture =
 587             vnfapiProvider.vnfTopologyOperation(vnfTopologyOperationInput);
 588
 589         Assert.assertEquals("503", rpcResultFuture.get().getResult().getResponseCode());
 590         Assert.assertTrue(
 591             rpcResultFuture.get().getResult().getResponseMessage().contains("No service logic active for VNF-API"));
 592         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 593     }
 594
 595     /**
 596      * Test Success case
 597      *
 598      * @throws Exception
 599      */
 600     @Test public void vnfTopologyOperationSuccess() throws Exception {
 601         serviceInstanceId = "serviceInstanceId";
 602         String vnfId = "vnfId";
 603         VnfTopologyOperationInput vnfTopologyOperationInput = mock(VnfTopologyOperationInput.class);
 604         ServiceInformation serviceInformation = mock(ServiceInformation.class);
 605         doReturn(serviceInformation).when(vnfTopologyOperationInput).getServiceInformation();
 606         doReturn(serviceInstanceId).when(serviceInformation).getServiceInstanceId();
 607
 608         VnfRequestInformation vnfRequestInformation = mock(VnfRequestInformation.class);
 609         doReturn(vnfRequestInformation).when(vnfTopologyOperationInput).getVnfRequestInformation();
 610         doReturn(vnfId).when(vnfRequestInformation).getVnfId();
 611         doReturn(true).when(vnfsdnSvcLogicServiceClient).hasGraph(any(), any(), any(), any());
 612
 613         Future<RpcResult<VnfTopologyOperationOutput>> rpcResultFuture =
 614             vnfapiProvider.vnfTopologyOperation(vnfTopologyOperationInput);
 615
 616         Assert.assertEquals("200", rpcResultFuture.get().getResult().getResponseCode());
 617         Assert.assertEquals(null, rpcResultFuture.get().getResult().getResponseMessage());
 618         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 619     }
 620
 621     /**
 622      * Test Error case:
 623      * <p>
 624      * <code>input.getServiceInformation() == null</code>
 625      *
 626      * @throws Exception
 627      */
 628     @Test public void networkTopologyOperationErrorOne() throws Exception {
 629         VnfTopologyOperationInput vnfTopologyOperationInput = mock(VnfTopologyOperationInput.class);
 630         doReturn(null).when(vnfTopologyOperationInput).getServiceInformation();
 631
 632         Future<RpcResult<VnfTopologyOperationOutput>> rpcResultFuture =
 633             vnfapiProvider.vnfTopologyOperation(vnfTopologyOperationInput);
 634
 635         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
 636         Assert.assertEquals("invalid input, null or empty service-instance-id",
 637             rpcResultFuture.get().getResult().getResponseMessage());
 638         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 639     }
 640
 641     /**
 642      * Test Error case:
 643      * <p>
 644      * <code>input.getNetworkRequestInformation() == null</code>
 645      *
 646      * @throws Exception
 647      */
 648     @Test public void networkTopologyOperationErrorTwo() throws Exception {
 649         serviceInstanceId = "serviceInstanceId";
 650         NetworkTopologyOperationInput networkTopologyOperation = mock(NetworkTopologyOperationInput.class);
 651         ServiceInformation serviceInformation = mock(ServiceInformation.class);
 652         doReturn(serviceInstanceId).when(serviceInformation).getServiceInstanceId();
 653         doReturn(serviceInformation).when(networkTopologyOperation).getServiceInformation();
 654
 655         Future<RpcResult<NetworkTopologyOperationOutput>> rpcResultFuture =
 656             vnfapiProvider.networkTopologyOperation(networkTopologyOperation);
 657
 658         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
 659         Assert.assertEquals("invalid input, null or empty service-instance-id",
 660             rpcResultFuture.get().getResult().getResponseMessage());
 661         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 662     }
 663
 664     /**
 665      * Test Error case:
 666      * <p>
 667      * <code>svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync") == false</code>
 668      *
 669      * @throws Exception
 670      */
 671     @Test public void networkTopologyOperationErrorThree() throws Exception {
 672         serviceInstanceId = "serviceInstanceId";
 673         NetworkTopologyOperationInput networkTopologyOperationInput = mock(NetworkTopologyOperationInput.class);
 674         ServiceInformation serviceInformation = mock(ServiceInformation.class);
 675         doReturn(serviceInstanceId).when(serviceInformation).getServiceInstanceId();
 676         doReturn(serviceInformation).when(networkTopologyOperationInput).getServiceInformation();
 677
 678         NetworkRequestInformation networkRequestInformation = mock(NetworkRequestInformation.class);
 679         doReturn(networkRequestInformation).when(networkTopologyOperationInput).getNetworkRequestInformation();
 680         doReturn("NetworkName").when(networkRequestInformation).getNetworkName();
 681
 682         SdncRequestHeader sdncRequestHeader = mock(SdncRequestHeader.class);
 683         doReturn(SdncRequestHeader.SvcAction.Assign).when(sdncRequestHeader).getSvcAction();
 684         doReturn(sdncRequestHeader).when(networkTopologyOperationInput).getSdncRequestHeader();
 685
 686         Future<RpcResult<NetworkTopologyOperationOutput>> rpcResultFuture =
 687             vnfapiProvider.networkTopologyOperation(networkTopologyOperationInput);
 688
 689         Assert.assertEquals("503", rpcResultFuture.get().getResult().getResponseCode());
 690         Assert.assertTrue(
 691             rpcResultFuture.get().getResult().getResponseMessage().contains("No service logic active for VNF-API"));
 692         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 693     }
 694
 695     /**
 696      * Test Success case
 697      *
 698      * @throws Exception
 699      */
 700     @Test public void networkTopologyOperationSuccess() throws Exception {
 701         serviceInstanceId = "serviceInstanceId";
 702         NetworkTopologyOperationInput networkTopologyOperationInput = mock(NetworkTopologyOperationInput.class);
 703         ServiceInformation serviceInformation = mock(ServiceInformation.class);
 704         doReturn(serviceInstanceId).when(serviceInformation).getServiceInstanceId();
 705         doReturn(serviceInformation).when(networkTopologyOperationInput).getServiceInformation();
 706         //mock networkRequestInformation
 707         NetworkRequestInformation networkRequestInformation = mock(NetworkRequestInformation.class);
 708         doReturn(networkRequestInformation).when(networkTopologyOperationInput).getNetworkRequestInformation();
 709         doReturn("NetworkName").when(networkRequestInformation).getNetworkName();
 710         //mock sdncRequestHeader
 711         SdncRequestHeader sdncRequestHeader = mock(SdncRequestHeader.class);
 712         doReturn(SdncRequestHeader.SvcAction.Assign).when(sdncRequestHeader).getSvcAction();
 713         doReturn(sdncRequestHeader).when(networkTopologyOperationInput).getSdncRequestHeader();
 714         doReturn(true).when(vnfsdnSvcLogicServiceClient).hasGraph(any(), any(), any(), any());
 715
 716         Future<RpcResult<NetworkTopologyOperationOutput>> rpcResultFuture =
 717             vnfapiProvider.networkTopologyOperation(networkTopologyOperationInput);
 718
 719         Assert.assertEquals("200", rpcResultFuture.get().getResult().getResponseCode());
 720         Assert.assertEquals(null, rpcResultFuture.get().getResult().getResponseMessage());
 721         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 722     }
 723
 724     /**
 725      * Test Error case:
 726      * <p>
 727      * <code>input.getVnfTopologyInformation() == null</code>
 728      *
 729      * @throws Exception
 730      */
 731     @Test public void preloadVnfTopologyOperationErrorOne() throws Exception {
 732         PreloadVnfTopologyOperationInput preloadVnfTopologyOperationInput =
 733             mock(PreloadVnfTopologyOperationInput.class);
 734         doReturn(null).when(preloadVnfTopologyOperationInput).getVnfTopologyInformation();
 735
 736         Future<RpcResult<PreloadVnfTopologyOperationOutput>> rpcResultFuture =
 737             vnfapiProvider.preloadVnfTopologyOperation(preloadVnfTopologyOperationInput);
 738
 739         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
 740         Assert.assertEquals("invalid input, null or empty vnf-name or vnf-type",
 741             rpcResultFuture.get().getResult().getResponseMessage());
 742         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 743     }
 744
 745     /**
 746      * Test Error case:
 747      * <p>
 748      * <code>preload_name.length() == 0</code>
 749      * And
 750      * <code>preload_type.length() == 0</code>
 751      *
 752      * @throws Exception
 753      */
 754     @Test public void preloadVnfTopologyOperationErrorTwo() throws Exception {
 755         // preload_name.length() == 0
 756         vnfName = "";
 757         vnfType = "vfModuleModelId";
 758         PreloadVnfTopologyOperationInput preloadVnfTopologyOperationInput =
 759             mock(PreloadVnfTopologyOperationInput.class);
 760         doReturn(null).when(preloadVnfTopologyOperationInput).getVnfTopologyInformation();
 761
 762         VnfTopologyInformation vnfTopologyInformation = mock(VnfTopologyInformation.class);
 763         doReturn(vnfTopologyInformation).when(preloadVnfTopologyOperationInput).getVnfTopologyInformation();
 764         VnfTopologyIdentifier vnfTopologyIdentifier = mock(VnfTopologyIdentifier.class);
 765         doReturn(vnfName).when(vnfTopologyIdentifier).getVnfName();
 766         doReturn(vnfType).when(vnfTopologyIdentifier).getVnfType();
 767         doReturn(vnfTopologyIdentifier).when(vnfTopologyInformation).getVnfTopologyIdentifier();
 768
 769         Future<RpcResult<PreloadVnfTopologyOperationOutput>> rpcResultFuture =
 770             vnfapiProvider.preloadVnfTopologyOperation(preloadVnfTopologyOperationInput);
 771
 772         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
 773         Assert.assertEquals("invalid input, invalid preload-name",
 774             rpcResultFuture.get().getResult().getResponseMessage());
 775         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 776
 777         // preload_type.length() == 0
 778         vnfName = "vnfName";
 779         vnfType = "";
 780         doReturn(vnfName).when(vnfTopologyIdentifier).getVnfName();
 781         doReturn(vnfType).when(vnfTopologyIdentifier).getVnfType();
 782
 783         rpcResultFuture = vnfapiProvider.preloadVnfTopologyOperation(preloadVnfTopologyOperationInput);
 784
 785         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
 786         Assert.assertEquals("invalid input, invalid preload-type",
 787             rpcResultFuture.get().getResult().getResponseMessage());
 788         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 789     }
 790
 791     /**
 792      * Test Error case:
 793      * <code>svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync") = false</code>
 794      *
 795      * @throws Exception
 796      */
 797     @Test public void preloadVnfTopologyOperationErrorThree() throws Exception {
 798         // preload_name.length() == 0
 799         vnfName = "vnfName";
 800         vnfType = "vfModuleModelId";
 801         PreloadVnfTopologyOperationInput preloadVnfTopologyOperationInput =
 802             mock(PreloadVnfTopologyOperationInput.class);
 803         doReturn(null).when(preloadVnfTopologyOperationInput).getVnfTopologyInformation();
 804
 805         VnfTopologyInformation vnfTopologyInformation = mock(VnfTopologyInformation.class);
 806         doReturn(vnfTopologyInformation).when(preloadVnfTopologyOperationInput).getVnfTopologyInformation();
 807         VnfTopologyIdentifier vnfTopologyIdentifier = mock(VnfTopologyIdentifier.class);
 808         doReturn(vnfName).when(vnfTopologyIdentifier).getVnfName();
 809         doReturn(vnfType).when(vnfTopologyIdentifier).getVnfType();
 810         doReturn(vnfTopologyIdentifier).when(vnfTopologyInformation).getVnfTopologyIdentifier();
 811
 812         Future<RpcResult<PreloadVnfTopologyOperationOutput>> rpcResultFuture =
 813             vnfapiProvider.preloadVnfTopologyOperation(preloadVnfTopologyOperationInput);
 814
 815         Assert.assertEquals("503", rpcResultFuture.get().getResult().getResponseCode());
 816         Assert.assertTrue(
 817             rpcResultFuture.get().getResult().getResponseMessage().contains("No service logic active for VNF-API"));
 818         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 819     }
 820
 821     /**
 822      * Test Success case
 823      *
 824      * @throws Exception
 825      */
 826     @Test public void preloadVnfTopologyOperationSuccess() throws Exception {
 827         // preload_name.length() == 0
 828         vnfName = "vnfName";
 829         vnfType = "vfModuleModelId";
 830         PreloadVnfTopologyOperationInput preloadVnfTopologyOperationInput =
 831             mock(PreloadVnfTopologyOperationInput.class);
 832         doReturn(null).when(preloadVnfTopologyOperationInput).getVnfTopologyInformation();
 833
 834         VnfTopologyInformation vnfTopologyInformation = mock(VnfTopologyInformation.class);
 835         doReturn(vnfTopologyInformation).when(preloadVnfTopologyOperationInput).getVnfTopologyInformation();
 836         VnfTopologyIdentifier vnfTopologyIdentifier = mock(VnfTopologyIdentifier.class);
 837         doReturn(vnfName).when(vnfTopologyIdentifier).getVnfName();
 838         doReturn(vnfType).when(vnfTopologyIdentifier).getVnfType();
 839         doReturn(vnfTopologyIdentifier).when(vnfTopologyInformation).getVnfTopologyIdentifier();
 840         doReturn(true).when(vnfsdnSvcLogicServiceClient).hasGraph(any(), any(), any(), any());
 841
 842         Future<RpcResult<PreloadVnfTopologyOperationOutput>> rpcResultFuture =
 843             vnfapiProvider.preloadVnfTopologyOperation(preloadVnfTopologyOperationInput);
 844
 845         Assert.assertEquals("200", rpcResultFuture.get().getResult().getResponseCode());
 846         Assert.assertEquals(null, rpcResultFuture.get().getResult().getResponseMessage());
 847         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 848     }
 849
 850     /**
 851      * Test Error case:
 852      * <p>
 853      * <code>input.getVnfInstanceTopologyInformation() == null</code>
 854      *
 855      * @throws Exception
 856      */
 857     @Test public void preloadVnfInstanceTopologyOperationErrorOne() throws Exception {
 858         PreloadVnfInstanceTopologyOperationInput preloadVnfInstanceTopologyOperationInput =
 859             mock(PreloadVnfInstanceTopologyOperationInput.class);
 860         doReturn(null).when(preloadVnfInstanceTopologyOperationInput).getVnfInstanceTopologyInformation();
 861         Future<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> rpcResultFuture =
 862             vnfapiProvider.preloadVnfInstanceTopologyOperation(preloadVnfInstanceTopologyOperationInput);
 863
 864         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
 865         Assert.assertEquals("invalid input, null or empty vnf-instance-name or vnf-model-id",
 866             rpcResultFuture.get().getResult().getResponseMessage());
 867         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 868     }
 869
 870     /**
 871      * Test Error case:
 872      * <p>
 873      * <code>preload_name = ""</code>
 874      * And
 875      * <code>preload_type = ""</code>
 876      *
 877      * @throws Exception
 878      */
 879     @Test public void preloadVnfInstanceTopologyOperationErrorTwo() throws Exception {
 880         // preload_type = ""
 881         vnfInstanceName = "vnfInstanceName";
 882         vnfModelId = "";
 883         PreloadVnfInstanceTopologyOperationInput preloadVnfInstanceTopologyOperationInput =
 884             mock(PreloadVnfInstanceTopologyOperationInput.class);
 885         VnfInstanceTopologyInformation vnfInstanceTopologyInformation = mock(VnfInstanceTopologyInformation.class);
 886         doReturn(vnfInstanceTopologyInformation).when(preloadVnfInstanceTopologyOperationInput)
 887             .getVnfInstanceTopologyInformation();
 888         VnfInstanceIdentifiers vnfInstanceIdentifiers = mock(VnfInstanceIdentifiers.class);
 889         doReturn(vnfInstanceName).when(vnfInstanceIdentifiers).getVnfInstanceName();
 890         doReturn(vnfModelId).when(vnfInstanceIdentifiers).getVnfModelId();
 891         doReturn(vnfInstanceIdentifiers).when(vnfInstanceTopologyInformation).getVnfInstanceIdentifiers();
 892
 893         Future<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> rpcResultFuture =
 894             vnfapiProvider.preloadVnfInstanceTopologyOperation(preloadVnfInstanceTopologyOperationInput);
 895
 896         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
 897         Assert.assertEquals("invalid input, invalid preload-type",
 898             rpcResultFuture.get().getResult().getResponseMessage());
 899         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 900
 901         //preload_name == ""
 902         vnfInstanceName = "";
 903         vnfModelId = "vnfModelId";
 904         doReturn(vnfInstanceName).when(vnfInstanceIdentifiers).getVnfInstanceName();
 905         doReturn(vnfModelId).when(vnfInstanceIdentifiers).getVnfModelId();
 906
 907         rpcResultFuture = vnfapiProvider.preloadVnfInstanceTopologyOperation(preloadVnfInstanceTopologyOperationInput);
 908
 909         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
 910         Assert.assertEquals("invalid input, invalid preload-name",
 911             rpcResultFuture.get().getResult().getResponseMessage());
 912         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 913     }
 914
 915     /**
 916      * Test Error case:
 917      * <p>
 918      * <code>svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync") = false</code>
 919      *
 920      * @throws Exception
 921      */
 922     @Test public void preloadVnfInstanceTopologyOperationErrorThree() throws Exception {
 923         // preload_type = ""
 924         vnfInstanceName = "vnfInstanceName";
 925         vnfModelId = "vnfModelId";
 926         PreloadVnfInstanceTopologyOperationInput preloadVnfInstanceTopologyOperationInput =
 927             mock(PreloadVnfInstanceTopologyOperationInput.class);
 928         VnfInstanceTopologyInformation vnfInstanceTopologyInformation = mock(VnfInstanceTopologyInformation.class);
 929         doReturn(vnfInstanceTopologyInformation).when(preloadVnfInstanceTopologyOperationInput)
 930             .getVnfInstanceTopologyInformation();
 931         VnfInstanceIdentifiers vnfInstanceIdentifiers = mock(VnfInstanceIdentifiers.class);
 932         doReturn(vnfInstanceName).when(vnfInstanceIdentifiers).getVnfInstanceName();
 933         doReturn(vnfModelId).when(vnfInstanceIdentifiers).getVnfModelId();
 934         doReturn(vnfInstanceIdentifiers).when(vnfInstanceTopologyInformation).getVnfInstanceIdentifiers();
 935         SdncRequestHeader sdncRequestHeader = mock(SdncRequestHeader.class);
 936         doReturn(sdncRequestHeader).when(preloadVnfInstanceTopologyOperationInput).getSdncRequestHeader();
 937         doReturn(svcRequestId).when(sdncRequestHeader).getSvcRequestId();
 938
 939         Future<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> rpcResultFuture =
 940             vnfapiProvider.preloadVnfInstanceTopologyOperation(preloadVnfInstanceTopologyOperationInput);
 941
 942         Assert.assertEquals("503", rpcResultFuture.get().getResult().getResponseCode());
 943         Assert.assertTrue(
 944             rpcResultFuture.get().getResult().getResponseMessage().contains("No service logic active for VNF-API"));
 945         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 946     }
 947
 948     /**
 949      * Test Success case
 950      *
 951      * @throws Exception
 952      */
 953     @Test public void preloadVnfInstanceTopologyOperationSuccess() throws Exception {
 954         // preload_type = ""
 955         vnfInstanceName = "vnfInstanceName";
 956         vnfModelId = "vnfModelId";
 957         PreloadVnfInstanceTopologyOperationInput preloadVnfInstanceTopologyOperationInput =
 958             mock(PreloadVnfInstanceTopologyOperationInput.class);
 959         VnfInstanceTopologyInformation vnfInstanceTopologyInformation = mock(VnfInstanceTopologyInformation.class);
 960         doReturn(vnfInstanceTopologyInformation).when(preloadVnfInstanceTopologyOperationInput)
 961             .getVnfInstanceTopologyInformation();
 962         VnfInstanceIdentifiers vnfInstanceIdentifiers = mock(VnfInstanceIdentifiers.class);
 963         doReturn(vnfInstanceName).when(vnfInstanceIdentifiers).getVnfInstanceName();
 964         doReturn(vnfModelId).when(vnfInstanceIdentifiers).getVnfModelId();
 965         doReturn(vnfInstanceIdentifiers).when(vnfInstanceTopologyInformation).getVnfInstanceIdentifiers();
 966         SdncRequestHeader sdncRequestHeader = mock(SdncRequestHeader.class);
 967         doReturn(sdncRequestHeader).when(preloadVnfInstanceTopologyOperationInput).getSdncRequestHeader();
 968         doReturn(svcRequestId).when(sdncRequestHeader).getSvcRequestId();
 969         doReturn(true).when(vnfsdnSvcLogicServiceClient).hasGraph(any(), any(), any(), any());
 970
 971         Future<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> rpcResultFuture =
 972             vnfapiProvider.preloadVnfInstanceTopologyOperation(preloadVnfInstanceTopologyOperationInput);
 973
 974         Assert.assertEquals("200", rpcResultFuture.get().getResult().getResponseCode());
 975         Assert.assertEquals(null, rpcResultFuture.get().getResult().getResponseMessage());
 976         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 977     }
 978
 979     /**
 980      * Test Error case:
 981      * <p>
 982      * <code>input.getVfModuleTopologyInformation() == null</code>
 983      *
 984      * @throws Exception
 985      */
 986     @Test public void preloadVfModuleTopologyOperationErrorOne() throws Exception {
 987         PreloadVfModuleTopologyOperationInput preloadVnfTopologyOperationInput =
 988             mock(PreloadVfModuleTopologyOperationInput.class);
 989         doReturn(null).when(preloadVnfTopologyOperationInput).getVfModuleTopologyInformation();
 990
 991         Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> rpcResultFuture =
 992             vnfapiProvider.preloadVfModuleTopologyOperation(preloadVnfTopologyOperationInput);
 993
 994         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
 995         Assert.assertEquals("invalid input, null or empty vf-module-name or vf-module-model-id",
 996             rpcResultFuture.get().getResult().getResponseMessage());
 997         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
 998     }
 999
1000     /**
1001      * Test Error case:
1002      * <p>
1003      * <code>preload_name = ""</code>
1004      * And
1005      * <code>preload_type = ""</code>
1006      *
1007      * @throws Exception
1008      */
1009     @Test public void preloadVfModuleTopologyOperationErrorTwo() throws Exception {
1010         // preload_name = ""
1011         vfModuleName = "";
1012         vfModuleModelId = "vfModuleModelId";
1013         PreloadVfModuleTopologyOperationInput preloadVnfTopologyOperationInput =
1014             mock(PreloadVfModuleTopologyOperationInput.class);
1015         VfModuleTopologyInformation vfModuleTopologyInformation = mock(VfModuleTopologyInformation.class);
1016         doReturn(vfModuleTopologyInformation).when(preloadVnfTopologyOperationInput).getVfModuleTopologyInformation();
1017         VfModuleIdentifiers vfModuleIdentifiers = mock(VfModuleIdentifiers.class);
1018         doReturn(vfModuleName).when(vfModuleIdentifiers).getVfModuleName();
1019         doReturn(vfModuleModelId).when(vfModuleIdentifiers).getVfModuleModelId();
1020         doReturn(vfModuleIdentifiers).when(vfModuleTopologyInformation).getVfModuleIdentifiers();
1021
1022         Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> rpcResultFuture =
1023             vnfapiProvider.preloadVfModuleTopologyOperation(preloadVnfTopologyOperationInput);
1024
1025         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
1026         Assert.assertEquals("invalid input, invalid preload-name",
1027             rpcResultFuture.get().getResult().getResponseMessage());
1028         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
1029
1030         // preload_type = ""
1031         vfModuleName = "vfModuleName";
1032         vfModuleModelId = "";
1033         doReturn(vfModuleName).when(vfModuleIdentifiers).getVfModuleName();
1034         doReturn(vfModuleModelId).when(vfModuleIdentifiers).getVfModuleModelId();
1035
1036         rpcResultFuture = vnfapiProvider.preloadVfModuleTopologyOperation(preloadVnfTopologyOperationInput);
1037
1038         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
1039         Assert.assertEquals("invalid input, invalid preload-type",
1040             rpcResultFuture.get().getResult().getResponseMessage());
1041         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
1042     }
1043
1044     /**
1045      * Test Error case:
1046      * <p>
1047      * <code>svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync") = false</code>
1048      *
1049      * @throws Exception
1050      */
1051     @Test public void preloadVfModuleTopologyOperationErrorThree() throws Exception {
1052         // preload_name = ""
1053         vfModuleName = "vfModuleName";
1054         vfModuleModelId = "vfModuleModelId";
1055         PreloadVfModuleTopologyOperationInput preloadVnfTopologyOperationInput =
1056             mock(PreloadVfModuleTopologyOperationInput.class);
1057         VfModuleTopologyInformation vfModuleTopologyInformation = mock(VfModuleTopologyInformation.class);
1058         doReturn(vfModuleTopologyInformation).when(preloadVnfTopologyOperationInput).getVfModuleTopologyInformation();
1059         VfModuleIdentifiers vfModuleIdentifiers = mock(VfModuleIdentifiers.class);
1060         doReturn(vfModuleName).when(vfModuleIdentifiers).getVfModuleName();
1061         doReturn(vfModuleModelId).when(vfModuleIdentifiers).getVfModuleModelId();
1062         doReturn(vfModuleIdentifiers).when(vfModuleTopologyInformation).getVfModuleIdentifiers();
1063         SdncRequestHeader sdncRequestHeader = mock(SdncRequestHeader.class);
1064         doReturn(sdncRequestHeader).when(preloadVnfTopologyOperationInput).getSdncRequestHeader();
1065         doReturn(svcRequestId).when(sdncRequestHeader).getSvcRequestId();
1066
1067         Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> rpcResultFuture =
1068             vnfapiProvider.preloadVfModuleTopologyOperation(preloadVnfTopologyOperationInput);
1069
1070         Assert.assertEquals("503", rpcResultFuture.get().getResult().getResponseCode());
1071         Assert.assertTrue(
1072             rpcResultFuture.get().getResult().getResponseMessage().contains("No service logic active for VNF-API"));
1073         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
1074     }
1075
1076     /**
1077      * Test Success case
1078      *
1079      * @throws Exception
1080      */
1081     @Test public void preloadVfModuleTopologyOperationSuccess() throws Exception {
1082         // preload_name = ""
1083         vfModuleName = "vfModuleName";
1084         vfModuleModelId = "vfModuleModelId";
1085         PreloadVfModuleTopologyOperationInput preloadVnfTopologyOperationInput =
1086             mock(PreloadVfModuleTopologyOperationInput.class);
1087         VfModuleTopologyInformation vfModuleTopologyInformation = mock(VfModuleTopologyInformation.class);
1088         doReturn(vfModuleTopologyInformation).when(preloadVnfTopologyOperationInput).getVfModuleTopologyInformation();
1089         VfModuleIdentifiers vfModuleIdentifiers = mock(VfModuleIdentifiers.class);
1090         doReturn(vfModuleName).when(vfModuleIdentifiers).getVfModuleName();
1091         doReturn(vfModuleModelId).when(vfModuleIdentifiers).getVfModuleModelId();
1092         doReturn(vfModuleIdentifiers).when(vfModuleTopologyInformation).getVfModuleIdentifiers();
1093         SdncRequestHeader sdncRequestHeader = mock(SdncRequestHeader.class);
1094         doReturn(sdncRequestHeader).when(preloadVnfTopologyOperationInput).getSdncRequestHeader();
1095         doReturn(svcRequestId).when(sdncRequestHeader).getSvcRequestId();
1096         doReturn(true).when(vnfsdnSvcLogicServiceClient).hasGraph(any(), any(), any(), any());
1097
1098         Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> rpcResultFuture =
1099             vnfapiProvider.preloadVfModuleTopologyOperation(preloadVnfTopologyOperationInput);
1100
1101         Assert.assertEquals("200", rpcResultFuture.get().getResult().getResponseCode());
1102         Assert.assertEquals(null, rpcResultFuture.get().getResult().getResponseMessage());
1103         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
1104     }
1105
1106     /**
1107      * Test Error case:
1108      * <p>
1109      * <code>input.getNetworkTopologyInformation() == null</code>
1110      *
1111      * @throws Exception
1112      */
1113     @Test public void preloadNetworkTopologyOperationErrorOne() throws Exception {
1114         PreloadNetworkTopologyOperationInput PreloadNetworkTopologyOperationInput =
1115             mock(PreloadNetworkTopologyOperationInput.class);
1116         doReturn(null).when(PreloadNetworkTopologyOperationInput).getNetworkTopologyInformation();
1117
1118         Future<RpcResult<PreloadNetworkTopologyOperationOutput>> rpcResultFuture =
1119             vnfapiProvider.preloadNetworkTopologyOperation(PreloadNetworkTopologyOperationInput);
1120
1121         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
1122         Assert.assertEquals("input, null or empty network-name or network-type",
1123             rpcResultFuture.get().getResult().getResponseMessage());
1124         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
1125     }
1126
1127     /**
1128      * Test Error case:
1129      * <p>
1130      * <code>preload_name == ""</code>
1131      * ANd
1132      * <code>preload_type == ""ss</code>
1133      *
1134      * @throws Exception
1135      */
1136     @Test public void preloadNetworkTopologyOperationErrorTwo() throws Exception {
1137         String networkName = "";
1138         String networkType = "NetworkType";
1139         PreloadNetworkTopologyOperationInput PreloadNetworkTopologyOperationInput =
1140             mock(PreloadNetworkTopologyOperationInput.class);
1141         NetworkTopologyInformation networkTopologyInformation = mock(NetworkTopologyInformation.class);
1142         doReturn(networkTopologyInformation).when(PreloadNetworkTopologyOperationInput).getNetworkTopologyInformation();
1143         NetworkTopologyIdentifier networkTopologyIdentifier = mock(NetworkTopologyIdentifier.class);
1144         doReturn(networkTopologyIdentifier).when(networkTopologyInformation).getNetworkTopologyIdentifier();
1145         doReturn(networkName).when(networkTopologyIdentifier).getNetworkName();
1146         doReturn(networkType).when(networkTopologyIdentifier).getNetworkType();
1147
1148         Future<RpcResult<PreloadNetworkTopologyOperationOutput>> rpcResultFuture =
1149             vnfapiProvider.preloadNetworkTopologyOperation(PreloadNetworkTopologyOperationInput);
1150
1151         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
1152         Assert.assertEquals("input, invalid preload-name", rpcResultFuture.get().getResult().getResponseMessage());
1153         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
1154
1155         networkName = "NetworkName";
1156         networkType = "";
1157         doReturn(networkName).when(networkTopologyIdentifier).getNetworkName();
1158         doReturn(networkType).when(networkTopologyIdentifier).getNetworkType();
1159
1160         rpcResultFuture = vnfapiProvider.preloadNetworkTopologyOperation(PreloadNetworkTopologyOperationInput);
1161
1162         Assert.assertEquals("403", rpcResultFuture.get().getResult().getResponseCode());
1163         Assert.assertEquals("input, invalid preload-type", rpcResultFuture.get().getResult().getResponseMessage());
1164         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
1165     }
1166
1167     /**
1168      * Test Error case:
1169      * <p>
1170      * <code>svcLogicClient.hasGraph("VNF-API",SVC_OPERATION,null,"sync" = false</code>
1171      *
1172      * @throws Exception
1173      */
1174     @Test public void preloadNetworkTopologyOperationErrorThree() throws Exception {
1175         String networkName = "NetworkName";
1176         String networkType = "NetworkType";
1177         PreloadNetworkTopologyOperationInput PreloadNetworkTopologyOperationInput =
1178             mock(PreloadNetworkTopologyOperationInput.class);
1179         NetworkTopologyInformation networkTopologyInformation = mock(NetworkTopologyInformation.class);
1180         doReturn(networkTopologyInformation).when(PreloadNetworkTopologyOperationInput).getNetworkTopologyInformation();
1181         NetworkTopologyIdentifier networkTopologyIdentifier = mock(NetworkTopologyIdentifier.class);
1182         doReturn(networkTopologyIdentifier).when(networkTopologyInformation).getNetworkTopologyIdentifier();
1183         doReturn(networkName).when(networkTopologyIdentifier).getNetworkName();
1184         doReturn(networkType).when(networkTopologyIdentifier).getNetworkType();
1185         SdncRequestHeader sdncRequestHeader = mock(SdncRequestHeader.class);
1186         doReturn(sdncRequestHeader).when(PreloadNetworkTopologyOperationInput).getSdncRequestHeader();
1187         doReturn(svcRequestId).when(sdncRequestHeader).getSvcRequestId();
1188
1189         Future<RpcResult<PreloadNetworkTopologyOperationOutput>> rpcResultFuture =
1190             vnfapiProvider.preloadNetworkTopologyOperation(PreloadNetworkTopologyOperationInput);
1191
1192         Assert.assertEquals("503", rpcResultFuture.get().getResult().getResponseCode());
1193         Assert.assertTrue(
1194             rpcResultFuture.get().getResult().getResponseMessage().contains("No service logic active for VNF-API"));
1195         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
1196     }
1197
1198     /**
1199      * Test Success case
1200      *
1201      * @throws Exception
1202      */
1203     @Test public void preloadNetworkTopologyOperationErrorFour() throws Exception {
1204         String networkName = "NetworkName";
1205         String networkType = "NetworkType";
1206         PreloadNetworkTopologyOperationInput PreloadNetworkTopologyOperationInput =
1207             mock(PreloadNetworkTopologyOperationInput.class);
1208         NetworkTopologyInformation networkTopologyInformation = mock(NetworkTopologyInformation.class);
1209         doReturn(networkTopologyInformation).when(PreloadNetworkTopologyOperationInput).getNetworkTopologyInformation();
1210         NetworkTopologyIdentifier networkTopologyIdentifier = mock(NetworkTopologyIdentifier.class);
1211         doReturn(networkTopologyIdentifier).when(networkTopologyInformation).getNetworkTopologyIdentifier();
1212         doReturn(networkName).when(networkTopologyIdentifier).getNetworkName();
1213         doReturn(networkType).when(networkTopologyIdentifier).getNetworkType();
1214         SdncRequestHeader sdncRequestHeader = mock(SdncRequestHeader.class);
1215         doReturn(sdncRequestHeader).when(PreloadNetworkTopologyOperationInput).getSdncRequestHeader();
1216         doReturn(svcRequestId).when(sdncRequestHeader).getSvcRequestId();
1217         doReturn(true).when(vnfsdnSvcLogicServiceClient).hasGraph(any(), any(), any(), any());
1218         doReturn(null).when(dataBroker).newWriteOnlyTransaction();
1219
1220         Future<RpcResult<PreloadNetworkTopologyOperationOutput>> rpcResultFuture =
1221             vnfapiProvider.preloadNetworkTopologyOperation(PreloadNetworkTopologyOperationInput);
1222
1223         Assert.assertEquals("500", rpcResultFuture.get().getResult().getResponseCode());
1224         Assert.assertEquals("java.lang.NullPointerException", rpcResultFuture.get().getResult().getResponseMessage());
1225         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
1226     }
1227
1228     /**
1229      * Test Success case
1230      *
1231      * @throws Exception
1232      */
1233     @Test public void preloadNetworkTopologyOperationSuccess() throws Exception {
1234         String networkName = "NetworkName";
1235         String networkType = "NetworkType";
1236         PreloadNetworkTopologyOperationInput PreloadNetworkTopologyOperationInput =
1237             mock(PreloadNetworkTopologyOperationInput.class);
1238         NetworkTopologyInformation networkTopologyInformation = mock(NetworkTopologyInformation.class);
1239         doReturn(networkTopologyInformation).when(PreloadNetworkTopologyOperationInput).getNetworkTopologyInformation();
1240         NetworkTopologyIdentifier networkTopologyIdentifier = mock(NetworkTopologyIdentifier.class);
1241         doReturn(networkTopologyIdentifier).when(networkTopologyInformation).getNetworkTopologyIdentifier();
1242         doReturn(networkName).when(networkTopologyIdentifier).getNetworkName();
1243         doReturn(networkType).when(networkTopologyIdentifier).getNetworkType();
1244         SdncRequestHeader sdncRequestHeader = mock(SdncRequestHeader.class);
1245         doReturn(sdncRequestHeader).when(PreloadNetworkTopologyOperationInput).getSdncRequestHeader();
1246         doReturn(svcRequestId).when(sdncRequestHeader).getSvcRequestId();
1247         doReturn(true).when(vnfsdnSvcLogicServiceClient).hasGraph(any(), any(), any(), any());
1248
1249         Future<RpcResult<PreloadNetworkTopologyOperationOutput>> rpcResultFuture =
1250             vnfapiProvider.preloadNetworkTopologyOperation(PreloadNetworkTopologyOperationInput);
1251
1252         Assert.assertEquals("200", rpcResultFuture.get().getResult().getResponseCode());
1253         Assert.assertEquals(null, rpcResultFuture.get().getResult().getResponseMessage());
1254         Assert.assertEquals("Y", rpcResultFuture.get().getResult().getAckFinalIndicator());
1255     }
1256
1257     @Test public void getVfModuleServiceData() throws Exception {
1258         // Three parameters: siid, vfModuleServiceDataBuilder, LogicalDatastoreType
1259         String ssid = "ssid";
1260         VfModuleServiceDataBuilder vfModuleServiceDataBuilder = spy(new VfModuleServiceDataBuilder());
1261         Optional<VfModuleList> optional = mock(Optional.class);
1262         doReturn(optional).when(checkedFuture).get();
1263         doReturn(true).when(optional).isPresent();
1264         VfModuleList vfModuleList = mock(VfModuleList.class);
1265         doReturn(vfModuleList).when(optional).get();
1266         VfModuleServiceData vfModuleServiceData = mock(VfModuleServiceData.class);
1267         doReturn(vfModuleServiceData).when(vfModuleList).getVfModuleServiceData();
1268         SdncRequestHeader sdncRequestHeader = mock(SdncRequestHeader.class);
1269         doReturn(sdncRequestHeader).when(vfModuleServiceData).getSdncRequestHeader();
1270
1271         Whitebox.invokeMethod(vnfapiProvider, "getVfModuleServiceData", ssid, vfModuleServiceDataBuilder,
1272             LogicalDatastoreType.CONFIGURATION);
1273
1274         Assert.assertEquals(sdncRequestHeader, vfModuleServiceDataBuilder.getSdncRequestHeader());
1275
1276         //With Two parameters: siid, vfModuleServiceDataBuilder
1277         Whitebox.invokeMethod(vnfapiProvider, "getVfModuleServiceData", ssid, vfModuleServiceDataBuilder);
1278
1279         Assert.assertEquals(sdncRequestHeader, vfModuleServiceDataBuilder.getSdncRequestHeader());
1280     }
1281
1282     @Test public void getPreloadData() throws Exception {
1283         // Four parameters:
1284         // String preload_name, String preload_type, PreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type
1285         PreloadDataBuilder preloadDataBuilder = spy(new PreloadDataBuilder());
1286         // mock optional
1287         Optional<VnfPreloadList> optional = mock(Optional.class);
1288         doReturn(optional).when(checkedFuture).get();
1289         doReturn(true).when(optional).isPresent();
1290
1291         VnfPreloadList vnfPreloadList = mock(VnfPreloadList.class);
1292         doReturn(vnfPreloadList).when(optional).get();
1293         PreloadData preloadData = mock(PreloadData.class);
1294         doReturn(preloadData).when(vnfPreloadList).getPreloadData();
1295
1296         VnfTopologyInformation vnfTopologyInformation = mock(VnfTopologyInformation.class);
1297         doReturn(vnfTopologyInformation).when(preloadData).getVnfTopologyInformation();
1298
1299         Whitebox.invokeMethod(vnfapiProvider, "getPreloadData", "preloadName", "preloadType", preloadDataBuilder,
1300             LogicalDatastoreType.CONFIGURATION);
1301
1302         Assert.assertEquals(vnfTopologyInformation, preloadDataBuilder.getVnfTopologyInformation());
1303
1304         // Three parameters:
1305         // String preload_name, String preload_type, PreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type
1306         Whitebox.invokeMethod(vnfapiProvider, "getPreloadData", "preloadName", "preloadType", preloadDataBuilder);
1307
1308         Assert.assertEquals(vnfTopologyInformation, preloadDataBuilder.getVnfTopologyInformation());
1309     }
1310
1311     @Test public void getVnfInstancePreloadData() throws Exception {
1312         // Four parameters:
1313         // String preload_name, String preload_type, VnfInstancePreloadDataBuilder preloadDataBuilder,
1314         // LogicalDatastoreType type
1315         VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = spy(new VnfInstancePreloadDataBuilder());
1316         // mock optional
1317         Optional<VnfPreloadList> optional = mock(Optional.class);
1318         doReturn(optional).when(checkedFuture).get();
1319         doReturn(true).when(optional).isPresent();
1320         VnfInstancePreloadList vnfInstancePreloadList = mock(VnfInstancePreloadList.class);
1321         doReturn(vnfInstancePreloadList).when(optional).get();
1322         VnfInstancePreloadData vnfInstancePreloadData = mock(VnfInstancePreloadData.class);
1323         doReturn(vnfInstancePreloadData).when(vnfInstancePreloadList).getVnfInstancePreloadData();
1324         VnfInstanceTopologyInformation vnfInstanceTopologyInformation = mock(VnfInstanceTopologyInformation.class);
1325         doReturn(vnfInstanceTopologyInformation).when(vnfInstancePreloadData).getVnfInstanceTopologyInformation();
1326
1327         Whitebox.invokeMethod(vnfapiProvider, "getVnfInstancePreloadData", "preloadName", "preloadType",
1328             vnfInstancePreloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
1329
1330         Assert.assertEquals(vnfInstanceTopologyInformation,
1331             vnfInstancePreloadDataBuilder.getVnfInstanceTopologyInformation());
1332
1333         // Three Parameters:
1334         // String preload_name, String preload_type, VnfInstancePreloadDataBuilder preloadDataBuilder
1335         Whitebox.invokeMethod(vnfapiProvider, "getVnfInstancePreloadData", "preloadName", "preloadType",
1336             vnfInstancePreloadDataBuilder);
1337
1338         Assert.assertEquals(vnfInstanceTopologyInformation,
1339             vnfInstancePreloadDataBuilder.getVnfInstanceTopologyInformation());
1340     }
1341
1342     @Test public void getVfModulePreloadData() throws Exception {
1343         // Four Parameters
1344         // String preload_name, String preload_type, VfModulePreloadDataBuilder preloadDataBuilder,
1345         // LogicalDatastoreType type
1346         VfModulePreloadDataBuilder vfModulePreloadDataBuilder = spy(new VfModulePreloadDataBuilder());
1347         // mock optional
1348         Optional<VfModulePreloadList> optional = mock(Optional.class);
1349         doReturn(optional).when(checkedFuture).get();
1350         doReturn(true).when(optional).isPresent();
1351         VfModulePreloadList vfModulePreloadList = mock(VfModulePreloadList.class);
1352         doReturn(vfModulePreloadList).when(optional).get();
1353         VfModulePreloadData vfModulePreloadData = mock(VfModulePreloadData.class);
1354         doReturn(vfModulePreloadData).when(vfModulePreloadList).getVfModulePreloadData();
1355         VfModuleTopologyInformation vfModuleTopologyInformation = mock(VfModuleTopologyInformation.class);
1356         doReturn(vfModuleTopologyInformation).when(vfModulePreloadData).getVfModuleTopologyInformation();
1357
1358         Whitebox.invokeMethod(vnfapiProvider, "getVfModulePreloadData", "preloadName", "preloadType",
1359             vfModulePreloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
1360
1361         Assert.assertEquals(vfModuleTopologyInformation, vfModulePreloadDataBuilder.getVfModuleTopologyInformation());
1362
1363         // Three Parameters:
1364         // String vnf_name, String vnf_type, VfModulePreloadDataBuilder preloadDataBuilder
1365         Whitebox.invokeMethod(vnfapiProvider, "getVfModulePreloadData", "preloadName", "preloadType",
1366             vfModulePreloadDataBuilder);
1367
1368         Assert.assertEquals(vfModuleTopologyInformation, vfModulePreloadDataBuilder.getVfModuleTopologyInformation());
1369     }
1370
1371     /**
1372      * With ServiceStatusBuilder, RequestInformation
1373      */
1374     @Test public void setServiceStatusOne() throws Exception {
1375         // VNFActivateRequest
1376         RequestInformation requestInformation = mock(RequestInformation.class);
1377         ServiceStatusBuilder serviceStatusBuilder = spy(new ServiceStatusBuilder());
1378         doReturn(RequestInformation.RequestAction.VNFActivateRequest).when(requestInformation).getRequestAction();
1379         doReturn(RequestInformation.RequestSubAction.SUPP).when(requestInformation).getRequestSubAction();
1380         Whitebox.invokeMethod(vnfapiProvider, "setServiceStatus", serviceStatusBuilder, requestInformation);
1381         Assert.assertEquals(ServiceStatus.VnfsdnAction.VNFActivateRequest, serviceStatusBuilder.getVnfsdnAction());
1382
1383         //ChangeVNFActivateRequest
1384         doReturn(RequestInformation.RequestAction.ChangeVNFActivateRequest).when(requestInformation).getRequestAction();
1385         doReturn(RequestInformation.RequestSubAction.CANCEL).when(requestInformation).getRequestSubAction();
1386         Whitebox.invokeMethod(vnfapiProvider, "setServiceStatus", serviceStatusBuilder, requestInformation);
1387         Assert
1388             .assertEquals(ServiceStatus.VnfsdnAction.ChangeVNFActivateRequest, serviceStatusBuilder.getVnfsdnAction());
1389
1390         //DisconnectVNFRequest
1391         doReturn(RequestInformation.RequestAction.DisconnectVNFRequest).when(requestInformation).getRequestAction();
1392         Whitebox.invokeMethod(vnfapiProvider, "setServiceStatus", serviceStatusBuilder, requestInformation);
1393         Assert.assertEquals(ServiceStatus.VnfsdnAction.DisconnectVNFRequest, serviceStatusBuilder.getVnfsdnAction());
1394
1395         //PreloadVNFRequest
1396         doReturn(RequestInformation.RequestAction.PreloadVNFRequest).when(requestInformation).getRequestAction();
1397         Whitebox.invokeMethod(vnfapiProvider, "setServiceStatus", serviceStatusBuilder, requestInformation);
1398         Assert.assertEquals(ServiceStatus.VnfsdnAction.PreloadVNFRequest, serviceStatusBuilder.getVnfsdnAction());
1399
1400         //DeletePreloadVNFRequest
1401         doReturn(RequestInformation.RequestAction.DeletePreloadVNFRequest).when(requestInformation).getRequestAction();
1402         Whitebox.invokeMethod(vnfapiProvider, "setServiceStatus", serviceStatusBuilder, requestInformation);
1403         Assert.assertEquals(ServiceStatus.VnfsdnAction.DeletePreloadVNFRequest, serviceStatusBuilder.getVnfsdnAction());
1404
1405         //VnfInstanceActivateRequest
1406         doReturn(RequestInformation.RequestAction.VnfInstanceActivateRequest).when(requestInformation)
1407             .getRequestAction();
1408         Whitebox.invokeMethod(vnfapiProvider, "setServiceStatus", serviceStatusBuilder, requestInformation);
1409         Assert.assertEquals(ServiceStatus.VnfsdnAction.VnfInstanceActivateRequest,
1410             serviceStatusBuilder.getVnfsdnAction());
1411
1412         //ChangeVnfInstanceActivateRequest
1413         doReturn(RequestInformation.RequestAction.ChangeVnfInstanceActivateRequest).when(requestInformation)
1414             .getRequestAction();
1415         Whitebox.invokeMethod(vnfapiProvider, "setServiceStatus", serviceStatusBuilder, requestInformation);
1416         Assert.assertEquals(ServiceStatus.VnfsdnAction.ChangeVnfInstanceActivateRequest,
1417             serviceStatusBuilder.getVnfsdnAction());
1418
1419         //DisconnectVnfInstanceRequest
1420         doReturn(RequestInformation.RequestAction.DisconnectVnfInstanceRequest).when(requestInformation)
1421             .getRequestAction();
1422         Whitebox.invokeMethod(vnfapiProvider, "setServiceStatus", serviceStatusBuilder, requestInformation);
1423         Assert.assertEquals(ServiceStatus.VnfsdnAction.DisconnectVnfInstanceRequest,
1424             serviceStatusBuilder.getVnfsdnAction());
1425
1426         //PreloadVnfInstanceRequest
1427         doReturn(RequestInformation.RequestAction.PreloadVnfInstanceRequest).when(requestInformation)
1428             .getRequestAction();
1429         Whitebox.invokeMethod(vnfapiProvider, "setServiceStatus", serviceStatusBuilder, requestInformation);
1430         Assert
1431             .assertEquals(ServiceStatus.VnfsdnAction.PreloadVnfInstanceRequest, serviceStatusBuilder.getVnfsdnAction());
1432
1433         //VfModuleActivateRequest
1434         doReturn(RequestInformation.RequestAction.VfModuleActivateRequest).when(requestInformation).getRequestAction();
1435         Whitebox.invokeMethod(vnfapiProvider, "setServiceStatus", serviceStatusBuilder, requestInformation);
1436         Assert.assertEquals(ServiceStatus.VnfsdnAction.VfModuleActivateRequest, serviceStatusBuilder.getVnfsdnAction());
1437
1438         //ChangeVfModuleActivateRequest
1439         doReturn(RequestInformation.RequestAction.ChangeVfModuleActivateRequest).when(requestInformation)
1440             .getRequestAction();
1441         Whitebox.invokeMethod(vnfapiProvider, "setServiceStatus", serviceStatusBuilder, requestInformation);
1442         Assert.assertEquals(ServiceStatus.VnfsdnAction.ChangeVfModuleActivateRequest,
1443             serviceStatusBuilder.getVnfsdnAction());
1444
1445         //DisconnectVfModuleRequest
1446         doReturn(RequestInformation.RequestAction.DisconnectVfModuleRequest).when(requestInformation)
1447             .getRequestAction();
1448         Whitebox.invokeMethod(vnfapiProvider, "setServiceStatus", serviceStatusBuilder, requestInformation);
1449         Assert
1450             .assertEquals(ServiceStatus.VnfsdnAction.DisconnectVfModuleRequest, serviceStatusBuilder.getVnfsdnAction());
1451
1452         //PreloadVfModuleRequest
1453         doReturn(RequestInformation.RequestAction.PreloadVfModuleRequest).when(requestInformation).getRequestAction();
1454         Whitebox.invokeMethod(vnfapiProvider, "setServiceStatus", serviceStatusBuilder, requestInformation);
1455         Assert.assertEquals(ServiceStatus.VnfsdnAction.PreloadVfModuleRequest, serviceStatusBuilder.getVnfsdnAction());
1456     }
1457
1458     @Test public void getServiceData() throws Exception {
1459         ServiceDataBuilder serviceDataBuilder = spy(new ServiceDataBuilder());
1460         // mock optional
1461         Optional<VnfList> optional = mock(Optional.class);
1462         doReturn(optional).when(checkedFuture).get();
1463         doReturn(true).when(optional).isPresent();
1464         VnfList vnfList = mock(VnfList.class);
1465         doReturn(vnfList).when(optional).get();
1466         ServiceData serviceData = mock(ServiceData.class);
1467         doReturn(serviceData).when(vnfList).getServiceData();
1468         SdncRequestHeader sdncRequestHeader = mock(SdncRequestHeader.class);
1469         doReturn(sdncRequestHeader).when(serviceData).getSdncRequestHeader();
1470
1471         Whitebox.invokeMethod(vnfapiProvider, "getServiceData", "siid", serviceDataBuilder,
1472             LogicalDatastoreType.CONFIGURATION);
1473
1474         Assert.assertEquals(sdncRequestHeader, serviceDataBuilder.getSdncRequestHeader());
1475     }
1476
1477     @Test public void getVnfInstanceServiceData() throws Exception {
1478         VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = spy(new VnfInstanceServiceDataBuilder());
1479         // mock optional
1480         Optional<VnfList> optional = mock(Optional.class);
1481         doReturn(optional).when(checkedFuture).get();
1482         doReturn(true).when(optional).isPresent();
1483         VnfInstanceList vnfInstanceList = mock(VnfInstanceList.class);
1484         doReturn(vnfInstanceList).when(optional).get();
1485         VnfInstanceServiceData vnfInstanceServiceData = mock(VnfInstanceServiceData.class);
1486         doReturn(vnfInstanceServiceData).when(vnfInstanceList).getVnfInstanceServiceData();
1487         SdncRequestHeader sdncRequestHeader = mock(SdncRequestHeader.class);
1488         doReturn(sdncRequestHeader).when(vnfInstanceServiceData).getSdncRequestHeader();
1489
1490         Whitebox.invokeMethod(vnfapiProvider, "getVnfInstanceServiceData", "siid", vnfInstanceServiceDataBuilder,
1491             LogicalDatastoreType.CONFIGURATION);
1492
1493         Assert.assertEquals(sdncRequestHeader, vnfInstanceServiceDataBuilder.getSdncRequestHeader());
1494     }
1495
1496     @Test public void DeleteVnfList() throws Exception {
1497         LogicalDatastoreType configuration = LogicalDatastoreType.CONFIGURATION;
1498         VnfList vnfList = mock(VnfList.class);
1499         VnfListKey vnfListKey = mock(VnfListKey.class);
1500         doReturn(vnfListKey).when(vnfList).getKey();
1501         InstanceIdentifier<VnfList> vnfListInstanceIdentifier = mock(InstanceIdentifier.class);
1502         dataBroker.newWriteOnlyTransaction().put(configuration, vnfListInstanceIdentifier, vnfList);
1503
1504         Whitebox.invokeMethod(vnfapiProvider, "DeleteVnfList", vnfList, configuration);
1505
1506         verify(dataBroker, times(2)).newWriteOnlyTransaction();
1507     }
1508 }