itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmManagerRpcServiceTest.java

   1 /*
   2  * Copyright (c) 2016, 2017 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.genius.itm.tests;
   9
  10 import static com.google.common.truth.Truth.assertThat;
  11 import static org.opendaylight.mdsal.binding.testutils.AssertDataObjects.assertEqualBeans;
  12
  13 import com.google.common.util.concurrent.ListenableFuture;
  14 import java.util.ArrayList;
  15 import java.util.Collections;
  16 import java.util.List;
  17 import java.util.Optional;
  18 import java.util.concurrent.ExecutionException;
  19 import java.util.concurrent.Future;
  20 import javax.inject.Inject;
  21 import org.junit.Before;
  22 import org.junit.Rule;
  23 import org.junit.Test;
  24 import org.junit.rules.MethodRule;
  25 import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorEventsWaiter;
  26 import org.opendaylight.genius.datastoreutils.testutils.JobCoordinatorTestModule;
  27 import org.opendaylight.genius.datastoreutils.testutils.TestableDataTreeChangeListenerModule;
  28 import org.opendaylight.genius.itm.impl.ItmUtils;
  29 import org.opendaylight.genius.itm.rpc.ItmManagerRpcService;
  30 import org.opendaylight.genius.itm.tests.xtend.ExpectedDeviceVtepsObjects;
  31 import org.opendaylight.genius.itm.tests.xtend.ExpectedExternalTunnelObjects;
  32 import org.opendaylight.genius.itm.tests.xtend.ExpectedInternalTunnelIdentifierObjects;
  33 import org.opendaylight.infrautils.caches.testutils.CacheModule;
  34 import org.opendaylight.infrautils.inject.guice.testutils.GuiceRule;
  35 import org.opendaylight.infrautils.testutils.LogRule;
  36 import org.opendaylight.mdsal.binding.api.DataBroker;
  37 import org.opendaylight.mdsal.binding.util.Datastore;
  38 import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunner;
  39 import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunnerImpl;
  40 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeMplsOverGre;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnEndpoints;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.ExternalTunnelList;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelList;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfoBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfoKey;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPointsBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPointsKey;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnel;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnelBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnelKey;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelKey;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneKey;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.DeviceVteps;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.DeviceVtepsBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.DeviceVtepsKey;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInput;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInputBuilder;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointOutput;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceInput;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceInputBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceOutput;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceInput;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceInputBuilder;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceOutput;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsInput;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsInputBuilder;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsOutput;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceInput;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceInputBuilder;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceOutput;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceInput;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceInputBuilder;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceOutput;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetExternalTunnelInterfaceNameInput;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetExternalTunnelInterfaceNameInputBuilder;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetExternalTunnelInterfaceNameOutput;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetInternalOrExternalInterfaceNameInput;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetInternalOrExternalInterfaceNameInputBuilder;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetInternalOrExternalInterfaceNameOutput;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetInternalOrExternalInterfaceNameOutputBuilder;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameInput;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameInputBuilder;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameOutput;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInput;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInputBuilder;
  95 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointOutput;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsInput;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsInputBuilder;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsOutput;
  99 import org.opendaylight.yangtools.yang.binding.DataObject;
 100 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 101 import org.opendaylight.yangtools.yang.common.RpcResult;
 102 import org.opendaylight.yangtools.yang.common.Uint64;
 103
 104 public class ItmManagerRpcServiceTest {
 105
 106     public @Rule LogRule logRule = new LogRule();
 107     // TODO public @Rule LogCaptureRule logCaptureRule = new LogCaptureRule();
 108     public @Rule MethodRule guice = new GuiceRule(ItmTestModule.class,  TestableDataTreeChangeListenerModule.class,
 109             JobCoordinatorTestModule.class, CacheModule.class);
 110
 111     String trunkInterfaceName;
 112
 113     ExternalTunnel externalTunnel;
 114     ExternalTunnel externalTunnel2;
 115     InternalTunnel internalTunnel;
 116     DpnEndpoints dpnEndpoints;
 117     DPNTEPsInfo dpntePsInfoVxlan;
 118     TunnelEndPoints tunnelEndPointsVxlan;
 119     Interface iface;
 120     TransportZones transportZones;
 121     TransportZone transportZone;
 122     DeviceVteps deviceVteps;
 123     List<DPNTEPsInfo> cfgdDpnListVxlan = new ArrayList<>();
 124     List<TunnelEndPoints> tunnelEndPointsListVxlan = new ArrayList<>();
 125     List<TransportZone> transportZoneList = new ArrayList<>();
 126     List<DeviceVteps> deviceVtepsList = new ArrayList<>();
 127     List<String> stringList = new ArrayList<>();
 128     List<Uint64> dpId1List = new ArrayList<>();
 129     DeviceVtepsKey deviceVtepKey = new DeviceVtepsKey(ItmTestConstants.IP_ADDRESS_3, ItmTestConstants.SOURCE_DEVICE);
 130     DeviceVtepsKey deviceVtep2Key = new DeviceVtepsKey(ItmTestConstants.IP_ADDRESS_3, ItmTestConstants.SOURCE_DEVICE_2);
 131     AddExternalTunnelEndpointInput addExternalTunnelEndpointInput;
 132     GetInternalOrExternalInterfaceNameInput getExternalInterfaceNameInput;
 133     GetInternalOrExternalInterfaceNameInput getInternalInterfaceNameInput;
 134     GetInternalOrExternalInterfaceNameOutput getInternalOrExternalInterfaceNameOutput;
 135     BuildExternalTunnelFromDpnsInput buildExternalTunnelFromDpnsInput;
 136     RemoveExternalTunnelFromDpnsInput removeExternalTunnelFromDpnsInput;
 137     RemoveExternalTunnelEndpointInput removeExternalTunnelEndpointInput;
 138     GetExternalTunnelInterfaceNameInput getExternalTunnelInterfaceNameInput;
 139     AddL2GwDeviceInput addL2GwDeviceInput;
 140     DeleteL2GwDeviceInput deleteL2GwDeviceInput;
 141     AddL2GwMlagDeviceInput addL2GwMlagDeviceInput;
 142     DeleteL2GwMlagDeviceInput deleteL2GwMlagDeviceInput;
 143     GetTunnelInterfaceNameInput getTunnelInterfaceNameInput;
 144
 145     InstanceIdentifier<ExternalTunnel> externalTunnelIdentifier = InstanceIdentifier.create(ExternalTunnelList.class)
 146             .child(ExternalTunnel.class, new ExternalTunnelKey(ItmTestConstants.IP_ADDRESS_3.stringValue(),
 147                     ItmTestConstants.DP_ID_1.toString(), TunnelTypeMplsOverGre.class));
 148     InstanceIdentifier<ExternalTunnel> externalTunnelIdentifierNew = InstanceIdentifier.create(ExternalTunnelList.class)
 149             .child(ExternalTunnel.class, new ExternalTunnelKey(ItmTestConstants.IP_ADDRESS_3.stringValue(),
 150                     ItmTestConstants.DP_ID_1.toString(), ItmTestConstants.TUNNEL_TYPE_VXLAN));
 151     InstanceIdentifier<ExternalTunnel> externalTunnelIdentifier2 = InstanceIdentifier.create(ExternalTunnelList.class)
 152             .child(ExternalTunnel.class, new ExternalTunnelKey(ItmTestConstants.DESTINATION_DEVICE,
 153                     ItmTestConstants.SOURCE_DEVICE, ItmTestConstants.TUNNEL_TYPE_VXLAN));
 154     InstanceIdentifier<InternalTunnel> internalTunnelIdentifier = InstanceIdentifier.create(TunnelList.class)
 155             .child(InternalTunnel.class, new InternalTunnelKey(ItmTestConstants.DP_ID_2, ItmTestConstants.DP_ID_1,
 156                     ItmTestConstants.TUNNEL_TYPE_VXLAN));
 157     //InstanceIdentifier<DpnEndpoints> dpnEndpointsIdentifier = InstanceIdentifier.builder(DpnEndpoints.class).build();
 158
 159
 160     InstanceIdentifier<DPNTEPsInfo> dpnEndpointsIdentifier = InstanceIdentifier.builder(DpnEndpoints.class)
 161             .child(DPNTEPsInfo.class, new DPNTEPsInfoKey(ItmTestConstants.DP_ID_1)).build();
 162
 163     InstanceIdentifier<Interface> interfaceIdentifier;
 164
 165     InstanceIdentifier<TransportZone> transportZonesIdentifier = InstanceIdentifier.builder(TransportZones.class)
 166             .child(TransportZone.class, new TransportZoneKey(ItmTestConstants.TZ_NAME)).build();
 167
 168     InstanceIdentifier<DeviceVteps> deviceVtepsIdentifier = InstanceIdentifier.builder(TransportZones.class)
 169             .child(TransportZone.class, new TransportZoneKey(ItmTestConstants.TZ_NAME))
 170             .child(DeviceVteps.class, deviceVtepKey).build();
 171     InstanceIdentifier<DeviceVteps> deviceVtepsIdentifier2 = InstanceIdentifier.builder(TransportZones.class)
 172             .child(TransportZone.class, new TransportZoneKey(ItmTestConstants.TZ_NAME))
 173             .child(DeviceVteps.class, deviceVtep2Key).build();
 174
 175     @Inject DataBroker dataBroker;
 176     private @Inject JobCoordinatorEventsWaiter coordinatorEventsWaiter;
 177     @Inject ItmManagerRpcService itmManagerRpcService ;
 178     ManagedNewTransactionRunner txRunner;
 179
 180     @Before
 181     public void setUp() throws Exception {
 182         //////db,txrunner
 183
 184         this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
 185
 186
 187         /*if (dataBroker != null)
 188         {
 189             String errMsg = "present db :" + txRunner;
 190             throw new NullPointerException(errMsg);
 191         }*/
 192
 193         deviceVteps = new DeviceVtepsBuilder().setIpAddress(ItmTestConstants.IP_ADDRESS_3).withKey(new DeviceVtepsKey(
 194             ItmTestConstants.IP_ADDRESS_3,ItmTestConstants.SOURCE_DEVICE))
 195             .setNodeId(ItmTestConstants.SOURCE_DEVICE).setTopologyId(ItmTestConstants.DESTINATION_DEVICE).build();
 196         deviceVtepsList.add(deviceVteps);
 197         stringList.add(ItmTestConstants.SOURCE_DEVICE);
 198         dpId1List.add(ItmTestConstants.DP_ID_1);
 199         stringList.add(ItmTestConstants.SOURCE_DEVICE_2);
 200
 201         trunkInterfaceName = ItmUtils.getTrunkInterfaceName(ItmTestConstants.PARENT_INTERFACE_NAME,
 202             ItmTestConstants.IP_ADDRESS_3.stringValue(),
 203             ItmTestConstants.IP_ADDRESS_3.stringValue(),
 204                 ItmTestConstants.TUNNEL_TYPE_VXLAN.getName());
 205         interfaceIdentifier = ItmUtils.buildId(trunkInterfaceName);
 206         tunnelEndPointsVxlan = new TunnelEndPointsBuilder().setIpAddress(ItmTestConstants.IP_ADDRESS_3)
 207                 .setInterfaceName(ItmTestConstants.PARENT_INTERFACE_NAME)
 208                 .setTzMembership(ItmUtils.createTransportZoneMembership(ItmTestConstants.TZ_NAME))
 209                 .setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
 210                 .withKey(new TunnelEndPointsKey(ItmTestConstants.IP_ADDRESS_3,
 211                         ItmTestConstants.TUNNEL_TYPE_VXLAN)).build();
 212         tunnelEndPointsListVxlan.add(tunnelEndPointsVxlan);
 213         dpntePsInfoVxlan = new DPNTEPsInfoBuilder().setDPNID(ItmTestConstants.DP_ID_1)
 214                 .withKey(new DPNTEPsInfoKey(ItmTestConstants.DP_ID_1)).setUp(true)
 215                 .setTunnelEndPoints(tunnelEndPointsListVxlan).build();
 216         //cfgdDpnListVxlan.add(dpntePsInfoVxlan);
 217         //dpnEndpoints = new DpnEndpointsBuilder().setDPNTEPsInfo(cfgdDpnListVxlan).build();
 218
 219         internalTunnel = new InternalTunnelBuilder()
 220                 .setTunnelInterfaceNames(Collections.singletonList(ItmTestConstants.PARENT_INTERFACE_NAME))
 221                 .setDestinationDPN(ItmTestConstants.DP_ID_2).setSourceDPN(ItmTestConstants.DP_ID_1)
 222                 .setTransportType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
 223                 .withKey(new InternalTunnelKey(ItmTestConstants.DP_ID_2, ItmTestConstants.DP_ID_1,
 224                         ItmTestConstants.TUNNEL_TYPE_VXLAN))
 225                 .build();
 226         getExternalInterfaceNameInput = new GetInternalOrExternalInterfaceNameInputBuilder()
 227                 .setDestinationIp(ItmTestConstants.IP_ADDRESS_3).setSourceDpid(ItmTestConstants.DP_ID_1)
 228                 .setTunnelType(ItmTestConstants.TUNNEL_TYPE_MPLS_OVER_GRE).build();
 229         getInternalInterfaceNameInput = new GetInternalOrExternalInterfaceNameInputBuilder()
 230                 .setDestinationIp(ItmTestConstants.IP_ADDRESS_3).setSourceDpid(ItmTestConstants.DP_ID_1)
 231                 .setTunnelType(ItmTestConstants.TUNNEL_TYPE_MPLS_OVER_GRE).build();
 232         addExternalTunnelEndpointInput = new AddExternalTunnelEndpointInputBuilder()
 233                 .setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
 234                 .setDestinationIp(ItmTestConstants.IP_ADDRESS_3).build();
 235         addL2GwDeviceInput = new AddL2GwDeviceInputBuilder().setIpAddress(ItmTestConstants.IP_ADDRESS_3)
 236                 .setNodeId(ItmTestConstants.SOURCE_DEVICE)
 237                 .setTopologyId(ItmTestConstants.DESTINATION_DEVICE).build();
 238         deleteL2GwDeviceInput = new DeleteL2GwDeviceInputBuilder().setIpAddress(ItmTestConstants.IP_ADDRESS_3)
 239                 .setNodeId(ItmTestConstants.SOURCE_DEVICE)
 240                 .setTopologyId(ItmTestConstants.DESTINATION_DEVICE).build();
 241         addL2GwMlagDeviceInput = new AddL2GwMlagDeviceInputBuilder().setIpAddress(ItmTestConstants.IP_ADDRESS_3)
 242                 .setNodeId(stringList)
 243                 .setTopologyId(ItmTestConstants.DESTINATION_DEVICE).build();
 244         deleteL2GwMlagDeviceInput = new DeleteL2GwMlagDeviceInputBuilder().setIpAddress(ItmTestConstants.IP_ADDRESS_3)
 245                 .setNodeId(stringList).setTopologyId(ItmTestConstants.DESTINATION_DEVICE).build();
 246         buildExternalTunnelFromDpnsInput = new BuildExternalTunnelFromDpnsInputBuilder()
 247                 .setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
 248                 .setDestinationIp(ItmTestConstants.IP_ADDRESS_3).setDpnId(dpId1List).build();
 249         removeExternalTunnelFromDpnsInput = new RemoveExternalTunnelFromDpnsInputBuilder()
 250                 .setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
 251                 .setDestinationIp(ItmTestConstants.IP_ADDRESS_3).setDpnId(dpId1List).build();
 252         removeExternalTunnelEndpointInput = new RemoveExternalTunnelEndpointInputBuilder()
 253                 .setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
 254                 .setDestinationIp(ItmTestConstants.IP_ADDRESS_3).build();
 255         getTunnelInterfaceNameInput = new GetTunnelInterfaceNameInputBuilder()
 256                 .setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
 257                 .setSourceDpid(ItmTestConstants.DP_ID_1).setDestinationDpid(ItmTestConstants.DP_ID_2).build();
 258         getExternalTunnelInterfaceNameInput = new GetExternalTunnelInterfaceNameInputBuilder()
 259                 .setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
 260                 .setDestinationNode(ItmTestConstants.DESTINATION_DEVICE)
 261                 .setSourceNode(ItmTestConstants.SOURCE_DEVICE).build();
 262         iface = ItmUtils.buildTunnelInterface(ItmTestConstants.DP_ID_1,trunkInterfaceName, String.format("%s %s",
 263                 ItmUtils.convertTunnelTypetoString(ItmTestConstants.TUNNEL_TYPE_VXLAN), "Trunk Interface"),
 264                 true,ItmTestConstants.TUNNEL_TYPE_VXLAN,tunnelEndPointsVxlan.getIpAddress(),
 265                 ItmTestConstants.IP_ADDRESS_3,false,false, ItmTestConstants.MONITOR_PROTOCOL,null, false, null);
 266
 267         transportZone = new TransportZoneBuilder().setZoneName(ItmTestConstants.TZ_NAME)
 268                 .setTunnelType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
 269                 .withKey(new TransportZoneKey(ItmTestConstants.TZ_NAME)).build();
 270         //transportZoneList.add(transportZone);
 271         //transportZones = new TransportZonesBuilder().setTransportZone(transportZoneList).build();
 272
 273         // build external tunnel objects
 274         externalTunnel = new ExternalTunnelBuilder().setSourceDevice(ItmTestConstants.DP_ID_1.toString())
 275                 .setDestinationDevice(ItmTestConstants.IP_ADDRESS_3.stringValue())
 276                 .setTransportType(TunnelTypeMplsOverGre.class)
 277                 .setTunnelInterfaceName(ItmTestConstants.PARENT_INTERFACE_NAME).build();
 278
 279         externalTunnel2 = new ExternalTunnelBuilder().setSourceDevice(ItmTestConstants.SOURCE_DEVICE)
 280                 .setDestinationDevice(ItmTestConstants.DESTINATION_DEVICE)
 281                 .setTransportType(ItmTestConstants.TUNNEL_TYPE_VXLAN)
 282                 .setTunnelInterfaceName(ItmTestConstants.PARENT_INTERFACE_NAME).build();
 283
 284         getInternalOrExternalInterfaceNameOutput = new GetInternalOrExternalInterfaceNameOutputBuilder()
 285                 .setInterfaceName(ItmTestConstants.PARENT_INTERFACE_NAME).build();
 286
 287         // commit external tunnel into config DS
 288         syncWrite(externalTunnelIdentifier, externalTunnel);
 289         syncWrite(externalTunnelIdentifier2, externalTunnel2);
 290
 291         /*if (dataBroker != null)
 292         {
 293             String errMsg = "present db :" + internalTunnelIdentifier + "  present 2" + internalTunnel ;
 294             throw new NullPointerException(errMsg);
 295         }*/
 296
 297         // commit internal tunnel into config DS.
 298         syncWrite(internalTunnelIdentifier, internalTunnel);
 299
 300
 301         // commit dpnEndpoints into config DS
 302
 303         syncWrite(dpnEndpointsIdentifier, dpntePsInfoVxlan);
 304
 305         // wait for completion of ITM config DS default-TZ creation task of DJC
 306         coordinatorEventsWaiter.awaitEventsConsumption();
 307         // commit TZ into config DS
 308
 309         syncWrite(transportZonesIdentifier, transportZone);
 310     }
 311
 312     @Test
 313     public void testGetExternalInterfaceNameExtTunnelPresent() throws Exception {
 314         Future<RpcResult<GetInternalOrExternalInterfaceNameOutput>> rpcRes  = itmManagerRpcService
 315                 .getInternalOrExternalInterfaceName(getExternalInterfaceNameInput);
 316         // check RPC response is SUCCESS
 317         assertThat(rpcRes.get().isSuccessful()).isTrue();
 318
 319         assertThat(getInternalOrExternalInterfaceNameOutput).isEqualTo(rpcRes.get().getResult());
 320     }
 321
 322     @Test
 323     public void testGetInternalInterfaceNameIntTunnelPresent() throws Exception {
 324         Future<RpcResult<GetInternalOrExternalInterfaceNameOutput>> rpcRes  = itmManagerRpcService
 325                 .getInternalOrExternalInterfaceName(getInternalInterfaceNameInput);
 326         // check RPC response is SUCCESS
 327         assertThat(rpcRes.get().isSuccessful()).isTrue();
 328
 329         assertThat(getInternalOrExternalInterfaceNameOutput).isEqualTo(rpcRes.get().getResult());
 330     }
 331
 332     @Test
 333     public void testAddExternalTunnelEndpoint() throws Exception {
 334         ListenableFuture<RpcResult<AddExternalTunnelEndpointOutput>> rpcRes =
 335                 itmManagerRpcService.addExternalTunnelEndpoint(addExternalTunnelEndpointInput);
 336
 337         // check RPC response is SUCCESS
 338         assertThat(rpcRes.get().isSuccessful()).isTrue();
 339
 340         // check ExternalTunnelEndpoint is added in config DS
 341         assertEqualBeans(ExpectedExternalTunnelObjects.newExternalTunnelForRpcTest(),
 342                 dataBroker.newReadOnlyTransaction()
 343                         .read(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifierNew).get().get());
 344     }
 345
 346     @Test
 347     public void testAddL2GwDevice() throws Exception {
 348         ListenableFuture<RpcResult<AddL2GwDeviceOutput>> rpcRes =
 349                 itmManagerRpcService.addL2GwDevice(addL2GwDeviceInput);
 350
 351         coordinatorEventsWaiter.awaitEventsConsumption();
 352         Thread.sleep(5000);
 353
 354         // check RPC response is SUCCESS
 355         assertThat(rpcRes.get().isSuccessful()).isTrue();
 356
 357         // check L2GwDevice is added in config DS
 358         assertEqualBeans(ExpectedDeviceVtepsObjects.newDeviceVtepsObject(),  dataBroker.newReadOnlyTransaction()
 359                 .read(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier).get().get());
 360     }
 361
 362     @Test
 363     public void testAddL2GwMlagDevice() throws Exception {
 364         ListenableFuture<RpcResult<AddL2GwMlagDeviceOutput>> rpcRes =
 365                 itmManagerRpcService.addL2GwMlagDevice(addL2GwMlagDeviceInput);
 366
 367         coordinatorEventsWaiter.awaitEventsConsumption();
 368         Thread.sleep(5000);
 369
 370
 371         // check RPC response is SUCCESS
 372         assertThat(rpcRes.get().isSuccessful()).isTrue();
 373
 374         // check L2GwMlagDevice is added in config DS
 375         assertEqualBeans(ExpectedDeviceVtepsObjects.newDeviceVtepsObject(), dataBroker.newReadOnlyTransaction()
 376                 .read(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier).get().get());
 377         assertEqualBeans(ExpectedDeviceVtepsObjects.newDeviceVtepsObject2(), dataBroker.newReadOnlyTransaction()
 378                 .read(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier2).get().get());
 379     }
 380
 381     @Test
 382     public void testDeleteL2GwDevice() throws Exception {
 383         ListenableFuture<RpcResult<DeleteL2GwDeviceOutput>> rpcRes =
 384                 itmManagerRpcService.deleteL2GwDevice(deleteL2GwDeviceInput);
 385
 386         // check RPC response is SUCCESS
 387         assertThat(rpcRes.get().isSuccessful()).isTrue();
 388
 389         // check L2GwDevice is deleted from config DS
 390         assertThat(Optional.empty()).isEqualTo(dataBroker.newReadOnlyTransaction()
 391                 .read(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier).get());
 392     }
 393
 394     @Test
 395     public void testDeleteL2GwMlagDevice() throws Exception {
 396         ListenableFuture<RpcResult<DeleteL2GwMlagDeviceOutput>> rpcRes =
 397                 itmManagerRpcService.deleteL2GwMlagDevice(deleteL2GwMlagDeviceInput);
 398
 399         // check RPC response is SUCCESS
 400         assertThat(rpcRes.get().isSuccessful()).isTrue();
 401
 402         // check L2GwMlagDevice is deleted from config DS
 403         assertThat(Optional.empty()).isEqualTo(dataBroker.newReadOnlyTransaction()
 404                 .read(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier).get());
 405         assertThat(Optional.empty()).isEqualTo(dataBroker.newReadOnlyTransaction()
 406                 .read(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier2).get());
 407     }
 408
 409     @Test
 410     public void testBuildExternalTunnelFromDpns() throws Exception {
 411         ListenableFuture<RpcResult<BuildExternalTunnelFromDpnsOutput>> rpcRes =
 412                 itmManagerRpcService.buildExternalTunnelFromDpns(buildExternalTunnelFromDpnsInput);
 413
 414         // check RPC response is SUCCESS
 415         assertThat(rpcRes.get().isSuccessful()).isTrue();
 416
 417         // check ExternalTunnel From Dpns is added in config DS
 418         assertEqualBeans(ExpectedExternalTunnelObjects.newExternalTunnelForRpcTest(),
 419                 dataBroker.newReadOnlyTransaction()
 420                         .read(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifierNew).get().get());
 421     }
 422
 423     @Test
 424     public void testRemoveExternalTunnelFromDpns() throws Exception {
 425         ListenableFuture<RpcResult<RemoveExternalTunnelFromDpnsOutput>> rpcRes =
 426                 itmManagerRpcService.removeExternalTunnelFromDpns(removeExternalTunnelFromDpnsInput);
 427
 428         // check RPC response is SUCCESS
 429         assertThat(rpcRes.get().isSuccessful()).isTrue();
 430
 431         // check ExternalTunnel From Dpns is deleted from config DS
 432         assertThat(Optional.empty()).isEqualTo(dataBroker.newReadOnlyTransaction()
 433                 .read(LogicalDatastoreType.CONFIGURATION, externalTunnelIdentifierNew).get());
 434         // check iface is removed
 435         assertThat(Optional.empty()).isEqualTo(dataBroker.newReadOnlyTransaction()
 436                 .read(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier).get());
 437     }
 438
 439     @Test
 440     public void testRemoveExternalTunnelEndpoint() throws Exception {
 441         // call RPC to add ExternalTunnelEndpoint as pre-requisite
 442         ListenableFuture<RpcResult<AddExternalTunnelEndpointOutput>> rpcRes =
 443                 itmManagerRpcService.addExternalTunnelEndpoint(addExternalTunnelEndpointInput);
 444
 445         // check RPC response is SUCCESS
 446         assertThat(rpcRes.get().isSuccessful()).isTrue();
 447
 448         ListenableFuture<RpcResult<RemoveExternalTunnelEndpointOutput>> removeExternalTunnelEndpoint =
 449                 itmManagerRpcService.removeExternalTunnelEndpoint(removeExternalTunnelEndpointInput);
 450
 451         // check RPC response is SUCCESS
 452         assertThat(removeExternalTunnelEndpoint.get().isSuccessful()).isTrue();
 453
 454         // check ExternalTunnelEndpoint is deleted from config DS
 455         assertThat(Optional.empty()).isEqualTo(dataBroker.newReadOnlyTransaction()
 456                 .read(LogicalDatastoreType.CONFIGURATION, externalTunnelIdentifierNew).get());
 457         // check iface is removed
 458         assertThat(Optional.empty()).isEqualTo(dataBroker.newReadOnlyTransaction()
 459                 .read(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier).get());
 460     }
 461
 462     @Test
 463     public void testGetTunnelInterfaceName() throws Exception {
 464         Future<RpcResult<GetTunnelInterfaceNameOutput>> rpcRes = itmManagerRpcService
 465                 .getTunnelInterfaceName(getTunnelInterfaceNameInput);
 466         // check RPC response is SUCCESS
 467         assertThat(rpcRes.get().isSuccessful()).isTrue();
 468
 469         // check ExternalTunnel From Dpns is added in config DS
 470         assertEqualBeans(ExpectedInternalTunnelIdentifierObjects.newInternalTunnelObjVxLanOneToTwo(),
 471             dataBroker.newReadOnlyTransaction()
 472                     .read(LogicalDatastoreType.CONFIGURATION,internalTunnelIdentifier).get().get());
 473     }
 474
 475     @Test
 476     public void testGetExternalTunnelInterfaceName() throws Exception {
 477         Future<RpcResult<GetExternalTunnelInterfaceNameOutput>> rpcRes = itmManagerRpcService
 478                 .getExternalTunnelInterfaceName(getExternalTunnelInterfaceNameInput);
 479
 480         // check RPC response is SUCCESS
 481         assertThat(rpcRes.get().isSuccessful()).isTrue();
 482
 483         // check ExternalTunnel From Dpns is added in config DS
 484         assertEqualBeans(ExpectedExternalTunnelObjects.newExternalTunnel2ForRpcTest(),
 485             dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType
 486                     .CONFIGURATION,externalTunnelIdentifier2).get().get());
 487
 488         // check for interfaceName
 489         assertThat(ItmTestConstants.PARENT_INTERFACE_NAME).isEqualTo(rpcRes.get().getResult().getInterfaceName());
 490     }
 491
 492     private <T extends DataObject> void syncWrite(InstanceIdentifier<T> path, T data) {
 493         try {
 494             txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
 495                 tx -> tx.mergeParentStructurePut(path, data)).get();
 496         } catch (InterruptedException | ExecutionException e) {
 497             throw new RuntimeException(e.getMessage(), e);
 498         }
 499     }
 500 }