applications/lldp-speaker/src/test/java/org/opendaylight/openflowplugin/applications/lldpspeaker/LLDPSpeakerTest.java

   1 /*
   2  * Copyright (c) 2014 Pacnet 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
   9 package org.opendaylight.openflowplugin.applications.lldpspeaker;
  10
  11 import static org.mockito.Matchers.any;
  12 import static org.mockito.Matchers.anyLong;
  13 import static org.mockito.Mockito.doReturn;
  14 import static org.mockito.Mockito.never;
  15 import static org.mockito.Mockito.times;
  16 import static org.mockito.Mockito.verify;
  17 import static org.mockito.Mockito.verifyNoMoreInteractions;
  18 import static org.mockito.Mockito.when;
  19
  20 import com.google.common.base.Optional;
  21 import java.security.NoSuchAlgorithmException;
  22 import java.util.concurrent.ScheduledExecutorService;
  23 import java.util.concurrent.ScheduledFuture;
  24 import java.util.concurrent.TimeUnit;
  25 import org.junit.Before;
  26 import org.junit.Test;
  27 import org.junit.runner.RunWith;
  28 import org.mockito.Mock;
  29 import org.mockito.runners.MockitoJUnitRunner;
  30 import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
  31 import org.opendaylight.mdsal.eos.common.api.EntityOwnershipState;
  32 import org.opendaylight.openflowplugin.libraries.liblldp.PacketException;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortNumberUni;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInput;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInputBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.applications.lldp.speaker.rev141023.OperStatus;
  46 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  47 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  48
  49 /**
  50  * Tests for {@link LLDPSpeaker}.
  51  */
  52 @RunWith(MockitoJUnitRunner.class)
  53 public class LLDPSpeakerTest {
  54     private static final InstanceIdentifier<NodeConnector> ID = TestUtils.createNodeConnectorId("openflow:1",
  55             "openflow:1:1");
  56     private static final MacAddress MAC_ADDRESS = new MacAddress("01:23:45:67:89:AB");
  57     private static final FlowCapableNodeConnector FLOW_CAPABLE_NODE_CONNECTOR =
  58             TestUtils.createFlowCapableNodeConnector(MAC_ADDRESS, 1L).build();
  59     private TransmitPacketInput packetInput;
  60
  61     @Mock
  62     private PacketProcessingService packetProcessingService;
  63     @Mock
  64     private ScheduledExecutorService scheduledExecutorService;
  65     @Mock
  66     private ScheduledFuture scheduledSpeakerTask;
  67     @Mock
  68     private EntityOwnershipService entityOwnershipService;
  69
  70     private LLDPSpeaker lldpSpeaker;
  71
  72     @Before
  73     public void setUp() throws NoSuchAlgorithmException, PacketException {
  74         byte[] lldpFrame = LLDPUtil.buildLldpFrame(new NodeId("openflow:1"),
  75                 new NodeConnectorId("openflow:1:1"), MAC_ADDRESS, 1L);
  76         packetInput = new TransmitPacketInputBuilder().setEgress(new NodeConnectorRef(ID))
  77                 .setNode(new NodeRef(ID.firstIdentifierOf(Node.class))).setPayload(lldpFrame).build();
  78
  79         when(scheduledExecutorService.scheduleAtFixedRate(any(Runnable.class), anyLong(), anyLong(),
  80                 any(TimeUnit.class))).thenReturn(scheduledSpeakerTask);
  81         lldpSpeaker = new LLDPSpeaker(packetProcessingService,
  82                 scheduledExecutorService, null, entityOwnershipService);
  83         when(entityOwnershipService.getOwnershipState(any())).thenReturn(Optional.of(EntityOwnershipState.IS_OWNER));
  84         lldpSpeaker.setOperationalStatus(OperStatus.RUN);
  85
  86         doReturn(RpcResultBuilder.success().buildFuture()).when(packetProcessingService).transmitPacket(any());
  87     }
  88
  89     /**
  90      * Test that speaker does nothing when in {@link OperStatus.STANDBY} mode.
  91      */
  92     @Test
  93     public void testStandBy() {
  94         lldpSpeaker.setOperationalStatus(OperStatus.STANDBY);
  95         // Add node connector - LLDP packet should be transmitted through
  96         // packetProcessingService
  97         lldpSpeaker.nodeConnectorAdded(ID, FLOW_CAPABLE_NODE_CONNECTOR);
  98
  99         // Execute one iteration of periodic task - LLDP packet should be
 100         // transmitted second time
 101         lldpSpeaker.run();
 102
 103         // Check packet transmission
 104         verify(packetProcessingService, times(1)).transmitPacket(packetInput);
 105         verifyNoMoreInteractions(packetProcessingService);
 106     }
 107
 108     /**
 109      * Test that LLDP frame is transmitted after port appeared in inventory and
 110      * periodically after that.
 111      */
 112     @Test
 113     public void testNodeConnectorAdd() {
 114         // Add node connector - LLDP packet should be transmitted through
 115         // packetProcessingService
 116         lldpSpeaker.nodeConnectorAdded(ID, FLOW_CAPABLE_NODE_CONNECTOR);
 117
 118
 119         when(entityOwnershipService.getOwnershipState(any()))
 120                 .thenReturn(Optional.of(EntityOwnershipState.OWNED_BY_OTHER));
 121         // Execute one iteration of periodic task - LLDP packet should be
 122         // not transmit second packet because it doesn't own the device.
 123         lldpSpeaker.run();
 124
 125         // Check packet transmission
 126         verify(packetProcessingService, times(1)).transmitPacket(packetInput);
 127         verifyNoMoreInteractions(packetProcessingService);
 128     }
 129
 130     /**
 131      * Test that LLDP frame stop to periodically transmit after port disappeared
 132      * from inventory.
 133      */
 134     @Test
 135     public void testNodeConnectorRemoval() {
 136         // Prepare for test - add node connector first
 137         lldpSpeaker.nodeConnectorAdded(ID, FLOW_CAPABLE_NODE_CONNECTOR);
 138
 139         // Trigger removal of packet
 140         lldpSpeaker.nodeConnectorRemoved(ID);
 141
 142         // Run one iteration of LLDP flood
 143         lldpSpeaker.run();
 144
 145         // Verify that LLDP frame sent only once (by nodeConnectorAdded),
 146         // e.g. no flood after removal
 147         verify(packetProcessingService, times(1)).transmitPacket(packetInput);
 148         verifyNoMoreInteractions(packetProcessingService);
 149     }
 150
 151     /**
 152      * Test that when {@link LLDPSpeaker#nodeConnectorAdded} is called multiple times
 153      * with same arguments, only the first one have effect.
 154      */
 155     @Test
 156     public void testMultipleSameNodeConnectorAddEvents() {
 157         // Add node connector - LLDP packet should be transmitted through
 158         // packetProcessingService
 159         for (int i = 0; i < 10; i++) {
 160             lldpSpeaker.nodeConnectorAdded(ID, FLOW_CAPABLE_NODE_CONNECTOR);
 161         }
 162
 163         // Check packet transmission
 164         verify(packetProcessingService, times(1)).transmitPacket(packetInput);
 165         verifyNoMoreInteractions(packetProcessingService);
 166     }
 167
 168     /**
 169      * Test that checks if LLDPSpeaker working fine with local ports.
 170      */
 171     @Test
 172     public void testLocalNodeConnectorCreation() {
 173         // Call nodeConnectorAdded with local port
 174         FlowCapableNodeConnector fcnc = TestUtils
 175                 .createFlowCapableNodeConnector()
 176                 .setPortNumber(new PortNumberUni("LOCAL")).build();
 177         lldpSpeaker.nodeConnectorAdded(ID, fcnc);
 178
 179         // Verify that nothing happened for local port
 180         verify(packetProcessingService, never()).transmitPacket(
 181                 any(TransmitPacketInput.class));
 182     }
 183 }