* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.itm.impl;
-import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-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.concurrent.Future;
+import java.util.Optional;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.runners.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.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
+import org.opendaylight.genius.interfacemanager.interfaces.InterfaceManagerService;
+import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache;
+import org.opendaylight.genius.itm.cache.DpnTepStateCache;
+import org.opendaylight.genius.itm.cache.OvsBridgeRefEntryCache;
+import org.opendaylight.genius.itm.cache.TunnelStateCache;
+import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorCache;
+import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorEndPointCache;
import org.opendaylight.genius.itm.globals.ITMConstants;
+import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
import org.opendaylight.genius.itm.rpc.ItmManagerRpcService;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
+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.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefixBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeMplsOverGre;
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.RpcResult;
-import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+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;
DpnEndpoints dpnEndpoints = null;
DPNTEPsInfo dpntePsInfoVxlan = null;
TunnelEndPoints tunnelEndPointsVxlan = null;
- AllocateIdInput getIdInput1 = 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;
DeleteL2GwMlagDeviceInput deleteL2GwMlagDeviceInput = null;
GetTunnelInterfaceNameInput getTunnelInterfaceNameInput = null;
java.lang.Class<? extends TunnelTypeBase> tunnelType1 = TunnelTypeVxlan.class;
- AllocateIdOutput expectedId1 = new AllocateIdOutputBuilder().setIdValue(Long.valueOf("100")).build();
- Future<RpcResult<AllocateIdOutput>> idOutputOptional1 ;
+ java.lang.Class<? extends TunnelTypeBase> tunnelType2 = TunnelTypeMplsOverGre.class;
Class<? extends TunnelMonitoringTypeBase> monitorProtocol = ITMConstants.DEFAULT_MONITOR_PROTOCOL;
InstanceIdentifier<ExternalTunnel> externalTunnelIdentifier = InstanceIdentifier.create(ExternalTunnelList.class)
- .child(ExternalTunnel.class, new ExternalTunnelKey(String.valueOf(ipAddress1), dpId1.toString(),
+ .child(ExternalTunnel.class, new ExternalTunnelKey(ipAddress1.stringValue(), dpId1.toString(),
TunnelTypeMplsOverGre.class));
InstanceIdentifier<ExternalTunnel> externalTunnelIdentifierNew = InstanceIdentifier.create(ExternalTunnelList.class)
- .child(ExternalTunnel.class, new ExternalTunnelKey(String.valueOf(ipAddress1), dpId1.toString(),
+ .child(ExternalTunnel.class, new ExternalTunnelKey(ipAddress1.stringValue(), dpId1.toString(),
tunnelType1));
InstanceIdentifier<ExternalTunnel> externalTunnelIdentifier1 = InstanceIdentifier.create(ExternalTunnelList.class)
.child(ExternalTunnel.class, new ExternalTunnelKey(destinationDevice, sourceDevice,
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 ReadOnlyTransaction mockReadTx;
+ @Mock JobCoordinator jobCoordinator;
+ @Mock ReadTransaction mockReadTx;
@Mock WriteTransaction mockWriteTx;
- @Mock IdManagerService idManagerService;
@Mock IMdsalApiManager mdsalApiManager;
@Mock ItmConfig itmConfig;
+ @Mock IInterfaceManager interfaceManager;
+ @Mock InterfaceManagerService interfaceManagerService;
+ @Mock EntityOwnershipUtils entityOwnershipUtils;
+ @Mock TypedReadWriteTransaction mockTypedReadWriteTx;
ItmManagerRpcService itmManagerRpcService ;
+ DirectTunnelUtils directTunnelUtils;
+ UnprocessedNodeConnectorCache unprocessedNodeConnectorCache;
+ UnprocessedNodeConnectorEndPointCache unprocessedNodeConnectorEndPointCache;
Optional<ExternalTunnel> externalTunnelOptional ;
Optional<InternalTunnel> internalTunnelOptional;
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);
- doReturn(Futures.immediateCheckedFuture(internalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
- .CONFIGURATION,internalTunnelIdentifierNew);
- doReturn(Futures.immediateCheckedFuture(dpnEndpointsOptional)).when(mockReadTx).read(LogicalDatastoreType
- .CONFIGURATION,dpnEndpointsIdentifier);
- doReturn(Futures.immediateCheckedFuture(transportZonesOptional)).when(mockReadTx).read(LogicalDatastoreType
+ lenient().doReturn(FluentFutures.immediateFluentFuture(internalTunnelOptional)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION,internalTunnelIdentifierNew);
+ lenient().doReturn(FluentFutures.immediateFluentFuture(dpnEndpointsOptional)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION,dpnEndpointsIdentifier);
+ doReturn(FluentFutures.immediateFluentFuture(transportZonesOptional)).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,transportZonesIdentifier);
- itmManagerRpcService = new ItmManagerRpcService(dataBroker,idManagerService, mdsalApiManager, itmConfig);
+ DPNTEPsInfoCache dpntePsInfoCache =
+ new DPNTEPsInfoCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()),
+ directTunnelUtils, jobCoordinator, unprocessedNodeConnectorEndPointCache);
+ DpnTepStateCache dpnTepStateCache =
+ new DpnTepStateCache(dataBroker, jobCoordinator, new GuavaCacheProvider(new CacheManagersRegistryImpl()),
+ directTunnelUtils, dpntePsInfoCache, unprocessedNodeConnectorCache, unprocessedNodeConnectorEndPointCache);
+ TunnelStateCache tunnelStateCache =
+ new TunnelStateCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()));
+ OvsBridgeRefEntryCache ovsBridgeRefEntryCache =
+ new OvsBridgeRefEntryCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()));
+
+ itmManagerRpcService = new ItmManagerRpcService(dataBroker, mdsalApiManager, itmConfig,
+ dpntePsInfoCache, interfaceManager, dpnTepStateCache, tunnelStateCache, interfaceManagerService,
+ ovsBridgeRefEntryCache, directTunnelUtils);
}
@After
}
private void setupMocks() {
-
- deviceVteps = new DeviceVtepsBuilder().setIpAddress(ipAddress1).setKey(new DeviceVtepsKey(ipAddress1,"abc"))
+ deviceVteps = new DeviceVtepsBuilder().setIpAddress(ipAddress1).withKey(new DeviceVtepsKey(ipAddress1,"abc"))
.setNodeId(sourceDevice).setTopologyId(destinationDevice).build();
deviceVtepsList.add(deviceVteps);
stringList.add(sourceDevice);
dpId1List.add(dpId1);
stringList.add("def");
- idOutputOptional1 = RpcResultBuilder.success(expectedId1).buildFuture();
- getIdInput1 = new AllocateIdInputBuilder()
- .setPoolName(ITMConstants.ITM_IDPOOL_NAME)
- .setIdKey("1:phy0:100:192.168.56.101:192.168.56.101:VXLAN").build();
- doReturn(idOutputOptional1).when(idManagerService).allocateId(getIdInput1);
- when(idManagerService.releaseId(any(ReleaseIdInput.class))).thenReturn(Futures.immediateFuture(RpcResultBuilder
- .<Void>success().build()));
- trunkInterfaceName = ItmUtils.getTrunkInterfaceName(idManagerService, tunnelInterfaceName, ipAddress1
- .getIpv4Address().getValue(), ipAddress1.getIpv4Address().getValue(), tunnelType1.getName());
+ 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)
- .setKey(new TunnelEndPointsKey(ipAddress1,portName1,tunnelType1,vlanId)).build();
+ .withKey(new TunnelEndPointsKey(ipAddress1,tunnelType1)).build();
tunnelEndPointsListVxlan.add(tunnelEndPointsVxlan);
- dpntePsInfoVxlan = new DPNTEPsInfoBuilder().setDPNID(dpId1).setKey(new DPNTEPsInfoKey(dpId1)).setUp(true)
+ dpntePsInfoVxlan = new DPNTEPsInfoBuilder().setDPNID(dpId1).withKey(new DPNTEPsInfoKey(dpId1)).setUp(true)
.setTunnelEndPoints(tunnelEndPointsListVxlan).build();
cfgdDpnListVxlan.add(dpntePsInfoVxlan);
dpnEndpoints = new DpnEndpointsBuilder().setDPNTEPsInfo(cfgdDpnListVxlan).build();
externalTunnel = new ExternalTunnelBuilder().setSourceDevice(sourceDevice)
.setDestinationDevice(destinationDevice).setTransportType(tunnelType1)
.setTunnelInterfaceName(tunnelInterfaceName)
- .setKey(new ExternalTunnelKey(destinationDevice,sourceDevice,tunnelType1)).build();
+ .withKey(new ExternalTunnelKey(destinationDevice,sourceDevice,tunnelType1)).build();
internalTunnel = new InternalTunnelBuilder()
.setTunnelInterfaceNames(Collections.singletonList(tunnelInterfaceName)).setDestinationDPN(dpId2)
.setSourceDPN(dpId1).setTransportType(tunnelType1)
- .setKey(new InternalTunnelKey(dpId2, dpId1, tunnelType1)).build();
+ .withKey(new InternalTunnelKey(dpId2, dpId1, tunnelType1)).build();
getInternalOrExternalInterfaceNameInput = new GetInternalOrExternalInterfaceNameInputBuilder()
- .setDestinationIp(ipAddress1).setSourceDpid(dpId1).setTunnelType(tunnelType1).build();
+ .setDestinationIp(ipAddress1).setSourceDpid(dpId1).setTunnelType(tunnelType2).build();
addExternalTunnelEndpointInput = new AddExternalTunnelEndpointInputBuilder().setTunnelType(tunnelType1)
.setDestinationIp(ipAddress1).build();
addL2GwDeviceInput = new AddL2GwDeviceInputBuilder().setIpAddress(ipAddress1).setNodeId(sourceDevice)
.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).setKey(new SubnetsKey(ipPrefixTest))
- .setDeviceVteps(deviceVtepsList).build();
- subnetsList.add(subnetsTest);
+
transportZone = new TransportZoneBuilder().setZoneName(transportZone1)
- .setTunnelType(tunnelType1).setKey(new TransportZoneKey(transportZone1))
- .setSubnets(subnetsList).build();
+ .setTunnelType(tunnelType1).withKey(new TransportZoneKey(transportZone1))
+ .build();
transportZoneList.add(transportZone);
transportZones = new TransportZonesBuilder().setTransportZone(transportZoneList).build();
doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
- doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
+ lenient().doReturn(FluentFutures.immediateNullFluentFuture()).when(mockWriteTx).commit();
}
@Test
public void testGetInternalOrExternalInterfaceNameExtTunnelPresent() {
-
itmManagerRpcService.getInternalOrExternalInterfaceName(getInternalOrExternalInterfaceNameInput);
- verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifier);
+ verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION, externalTunnelIdentifier);
}
@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);
- verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifier);
- verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,internalTunnelIdentifierNew);
-
+ verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION, externalTunnelIdentifier);
+ verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifierNew);
}
@Ignore
@Test
public void testAddExternalTunnelEndpoint() {
-
- externalTunnelNew = ItmUtils.buildExternalTunnel(dpId1.toString(), ipAddress1.toString(),
+ externalTunnelNew = ItmUtils.buildExternalTunnel(dpId1.toString(), ipAddress1.stringValue(),
tunnelType1, trunkInterfaceName);
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
public void testDeleteL2GwDevice() {
-
itmManagerRpcService.deleteL2GwDevice(deleteL2GwDeviceInput);
verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,deviceVtepsIdentifier);
@Test
public void testDeleteL2GwMlagDevice() {
-
itmManagerRpcService.deleteL2GwMlagDevice(deleteL2GwMlagDeviceInput);
verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,deviceVtepsIdentifier);
@Ignore
@Test
public void testBuildExternalTunnelFromDpns() {
-
- externalTunnelNew = ItmUtils.buildExternalTunnel(dpId1.toString(), ipAddress1.toString(),
+ externalTunnelNew = ItmUtils.buildExternalTunnel(dpId1.toString(), ipAddress1.stringValue(),
tunnelType1, trunkInterfaceName);
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
@Ignore
@Test
public void testRemoveExternalTunnelEndpoint() {
-
itmManagerRpcService.removeExternalTunnelEndpoint(removeExternalTunnelEndpointInput);
verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,interfaceIdentifier);
@Test
public void testGetTunnelInterfaceName() {
-
itmManagerRpcService.getTunnelInterfaceName(getTunnelInterfaceNameInput);
verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,internalTunnelIdentifier);
@Test
public void testGetExternalTunnelInterfaceName() {
-
itmManagerRpcService.getExternalTunnelInterfaceName(getExternalTunnelInterfaceNameInput);
verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifier1);