From c2382c2e8bd50b28003d41bcf1f5129273379f53 Mon Sep 17 00:00:00 2001 From: Kiran N Upadhyaya Date: Wed, 30 Mar 2016 18:59:36 +0530 Subject: [PATCH] HwVTEP JUNITs, and fixing show:vxlan CLI 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 --- .../HwVTEPInterfaceConfigAddHelper.java | 19 -- .../test/HwVTEPConfigurationTest.java | 209 ++++++++++++++++++ .../test/InterfaceManagerTestUtil.java | 1 + .../interfacemgr/test/StateInterfaceTest.java | 100 ++++++++- .../test/TopologyStateInterfaceTest.java | 70 ++++-- .../test/VlanInterfaceConfigurationTest.java | 77 ++++++- .../interfacemgr/shell/IfmCLIUtil.java | 5 +- 7 files changed, 425 insertions(+), 56 deletions(-) create mode 100644 interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/HwVTEPConfigurationTest.java diff --git a/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/renderer/hwvtep/confighelpers/HwVTEPInterfaceConfigAddHelper.java b/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/renderer/hwvtep/confighelpers/HwVTEPInterfaceConfigAddHelper.java index 202b6b59..113f76e0 100644 --- a/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/renderer/hwvtep/confighelpers/HwVTEPInterfaceConfigAddHelper.java +++ b/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/renderer/hwvtep/confighelpers/HwVTEPInterfaceConfigAddHelper.java @@ -77,25 +77,6 @@ public class HwVTEPInterfaceConfigAddHelper { return tpPath; } - - private static InstanceIdentifier createLocalPhysicalLocatorEntryIfNotPresent(List> futures, - DataBroker dataBroker, - WriteTransaction transaction, - IfTunnel ifTunnel, - InstanceIdentifier nodeIid){ - String localIp = ifTunnel.getTunnelSource().getIpv4Address().getValue(); - LOG.debug("creating local physical locator entry {}", localIp); - TerminationPointKey tpKey = SouthboundUtils.getTerminationPointKey(localIp); - InstanceIdentifier 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 */ diff --git a/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/HwVTEPConfigurationTest.java b/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/HwVTEPConfigurationTest.java new file mode 100644 index 00000000..048f6386 --- /dev/null +++ b/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/HwVTEPConfigurationTest.java @@ -0,0 +1,209 @@ +/* + * 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 dataChangeListenerRegistration; + @Mock ReadOnlyTransaction mockReadTx; + @Mock WriteTransaction mockWriteTx; + @Mock InstanceIdentifier 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 tpPath; + TerminationPoint terminationPoint; + InstanceIdentifier physicalSwitchId; + InstanceIdentifier globalId; + InstanceIdentifier tunnelsInstanceIdentifier; + InstanceIdentifier 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 tunnelInterfaceOptional = Optional.of(tunnelInterface); + + doReturn(Futures.immediateCheckedFuture(tunnelInterfaceOptional)).when(mockReadTx).read( + LogicalDatastoreType.OPERATIONAL, tunnelInterfaceId); + List bfdStatus = new ArrayList(); + 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 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 = new ArrayList<>(); + SouthboundUtils.fillBfdParameters(bfdParams, null); + tBuilder.setBfdParams(bfdParams); + //Verify + verify(mockWriteTx).put(LogicalDatastoreType.CONFIGURATION, tunnelsInstanceIdentifier, tBuilder.build(), true); + } +} diff --git a/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/InterfaceManagerTestUtil.java b/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/InterfaceManagerTestUtil.java index 9b1e0feb..28bb7643 100644 --- a/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/InterfaceManagerTestUtil.java +++ b/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/InterfaceManagerTestUtil.java @@ -105,6 +105,7 @@ import java.util.*; 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")); diff --git a/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/StateInterfaceTest.java b/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/StateInterfaceTest.java index 14a94450..1092f7ed 100644 --- a/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/StateInterfaceTest.java +++ b/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/StateInterfaceTest.java @@ -48,6 +48,10 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.met 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; @@ -70,16 +74,23 @@ public class StateInterfaceTest { FlowCapableNodeConnector fcNodeConnectorNew = null; Interface vlanInterfaceEnabled = null; Interface vlanInterfaceDisabled = null; + Interface tunnelInterfaceEnabled; + Interface childVlanInterfaceEnabled = null; InterfaceParentEntryKey interfaceParentEntryKey = null; + InterfaceParentEntryKey higherLayerInterfaceParentEntryKey = null; IfIndexInterface IfindexInterface = null; InstanceIdentifier interfaceInstanceIdentifier = null; + InstanceIdentifier childInterfaceInstanceIdentifier= null; InstanceIdentifier interfaceParentEntryInstanceIdentifier = null; InstanceIdentifier fcNodeConnectorId = null; InstanceIdentifier ifIndexId =null; InstanceIdentifier interfaceStateIdentifier = null; + InstanceIdentifier childInterfaceStateIdentifier = null; InstanceIdentifier interfaceParentEntryIdentifier = null; + InstanceIdentifier 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; @@ -112,11 +123,17 @@ public class StateInterfaceTest { 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 lowerLayerIfList = new ArrayList<>(); lowerLayerIfList.add(nodeConnectorId.getValue()); @@ -130,8 +147,13 @@ public class StateInterfaceTest { InterfaceParentEntryBuilder ifaceParentEntryBuilder = new InterfaceParentEntryBuilder(); List ifaceChildEntryList= new ArrayList<>(); + ifaceChildEntryList.add(new InterfaceChildEntryBuilder().setChildInterface(InterfaceManagerTestUtil.interfaceName2).build()); interfaceParentEntry = ifaceParentEntryBuilder.setInterfaceChildEntry(ifaceChildEntryList).build(); + InterfaceParentEntryBuilder higherLayerIfParentEntryBuilder = new InterfaceParentEntryBuilder(); + List ifaceChildEntryListForHigherParent= new ArrayList<>(); + higherLayerInterfaceParentEntry = higherLayerIfParentEntryBuilder.setInterfaceChildEntry(ifaceChildEntryListForHigherParent).build(); + when(dataBroker.newReadOnlyTransaction()).thenReturn(mockReadTx); when(dataBroker.newWriteOnlyTransaction()).thenReturn(mockWriteTx); } @@ -140,17 +162,31 @@ public class StateInterfaceTest { public void testAddStateInterface() { Optional expectedInterface = Optional.of(vlanInterfaceEnabled); AllocateIdOutput expectedId = new AllocateIdOutputBuilder().setIdValue(Long.valueOf("100")).build(); + AllocateIdOutput expectedId2 = new AllocateIdOutputBuilder().setIdValue(Long.valueOf("200")).build(); + OptionalexpectedParentEntry = Optional.of(interfaceParentEntry); + Optional higherLayerParentOptional = Optional.of(higherLayerInterfaceParentEntry); + Optional expectedChildInterface = Optional.of(childVlanInterfaceEnabled); Future> idOutputOptional = RpcResultBuilder.success(expectedId).buildFuture(); + Future> 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); @@ -159,19 +195,48 @@ public class StateInterfaceTest { verify(mockWriteTx).put(LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier, stateInterface,true); } + + @Test + public void testAddStateTunnelInterface() { + + Optional expectedInterface = Optional.of(tunnelInterfaceEnabled); + AllocateIdOutput expectedId = new AllocateIdOutputBuilder().setIdValue(Long.valueOf("100")).build(); + + Future> 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 expectedStateInterface = Optional.of(stateInterface); Optional expectedIfindexInterface = Optional.of(IfindexInterface); + Optional expectedInterface = Optional.of(vlanInterfaceEnabled); + OptionalexpectedParentEntry = Optional.of(interfaceParentEntry); + Optional 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) @@ -184,29 +249,55 @@ public class StateInterfaceTest { verify(mockWriteTx).delete(LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier); } + + @Test + public void testDeleteStateTunnelInterface() { + Optional + expectedStateInterface = Optional.of(stateInterface); + Optional 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 expectedStateInterface = Optional.of(stateInterface); OptionalexpectedParentEntry = Optional.of(interfaceParentEntry); + Optional expectedInterface = Optional.of(vlanInterfaceEnabled); + Optional expectedChildInterface = Optional.of(childVlanInterfaceEnabled); + Optional 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()); @@ -215,5 +306,6 @@ public class StateInterfaceTest { 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 diff --git a/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/TopologyStateInterfaceTest.java b/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/TopologyStateInterfaceTest.java index 36649f99..6938837b 100644 --- a/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/TopologyStateInterfaceTest.java +++ b/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/TopologyStateInterfaceTest.java @@ -16,27 +16,17 @@ 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.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; @@ -51,14 +41,10 @@ import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology. 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.*; @@ -82,9 +68,11 @@ public class TopologyStateInterfaceTest { @Mock ListenerRegistration dataChangeListenerRegistration; @Mock ReadOnlyTransaction mockReadTx; @Mock WriteTransaction mockWriteTx; + @Mock OvsdbTerminationPointAugmentation newTerminationPoint; OvsInterfaceTopologyStateAddHelper addHelper; OvsInterfaceTopologyStateRemoveHelper removeHelper; + OvsInterfaceTopologyStateUpdateHelper updateHelper; @Before public void setUp() throws Exception { @@ -166,4 +154,44 @@ public class TopologyStateInterfaceTest { verify(mockWriteTx).delete(LogicalDatastoreType.OPERATIONAL,bridgeEntryId); } + + @Test + public void testUpdateBridgeReferenceEntry() + { + OptionalexpectedOvsdbBridgeAugmentation = Optional.of(bridgeNew); + Optional expectedBridgeEntry = Optional.of(bridgeEntry); + Optional 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 = new ArrayList(); + 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 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()); + + } } diff --git a/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/VlanInterfaceConfigurationTest.java b/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/VlanInterfaceConfigurationTest.java index 0f61af1f..2ec295df 100644 --- a/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/VlanInterfaceConfigurationTest.java +++ b/interfacemgr/interfacemgr-impl/src/test/java/org/opendaylight/vpnservice/interfacemgr/test/VlanInterfaceConfigurationTest.java @@ -8,21 +8,14 @@ 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; @@ -33,8 +26,7 @@ import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; 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; @@ -46,16 +38,25 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150 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 { @@ -70,6 +71,9 @@ public class VlanInterfaceConfigurationTest { @Mock IMdsalApiManager mdsalApiManager; OvsInterfaceConfigAddHelper addHelper; OvsInterfaceConfigRemoveHelper removeHelper; + OvsVlanMemberConfigAddHelper memberConfigAddHelper; + OvsVlanMemberConfigRemoveHelper memberConfigRemoveHelper; + OvsVlanMemberConfigUpdateHelper memberConfigUpdateHelper; NodeConnectorId nodeConnectorId; NodeConnector nodeConnector; @@ -78,6 +82,7 @@ public class VlanInterfaceConfigurationTest { InstanceIdentifier interfaceInstanceIdentifier; InstanceIdentifier nodeConnectorInstanceIdentifier; InstanceIdentifier interfaceParentEntryIdentifier = null; + InterfaceParentEntry interfaceParentEntry; InterfaceChildEntry interfaceChildEntry = null; InstanceIdentifier interfaceChildEntryInstanceIdentifier; InstanceIdentifier interfaceStateIdentifier; @@ -117,6 +122,12 @@ public class VlanInterfaceConfigurationTest { new InterfaceChildEntryKey(vlanInterfaceEnabled.getName())); interfaceChildEntry = new InterfaceChildEntryBuilder().setKey(new InterfaceChildEntryKey(vlanInterfaceEnabled.getName())). setChildInterface(vlanInterfaceEnabled.getName()).build(); + + InterfaceParentEntryBuilder ifaceParentEntryBuilder = new InterfaceParentEntryBuilder(); + List ifaceChildEntryList= new ArrayList<>(); + ifaceChildEntryList.add(interfaceChildEntry); + interfaceParentEntry = ifaceParentEntryBuilder.setInterfaceChildEntry(ifaceChildEntryList).build(); + // Setup mocks when(dataBroker.newReadOnlyTransaction()).thenReturn(mockReadTx); when(dataBroker.newWriteOnlyTransaction()).thenReturn(mockWriteTx); @@ -209,4 +220,52 @@ public class VlanInterfaceConfigurationTest { //verification verify(mockWriteTx).delete(LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier); } + + @Test + public void testAddMemberConfiguration(){ + + Optional expectedInterface = Optional.of(vlanInterfaceEnabled); + Optional 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 expectedParentEntry = Optional.of(interfaceParentEntry); + Optional 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 expectedChildEntry = Optional.of(interfaceChildEntry); + Optional expectedParentEntry = Optional.of(interfaceParentEntry); + Optional expectedStateInterface = Optional.of(stateInterface); + Optional 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); + } } diff --git a/interfacemgr/interfacemgr-shell/src/main/java/org/opendaylight/vpnservice/interfacemgr/shell/IfmCLIUtil.java b/interfacemgr/interfacemgr-shell/src/main/java/org/opendaylight/vpnservice/interfacemgr/shell/IfmCLIUtil.java index d90f57e3..f2662e4e 100644 --- a/interfacemgr/interfacemgr-shell/src/main/java/org/opendaylight/vpnservice/interfacemgr/shell/IfmCLIUtil.java +++ b/interfacemgr/interfacemgr-shell/src/main/java/org/opendaylight/vpnservice/interfacemgr/shell/IfmCLIUtil.java @@ -9,7 +9,6 @@ package org.opendaylight.vpnservice.interfacemgr.shell; 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; @@ -95,11 +94,11 @@ public class IfmCLIUtil { 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(), "")); -- 2.36.6