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