Completed testing of EdgeManager

Change-Id: I2d2f5ba62951951f29780904acfa5eec07657129

@@ -15,47 +15,80 @@
  */
 package org.onosproject.net.edgeservice.impl;
 
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.onosproject.common.event.impl.TestEventDispatcher;
+import org.onosproject.event.Event;
 import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.DefaultPort;
 import org.onosproject.net.Device;
 import org.onosproject.net.DeviceId;
+import org.onosproject.net.NetTestTools;
 import org.onosproject.net.Port;
+import org.onosproject.net.PortNumber;
+import org.onosproject.net.device.DeviceEvent;
 import org.onosproject.net.device.DeviceServiceAdapter;
 import org.onosproject.net.edge.EdgePortEvent;
 import org.onosproject.net.edge.EdgePortListener;
+import org.onosproject.net.flow.TrafficTreatment;
+import org.onosproject.net.link.LinkEvent;
+import org.onosproject.net.packet.OutboundPacket;
 import org.onosproject.net.packet.PacketServiceAdapter;
 import org.onosproject.net.topology.Topology;
+import org.onosproject.net.topology.TopologyEvent;
 import org.onosproject.net.topology.TopologyListener;
 import org.onosproject.net.topology.TopologyServiceAdapter;
 
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 
-import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.*;
+import static org.onosproject.net.device.DeviceEvent.Type.*;
+import static org.onosproject.net.edge.EdgePortEvent.Type.EDGE_PORT_ADDED;
+import static org.onosproject.net.edge.EdgePortEvent.Type.EDGE_PORT_REMOVED;
+import static org.onosproject.net.link.LinkEvent.Type.LINK_ADDED;
+import static org.onosproject.net.link.LinkEvent.Type.LINK_REMOVED;
+import static org.onosproject.net.topology.TopologyEvent.Type.TOPOLOGY_CHANGED;
 
 /**
- * Test of the edge port manager.
+ * Test of the edge port manager. Each device has ports '0' through 'numPorts - 1'
+ * as specified by the variable 'numPorts'.
  */
 public class EdgeManagerTest {
 
     private EdgeManager mgr;
-    private final EdgePortListener testListener = new TestListener();
-
+    private int totalPorts = 10;
+    private boolean alwaysReturnPorts = false;
+    private final Set<ConnectPoint> infrastructurePorts = Sets.newConcurrentHashSet();
+    private List<EdgePortEvent> events = Lists.newArrayList();
+    private final Map<DeviceId, Device> devices = Maps.newConcurrentMap();
+    private Set<OutboundPacket> packets = Sets.newConcurrentHashSet();
+    private final EdgePortListener testListener = new TestListener(events);
+    private TestTopologyManager testTopologyManager;
 
     @Before
     public void setUp() {
         mgr = new EdgeManager();
         mgr.eventDispatcher = new TestEventDispatcher();
-        mgr.topologyService = new TestTopologyManager();
-        mgr.deviceService = new TestDeviceManager();
+        testTopologyManager = new TestTopologyManager(infrastructurePorts);
+        mgr.topologyService = testTopologyManager;
+        mgr.deviceService = new TestDeviceManager(devices);
         mgr.packetService = new TestPacketManager();
         mgr.activate();
         mgr.addListener(testListener);
+
     }
 
+
     @After
     public void tearDown() {
         mgr.removeListener(testListener);
@@ -63,14 +96,347 @@ public class EdgeManagerTest {
     }
 
     @Test
-    public void basics() {
+    public void testBasics() {
+        //Setup
+        int numDevices = 20;
+        int numPorts = 4;
+        defaultPopulator(numDevices, numPorts);
+
+        assertEquals("Unexpected number of ports", numDevices * numPorts, infrastructurePorts.size());
+
         assertFalse("no ports expected", mgr.getEdgePoints().iterator().hasNext());
+
+        assertFalse("Expected isEdge to return false",
+                mgr.isEdgePoint(NetTestTools.connectPoint(Integer.toString(1), 1)));
+
+        removeInfraPort(NetTestTools.connectPoint(Integer.toString(1), 1));
+        assertTrue("Expected isEdge to return false",
+                mgr.isEdgePoint(NetTestTools.connectPoint(Integer.toString(1), 1)));
+    }
+
+    @Test
+    public void testLinkUpdates() {
+        //Setup
+        ConnectPoint testPoint, referencePoint;
+
+        //Testing link removal
+        List<Event> eventsToAdd = Lists.newArrayList();
+        eventsToAdd.add(new LinkEvent(LINK_REMOVED, NetTestTools.link("a", 1, "b", 2)));
+        TopologyEvent event = new TopologyEvent(TOPOLOGY_CHANGED, null, eventsToAdd);
+        testTopologyManager.listener.event(event);
+
+        assertTrue("The list contained an unexpected number of events", events.size() == 2);
+        assertTrue("The first element is of the wrong type.",
+                events.get(0).type() == EDGE_PORT_ADDED);
+        assertTrue("The second element is of the wrong type.",
+                events.get(1).type() == EDGE_PORT_ADDED);
+
+        testPoint = events.get(0).subject();
+        referencePoint = NetTestTools.connectPoint("a", 1);
+        assertTrue("The port numbers of the first element are incorrect",
+                testPoint.port().toLong() == referencePoint.port().toLong());
+        assertTrue("The device id of the first element is incorrect.",
+                testPoint.deviceId().equals(referencePoint.deviceId()));
+
+        testPoint = events.get(1).subject();
+        referencePoint = NetTestTools.connectPoint("b", 2);
+        assertTrue("The port numbers of the second element are incorrect",
+                testPoint.port().toLong() == referencePoint.port().toLong());
+        assertTrue("The device id of the second element is incorrect.",
+                testPoint.deviceId().equals(referencePoint.deviceId()));
+
+        //Rebroadcast event to ensure it results in no additional events
+        testTopologyManager.listener.event(event);
+        assertTrue("The list contained an unexpected number of events", events.size() == 2);
+
+        //Testing link adding when links to remove exist
+        eventsToAdd.clear();
+        events.clear();
+        eventsToAdd.add(new LinkEvent(LINK_ADDED, NetTestTools.link("a", 1, "b", 2)));
+        event = new TopologyEvent(TOPOLOGY_CHANGED, null, eventsToAdd);
+        testTopologyManager.listener.event(event);
+
+        assertTrue("The list contained an unexpected number of events", events.size() == 2);
+        assertTrue("The first element is of the wrong type.",
+                events.get(0).type() == EDGE_PORT_REMOVED);
+        assertTrue("The second element is of the wrong type.",
+                events.get(1).type() == EDGE_PORT_REMOVED);
+
+        testPoint = events.get(0).subject();
+        referencePoint = NetTestTools.connectPoint("a", 1);
+        assertTrue("The port numbers of the first element are incorrect",
+                testPoint.port().toLong() == referencePoint.port().toLong());
+        assertTrue("The device id of the first element is incorrect.",
+                testPoint.deviceId().equals(referencePoint.deviceId()));
+
+        testPoint = events.get(1).subject();
+        referencePoint = NetTestTools.connectPoint("b", 2);
+        assertTrue("The port numbers of the second element are incorrect",
+                testPoint.port().toLong() == referencePoint.port().toLong());
+        assertTrue("The device id of the second element is incorrect.",
+                testPoint.deviceId().equals(referencePoint.deviceId()));
+
+        //Apparent duplicate of previous method tests removal when the elements have already been removed
+        eventsToAdd.clear();
+        events.clear();
+        eventsToAdd.add(new LinkEvent(LINK_ADDED, NetTestTools.link("a", 1, "b", 2)));
+        event = new TopologyEvent(TOPOLOGY_CHANGED, null, eventsToAdd);
+        testTopologyManager.listener.event(event);
+
+        assertTrue("The list should contain no events, the removed elements don't exist.", events.size() == 0);
+    }
+
+    @Test
+    public void testDeviceUpdates() {
+        //Setup
+
+        Device referenceDevice;
+        TopologyEvent event;
+        List<Event> eventsToAdd = Lists.newArrayList();
+        int numDevices = 10;
+        int numInfraPorts = 5;
+        totalPorts = 10;
+        defaultPopulator(numDevices, numInfraPorts);
+
+        //Test response to device added events
+        referenceDevice = NetTestTools.device("1");
+        eventsToAdd.add(new DeviceEvent(DEVICE_ADDED, referenceDevice,
+                new DefaultPort(referenceDevice, PortNumber.portNumber(1), true)));
+        event = new TopologyEvent(TOPOLOGY_CHANGED, null, eventsToAdd);
+        testTopologyManager.listener.event(event);
+
+        //Check that ports were populated correctly
+        assertTrue("Unexpected number of new ports added",
+                mgr.deviceService.getPorts(NetTestTools.did("1")).size() == 10);
+
+        //Check that of the ten ports the half that are infrastructure ports aren't added
+        assertEquals("Unexpected number of new edge ports added", (totalPorts - numInfraPorts), events.size());
+
+        for (int index = 0; index < numInfraPorts; index++) {
+            assertTrue("Unexpected type of event", events.get(index).type() == EDGE_PORT_ADDED);
+        }
+        //Names here are irrelevant, the first 5 ports are populated as infrastructure, 6-10 are edge
+        for (int index = 0; index < events.size(); index++) {
+            assertEquals("Port added had unexpected port number.",
+                    events.get(index).subject().port(),
+                    NetTestTools.connectPoint("a", index + numInfraPorts + 1).port());
+        }
+        events.clear();
+
+        //Repost the event to test repeated posts
+        testTopologyManager.listener.event(event);
+        assertEquals("The redundant notification should not have created additional notifications.",
+                0, events.size());
+        //Calculate the size of the returned iterable of edge points.
+        Iterable<ConnectPoint> pts = mgr.getEdgePoints();
+        Iterator pointIterator = pts.iterator();
+        int count = 0;
+        for (; pointIterator.hasNext(); count++) {
+            pointIterator.next();
+        }
+        assertEquals("Unexpected number of edge points", totalPorts - numInfraPorts, count);
+        //Testing device removal
+        events.clear();
+        eventsToAdd.clear();
+        eventsToAdd.add(new DeviceEvent(DEVICE_REMOVED, referenceDevice,
+                new DefaultPort(referenceDevice, PortNumber.portNumber(1), true)));
+        event = new TopologyEvent(TOPOLOGY_CHANGED, null, eventsToAdd);
+        testTopologyManager.listener.event(event);
+
+        assertEquals("There should be five new events from removal of edge points",
+                totalPorts - numInfraPorts, events.size());
+        for (int index = 0; index < events.size(); index++) {
+            //Assert that the correct port numbers were removed in the correct order
+            assertEquals("Port removed had unexpected port number.",
+                    events.get(index).subject().port(),
+                    (NetTestTools.connectPoint("a", index + numInfraPorts + 1).port()));
+            //Assert that the events are of the correct type
+            assertEquals("Unexpected type of event", events.get(index).type(), EDGE_PORT_REMOVED);
+        }
+        events.clear();
+        //Rebroadcast event to check that it triggers no new behavior
+        testTopologyManager.listener.event(event);
+        assertEquals("Rebroadcast of removal event should not produce additional events",
+                0, events.size());
+
+        //Testing device status change, changed from unavailable to available
+        events.clear();
+        eventsToAdd.clear();
+        //Make sure that the devicemanager shows the device as available.
+        addDevice(referenceDevice, "1", 5);
+        devices.put(referenceDevice.id(), referenceDevice);
+
+        eventsToAdd.add(new DeviceEvent(DEVICE_AVAILABILITY_CHANGED, referenceDevice));
+        event = new TopologyEvent(TOPOLOGY_CHANGED, null, eventsToAdd);
+        testTopologyManager.listener.event(event);
+        //An earlier setup set half of the reference device ports to infrastructure
+        assertEquals("An unexpected number of events were generated.", totalPorts - numInfraPorts, events.size());
+        for (int i = 0; i < 5; i++) {
+            assertEquals("The event was not of the right type", events.get(i).type(), EDGE_PORT_ADDED);
+        }
+        events.clear();
+        testTopologyManager.listener.event(event);
+        assertEquals("No events should have been generated for a set of existing ports.", 0, events.size());
+
+        //Test removal when state changes when the device becomes unavailable
+
+        //Ensure that the deviceManager shows the device as unavailable
+        removeDevice(referenceDevice);
+        /*This variable copies the behavior of the topology by returning ports attached to an unavailable device
+        //this behavior is necessary for the following event to execute properly, if these statements are removed
+        no events will be generated since no ports will be provided in getPorts() to EdgeManager.
+        */
+        alwaysReturnPorts = true;
+        testTopologyManager.listener.event(event);
+        alwaysReturnPorts = false;
+        assertEquals("An unexpected number of events were created.", totalPorts - numInfraPorts, events.size());
+        for (int i = 0; i < 5; i++) {
+            EdgePortEvent edgeEvent = events.get(i);
+            assertEquals("The event is of an unexpected type.",
+                    EdgePortEvent.Type.EDGE_PORT_REMOVED, edgeEvent.type());
+            assertEquals("The event pertains to an unexpected port", PortNumber.portNumber(i + numInfraPorts + 1),
+                    edgeEvent.subject().port());
+        }
+    }
+
+    @Test
+    public void testInternalCache() {
+        List<Event> eventsToAdd = Lists.newArrayList();
+        int numDevices = 10;
+        //Number of infrastructure ports per device
+        int numPorts = 5;
+        //Total ports per device when requesting all devices
+        totalPorts = 10;
+        defaultPopulator(numDevices, numPorts);
+        for (int i = 0; i < numDevices; i++) {
+            Device newDevice = NetTestTools.device(Integer.toString(i));
+            devices.put(newDevice.id(), newDevice);
+            eventsToAdd.add(new DeviceEvent(DEVICE_ADDED, newDevice));
+        }
+        TopologyEvent event = new TopologyEvent(TOPOLOGY_CHANGED, null, eventsToAdd);
+        testTopologyManager.listener.event(event);
+
+        //Check all ports have correct designations
+        ConnectPoint testPoint;
+        for (int deviceNum = 0; deviceNum < numDevices; deviceNum++) {
+            for (int portNum = 1; portNum <= totalPorts; portNum++) {
+                testPoint = NetTestTools.connectPoint(Integer.toString(deviceNum), portNum);
+                if (portNum <= numPorts) {
+                    assertFalse("This should not be an edge point", mgr.isEdgePoint(testPoint));
+                } else {
+                    assertTrue("This should be an edge point", mgr.isEdgePoint(testPoint));
+                }
+            }
+        }
+        int count = 0;
+        for (ConnectPoint ignored : mgr.getEdgePoints()) {
+            count++;
+        }
+        assertEquals("There are an unexpeceted number of edge points returned.",
+                (totalPorts - numPorts) * numDevices, count);
+        for (int deviceNumber = 0; deviceNumber < numDevices; deviceNumber++) {
+            count = 0;
+            for (ConnectPoint ignored : mgr.getEdgePoints(NetTestTools.did("1"))) {
+                count++;
+            }
+            assertEquals("This element has an unexpected number of edge points.", (totalPorts - numPorts), count);
+        }
+    }
+
+
+    @Test
+    public void testEmit() {
+        byte[] arr = new byte[10];
+        Device referenceDevice;
+        TopologyEvent event;
+        List<Event> eventsToAdd = Lists.newArrayList();
+        int numDevices = 10;
+        int numInfraPorts = 5;
+        totalPorts = 10;
+        defaultPopulator(numDevices, numInfraPorts);
+        for (byte byteIndex = 0; byteIndex < arr.length; byteIndex++) {
+            arr[byteIndex] = byteIndex;
+        }
+        for (int i = 0; i < numDevices; i++) {
+            referenceDevice = NetTestTools.device(Integer.toString(i));
+            eventsToAdd.add(new DeviceEvent(DEVICE_ADDED, referenceDevice,
+                    new DefaultPort(referenceDevice, PortNumber.portNumber(1), true)));
+        }
+        event = new TopologyEvent(TOPOLOGY_CHANGED, null, eventsToAdd);
+        testTopologyManager.listener.event(event);
+
+        mgr.emitPacket(ByteBuffer.wrap(arr), Optional.<TrafficTreatment>empty());
+
+        assertEquals("There were an unexpected number of emitted packets",
+                (totalPorts - numInfraPorts) * numDevices, packets.size());
+        Iterator<OutboundPacket> packetIter = packets.iterator();
+        OutboundPacket packet;
+        while (packetIter.hasNext()) {
+            packet = packetIter.next();
+            assertEquals("The packet had an incorrect payload.", arr, packet.data().array());
+        }
+        //Start testing emission to a specific device
+        packets.clear();
+        mgr.emitPacket(NetTestTools.did(Integer.toString(1)), ByteBuffer.wrap(arr), Optional.<TrafficTreatment>empty());
+
+        assertEquals("Unexpected number of outbound packets were emitted.",
+                totalPorts - numInfraPorts, packets.size());
+        packetIter = packets.iterator();
+        while (packetIter.hasNext()) {
+            packet = packetIter.next();
+            assertEquals("The packet had an incorrect payload", arr, packet.data().array());
+        }
+    }
+
+
+    /**
+     * @param numDevices    the number of devices to populate.
+     * @param numInfraPorts the number of ports to be set as infrastructure on each device, numbered base 0, ports 0
+     *                      through numInfraPorts - 1
+     */
+    private void defaultPopulator(int numDevices, int numInfraPorts) {
+        for (int device = 0; device < numDevices; device++) {
+            String str = Integer.toString(device);
+            Device deviceToAdd = NetTestTools.device(str);
+            devices.put(deviceToAdd.id(), deviceToAdd);
+            for (int port = 1; port <= numInfraPorts; port++) {
+                infrastructurePorts.add(NetTestTools.connectPoint(str, port));
+            }
+        }
+    }
+
+    /**
+     * Adds the specified device with the specified number of edge ports so long as it is less than the total ports.
+     *
+     * @param device        The device to be added
+     * @param deviceName    The name given to generate the devices DID
+     * @param numInfraPorts The number of ports to be added numbered 1 ... numInfraPorts
+     */
+    private void addDevice(Device device, String deviceName, int numInfraPorts) {
+        if (!devices.keySet().contains(device.id())) {
+            devices.put(device.id(), device);
+            for (int i = 1; i <= numInfraPorts && i <= totalPorts; i++) {
+                infrastructurePorts.add(NetTestTools.connectPoint(deviceName, i));
+            }
+        }
+    }
+
+    private void removeDevice(Device device) {
+        devices.remove(device.id());
+    }
+
+    private void removeInfraPort(ConnectPoint port) {
+        infrastructurePorts.remove(port);
     }
 
     private class TestTopologyManager extends TopologyServiceAdapter {
         private TopologyListener listener;
         private Set<ConnectPoint> infrastructurePorts;
 
+        public TestTopologyManager(Set<ConnectPoint> infrastructurePorts) {
+            this.infrastructurePorts = infrastructurePorts;
+        }
+
         @Override
         public boolean isInfrastructure(Topology topology, ConnectPoint connectPoint) {
             return infrastructurePorts.contains(connectPoint);
@@ -89,12 +455,16 @@ public class EdgeManagerTest {
 
     private class TestDeviceManager extends DeviceServiceAdapter {
 
-        private Set<Device> devices;
+        private Map<DeviceId, Device> devices;
+
+        public TestDeviceManager(Map<DeviceId, Device> devices) {
+            this.devices = devices;
+        }
 
         @Override
         public boolean isAvailable(DeviceId deviceId) {
-            for (Device device : devices) {
-                if (device.id().equals(deviceId)) {
+            for (DeviceId id : devices.keySet()) {
+                if (id.equals(deviceId)) {
                     return true;
                 }
             }
@@ -103,22 +473,38 @@ public class EdgeManagerTest {
 
         @Override
         public List<Port> getPorts(DeviceId deviceId) {
-            return super.getPorts(deviceId);
+            List<Port> ports = new ArrayList<>();
+            Device device = devices.get(deviceId);
+            if (device == null && !alwaysReturnPorts) {
+                return ports;
+            }
+            for (int portNum = 1; portNum <= totalPorts; portNum++) {
+                //String is generated using 'of:' + the passed name, this creates a
+                ports.add(new DefaultPort(device, PortNumber.portNumber(portNum), true));
+            }
+            return ports;
         }
 
         @Override
         public Iterable<Device> getAvailableDevices() {
-            return devices;
+            return devices.values();
         }
     }
 
     private class TestPacketManager extends PacketServiceAdapter {
+        @Override
+        public void emit(OutboundPacket packet) {
+            packets.add(packet);
+        }
     }
 
-
     private class TestListener implements EdgePortListener {
         private List<EdgePortEvent> events;
 
+        public TestListener(List<EdgePortEvent> events) {
+            this.events = events;
+        }
+
         @Override
         public void event(EdgePortEvent event) {
             events.add(event);