add unit test to Router class
Change-Id: I26d129fdae3b247e7f3976b7fbe953bef47cd4fd
diff --git a/apps/sdnip/src/test/java/org/onlab/onos/sdnip/RouterTest.java b/apps/sdnip/src/test/java/org/onlab/onos/sdnip/RouterTest.java
new file mode 100644
index 0000000..9ab5916
--- /dev/null
+++ b/apps/sdnip/src/test/java/org/onlab/onos/sdnip/RouterTest.java
@@ -0,0 +1,465 @@
+package org.onlab.onos.sdnip;
+
+import static org.easymock.EasyMock.createMock;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.replay;
+import static org.easymock.EasyMock.reset;
+import static org.easymock.EasyMock.verify;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.onos.ApplicationId;
+import org.onlab.onos.net.ConnectPoint;
+import org.onlab.onos.net.DefaultHost;
+import org.onlab.onos.net.DeviceId;
+import org.onlab.onos.net.Host;
+import org.onlab.onos.net.HostId;
+import org.onlab.onos.net.HostLocation;
+import org.onlab.onos.net.PortNumber;
+import org.onlab.onos.net.flow.DefaultTrafficSelector;
+import org.onlab.onos.net.flow.DefaultTrafficTreatment;
+import org.onlab.onos.net.flow.TrafficSelector;
+import org.onlab.onos.net.flow.TrafficTreatment;
+import org.onlab.onos.net.host.HostService;
+import org.onlab.onos.net.intent.IntentService;
+import org.onlab.onos.net.intent.MultiPointToSinglePointIntent;
+import org.onlab.onos.net.provider.ProviderId;
+import org.onlab.onos.sdnip.config.BgpPeer;
+import org.onlab.onos.sdnip.config.Interface;
+import org.onlab.onos.sdnip.config.SdnIpConfigService;
+import org.onlab.packet.Ethernet;
+import org.onlab.packet.IpAddress;
+import org.onlab.packet.IpPrefix;
+import org.onlab.packet.MacAddress;
+import org.onlab.packet.VlanId;
+import org.onlab.util.TestUtils;
+import org.onlab.util.TestUtils.TestUtilsException;
+
+import com.google.common.collect.Sets;
+
+/**
+ * This class tests adding a route, updating a route, deleting a route,
+ * and adding a route whose next hop is the local BGP speaker.
+ */
+public class RouterTest {
+
+ private SdnIpConfigService sdnIpConfigService;
+ private InterfaceService interfaceService;
+ private IntentService intentService;
+ private HostService hostService;
+
+ private Map<IpAddress, BgpPeer> bgpPeers;
+ private Map<IpAddress, BgpPeer> configuredPeers;
+ private Set<Interface> interfaces;
+ private Set<Interface> configuredInterfaces;
+
+ private static final ApplicationId APPID = new ApplicationId() {
+ @Override
+ public short id() {
+ return 1;
+ }
+
+ @Override
+ public String name() {
+ return "SDNIP";
+ }
+ };
+
+ private Router router;
+
+ @Before
+ public void setUp() throws Exception {
+ bgpPeers = setUpBgpPeers();
+ interfaces = setUpInterfaces();
+ initRouter();
+ }
+
+ /**
+ * Initializes Router class.
+ */
+ private void initRouter() {
+
+ intentService = createMock(IntentService.class);
+ hostService = createMock(HostService.class);
+
+ interfaceService = createMock(InterfaceService.class);
+ expect(interfaceService.getInterfaces()).andReturn(
+ interfaces).anyTimes();
+
+ Set<IpPrefix> ipAddressesOnSw1Eth1 = new HashSet<IpPrefix>();
+ ipAddressesOnSw1Eth1.add(IpPrefix.valueOf("192.168.10.0/24"));
+ Interface expectedInterface =
+ new Interface(new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000001"),
+ PortNumber.portNumber("1")),
+ ipAddressesOnSw1Eth1,
+ MacAddress.valueOf("00:00:00:00:00:01"));
+ ConnectPoint egressPoint = new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000001"),
+ PortNumber.portNumber(1));
+ expect(interfaceService.getInterface(egressPoint)).andReturn(
+ expectedInterface).anyTimes();
+
+ Set<IpPrefix> ipAddressesOnSw2Eth1 = new HashSet<IpPrefix>();
+ ipAddressesOnSw2Eth1.add(IpPrefix.valueOf("192.168.20.0/24"));
+ Interface expectedInterfaceNew =
+ new Interface(new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000002"),
+ PortNumber.portNumber("1")),
+ ipAddressesOnSw2Eth1,
+ MacAddress.valueOf("00:00:00:00:00:02"));
+ ConnectPoint egressPointNew = new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000002"),
+ PortNumber.portNumber(1));
+ expect(interfaceService.getInterface(egressPointNew)).andReturn(
+ expectedInterfaceNew).anyTimes();
+ replay(interfaceService);
+
+ sdnIpConfigService = createMock(SdnIpConfigService.class);
+ expect(sdnIpConfigService.getBgpPeers()).andReturn(bgpPeers).anyTimes();
+ replay(sdnIpConfigService);
+
+ router = new Router(APPID, intentService,
+ hostService, sdnIpConfigService, interfaceService);
+ }
+
+ /**
+ * Sets up BGP peers in external networks.
+ *
+ * @return configured BGP peers as a Map from peer IP address to BgpPeer
+ */
+ private Map<IpAddress, BgpPeer> setUpBgpPeers() {
+
+ configuredPeers = new HashMap<>();
+
+ String peerSw1Eth1 = "192.168.10.1";
+ configuredPeers.put(IpAddress.valueOf(peerSw1Eth1),
+ new BgpPeer("00:00:00:00:00:00:00:01", 1, peerSw1Eth1));
+
+ // Two BGP peers are connected to switch 2 port 1.
+ String peer1Sw2Eth1 = "192.168.20.1";
+ configuredPeers.put(IpAddress.valueOf(peer1Sw2Eth1),
+ new BgpPeer("00:00:00:00:00:00:00:02", 1, peer1Sw2Eth1));
+
+ String peer2Sw2Eth1 = "192.168.20.2";
+ configuredPeers.put(IpAddress.valueOf(peer2Sw2Eth1),
+ new BgpPeer("00:00:00:00:00:00:00:02", 1, peer2Sw2Eth1));
+
+ return configuredPeers;
+ }
+
+ /**
+ * Sets up logical interfaces, which emulate the configured interfaces
+ * in SDN-IP application.
+ *
+ * @return configured interfaces as a Set
+ */
+ private Set<Interface> setUpInterfaces() {
+
+ configuredInterfaces = Sets.newHashSet();
+
+ Set<IpPrefix> ipAddressesOnSw1Eth1 = new HashSet<IpPrefix>();
+ ipAddressesOnSw1Eth1.add(IpPrefix.valueOf("192.168.10.0/24"));
+ configuredInterfaces.add(
+ new Interface(new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000001"),
+ PortNumber.portNumber(1)),
+ ipAddressesOnSw1Eth1,
+ MacAddress.valueOf("00:00:00:00:00:01")));
+
+ Set<IpPrefix> ipAddressesOnSw2Eth1 = new HashSet<IpPrefix>();
+ ipAddressesOnSw2Eth1.add(IpPrefix.valueOf("192.168.20.0/24"));
+ configuredInterfaces.add(
+ new Interface(new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000002"),
+ PortNumber.portNumber(1)),
+ ipAddressesOnSw2Eth1,
+ MacAddress.valueOf("00:00:00:00:00:02")));
+
+ Set<IpPrefix> ipAddressesOnSw3Eth1 = new HashSet<IpPrefix>();
+ ipAddressesOnSw3Eth1.add(IpPrefix.valueOf("192.168.30.0/24"));
+ configuredInterfaces.add(
+ new Interface(new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000003"),
+ PortNumber.portNumber(1)),
+ ipAddressesOnSw3Eth1,
+ MacAddress.valueOf("00:00:00:00:00:03")));
+
+ return configuredInterfaces;
+ }
+
+ /**
+ * This method tests adding a route entry.
+ */
+ @Test
+ public void testProcessRouteAdd() throws TestUtilsException {
+
+ // Construct a route entry
+ RouteEntry routeEntry = new RouteEntry(
+ IpPrefix.valueOf("1.1.1.0/24"),
+ IpAddress.valueOf("192.168.10.1"));
+
+ // Construct a MultiPointToSinglePointIntent intent
+ TrafficSelector.Builder selectorBuilder =
+ DefaultTrafficSelector.builder();
+ selectorBuilder.matchEthType(Ethernet.TYPE_IPV4).matchIPDst(
+ routeEntry.prefix());
+
+ TrafficTreatment.Builder treatmentBuilder =
+ DefaultTrafficTreatment.builder();
+ treatmentBuilder.setEthDst(MacAddress.valueOf("00:00:00:00:00:01"));
+
+ Set<ConnectPoint> ingressPoints = new HashSet<ConnectPoint>();
+ ingressPoints.add(new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000002"),
+ PortNumber.portNumber("1")));
+ ingressPoints.add(new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000003"),
+ PortNumber.portNumber("1")));
+
+ ConnectPoint egressPoint = new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000001"),
+ PortNumber.portNumber("1"));
+
+ MultiPointToSinglePointIntent intent =
+ new MultiPointToSinglePointIntent(APPID,
+ selectorBuilder.build(), treatmentBuilder.build(),
+ ingressPoints, egressPoint);
+
+ // Reset host service
+ reset(hostService);
+ Set<Host> hosts = new HashSet<Host>(1);
+ Set<IpPrefix> ipPrefixes = new HashSet<IpPrefix>();
+ ipPrefixes.add(IpPrefix.valueOf("192.168.10.1/32"));
+ hosts.add(new DefaultHost(ProviderId.NONE, HostId.NONE,
+ MacAddress.valueOf("00:00:00:00:00:01"), VlanId.NONE,
+ new HostLocation(
+ DeviceId.deviceId("of:0000000000000001"),
+ PortNumber.portNumber(1), 1),
+ ipPrefixes));
+ expect(hostService.getHostsByIp(
+ IpPrefix.valueOf("192.168.10.1/32"))).andReturn(hosts);
+ replay(hostService);
+
+ // Set up test expectation
+ reset(intentService);
+ intentService.submit(intent);
+ replay(intentService);
+
+ // Call the processRouteAdd() method in Router class
+ router.leaderChanged(true);
+ TestUtils.setField(router, "isActivatedLeader", true);
+ router.processRouteAdd(routeEntry);
+
+ // Verify
+ assertEquals(router.getRoutes().size(), 1);
+ assertTrue(router.getRoutes().contains(routeEntry));
+ assertEquals(router.getPushedRouteIntents().size(), 1);
+ assertEquals(router.getPushedRouteIntents().iterator().next(),
+ intent);
+ verify(intentService);
+ }
+
+ /**
+ * This method tests updating a route entry.
+ *
+ * @throws TestUtilsException
+ */
+ @Test
+ public void testRouteUpdate() throws TestUtilsException {
+
+ // Firstly add a route
+ testProcessRouteAdd();
+
+ // Construct the existing route entry
+ RouteEntry routeEntry = new RouteEntry(
+ IpPrefix.valueOf("1.1.1.0/24"),
+ IpAddress.valueOf("192.168.10.1"));
+
+ // Construct the existing MultiPointToSinglePointIntent intent
+ TrafficSelector.Builder selectorBuilder =
+ DefaultTrafficSelector.builder();
+ selectorBuilder.matchEthType(Ethernet.TYPE_IPV4).matchIPDst(
+ routeEntry.prefix());
+
+ TrafficTreatment.Builder treatmentBuilder =
+ DefaultTrafficTreatment.builder();
+ treatmentBuilder.setEthDst(MacAddress.valueOf("00:00:00:00:00:01"));
+
+ ConnectPoint egressPoint = new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000001"),
+ PortNumber.portNumber("1"));
+
+ Set<ConnectPoint> ingressPoints = new HashSet<ConnectPoint>();
+ ingressPoints.add(new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000002"),
+ PortNumber.portNumber("1")));
+ ingressPoints.add(new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000003"),
+ PortNumber.portNumber("1")));
+
+ MultiPointToSinglePointIntent intent =
+ new MultiPointToSinglePointIntent(APPID,
+ selectorBuilder.build(), treatmentBuilder.build(),
+ ingressPoints, egressPoint);
+
+ // Start to construct a new route entry and new intent
+ RouteEntry routeEntryUpdate = new RouteEntry(
+ IpPrefix.valueOf("1.1.1.0/24"),
+ IpAddress.valueOf("192.168.20.1"));
+
+ // Construct a new MultiPointToSinglePointIntent intent
+ TrafficSelector.Builder selectorBuilderNew =
+ DefaultTrafficSelector.builder();
+ selectorBuilderNew.matchEthType(Ethernet.TYPE_IPV4).matchIPDst(
+ routeEntryUpdate.prefix());
+
+ TrafficTreatment.Builder treatmentBuilderNew =
+ DefaultTrafficTreatment.builder();
+ treatmentBuilderNew.setEthDst(MacAddress.valueOf("00:00:00:00:00:02"));
+
+ ConnectPoint egressPointNew = new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000002"),
+ PortNumber.portNumber("1"));
+
+ Set<ConnectPoint> ingressPointsNew = new HashSet<ConnectPoint>();
+ ingressPointsNew.add(new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000001"),
+ PortNumber.portNumber("1")));
+ ingressPointsNew.add(new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000003"),
+ PortNumber.portNumber("1")));
+
+ MultiPointToSinglePointIntent intentNew =
+ new MultiPointToSinglePointIntent(APPID,
+ selectorBuilderNew.build(),
+ treatmentBuilderNew.build(),
+ ingressPointsNew, egressPointNew);
+
+ // Reset host service
+ reset(hostService);
+ Set<Host> hosts = new HashSet<Host>(1);
+ Set<IpPrefix> ipPrefixes = new HashSet<IpPrefix>();
+ ipPrefixes.add(IpPrefix.valueOf("192.168.20.1/32"));
+ hosts.add(new DefaultHost(ProviderId.NONE, HostId.NONE,
+ MacAddress.valueOf("00:00:00:00:00:02"), VlanId.NONE,
+ new HostLocation(
+ DeviceId.deviceId("of:0000000000000002"),
+ PortNumber.portNumber(1), 1),
+ ipPrefixes));
+ expect(hostService.getHostsByIp(
+ IpPrefix.valueOf("192.168.20.1/32"))).andReturn(hosts);
+ replay(hostService);
+
+ // Set up test expectation
+ reset(intentService);
+ intentService.withdraw(intent);
+ intentService.submit(intentNew);
+ replay(intentService);
+
+ // Call the processRouteAdd() method in Router class
+ router.leaderChanged(true);
+ TestUtils.setField(router, "isActivatedLeader", true);
+ router.processRouteAdd(routeEntryUpdate);
+
+ // Verify
+ assertEquals(router.getRoutes().size(), 1);
+ assertTrue(router.getRoutes().contains(routeEntryUpdate));
+ assertEquals(router.getPushedRouteIntents().size(), 1);
+ assertEquals(router.getPushedRouteIntents().iterator().next(),
+ intentNew);
+ verify(intentService);
+ }
+
+ /**
+ * This method tests deleting a route entry.
+ */
+ @Test
+ public void testProcessRouteDelete() throws TestUtilsException {
+
+ // Firstly add a route
+ testProcessRouteAdd();
+
+ // Construct the existing route entry
+ RouteEntry routeEntry = new RouteEntry(
+ IpPrefix.valueOf("1.1.1.0/24"),
+ IpAddress.valueOf("192.168.10.1"));
+
+ // Construct the existing MultiPointToSinglePointIntent intent
+ TrafficSelector.Builder selectorBuilder =
+ DefaultTrafficSelector.builder();
+ selectorBuilder.matchEthType(Ethernet.TYPE_IPV4).matchIPDst(
+ routeEntry.prefix());
+
+ TrafficTreatment.Builder treatmentBuilder =
+ DefaultTrafficTreatment.builder();
+ treatmentBuilder.setEthDst(MacAddress.valueOf("00:00:00:00:00:01"));
+
+ ConnectPoint egressPoint = new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000001"),
+ PortNumber.portNumber("1"));
+
+ Set<ConnectPoint> ingressPoints = new HashSet<ConnectPoint>();
+ ingressPoints.add(new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000002"),
+ PortNumber.portNumber("1")));
+ ingressPoints.add(new ConnectPoint(
+ DeviceId.deviceId("of:0000000000000003"),
+ PortNumber.portNumber("1")));
+
+ MultiPointToSinglePointIntent intent =
+ new MultiPointToSinglePointIntent(APPID,
+ selectorBuilder.build(), treatmentBuilder.build(),
+ ingressPoints, egressPoint);
+
+ // Set up expectation
+ reset(intentService);
+ intentService.withdraw(intent);
+ replay(intentService);
+
+ // Call route deleting method in Router class
+ router.leaderChanged(true);
+ TestUtils.setField(router, "isActivatedLeader", true);
+ router.processRouteDelete(routeEntry);
+
+ // Verify
+ assertEquals(router.getRoutes().size(), 0);
+ assertEquals(router.getPushedRouteIntents().size(), 0);
+ verify(intentService);
+ }
+
+ /**
+ * This method tests when the next hop of a route is the local BGP speaker.
+ *
+ * @throws TestUtilsException
+ */
+ @Test
+ public void testLocalRouteAdd() throws TestUtilsException {
+
+ // Construct a route entry, the next hop is the local BGP speaker
+ RouteEntry routeEntry = new RouteEntry(
+ IpPrefix.valueOf("1.1.1.0/24"), IpAddress.valueOf("0.0.0.0"));
+
+ // Reset intentService to check whether the submit method is called
+ reset(intentService);
+ replay(intentService);
+
+ // Call the processRouteAdd() method in Router class
+ router.leaderChanged(true);
+ TestUtils.setField(router, "isActivatedLeader", true);
+ router.processRouteAdd(routeEntry);
+
+ // Verify
+ assertEquals(router.getRoutes().size(), 1);
+ assertTrue(router.getRoutes().contains(routeEntry));
+ assertEquals(router.getPushedRouteIntents().size(), 0);
+ verify(intentService);
+ }
+}