import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.verify;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.interfacemanager.interfaces.InterfaceManagerService;
import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache;
import org.opendaylight.infrautils.caches.baseimpl.internal.CacheManagersRegistryImpl;
import org.opendaylight.infrautils.caches.guava.internal.GuavaCacheProvider;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.util.TypedReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Subnets;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.SubnetsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.SubnetsKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.DeviceVteps;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.DeviceVtepsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.DeviceVtepsKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.DeviceVteps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.DeviceVtepsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.DeviceVtepsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInputBuilder;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
@RunWith(MockitoJUnitRunner.class)
public class ItmManagerRpcServiceTest {
IpAddress ipAddress1 = IpAddressBuilder.getDefaultInstance(tepIp1);
IpAddress gtwyIp1 = IpAddressBuilder.getDefaultInstance(gwyIp1);
IpPrefix ipPrefixTest = IpPrefixBuilder.getDefaultInstance(subnetIp + "/24");
- BigInteger dpId1 = BigInteger.valueOf(1);
- BigInteger dpId2 = BigInteger.valueOf(2);
+ Uint64 dpId1 = Uint64.ONE;
+ Uint64 dpId2 = Uint64.valueOf(2);
ExternalTunnel externalTunnel = null;
ExternalTunnel externalTunnelNew = null;
InternalTunnel internalTunnel = null;
DPNTEPsInfo dpntePsInfoVxlan = null;
TunnelEndPoints tunnelEndPointsVxlan = null;
Interface iface = null;
- Subnets subnetsTest = null;
TransportZones transportZones = null;
TransportZone transportZone = null;
DeviceVteps deviceVteps = null;
List<DPNTEPsInfo> cfgdDpnListVxlan = new ArrayList<>() ;
List<TunnelEndPoints> tunnelEndPointsListVxlan = new ArrayList<>();
List<TransportZone> transportZoneList = new ArrayList<>() ;
- List<Subnets> subnetsList = new ArrayList<>() ;
List<DeviceVteps> deviceVtepsList = new ArrayList<>();
List<String> stringList = new ArrayList<>();
- List<BigInteger> dpId1List = new ArrayList<>();
+ List<Uint64> dpId1List = new ArrayList<>();
DeviceVtepsKey deviceVtepKey = new DeviceVtepsKey(ipAddress1, sourceDevice);
AddExternalTunnelEndpointInput addExternalTunnelEndpointInput = null;
GetInternalOrExternalInterfaceNameInput getInternalOrExternalInterfaceNameInput = null;
InstanceIdentifier<TransportZones> transportZonesIdentifier = InstanceIdentifier.create(TransportZones.class);
InstanceIdentifier<DeviceVteps> deviceVtepsIdentifier = InstanceIdentifier.builder(TransportZones.class)
.child(TransportZone.class, new TransportZoneKey(transportZone1))
- .child(Subnets.class, new SubnetsKey(ipPrefixTest)).child(DeviceVteps.class, deviceVtepKey).build();
+ .child(DeviceVteps.class, deviceVtepKey).build();
@Mock DataBroker dataBroker;
@Mock JobCoordinator jobCoordinator;
- @Mock ReadOnlyTransaction mockReadTx;
+ @Mock ReadTransaction mockReadTx;
@Mock WriteTransaction mockWriteTx;
@Mock IMdsalApiManager mdsalApiManager;
@Mock ItmConfig itmConfig;
@Mock IInterfaceManager interfaceManager;
@Mock InterfaceManagerService interfaceManagerService;
@Mock EntityOwnershipUtils entityOwnershipUtils;
+ @Mock TypedReadWriteTransaction mockTypedReadWriteTx;
ItmManagerRpcService itmManagerRpcService ;
DirectTunnelUtils directTunnelUtils;
dpnEndpointsOptional = Optional.of(dpnEndpoints);
transportZonesOptional = Optional.of(transportZones);
- doReturn(Futures.immediateCheckedFuture(externalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(externalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,externalTunnelIdentifier);
- doReturn(Futures.immediateCheckedFuture(externalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(externalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,externalTunnelIdentifier1);
- doReturn(Futures.immediateCheckedFuture(internalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(internalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,internalTunnelIdentifier);
- lenient().doReturn(Futures.immediateCheckedFuture(internalTunnelOptional)).when(mockReadTx).read(
+ lenient().doReturn(FluentFutures.immediateFluentFuture(internalTunnelOptional)).when(mockReadTx).read(
LogicalDatastoreType.CONFIGURATION,internalTunnelIdentifierNew);
- lenient().doReturn(Futures.immediateCheckedFuture(dpnEndpointsOptional)).when(mockReadTx).read(
+ lenient().doReturn(FluentFutures.immediateFluentFuture(dpnEndpointsOptional)).when(mockReadTx).read(
LogicalDatastoreType.CONFIGURATION,dpnEndpointsIdentifier);
- doReturn(Futures.immediateCheckedFuture(transportZonesOptional)).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(transportZonesOptional)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,transportZonesIdentifier);
DPNTEPsInfoCache dpntePsInfoCache =
trunkInterfaceName = ItmUtils.getTrunkInterfaceName(tunnelInterfaceName, ipAddress1.stringValue(),
ipAddress1.stringValue(), tunnelType1.getName());
interfaceIdentifier = ItmUtils.buildId(trunkInterfaceName);
- tunnelEndPointsVxlan = new TunnelEndPointsBuilder().setVLANID(vlanId).setPortname(portName1)
- .setIpAddress(ipAddress1).setGwIpAddress(gtwyIp1).setInterfaceName(tunnelInterfaceName)
+ tunnelEndPointsVxlan = new TunnelEndPointsBuilder()
+ .setIpAddress(ipAddress1).setInterfaceName(tunnelInterfaceName)
.setTzMembership(ItmUtils.createTransportZoneMembership(transportZone1)).setTunnelType(tunnelType1)
- .setSubnetMask(ipPrefixTest)
- .withKey(new TunnelEndPointsKey(ipAddress1,portName1,tunnelType1,vlanId)).build();
+ .withKey(new TunnelEndPointsKey(ipAddress1,tunnelType1)).build();
tunnelEndPointsListVxlan.add(tunnelEndPointsVxlan);
dpntePsInfoVxlan = new DPNTEPsInfoBuilder().setDPNID(dpId1).withKey(new DPNTEPsInfoKey(dpId1)).setUp(true)
.setTunnelEndPoints(tunnelEndPointsListVxlan).build();
.setTunnelType(tunnelType1).setDestinationNode(destinationDevice).setSourceNode(sourceDevice).build();
iface = ItmUtils.buildTunnelInterface(dpId1,trunkInterfaceName, String.format("%s %s",
ItmUtils.convertTunnelTypetoString(tunnelType1), "Trunk Interface"),true,tunnelType1,
- tunnelEndPointsVxlan.getIpAddress(),ipAddress1,gtwyIp1,tunnelEndPointsVxlan.getVLANID(), false, false,
+ tunnelEndPointsVxlan.getIpAddress(),ipAddress1, false, false,
monitorProtocol,null, false, null);
- subnetsTest = new SubnetsBuilder().setGatewayIp(gtwyIp1).setVlanId(vlanId).withKey(new SubnetsKey(ipPrefixTest))
- .setDeviceVteps(deviceVtepsList).build();
- subnetsList.add(subnetsTest);
+
transportZone = new TransportZoneBuilder().setZoneName(transportZone1)
.setTunnelType(tunnelType1).withKey(new TransportZoneKey(transportZone1))
- .setSubnets(subnetsList).build();
+ .build();
transportZoneList.add(transportZone);
transportZones = new TransportZonesBuilder().setTransportZone(transportZoneList).build();
doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
- lenient().doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
+ lenient().doReturn(FluentFutures.immediateNullFluentFuture()).when(mockWriteTx).commit();
}
@Test
@Ignore
@Test
public void testGetInternalOrExternalInterfaceNameExtTunnelAbsent() {
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(LogicalDatastoreType
+ doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,externalTunnelIdentifier);
itmManagerRpcService.getInternalOrExternalInterfaceName(getInternalOrExternalInterfaceNameInput);
itmManagerRpcService.addExternalTunnelEndpoint(addExternalTunnelEndpointInput);
- verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier, iface, true);
- verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION, externalTunnelIdentifierNew,
- externalTunnelNew,true);
+ verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier, iface);
+ verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, externalTunnelIdentifierNew,
+ externalTunnelNew);
}
@Test
public void testAddL2GwDevice() {
itmManagerRpcService.addL2GwDevice(addL2GwDeviceInput);
- verify(mockWriteTx).put(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier, deviceVteps, true);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier,
+ deviceVteps);
}
@Test
public void testAddL2GwMlagDevice() {
itmManagerRpcService.addL2GwMlagDevice(addL2GwMlagDeviceInput);
- verify(mockWriteTx).put(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier, deviceVteps, true);
+ verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier,
+ deviceVteps);
}
@Test
itmManagerRpcService.buildExternalTunnelFromDpns(buildExternalTunnelFromDpnsInput);
- verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,interfaceIdentifier,iface,true);
- verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifierNew,
- externalTunnelNew,true);
+ verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,interfaceIdentifier,iface);
+ verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifierNew,
+ externalTunnelNew);
}
@Ignore
Code Review / genius.git / blobdiff