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

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