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