arphandler/src/test/java/org/opendaylight/l2switch/arphandler/core/PacketDispatcherTest.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.l2switch.arphandler.core;
   9
  10 import static org.mockito.ArgumentMatchers.any;
  11 import static org.mockito.Mockito.doReturn;
  12 import static org.mockito.Mockito.times;
  13 import static org.mockito.Mockito.verify;
  14 import static org.mockito.Mockito.when;
  15
  16 import java.util.ArrayList;
  17 import java.util.HashMap;
  18 import java.util.List;
  19 import org.junit.Before;
  20 import org.junit.Test;
  21 import org.mockito.Mock;
  22 import org.mockito.Mockito;
  23 import org.mockito.MockitoAnnotations;
  24 import org.opendaylight.l2switch.arphandler.inventory.InventoryReader;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInput;
  36 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  37 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  38
  39 public class PacketDispatcherTest {
  40     @Mock
  41     private PacketProcessingService packetProcessingService;
  42     @Mock
  43     private InventoryReader inventoryReader;
  44     private PacketDispatcher packetDispatcher;
  45
  46     @Before
  47     public void initMocks() {
  48         MockitoAnnotations.initMocks(this);
  49         packetDispatcher = new PacketDispatcher();
  50         packetDispatcher.setPacketProcessingService(packetProcessingService);
  51         packetDispatcher.setInventoryReader(inventoryReader);
  52
  53         doReturn(RpcResultBuilder.success().buildFuture()).when(packetProcessingService).transmitPacket(any());
  54     }
  55
  56     @Test
  57     public void testSendPacketOut() throws Exception {
  58         InstanceIdentifier<NodeConnector> ncInsId1 = InstanceIdentifier.builder(Nodes.class).child(Node.class)
  59                 .child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId("1"))).build();
  60         packetDispatcher.sendPacketOut(null, new NodeConnectorRef(ncInsId1), new NodeConnectorRef(ncInsId1));
  61         verify(packetProcessingService, times(1)).transmitPacket(any(TransmitPacketInput.class));
  62     }
  63
  64     @Test
  65     public void testSendPacketOut_NullIngress() throws Exception {
  66         packetDispatcher.sendPacketOut(null, null,
  67                 new NodeConnectorRef(InstanceIdentifier.create(NodeConnector.class)));
  68         verify(packetProcessingService, times(0)).transmitPacket(any(TransmitPacketInput.class));
  69     }
  70
  71     @Test
  72     public void testSendPacketOut_NullEgress() throws Exception {
  73         packetDispatcher.sendPacketOut(null, new NodeConnectorRef(InstanceIdentifier.create(NodeConnector.class)),
  74                 null);
  75         verify(packetProcessingService, times(0)).transmitPacket(any(TransmitPacketInput.class));
  76     }
  77
  78     @Test
  79     public void testFloodPacket() throws Exception {
  80         List<NodeConnectorRef> nodeConnectors = new ArrayList<>();
  81         InstanceIdentifier<NodeConnector> ncInsId1 = InstanceIdentifier.builder(Nodes.class).child(Node.class)
  82                 .child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId("1"))).build();
  83         InstanceIdentifier<NodeConnector> ncInsId2 = InstanceIdentifier.builder(Nodes.class).child(Node.class)
  84                 .child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId("2"))).build();
  85         nodeConnectors.add(new NodeConnectorRef(ncInsId1));
  86         nodeConnectors.add(new NodeConnectorRef(ncInsId1));
  87         nodeConnectors.add(new NodeConnectorRef(ncInsId2));
  88         HashMap<String, List<NodeConnectorRef>> switchNodeConnectors = Mockito.mock(HashMap.class);
  89         when(switchNodeConnectors.get(any(String.class))).thenReturn(nodeConnectors);
  90         when(inventoryReader.getSwitchNodeConnectors()).thenReturn(switchNodeConnectors);
  91
  92         packetDispatcher.floodPacket("", null, new NodeConnectorRef(ncInsId2),
  93                 new NodeConnectorRef(InstanceIdentifier.create(NodeConnector.class)));
  94         verify(inventoryReader, times(0)).setRefreshData(true);
  95         verify(inventoryReader, times(0)).readInventory();
  96         verify(packetProcessingService, times(2)).transmitPacket(any(TransmitPacketInput.class));
  97     }
  98
  99     @Test
 100     public void testFloodPacket_NullList() throws Exception {
 101         HashMap<String, List<NodeConnectorRef>> switchNodeConnectors = Mockito.mock(HashMap.class);
 102         when(switchNodeConnectors.get(any(String.class))).thenReturn(null);
 103         when(inventoryReader.getSwitchNodeConnectors()).thenReturn(switchNodeConnectors);
 104
 105         packetDispatcher.floodPacket("", null, new NodeConnectorRef(InstanceIdentifier.create(NodeConnector.class)),
 106                 new NodeConnectorRef(InstanceIdentifier.create(NodeConnector.class)));
 107         verify(inventoryReader, times(1)).setRefreshData(true);
 108         verify(inventoryReader, times(1)).readInventory();
 109         verify(packetProcessingService, times(0)).transmitPacket(any(TransmitPacketInput.class));
 110     }
 111
 112     @Test
 113     public void testDispatchPacket_noDispatch() throws Exception {
 114         InstanceIdentifier<NodeConnector> ncInsId = InstanceIdentifier.builder(Nodes.class)
 115                 .child(Node.class, new NodeKey(new NodeId("1")))
 116                 .child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId("1"))).build();
 117         HashMap<String, NodeConnectorRef> controllerSwitchConnectors = Mockito.mock(HashMap.class);
 118         when(controllerSwitchConnectors.get(any(String.class))).thenReturn(null);
 119         when(inventoryReader.getControllerSwitchConnectors()).thenReturn(controllerSwitchConnectors);
 120
 121         packetDispatcher.dispatchPacket(null, new NodeConnectorRef(ncInsId), null, null);
 122         verify(inventoryReader, times(2)).readInventory();
 123         verify(inventoryReader, times(1)).setRefreshData(true);
 124         verify(packetProcessingService, times(0)).transmitPacket(any(TransmitPacketInput.class));
 125     }
 126
 127     @Test
 128     public void testDispatchPacket_toSendPacketOut() throws Exception {
 129         InstanceIdentifier<NodeConnector> ncInsId1 = InstanceIdentifier.builder(Nodes.class)
 130                 .child(Node.class, new NodeKey(new NodeId("1")))
 131                 .child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId("1"))).build();
 132         NodeConnectorRef ncRef1 = new NodeConnectorRef(ncInsId1);
 133         HashMap<String, NodeConnectorRef> controllerSwitchConnectors = Mockito.mock(HashMap.class);
 134         when(controllerSwitchConnectors.get(any(String.class))).thenReturn(ncRef1);
 135         when(inventoryReader.getControllerSwitchConnectors()).thenReturn(controllerSwitchConnectors);
 136         when(inventoryReader.getNodeConnector(any(InstanceIdentifier.class), any())).thenReturn(ncRef1);
 137
 138         packetDispatcher.dispatchPacket(null, new NodeConnectorRef(ncInsId1), null, null);
 139         verify(inventoryReader, times(1)).readInventory();
 140         verify(inventoryReader, times(0)).setRefreshData(true);
 141         verify(packetProcessingService, times(1)).transmitPacket(any(TransmitPacketInput.class));
 142     }
 143
 144     @Test
 145     public void testDispatchPacket_toFloodPacket() throws Exception {
 146         InstanceIdentifier<NodeConnector> ncInsId1 = InstanceIdentifier.builder(Nodes.class)
 147                 .child(Node.class, new NodeKey(new NodeId("1")))
 148                 .child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId("1"))).build();
 149         NodeConnectorRef ncRef1 = new NodeConnectorRef(ncInsId1);
 150         HashMap<String, NodeConnectorRef> controllerSwitchConnectors = Mockito.mock(HashMap.class);
 151         when(controllerSwitchConnectors.get(any(String.class))).thenReturn(ncRef1);
 152         when(inventoryReader.getControllerSwitchConnectors()).thenReturn(controllerSwitchConnectors);
 153         when(inventoryReader.getNodeConnector(any(InstanceIdentifier.class), any(MacAddress.class))).thenReturn(null);
 154
 155         List<NodeConnectorRef> nodeConnectors = new ArrayList<>();
 156         InstanceIdentifier<NodeConnector> ncInsId2 = InstanceIdentifier.builder(Nodes.class)
 157                 .child(Node.class, new NodeKey(new NodeId("2")))
 158                 .child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId("2"))).build();
 159         nodeConnectors.add(new NodeConnectorRef(ncInsId1));
 160         nodeConnectors.add(new NodeConnectorRef(ncInsId1));
 161         nodeConnectors.add(new NodeConnectorRef(ncInsId2));
 162         HashMap<String, List<NodeConnectorRef>> switchNodeConnectors = Mockito.mock(HashMap.class);
 163         when(switchNodeConnectors.get(any(String.class))).thenReturn(nodeConnectors);
 164         when(inventoryReader.getSwitchNodeConnectors()).thenReturn(switchNodeConnectors);
 165
 166         packetDispatcher.dispatchPacket(null, new NodeConnectorRef(ncInsId2), null, null);
 167         verify(inventoryReader, times(1)).readInventory();
 168         verify(inventoryReader, times(0)).setRefreshData(true);
 169         verify(packetProcessingService, times(2)).transmitPacket(any(TransmitPacketInput.class));
 170     }
 171 }