import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import io.netty.util.HashedWheelTimer;
-import io.netty.util.Timeout;
import java.math.BigInteger;
-import java.net.InetSocketAddress;
import java.util.concurrent.atomic.AtomicLong;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.mockito.InOrder;
-import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.openflowplugin.api.openflow.connection.OutboundQueueProvider;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
-import org.opendaylight.openflowplugin.api.openflow.device.DeviceManager;
-import org.opendaylight.openflowplugin.api.openflow.device.DeviceState;
import org.opendaylight.openflowplugin.api.openflow.device.MessageTranslator;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
import org.opendaylight.openflowplugin.api.openflow.device.TranslatorLibrary;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortStatusMessage;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.experimenter.core.ExperimenterDataOfChoice;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
-import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
DeviceContext deviceContext;
@Mock
- TransactionChainManager txChainManager;
- @Mock
RequestContext<GetAsyncReply> requestContext;
@Mock
RequestContext<MultipartReply> requestContextMultiReply;
@Mock
ConnectionContext connectionContext;
@Mock
- DeviceState deviceState;
- @Mock
GetFeaturesOutput featuresOutput;
@Mock
DataBroker dataBroker;
@Mock
TranslatorLibrary translatorLibrary;
@Mock
- Registration registration;
- @Mock
MessageTranslator messageTranslatorPacketReceived;
@Mock
MessageTranslator messageTranslatorFlowCapableNodeConnector;
@Mock
private DeviceInfo deviceInfo;
@Mock
- private DeviceManager deviceManager;
- @Mock
private ConvertorExecutor convertorExecutor;
@Mock
private MessageSpy messageSpy;
- private InOrder inOrderDevState;
-
private final AtomicLong atomicLong = new AtomicLong(0);
private DeviceContext deviceContextSpy;
dataBroker,
messageSpy,
translatorLibrary,
- deviceManager,
convertorExecutor,
false, timer, false,
- DeviceInitializerProviderFactory.createDefaultProvider());
+ DeviceInitializerProviderFactory.createDefaultProvider(),
+ true, false);
((DeviceContextImpl) deviceContext).lazyTransactionManagerInitialization();
deviceContextSpy = Mockito.spy(deviceContext);
verify(wTx).submit();
}
- @Test
- public void testAuxiliaryConnectionContext() {
- final ConnectionContext mockedConnectionContext = addDummyAuxiliaryConnectionContext();
- final ConnectionContext pickedConnectionContexts = deviceContext.getAuxiliaryConnectionContexts(DUMMY_COOKIE);
- assertEquals(mockedConnectionContext, pickedConnectionContexts);
- }
- @Test
- public void testRemoveAuxiliaryConnectionContext() {
- final ConnectionContext mockedConnectionContext = addDummyAuxiliaryConnectionContext();
-
- final ConnectionAdapter mockedAuxConnectionAdapter = mock(ConnectionAdapter.class);
- when(mockedConnectionContext.getConnectionAdapter()).thenReturn(mockedAuxConnectionAdapter);
-
- assertNotNull(deviceContext.getAuxiliaryConnectionContexts(DUMMY_COOKIE));
- deviceContext.removeAuxiliaryConnectionContext(mockedConnectionContext);
- assertNull(deviceContext.getAuxiliaryConnectionContexts(DUMMY_COOKIE));
- }
-
- private ConnectionContext addDummyAuxiliaryConnectionContext() {
- final ConnectionContext mockedConnectionContext = prepareConnectionContext();
- deviceContext.addAuxiliaryConnectionContext(mockedConnectionContext);
- return mockedConnectionContext;
- }
-
private ConnectionContext prepareConnectionContext() {
final ConnectionContext mockedConnectionContext = mock(ConnectionContext.class);
final FeaturesReply mockedFeaturesReply = mock(FeaturesReply.class);
public void testProcessReply() {
final Error mockedError = mock(Error.class);
deviceContext.processReply(mockedError);
- verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_FAILURE));
+ verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_FAILURE));
final OfHeader mockedOfHeader = mock(OfHeader.class);
deviceContext.processReply(mockedOfHeader);
- verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_SUCCESS));
+ verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_SUCCESS));
}
@Test
final Error mockedError = mock(Error.class);
deviceContext.processReply(dummyXid, Lists.newArrayList(mockedError));
- verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_FAILURE));
+ verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_FAILURE));
final MultipartReply mockedMultipartReply = mock(MultipartReply.class);
deviceContext.processReply(dummyXid, Lists.newArrayList(mockedMultipartReply));
- verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_SUCCESS));
+ verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_SUCCESS));
}
@Test
when(mockedNotificationPublishService.offerNotification(any(PacketReceived.class))).thenReturn(stringListenableFuture);
deviceContext.setNotificationPublishService(mockedNotificationPublishService);
deviceContext.processPacketInMessage(mockedPacketInMessage);
- verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_SUCCESS));
+ verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_SUCCESS));
}
@Test
when(mockedNotificationPublishService.offerNotification(any(PacketReceived.class))).thenReturn(dummyFuture);
deviceContext.setNotificationPublishService(mockedNotificationPublishService);
deviceContext.processPacketInMessage(mockedPacketInMessage);
- verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_NOTIFICATION_REJECTED));
+ verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.StatisticsGroup.FROM_SWITCH_NOTIFICATION_REJECTED));
}
@Test
assertEquals(translatorLibrary, pickedTranslatorLibrary);
}
- @Test
- public void testShutdownConnection() {
- final ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class);
- final InetSocketAddress mockRemoteAddress = InetSocketAddress.createUnresolved("odl-unit.example.org",999);
- when(mockedConnectionAdapter.getRemoteAddress()).thenReturn(mockRemoteAddress);
- when(connectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter);
-
- final NodeId dummyNodeId = new NodeId("dummyNodeId");
- when(deviceInfo.getNodeId()).thenReturn(dummyNodeId);
-
- final ConnectionContext mockedAuxiliaryConnectionContext = prepareConnectionContext();
- deviceContext.addAuxiliaryConnectionContext(mockedAuxiliaryConnectionContext);
- deviceContext.shutdownConnection();
- verify(connectionContext).closeConnection(true);
- }
-
- @Test
- public void testBarrierFieldSetGet() {
- final Timeout mockedTimeout = mock(Timeout.class);
- deviceContext.setCurrentBarrierTimeout(mockedTimeout);
- final Timeout pickedBarrierTimeout = deviceContext.getBarrierTaskTimeout();
- assertEquals(mockedTimeout, pickedBarrierTimeout);
- }
-
@Test
public void testGetMessageSpy() {
final MessageSpy pickedMessageSpy = deviceContext.getMessageSpy();
@Test
public void testOnPublished() {
- final ConnectionContext auxiliaryConnectionContext = addDummyAuxiliaryConnectionContext();
-
- final ConnectionAdapter mockedAuxConnectionAdapter = mock(ConnectionAdapter.class);
- when(auxiliaryConnectionContext.getConnectionAdapter()).thenReturn(mockedAuxConnectionAdapter);
-
final ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class);
when(connectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter);
.child(Table.class, new TableKey((short) 0))
.child(Flow.class, new FlowKey(new FlowId("ut-ofp:f456")));
- Mockito.when(deviceManager.isFlowRemovedNotificationOn()).thenReturn(true);
-
deviceContext.setNotificationPublishService(mockedNotificationPublishService);
deviceContext.processFlowRemovedMessage(flowRemovedBld.build());
Mockito.verify(itemLifecycleListener).onRemoved(flowToBeRemovedPath);
-
- Mockito.when(deviceManager.isFlowRemovedNotificationOn()).thenReturn(false);
- deviceContext.processFlowRemovedMessage(flowRemovedBld.build());
-
- Mockito.verify(mockedNotificationPublishService).offerNotification(Matchers.any(Notification.class));
}
@Test