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