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

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