JUNIT Test cases for HwVTEPInterface Helpers.
Fix for show:vxlan command output when switch is stopped.
Change-Id: Ic1a4d561a8e508bef1b896fcb2f77eb5caab4d3e
Signed-off-by: Kiran N Upadhyaya <kiran.n.upadhyaya@ericsson.com>
return tpPath;
}
-
- private static InstanceIdentifier<TerminationPoint> createLocalPhysicalLocatorEntryIfNotPresent(List<ListenableFuture<Void>> futures,
- DataBroker dataBroker,
- WriteTransaction transaction,
- IfTunnel ifTunnel,
- InstanceIdentifier<Node> nodeIid){
- String localIp = ifTunnel.getTunnelSource().getIpv4Address().getValue();
- LOG.debug("creating local physical locator entry {}", localIp);
- TerminationPointKey tpKey = SouthboundUtils.getTerminationPointKey(localIp);
- InstanceIdentifier<TerminationPoint> tpPath =
- SouthboundUtils.createInstanceIdentifier(nodeIid, tpKey);
- // if local tep is not present, create it
- TerminationPoint terminationPoint = SouthboundUtils.getTEPFromConfigDS(tpPath, dataBroker);
- if(terminationPoint == null) {
- createPhysicalLocatorEntry(transaction, futures, tpPath, tpKey, ifTunnel.getTunnelSource());
- }
- return tpPath;
- }
-
/*
* This method writes the termination end point details to the topology Config DS
*/
--- /dev/null
+/*
+ * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * 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.vpnservice.interfacemgr.test;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.Futures;
+import org.junit.After;
+import org.junit.Before;
+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.DataChangeListener;
+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.AsyncDataBroker.DataChangeScope;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.vpnservice.interfacemgr.IfmUtil;
+import org.opendaylight.vpnservice.interfacemgr.renderer.hwvtep.confighelpers.HwVTEPConfigRemoveHelper;
+import org.opendaylight.vpnservice.interfacemgr.renderer.hwvtep.confighelpers.HwVTEPInterfaceConfigAddHelper;
+import org.opendaylight.vpnservice.interfacemgr.renderer.hwvtep.statehelpers.HwVTEPInterfaceStateUpdateHelper;
+import org.opendaylight.vpnservice.interfacemgr.renderer.hwvtep.utilities.SouthboundUtils;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.EncapsulationTypeVxlanOverIpv4;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorAugmentationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.Tunnels;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelsKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdParams;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdStatus;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.tunnel.attributes.BfdStatusBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.TunnelInstanceInterfaceMap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.tunnel.instance._interface.map.TunnelInstanceInterface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.tunnel.instance._interface.map.TunnelInstanceInterfaceBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.tunnel.instance._interface.map.TunnelInstanceInterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfTunnel;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.ParentRefs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.TunnelTypeVxlan;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class HwVTEPConfigurationTest {
+
+ @Mock DataBroker dataBroker;
+ @Mock ListenerRegistration<DataChangeListener> dataChangeListenerRegistration;
+ @Mock ReadOnlyTransaction mockReadTx;
+ @Mock WriteTransaction mockWriteTx;
+ @Mock InstanceIdentifier<TunnelInstanceInterface> tunnelInterfaceId;
+ @Mock TunnelInstanceInterface tunnelInterface;
+ @Mock Tunnels newTunnel;
+ @Mock Tunnels oldTunnel;
+ HwVTEPInterfaceConfigAddHelper addHelper;
+ HwVTEPConfigRemoveHelper removeHelper;
+ HwVTEPInterfaceStateUpdateHelper updateHelper;
+
+ BigInteger dpId = BigInteger.valueOf(1);
+ Interface hwVTEPInterfaceEnabled;
+ Interface hwVTEPInterfaceDisabled;
+ ParentRefs parentRefs;
+ IfTunnel ifTunnel;
+ InstanceIdentifier<TerminationPoint> tpPath;
+ TerminationPoint terminationPoint;
+ InstanceIdentifier<Node> physicalSwitchId;
+ InstanceIdentifier<Node> globalId;
+ InstanceIdentifier<Tunnels> tunnelsInstanceIdentifier;
+ InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> interfaceStateIdentifier;
+
+ @Before
+ public void setUp() throws Exception {
+ when(dataBroker.registerDataChangeListener(
+ any(LogicalDatastoreType.class),
+ any(InstanceIdentifier.class),
+ any(DataChangeListener.class),
+ any(DataChangeScope.class)))
+ .thenReturn(dataChangeListenerRegistration);
+ setupMocks();
+ }
+
+ @After
+ public void cleanUp(){
+ }
+
+ private void setupMocks() {
+ hwVTEPInterfaceEnabled = InterfaceManagerTestUtil.buildTunnelInterface(dpId, InterfaceManagerTestUtil.tunnelInterfaceName ,"Test hwVTEP Interface1", true, TunnelTypeVxlan.class, "192.168.56.101", "192.168.56.102");
+ hwVTEPInterfaceDisabled = InterfaceManagerTestUtil.buildTunnelInterface(dpId, InterfaceManagerTestUtil.tunnelInterfaceName ,"Test hwVTEP Interface1", false, TunnelTypeVxlan.class, "192.168.56.101", "192.168.56.102");
+ interfaceStateIdentifier = IfmUtil.buildStateInterfaceId(hwVTEPInterfaceEnabled.getName());
+ parentRefs = hwVTEPInterfaceEnabled.getAugmentation(ParentRefs.class);
+ ifTunnel = hwVTEPInterfaceEnabled.getAugmentation(IfTunnel.class);
+ physicalSwitchId = SouthboundUtils.createPhysicalSwitchInstanceIdentifier("s1");
+ globalId = SouthboundUtils.createPhysicalSwitchInstanceIdentifier("s1");
+ tunnelsInstanceIdentifier = org.opendaylight.vpnservice.interfacemgr.renderer.hwvtep.utilities.SouthboundUtils.
+ createTunnelsInstanceIdentifier(physicalSwitchId,
+ ifTunnel.getTunnelSource(), ifTunnel.getTunnelDestination());
+ tunnelInterfaceId = InstanceIdentifier.builder(TunnelInstanceInterfaceMap.class).
+ child(TunnelInstanceInterface.class, new TunnelInstanceInterfaceKey(tunnelsInstanceIdentifier.toString())).build();
+ tunnelInterface = new TunnelInstanceInterfaceBuilder().
+ setTunnelInstanceIdentifier(tunnelsInstanceIdentifier.toString()).setKey(new TunnelInstanceInterfaceKey(tunnelsInstanceIdentifier.toString())).setInterfaceName(hwVTEPInterfaceEnabled.getName()).build();
+
+ //Setup termination points
+ TerminationPointKey tpKey = SouthboundUtils.getTerminationPointKey(ifTunnel.getTunnelDestination().getIpv4Address().getValue());
+ tpPath = SouthboundUtils.createInstanceIdentifier(globalId, tpKey);
+ TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
+ HwvtepPhysicalLocatorAugmentationBuilder tpAugmentationBuilder =
+ new HwvtepPhysicalLocatorAugmentationBuilder();
+ tpBuilder.setKey(tpKey);
+ tpBuilder.setTpId(tpKey.getTpId());
+ tpAugmentationBuilder.setEncapsulationType(EncapsulationTypeVxlanOverIpv4.class);
+ SouthboundUtils.setDstIp(tpAugmentationBuilder, ifTunnel.getTunnelDestination());
+ tpBuilder.addAugmentation(HwvtepPhysicalLocatorAugmentation.class, tpAugmentationBuilder.build());
+ terminationPoint = tpBuilder.build();
+ // Setup mocks
+ when(dataBroker.newReadOnlyTransaction()).thenReturn(mockReadTx);
+ when(dataBroker.newWriteOnlyTransaction()).thenReturn(mockWriteTx);
+ }
+
+ @Test
+ public void testAddHwVTEPInterfaceWithGlobalNodeId() {
+ addHelper.addConfiguration(dataBroker, physicalSwitchId, globalId,
+ hwVTEPInterfaceEnabled, ifTunnel);
+
+ //Verify
+ verify(mockWriteTx).put(LogicalDatastoreType.CONFIGURATION, tpPath, terminationPoint, true);
+ verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, tunnelInterfaceId, tunnelInterface, true);
+ }
+
+ @Test
+ public void testAddHwVTEPInterfaceWithoutGlobalNodeId() {
+
+ addHelper.addConfiguration(dataBroker, physicalSwitchId ,null ,
+ hwVTEPInterfaceEnabled, ifTunnel);
+
+ //Verification already performed in testAddHwVTEPInterfaceWithGlobalNodeId()
+ }
+
+ @Test
+ public void testAddHwVTEPInterfaceWhenAdminStateDisabled() {
+
+ addHelper.addConfiguration(dataBroker, physicalSwitchId, globalId,
+ hwVTEPInterfaceDisabled, ifTunnel);
+
+ //Verification already performed in testAddHwVTEPInterfaceWithGlobalNodeId()
+ }
+ @Test
+ public void testDeleteHWVTEPInterface() {
+ removeHelper.removeConfiguration(dataBroker, hwVTEPInterfaceEnabled, physicalSwitchId, globalId);
+ //verification
+ verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION, tpPath);
+ verify(mockWriteTx).delete(LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier);
+ verify(mockWriteTx).delete(LogicalDatastoreType.OPERATIONAL, tunnelsInstanceIdentifier);
+ }
+
+ @Test
+ public void testUpdatePhysicalSwitch(){
+
+ Optional<TunnelInstanceInterface> tunnelInterfaceOptional = Optional.of(tunnelInterface);
+
+ doReturn(Futures.immediateCheckedFuture(tunnelInterfaceOptional)).when(mockReadTx).read(
+ LogicalDatastoreType.OPERATIONAL, tunnelInterfaceId);
+ List<BfdStatus> bfdStatus = new ArrayList<BfdStatus>();
+ bfdStatus.add(new BfdStatusBuilder().setBfdStatusKey(SouthboundUtils.BFD_OP_STATE).setBfdStatusValue(SouthboundUtils.BFD_STATE_UP).build());
+ List bfdStatusSpy = spy(bfdStatus);
+ when(newTunnel.getBfdStatus()).thenReturn(bfdStatusSpy);
+ updateHelper.updatePhysicalSwitch(dataBroker, tunnelsInstanceIdentifier, newTunnel, oldTunnel);
+
+ //verify
+ InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateId =
+ IfmUtil.buildStateInterfaceId(hwVTEPInterfaceEnabled.getName());
+ InterfaceBuilder ifaceBuilder = new InterfaceBuilder().setOperStatus(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus.Up);
+ ifaceBuilder.setKey(IfmUtil.getStateInterfaceKeyFromName(hwVTEPInterfaceEnabled.getName()));
+ verify(mockWriteTx).merge(LogicalDatastoreType.OPERATIONAL, ifStateId, ifaceBuilder.build());
+ }
+
+ @Test
+ public void testStartBFDMonitoring(){
+
+ updateHelper.startBfdMonitoring(dataBroker, tunnelsInstanceIdentifier, newTunnel);
+
+ TunnelsBuilder tBuilder = new TunnelsBuilder();
+ tBuilder.setKey(new TunnelsKey(newTunnel.getLocalLocatorRef(), newTunnel.getRemoteLocatorRef()));
+ tBuilder.setLocalLocatorRef(newTunnel.getLocalLocatorRef());
+ tBuilder.setRemoteLocatorRef(newTunnel.getLocalLocatorRef());
+ List <BfdParams> bfdParams = new ArrayList<>();
+ SouthboundUtils.fillBfdParameters(bfdParams, null);
+ tBuilder.setBfdParams(bfdParams);
+ //Verify
+ verify(mockWriteTx).put(LogicalDatastoreType.CONFIGURATION, tunnelsInstanceIdentifier, tBuilder.build(), true);
+ }
+}
public class InterfaceManagerTestUtil {
public static final String interfaceName = "s1-eth1";
+ public static final String interfaceName2 = "s1-eth2";
public static final String tunnelInterfaceName = "s2-gre1";
public static final TopologyId OVSDB_TOPOLOGY_ID = new TopologyId(new Uri("ovsdb:1"));
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._interface.child.info.InterfaceParentEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._interface.child.info.InterfaceParentEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._interface.child.info._interface.parent.entry.InterfaceChildEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._interface.child.info._interface.parent.entry.InterfaceChildEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfTunnel;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.TunnelTypeGre;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.TunnelTypeVxlan;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
FlowCapableNodeConnector fcNodeConnectorNew = null;
Interface vlanInterfaceEnabled = null;
Interface vlanInterfaceDisabled = null;
+ Interface tunnelInterfaceEnabled;
+ Interface childVlanInterfaceEnabled = null;
InterfaceParentEntryKey interfaceParentEntryKey = null;
+ InterfaceParentEntryKey higherLayerInterfaceParentEntryKey = null;
IfIndexInterface IfindexInterface = null;
InstanceIdentifier<Interface> interfaceInstanceIdentifier = null;
+ InstanceIdentifier<Interface> childInterfaceInstanceIdentifier= null;
InstanceIdentifier<InterfaceParentEntry> interfaceParentEntryInstanceIdentifier = null;
InstanceIdentifier<FlowCapableNodeConnector> fcNodeConnectorId = null;
InstanceIdentifier<IfIndexInterface> ifIndexId =null;
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> interfaceStateIdentifier = null;
+ InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> childInterfaceStateIdentifier = null;
InstanceIdentifier<InterfaceParentEntry> interfaceParentEntryIdentifier = null;
+ InstanceIdentifier<InterfaceParentEntry> higherLevelInterfaceParentEntryIdentifier = null;
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface stateInterface;
InterfaceParentEntry interfaceParentEntry;
+ InterfaceParentEntry higherLayerInterfaceParentEntry;
@Mock DataBroker dataBroker;
@Mock IdManagerService idManager;
IfindexInterface = InterfaceManagerTestUtil.buildIfIndexInterface(100, InterfaceManagerTestUtil.interfaceName);
ifIndexId = InstanceIdentifier.builder(IfIndexesInterfaceMap.class).child(IfIndexInterface.class, new IfIndexInterfaceKey(100)).build();
interfaceInstanceIdentifier = InterfaceManagerCommonUtils.getInterfaceIdentifier(new InterfaceKey(InterfaceManagerTestUtil.interfaceName));
+ childInterfaceInstanceIdentifier = InterfaceManagerCommonUtils.getInterfaceIdentifier(new InterfaceKey(InterfaceManagerTestUtil.interfaceName2));
interfaceStateIdentifier = IfmUtil.buildStateInterfaceId(InterfaceManagerTestUtil.interfaceName);
+ childInterfaceStateIdentifier = IfmUtil.buildStateInterfaceId(InterfaceManagerTestUtil.interfaceName2);
vlanInterfaceEnabled = InterfaceManagerTestUtil.buildInterface(InterfaceManagerTestUtil.interfaceName, "Test Vlan Interface1", true, L2vlan.class, BigInteger.valueOf(1));
vlanInterfaceDisabled = InterfaceManagerTestUtil.buildInterface(InterfaceManagerTestUtil.interfaceName, "Test Vlan Interface1", false, L2vlan.class, BigInteger.valueOf(1));
+ tunnelInterfaceEnabled = InterfaceManagerTestUtil.buildTunnelInterface(dpId, InterfaceManagerTestUtil.tunnelInterfaceName ,"Test Tunnel Interface", true, TunnelTypeGre.class, "192.168.56.101", "192.168.56.102");
+ childVlanInterfaceEnabled = InterfaceManagerTestUtil.buildInterface(InterfaceManagerTestUtil.interfaceName2, "Test Vlan Interface2", true, L2vlan.class, BigInteger.valueOf(1));
interfaceParentEntryKey = new InterfaceParentEntryKey(InterfaceManagerTestUtil.interfaceName);
interfaceParentEntryIdentifier = InterfaceMetaUtils.getInterfaceParentEntryIdentifier(interfaceParentEntryKey);
+ higherLayerInterfaceParentEntryKey = new InterfaceParentEntryKey(InterfaceManagerTestUtil.interfaceName2);
+ higherLevelInterfaceParentEntryIdentifier= InterfaceMetaUtils.getInterfaceParentEntryIdentifier(higherLayerInterfaceParentEntryKey);
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder ifaceBuilder = new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder();
List<String> lowerLayerIfList = new ArrayList<>();
lowerLayerIfList.add(nodeConnectorId.getValue());
InterfaceParentEntryBuilder ifaceParentEntryBuilder = new InterfaceParentEntryBuilder();
List<InterfaceChildEntry> ifaceChildEntryList= new ArrayList<>();
+ ifaceChildEntryList.add(new InterfaceChildEntryBuilder().setChildInterface(InterfaceManagerTestUtil.interfaceName2).build());
interfaceParentEntry = ifaceParentEntryBuilder.setInterfaceChildEntry(ifaceChildEntryList).build();
+ InterfaceParentEntryBuilder higherLayerIfParentEntryBuilder = new InterfaceParentEntryBuilder();
+ List<InterfaceChildEntry> ifaceChildEntryListForHigherParent= new ArrayList<>();
+ higherLayerInterfaceParentEntry = higherLayerIfParentEntryBuilder.setInterfaceChildEntry(ifaceChildEntryListForHigherParent).build();
+
when(dataBroker.newReadOnlyTransaction()).thenReturn(mockReadTx);
when(dataBroker.newWriteOnlyTransaction()).thenReturn(mockWriteTx);
}
public void testAddStateInterface() {
Optional<Interface> expectedInterface = Optional.of(vlanInterfaceEnabled);
AllocateIdOutput expectedId = new AllocateIdOutputBuilder().setIdValue(Long.valueOf("100")).build();
+ AllocateIdOutput expectedId2 = new AllocateIdOutputBuilder().setIdValue(Long.valueOf("200")).build();
+ Optional<InterfaceParentEntry>expectedParentEntry = Optional.of(interfaceParentEntry);
+ Optional<InterfaceParentEntry> higherLayerParentOptional = Optional.of(higherLayerInterfaceParentEntry);
+ Optional<Interface> expectedChildInterface = Optional.of(childVlanInterfaceEnabled);
Future<RpcResult<AllocateIdOutput>> idOutputOptional = RpcResultBuilder.success(expectedId).buildFuture();
+ Future<RpcResult<AllocateIdOutput>> idOutputOptional2 = RpcResultBuilder.success(expectedId).buildFuture();
doReturn(Futures.immediateCheckedFuture(expectedInterface)).when(mockReadTx).read(
LogicalDatastoreType.CONFIGURATION, interfaceInstanceIdentifier);
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
+ doReturn(Futures.immediateCheckedFuture(expectedParentEntry)).when(mockReadTx).read(
LogicalDatastoreType.CONFIGURATION, interfaceParentEntryIdentifier);
+ doReturn(Futures.immediateCheckedFuture(higherLayerParentOptional)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, higherLevelInterfaceParentEntryIdentifier);
+ doReturn(Futures.immediateCheckedFuture(expectedChildInterface)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, childInterfaceInstanceIdentifier);
+
AllocateIdInput getIdInput = new AllocateIdInputBuilder()
.setPoolName(IfmConstants.IFM_IDPOOL_NAME)
.setIdKey(InterfaceManagerTestUtil.interfaceName).build();
doReturn(idOutputOptional).when(idManager).allocateId(getIdInput);
+ AllocateIdInput getIdInput2 = new AllocateIdInputBuilder()
+ .setPoolName(IfmConstants.IFM_IDPOOL_NAME)
+ .setIdKey(InterfaceManagerTestUtil.interfaceName2).build();
+ doReturn(idOutputOptional2).when(idManager).allocateId(getIdInput2);
addHelper.addState(dataBroker, idManager, mdsalManager, alivenessMonitorService,
nodeConnectorId, InterfaceManagerTestUtil.interfaceName, fcNodeConnectorNew);
verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier,
stateInterface,true);
}
+
+ @Test
+ public void testAddStateTunnelInterface() {
+
+ Optional<Interface> expectedInterface = Optional.of(tunnelInterfaceEnabled);
+ AllocateIdOutput expectedId = new AllocateIdOutputBuilder().setIdValue(Long.valueOf("100")).build();
+
+ Future<RpcResult<AllocateIdOutput>> idOutputOptional = RpcResultBuilder.success(expectedId).buildFuture();
+
+ doReturn(Futures.immediateCheckedFuture(expectedInterface)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, interfaceInstanceIdentifier);
+
+ AllocateIdInput getIdInput = new AllocateIdInputBuilder()
+ .setPoolName(IfmConstants.IFM_IDPOOL_NAME)
+ .setIdKey(InterfaceManagerTestUtil.interfaceName).build();
+ doReturn(idOutputOptional).when(idManager).allocateId(getIdInput);
+
+ addHelper.addState(dataBroker, idManager, mdsalManager, alivenessMonitorService,
+ nodeConnectorId, InterfaceManagerTestUtil.interfaceName, fcNodeConnectorNew);
+ }
+
@Test
public void testDeleteStateInterface() {
Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface>
expectedStateInterface = Optional.of(stateInterface);
Optional<IfIndexInterface> expectedIfindexInterface = Optional.of(IfindexInterface);
+ Optional<Interface> expectedInterface = Optional.of(vlanInterfaceEnabled);
+ Optional<InterfaceParentEntry>expectedParentEntry = Optional.of(interfaceParentEntry);
+ Optional<InterfaceParentEntry> higherLayerParentOptional = Optional.of(higherLayerInterfaceParentEntry);
+
doReturn(Futures.immediateCheckedFuture(expectedIfindexInterface)).when(mockReadTx).read(
LogicalDatastoreType.OPERATIONAL, ifIndexId);
doReturn(Futures.immediateCheckedFuture(expectedStateInterface)).when(mockReadTx).read(
LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier);
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
+ doReturn(Futures.immediateCheckedFuture(expectedStateInterface)).when(mockReadTx).read(
+ LogicalDatastoreType.OPERATIONAL, childInterfaceStateIdentifier);
+ doReturn(Futures.immediateCheckedFuture(expectedInterface)).when(mockReadTx).read(
LogicalDatastoreType.CONFIGURATION, interfaceInstanceIdentifier);
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
+ doReturn(Futures.immediateCheckedFuture(expectedParentEntry)).when(mockReadTx).read(
LogicalDatastoreType.CONFIGURATION, interfaceParentEntryIdentifier);
+ doReturn(Futures.immediateCheckedFuture(higherLayerParentOptional)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, higherLevelInterfaceParentEntryIdentifier);
ReleaseIdInput getIdInput = new ReleaseIdInputBuilder()
.setPoolName(IfmConstants.IFM_IDPOOL_NAME)
verify(mockWriteTx).delete(LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier);
}
+
+ @Test
+ public void testDeleteStateTunnelInterface() {
+ Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface>
+ expectedStateInterface = Optional.of(stateInterface);
+ Optional<Interface> expectedInterface = Optional.of(tunnelInterfaceEnabled);
+
+ doReturn(Futures.immediateCheckedFuture(expectedStateInterface)).when(mockReadTx).read(
+ LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier);
+ doReturn(Futures.immediateCheckedFuture(expectedInterface)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, interfaceInstanceIdentifier);
+
+ removeHelper.removeState(idManager, mdsalManager, alivenessMonitorService, fcNodeConnectorId, dataBroker, InterfaceManagerTestUtil.interfaceName, fcNodeConnectorNew);
+
+ }
+
@Test
public void testUpdateStateInterface(){
Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface>
expectedStateInterface = Optional.of(stateInterface);
Optional<InterfaceParentEntry>expectedParentEntry = Optional.of(interfaceParentEntry);
+ Optional<Interface> expectedInterface = Optional.of(vlanInterfaceEnabled);
+ Optional<Interface> expectedChildInterface = Optional.of(childVlanInterfaceEnabled);
+ Optional<InterfaceParentEntry> higherLayerParentOptional = Optional.of(higherLayerInterfaceParentEntry);
doReturn(Futures.immediateCheckedFuture(expectedStateInterface)).when(mockReadTx).read(
LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier);
doReturn(Futures.immediateCheckedFuture(expectedParentEntry)).when(mockReadTx).read(
LogicalDatastoreType.CONFIGURATION, interfaceParentEntryIdentifier);
+ doReturn(Futures.immediateCheckedFuture(higherLayerParentOptional)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, higherLevelInterfaceParentEntryIdentifier);
+ doReturn(Futures.immediateCheckedFuture(expectedInterface)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, interfaceInstanceIdentifier);
+ doReturn(Futures.immediateCheckedFuture(expectedChildInterface)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, childInterfaceInstanceIdentifier);
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder ifaceBuilder = new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder();
ifaceBuilder.setAdminStatus(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.AdminStatus.Up)
.setPhysAddress(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress.getDefaultInstance("AA:AA:AA:AA:AA:AA"));
ifaceBuilder.setKey(IfmUtil.getStateInterfaceKeyFromName(InterfaceManagerTestUtil.interfaceName));
+ ifaceBuilder.setOperStatus(OperStatus.Down);
stateInterface = ifaceBuilder.build();
FlowCapableNodeConnectorBuilder fcNodeConnectorOldupdate = new FlowCapableNodeConnectorBuilder().setHardwareAddress(MacAddress.getDefaultInstance("AA:AA:AA:AA:AA:AB"));
FlowCapableNodeConnectorBuilder fcNodeConnectorNewupdate = new FlowCapableNodeConnectorBuilder().setHardwareAddress(MacAddress.getDefaultInstance("AA:AA:AA:AA:AA:AA"));
- StateBuilder b2 = new StateBuilder().setBlocked(true).setLinkDown(true);
+ StateBuilder b2 = new StateBuilder().setBlocked(true).setLinkDown(false);
StateBuilder b3 = new StateBuilder().setBlocked(false).setLinkDown(true);
fcNodeConnectorOldupdate.setState(b2.build());
updateHelper.updateState(fcNodeConnectorId, alivenessMonitorService, dataBroker, InterfaceManagerTestUtil.interfaceName, fcNodeConnectorNewupdate.build(), fcNodeConnectorOldupdate.build());
verify(mockWriteTx).merge(LogicalDatastoreType.OPERATIONAL,interfaceStateIdentifier,stateInterface);
+ verify(mockWriteTx).merge(LogicalDatastoreType.OPERATIONAL,childInterfaceStateIdentifier,stateInterface);
}
}
\ No newline at end of file
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.vpnservice.interfacemgr.IfmConstants;
import org.opendaylight.vpnservice.interfacemgr.IfmUtil;
-import org.opendaylight.vpnservice.interfacemgr.commons.InterfaceManagerCommonUtils;
import org.opendaylight.vpnservice.interfacemgr.commons.InterfaceMetaUtils;
-import org.opendaylight.vpnservice.interfacemgr.renderer.ovs.statehelpers.*;
+import org.opendaylight.vpnservice.interfacemgr.renderer.hwvtep.utilities.SouthboundUtils;
+import org.opendaylight.vpnservice.interfacemgr.renderer.ovs.statehelpers.OvsInterfaceTopologyStateAddHelper;
+import org.opendaylight.vpnservice.interfacemgr.renderer.ovs.statehelpers.OvsInterfaceTopologyStateRemoveHelper;
+import org.opendaylight.vpnservice.interfacemgr.renderer.ovs.statehelpers.OvsInterfaceTopologyStateUpdateHelper;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.flow.capable.port.StateBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.*;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.*;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.IfIndexesInterfaceMap;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._if.indexes._interface.map.IfIndexInterface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._if.indexes._interface.map.IfIndexInterfaceKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._interface.child.info.InterfaceParentEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._interface.child.info.InterfaceParentEntryKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatus;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatusBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.bridge._interface.info.BridgeEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.bridge._interface.info.BridgeEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.bridge._interface.info.bridge.entry.BridgeInterfaceEntry;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
-import javax.swing.plaf.nimbus.State;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
-import java.util.concurrent.Future;
import static org.mockito.Mockito.*;
@Mock ListenerRegistration<DataChangeListener> dataChangeListenerRegistration;
@Mock ReadOnlyTransaction mockReadTx;
@Mock WriteTransaction mockWriteTx;
+ @Mock OvsdbTerminationPointAugmentation newTerminationPoint;
OvsInterfaceTopologyStateAddHelper addHelper;
OvsInterfaceTopologyStateRemoveHelper removeHelper;
+ OvsInterfaceTopologyStateUpdateHelper updateHelper;
@Before
public void setUp() throws Exception {
verify(mockWriteTx).delete(LogicalDatastoreType.OPERATIONAL,bridgeEntryId);
}
+
+ @Test
+ public void testUpdateBridgeReferenceEntry()
+ {
+ Optional<OvsdbBridgeAugmentation>expectedOvsdbBridgeAugmentation = Optional.of(bridgeNew);
+ Optional<BridgeEntry> expectedBridgeEntry = Optional.of(bridgeEntry);
+ Optional<Interface> expectedInterface = Optional.of(tunnelInterfaceEnabled);
+
+ doReturn(Futures.immediateCheckedFuture(expectedInterface)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, interfaceInstanceIdentifier);
+ doReturn(Futures.immediateCheckedFuture(expectedBridgeEntry)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION,bridgeEntryIid);
+ doReturn(Futures.immediateCheckedFuture(expectedOvsdbBridgeAugmentation)).when(mockReadTx).read(
+ LogicalDatastoreType.OPERATIONAL, bridgeIid);
+
+ OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentation = new OvsdbBridgeAugmentationBuilder(bridgeNew);
+ ovsdbBridgeAugmentation.setDatapathId(DatapathId.getDefaultInstance("00:00:00:00:00:00:00:01"));
+ ovsdbBridgeAugmentation.setBridgeName(OvsdbBridgeName.getDefaultInstance("a"));
+ bridgeNew = ovsdbBridgeAugmentation.build();
+
+ updateHelper.updateBridgeRefEntry(bridgeIid, bridgeNew, bridgeOld, dataBroker);
+ }
+
+ @Test
+ public void testUpdateTunnelState(){
+
+ List<InterfaceBfdStatus> interfaceBfdStatus = new ArrayList<InterfaceBfdStatus>();
+ interfaceBfdStatus.add(new InterfaceBfdStatusBuilder().setBfdStatusKey(SouthboundUtils.BFD_OP_STATE).setBfdStatusValue(SouthboundUtils.BFD_STATE_UP).build());
+ List bfdStatusSpy = spy(interfaceBfdStatus);
+ when(newTerminationPoint.getInterfaceBfdStatus()).thenReturn(bfdStatusSpy);
+ updateHelper.updateTunnelState(dataBroker, newTerminationPoint, null);
+
+ //verify
+ InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateId =
+ IfmUtil.buildStateInterfaceId(null);
+ InterfaceBuilder ifaceBuilder = new InterfaceBuilder().setOperStatus(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus.Up);
+ ifaceBuilder.setKey(IfmUtil.getStateInterfaceKeyFromName(null));
+ verify(mockWriteTx).merge(LogicalDatastoreType.OPERATIONAL, ifStateId, ifaceBuilder.build());
+
+ }
}
package org.opendaylight.vpnservice.interfacemgr.test;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.*;
-
import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
-
-import java.math.BigInteger;
-
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.idmanager.IdManager;
import org.opendaylight.vpnservice.interfacemgr.IfmUtil;
import org.opendaylight.vpnservice.interfacemgr.commons.InterfaceMetaUtils;
-import org.opendaylight.vpnservice.interfacemgr.renderer.ovs.confighelpers.OvsInterfaceConfigAddHelper;
-import org.opendaylight.vpnservice.interfacemgr.renderer.ovs.confighelpers.OvsInterfaceConfigRemoveHelper;
+import org.opendaylight.vpnservice.interfacemgr.renderer.ovs.confighelpers.*;
import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.L2vlan;
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.vpnservice.idmanager.rev150403.AllocateIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._interface.child.info.InterfaceParentEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._interface.child.info.InterfaceParentEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._interface.child.info.InterfaceParentEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._interface.child.info._interface.parent.entry.InterfaceChildEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._interface.child.info._interface.parent.entry.InterfaceChildEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._interface.child.info._interface.parent.entry.InterfaceChildEntryKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfL2vlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.ParentRefs;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.*;
+
@RunWith(MockitoJUnitRunner.class)
public class VlanInterfaceConfigurationTest {
@Mock IMdsalApiManager mdsalApiManager;
OvsInterfaceConfigAddHelper addHelper;
OvsInterfaceConfigRemoveHelper removeHelper;
+ OvsVlanMemberConfigAddHelper memberConfigAddHelper;
+ OvsVlanMemberConfigRemoveHelper memberConfigRemoveHelper;
+ OvsVlanMemberConfigUpdateHelper memberConfigUpdateHelper;
NodeConnectorId nodeConnectorId;
NodeConnector nodeConnector;
InstanceIdentifier<Interface> interfaceInstanceIdentifier;
InstanceIdentifier<NodeConnector> nodeConnectorInstanceIdentifier;
InstanceIdentifier<InterfaceParentEntry> interfaceParentEntryIdentifier = null;
+ InterfaceParentEntry interfaceParentEntry;
InterfaceChildEntry interfaceChildEntry = null;
InstanceIdentifier<InterfaceChildEntry> interfaceChildEntryInstanceIdentifier;
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> interfaceStateIdentifier;
new InterfaceChildEntryKey(vlanInterfaceEnabled.getName()));
interfaceChildEntry = new InterfaceChildEntryBuilder().setKey(new InterfaceChildEntryKey(vlanInterfaceEnabled.getName())).
setChildInterface(vlanInterfaceEnabled.getName()).build();
+
+ InterfaceParentEntryBuilder ifaceParentEntryBuilder = new InterfaceParentEntryBuilder();
+ List<InterfaceChildEntry> ifaceChildEntryList= new ArrayList<>();
+ ifaceChildEntryList.add(interfaceChildEntry);
+ interfaceParentEntry = ifaceParentEntryBuilder.setInterfaceChildEntry(ifaceChildEntryList).build();
+
// Setup mocks
when(dataBroker.newReadOnlyTransaction()).thenReturn(mockReadTx);
when(dataBroker.newWriteOnlyTransaction()).thenReturn(mockWriteTx);
//verification
verify(mockWriteTx).delete(LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier);
}
+
+ @Test
+ public void testAddMemberConfiguration(){
+
+ Optional<Interface> expectedInterface = Optional.of(vlanInterfaceEnabled);
+ Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> expectedStateInterface = Optional.of(stateInterface);
+
+ doReturn(Futures.immediateCheckedFuture(expectedInterface)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, interfaceInstanceIdentifier);
+ doReturn(Futures.immediateCheckedFuture(expectedStateInterface)).when(mockReadTx).read(
+ LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier);
+
+ memberConfigAddHelper.addConfiguration(dataBroker, vlanInterfaceEnabled.getAugmentation(ParentRefs.class), vlanInterfaceEnabled, null, idManager);
+ }
+
+ @Test
+ public void testRemoveMemberConfiguration(){
+
+ Optional<InterfaceParentEntry> expectedParentEntry = Optional.of(interfaceParentEntry);
+ Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> expectedStateInterface = Optional.of(stateInterface);
+
+ doReturn(Futures.immediateCheckedFuture(expectedParentEntry)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, interfaceParentEntryIdentifier);
+ doReturn(Futures.immediateCheckedFuture(expectedStateInterface)).when(mockReadTx).read(
+ LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier);
+
+ memberConfigRemoveHelper.removeConfiguration(dataBroker, vlanInterfaceEnabled.getAugmentation(ParentRefs.class), vlanInterfaceEnabled, null, idManager);
+ }
+
+ @Test
+ public void testUpdateMemberConfiguration(){
+
+ Optional<InterfaceChildEntry> expectedChildEntry = Optional.of(interfaceChildEntry);
+ Optional<InterfaceParentEntry> expectedParentEntry = Optional.of(interfaceParentEntry);
+ Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> expectedStateInterface = Optional.of(stateInterface);
+ Optional<Interface> expectedInterface = Optional.of(vlanInterfaceEnabled);
+
+ doReturn(Futures.immediateCheckedFuture(expectedChildEntry)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, interfaceChildEntryInstanceIdentifier);
+ doReturn(Futures.immediateCheckedFuture(expectedParentEntry)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, interfaceParentEntryIdentifier);
+ doReturn(Futures.immediateCheckedFuture(expectedStateInterface)).when(mockReadTx).read(
+ LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier);
+ doReturn(Futures.immediateCheckedFuture(expectedInterface)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, interfaceInstanceIdentifier);
+
+ memberConfigUpdateHelper.updateConfiguration(dataBroker, alivenessMonitorService, vlanInterfaceEnabled.getAugmentation(ParentRefs.class), vlanInterfaceDisabled, vlanInterfaceEnabled.getAugmentation(IfL2vlan.class), vlanInterfaceEnabled, idManager, mdsalApiManager);
+ }
}
import org.opendaylight.vpnservice.interfacemgr.globals.InterfaceInfo;
import org.opendaylight.vpnservice.interfacemgr.globals.InterfaceInfo.InterfaceOpState;
-import org.opendaylight.vpnservice.interfacemgr.globals.VlanInterfaceInfo;
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.vpnservice.interfacemgr.rev150331.IfL2vlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfTunnel;
ifTunnel.getTunnelSource().getIpv4Address().getValue(),
ifTunnel.getTunnelDestination().getIpv4Address().getValue(),
ifTunnel.getTunnelGateway() == null ? UNSET : ifTunnel.getTunnelGateway().getIpv4Address().getValue(),
- (interfaceInfo == null) ? UNSET : interfaceInfo.getAdminState()));
+ (interfaceInfo == null) ? InterfaceInfo.InterfaceAdminState.DISABLED : interfaceInfo.getAdminState()));
sb.setLength(0);
ParentRefs parentRefs = iface.getAugmentation(ParentRefs.class);
System.out.println(fmt.format(VXLAN_OUTPUT_FORMAT + "\n",
- (interfaceInfo == null) ? UNSET : interfaceInfo.getOpState(),
+ (interfaceInfo == null) ? InterfaceOpState.DOWN : interfaceInfo.getOpState(),
String.format("%s/%s", parentRefs.getDatapathNodeIdentifier(),
parentRefs.getParentInterface()),
(interfaceInfo == null) ? UNSET : interfaceInfo.getInterfaceTag(), ""));