X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=openflowplugin-impl%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fopenflowplugin%2Fimpl%2Fdevice%2FDeviceContextImplTest.java;h=3606665575f1219908390ac4250f4bf70ed2ff0b;hb=9899c3134d7cc24e9c8d57b34d9c19b111e00e33;hp=ad03534eb53e8aaaeafbc7f0197eb74ed557ee30;hpb=b996c77fd73f043cda13094b4befefd99c837ba9;p=openflowplugin.git diff --git a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/DeviceContextImplTest.java b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/DeviceContextImplTest.java index ad03534eb5..3606665575 100644 --- a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/DeviceContextImplTest.java +++ b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/DeviceContextImplTest.java @@ -10,16 +10,14 @@ package org.opendaylight.openflowplugin.impl.device; 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 static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import java.math.BigInteger; -import java.net.InetSocketAddress; -import java.util.concurrent.atomic.AtomicLong; - import com.google.common.base.Optional; import com.google.common.collect.Lists; import com.google.common.util.concurrent.CheckedFuture; @@ -28,17 +26,19 @@ 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.Assert; import org.junit.Before; -import org.junit.Ignore; 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.invocation.InvocationOnMock; import org.mockito.runners.MockitoJUnitRunner; -import org.mockito.stubbing.Answer; import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; @@ -48,16 +48,19 @@ import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter; +import org.opendaylight.openflowjava.protocol.api.keys.MessageTypeKey; import org.opendaylight.openflowplugin.api.OFConstants; import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext; 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.openflowplugin.api.openflow.device.Xid; -import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceContextClosedHandler; +import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceTerminationPhaseHandler; import org.opendaylight.openflowplugin.api.openflow.md.core.TranslatorKey; import org.opendaylight.openflowplugin.api.openflow.registry.flow.DeviceFlowRegistry; import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowDescriptor; @@ -66,12 +69,15 @@ import org.opendaylight.openflowplugin.api.openflow.registry.group.DeviceGroupRe import org.opendaylight.openflowplugin.api.openflow.registry.meter.DeviceMeterRegistry; import org.opendaylight.openflowplugin.api.openflow.rpc.ItemLifeCycleSource; import org.opendaylight.openflowplugin.api.openflow.rpc.listener.ItemLifecycleListener; -import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageIntelligenceAgency; import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageSpy; +import org.opendaylight.openflowplugin.extension.api.ConvertorMessageFromOFJava; +import org.opendaylight.openflowplugin.extension.api.core.extension.ExtensionConverterProvider; import org.opendaylight.openflowplugin.impl.registry.flow.FlowDescriptorFactory; import org.opendaylight.openflowplugin.impl.registry.flow.FlowRegistryKeyFactory; import org.opendaylight.openflowplugin.impl.util.DeviceStateUtil; +import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor; import org.opendaylight.openflowplugin.openflow.md.util.OpenflowPortsUtil; +import org.opendaylight.yang.gen.v1.urn.opendaylight.experimenter.message.service.rev151020.ExperimenterMessageFromDev; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId; @@ -82,13 +88,15 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.ta import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowRemovedBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.Capabilities; import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.PortReason; import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.Error; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterMessage; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterMessageBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FeaturesReply; import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FlowRemovedMessageBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetAsyncReply; @@ -99,11 +107,12 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketInMessage; import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortGrouping; 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.DataObject; 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; @@ -119,19 +128,21 @@ public class DeviceContextImplTest { private static final BigInteger DUMMY_DATAPATH_ID = new BigInteger("55"); Xid xid; Xid xidMulti; - DeviceContextImpl deviceContext; + + DeviceContext deviceContext; @Mock TransactionChainManager txChainManager; @Mock RequestContext requestContext; @Mock RequestContext requestContextMultiReply; - @Mock ConnectionContext connectionContext; @Mock DeviceState deviceState; @Mock + GetFeaturesOutput featuresOutput; + @Mock DataBroker dataBroker; @Mock WriteTransaction wTx; @@ -142,8 +153,6 @@ public class DeviceContextImplTest { @Mock HashedWheelTimer timer; @Mock - MessageIntelligenceAgency messageIntelligenceAgency; - @Mock OutboundQueueProvider outboundQueueProvider; @Mock ConnectionAdapter connectionAdapter; @@ -159,150 +168,164 @@ public class DeviceContextImplTest { MessageTranslator messageTranslatorFlowCapableNodeConnector; @Mock private MessageTranslator messageTranslatorFlowRemoved; + @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; + @Before - public void setUp() { + public void setUp() throws Exception{ final CheckedFuture, ReadFailedException> noExistNodeFuture = Futures.immediateCheckedFuture(Optional.absent()); Mockito.when(rTx.read(LogicalDatastoreType.OPERATIONAL, nodeKeyIdent)).thenReturn(noExistNodeFuture); Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(rTx); Mockito.when(dataBroker.createTransactionChain(Mockito.any(TransactionChainManager.class))).thenReturn(txChainFactory); - Mockito.when(deviceState.getNodeInstanceIdentifier()).thenReturn(nodeKeyIdent); - Mockito.when(deviceState.getNodeId()).thenReturn(nodeId); -// txChainManager = new TransactionChainManager(dataBroker, deviceState); + Mockito.when(deviceInfo.getNodeInstanceIdentifier()).thenReturn(nodeKeyIdent); + Mockito.when(deviceInfo.getNodeId()).thenReturn(nodeId); + Mockito.when(deviceInfo.getDatapathId()).thenReturn(BigInteger.ONE); final SettableFuture> settableFuture = SettableFuture.create(); final SettableFuture> settableFutureMultiReply = SettableFuture.create(); Mockito.when(requestContext.getFuture()).thenReturn(settableFuture); - Mockito.doAnswer(new Answer() { - @SuppressWarnings("unchecked") - @Override - public Object answer(final InvocationOnMock invocation) { - settableFuture.set((RpcResult) invocation.getArguments()[0]); - return null; - } + Mockito.doAnswer(invocation -> { + settableFuture.set((RpcResult) invocation.getArguments()[0]); + return null; }).when(requestContext).setResult(any(RpcResult.class)); Mockito.when(requestContextMultiReply.getFuture()).thenReturn(settableFutureMultiReply); - Mockito.doAnswer(new Answer() { - @SuppressWarnings("unchecked") - @Override - public Object answer(final InvocationOnMock invocation) { - settableFutureMultiReply.set((RpcResult) invocation.getArguments()[0]); - return null; - } + Mockito.doAnswer(invocation -> { + settableFutureMultiReply.set((RpcResult) invocation.getArguments()[0]); + return null; }).when(requestContextMultiReply).setResult(any(RpcResult.class)); Mockito.when(txChainFactory.newWriteOnlyTransaction()).thenReturn(wTx); Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(rTx); Mockito.when(connectionContext.getOutboundQueueProvider()).thenReturn(outboundQueueProvider); Mockito.when(connectionContext.getConnectionAdapter()).thenReturn(connectionAdapter); - - Mockito.when(deviceState.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3); - Mockito.when(messageTranslatorPacketReceived.translate(any(Object.class), any(DeviceContext.class), any(Object.class))).thenReturn(mock(PacketReceived.class)); - Mockito.when(messageTranslatorFlowCapableNodeConnector.translate(any(Object.class), any(DeviceContext.class), any(Object.class))).thenReturn(mock(FlowCapableNodeConnector.class)); + Mockito.when(connectionContext.getDeviceInfo()).thenReturn(deviceInfo); + final FeaturesReply mockedFeaturesReply = mock(FeaturesReply.class); + when(connectionContext.getFeatures()).thenReturn(mockedFeaturesReply); + when(connectionContext.getFeatures().getCapabilities()).thenReturn(mock(Capabilities.class)); + + Mockito.when(deviceInfo.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3); + Mockito.when(featuresOutput.getDatapathId()).thenReturn(DUMMY_DATAPATH_ID); + Mockito.when(featuresOutput.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3); + Mockito.when(messageTranslatorPacketReceived.translate(any(Object.class), any(DeviceInfo.class), any(Object.class))).thenReturn(mock(PacketReceived.class)); + Mockito.when(messageTranslatorFlowCapableNodeConnector.translate(any(Object.class), any(DeviceInfo.class), any(Object.class))).thenReturn(mock(FlowCapableNodeConnector.class)); Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3, PacketIn.class.getName())))).thenReturn(messageTranslatorPacketReceived); Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3, PortGrouping.class.getName())))).thenReturn(messageTranslatorFlowCapableNodeConnector); Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3, org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FlowRemoved.class.getName())))) .thenReturn(messageTranslatorFlowRemoved); - deviceContext = new DeviceContextImpl(connectionContext, deviceState, dataBroker, timer, messageIntelligenceAgency, outboundQueueProvider, translatorLibrary); - deviceContext.setTransactionChainManager(txChainManager); + deviceContext = new DeviceContextImpl( + connectionContext, + dataBroker, + messageSpy, + translatorLibrary, + deviceManager, + convertorExecutor, + false); + deviceContextSpy = Mockito.spy(deviceContext); xid = new Xid(atomicLong.incrementAndGet()); xidMulti = new Xid(atomicLong.incrementAndGet()); - } + ((DeviceContextImpl) deviceContext).lazyTransactionManagerInitialiaztion(); + + Mockito.doNothing().when(deviceContextSpy).writeToTransaction(Mockito.any(), Mockito.any(), any()); - @Test(expected = NullPointerException.class) - public void testDeviceContextImplConstructorNullDataBroker() throws Exception { - new DeviceContextImpl(connectionContext, deviceState, null, timer, messageIntelligenceAgency, outboundQueueProvider, translatorLibrary).close(); } @Test(expected = NullPointerException.class) - public void testDeviceContextImplConstructorNullDeviceState() throws Exception { - new DeviceContextImpl(connectionContext, null, dataBroker, timer, messageIntelligenceAgency, outboundQueueProvider, translatorLibrary).close(); + public void testDeviceContextImplConstructorNullDataBroker() throws Exception { + new DeviceContextImpl(connectionContext, null, null, translatorLibrary, deviceManager, convertorExecutor,false).close(); } @Test(expected = NullPointerException.class) public void testDeviceContextImplConstructorNullTimer() throws Exception { - new DeviceContextImpl(null, deviceState, dataBroker, null, messageIntelligenceAgency, outboundQueueProvider, translatorLibrary).close(); - } - - @Test - public void testGetDeviceState() { - final DeviceState deviceSt = deviceContext.getDeviceState(); - assertNotNull(deviceSt); - Assert.assertEquals(deviceState, deviceSt); + new DeviceContextImpl(null, dataBroker, null, translatorLibrary, deviceManager,convertorExecutor,false).close(); } @Test public void testGetReadTransaction() { final ReadTransaction readTx = deviceContext.getReadTransaction(); assertNotNull(readTx); - Assert.assertEquals(rTx, readTx); + assertEquals(rTx, readTx); } /** - * FIXME: Need to change the test on behalf the clustering transaction chain manager changes * @throws Exception */ - @Ignore @Test public void testInitialSubmitTransaction() throws Exception { + Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null)); + final InstanceIdentifier dummyII = InstanceIdentifier.create(Nodes.class); + ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ; + ((DeviceContextImpl) deviceContext).getTransactionChainManager().enableSubmit(); + deviceContext.addDeleteToTxChain(LogicalDatastoreType.CONFIGURATION, dummyII); deviceContext.initialSubmitTransaction(); - verify(txChainManager).initialSubmitWriteTransaction(); - } - - @Test - public void testGetReservedXid() { - deviceContext.getReservedXid(); - verify(outboundQueueProvider).reserveEntry(); + verify(wTx).submit(); } @Test public void testAuxiliaryConnectionContext() { - ConnectionContext mockedConnectionContext = addDummyAuxiliaryConnectionContext(); - final ConnectionContext pickedConnectiobContexts = deviceContext.getAuxiliaryConnectiobContexts(DUMMY_COOKIE); + final ConnectionContext mockedConnectionContext = addDummyAuxiliaryConnectionContext(); + final ConnectionContext pickedConnectiobContexts = deviceContext.getAuxiliaryConnectionContexts(DUMMY_COOKIE); assertEquals(mockedConnectionContext, pickedConnectiobContexts); } + @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() { - ConnectionContext mockedConnectionContext = prepareConnectionContext(); - deviceContext.addAuxiliaryConenctionContext(mockedConnectionContext); + final ConnectionContext mockedConnectionContext = prepareConnectionContext(); + deviceContext.addAuxiliaryConnectionContext(mockedConnectionContext); return mockedConnectionContext; } private ConnectionContext prepareConnectionContext() { - ConnectionContext mockedConnectionContext = mock(ConnectionContext.class); - FeaturesReply mockedFeaturesReply = mock(FeaturesReply.class); + final ConnectionContext mockedConnectionContext = mock(ConnectionContext.class); + final FeaturesReply mockedFeaturesReply = mock(FeaturesReply.class); when(mockedFeaturesReply.getAuxiliaryId()).thenReturn(DUMMY_AUXILIARY_ID); when(mockedConnectionContext.getFeatures()).thenReturn(mockedFeaturesReply); return mockedConnectionContext; } /** - * FIXME: Need to change the test on behalf the clustering transaction chain manager changes * @throws Exception */ - @Ignore @Test public void testAddDeleteToTxChain() throws Exception{ - InstanceIdentifier dummyII = InstanceIdentifier.create(Nodes.class); + final InstanceIdentifier dummyII = InstanceIdentifier.create(Nodes.class); + ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ; + ((DeviceContextImpl) deviceContext).getTransactionChainManager().enableSubmit(); deviceContext.addDeleteToTxChain(LogicalDatastoreType.CONFIGURATION, dummyII); - verify(txChainManager).addDeleteOperationTotTxChain(eq(LogicalDatastoreType.CONFIGURATION), eq(dummyII)); + verify(wTx).delete(eq(LogicalDatastoreType.CONFIGURATION), eq(dummyII)); } /** - * FIXME: Need to change the test on behalf the clustering transaction chain manager changes * @throws Exception */ - @Ignore @Test public void testSubmitTransaction() throws Exception { - deviceContext.submitTransaction(); - verify(txChainManager).submitWriteTransaction(); + ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ; + ((DeviceContextImpl) deviceContext).getTransactionChainManager().enableSubmit(); + assertTrue(deviceContext.submitTransaction()); } @Test @@ -331,44 +354,44 @@ public class DeviceContextImplTest { @Test public void testProcessReply() { - Error mockedError = mock(Error.class); + final Error mockedError = mock(Error.class); deviceContext.processReply(mockedError); - verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_FAILURE)); - OfHeader mockedOfHeader = mock(OfHeader.class); + verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_FAILURE)); + final OfHeader mockedOfHeader = mock(OfHeader.class); deviceContext.processReply(mockedOfHeader); - verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_SUCCESS)); + verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_SUCCESS)); } @Test public void testProcessReply2() { - MultipartReply mockedMultipartReply = mock(MultipartReply.class); - Xid dummyXid = new Xid(DUMMY_XID); + final MultipartReply mockedMultipartReply = mock(MultipartReply.class); + final Xid dummyXid = new Xid(DUMMY_XID); deviceContext.processReply(dummyXid, Lists.newArrayList(mockedMultipartReply)); - verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_FAILURE)); + verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_FAILURE)); } @Test public void testProcessPacketInMessageFutureSuccess() { - PacketInMessage mockedPacketInMessage = mock(PacketInMessage.class); - NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class); + final PacketInMessage mockedPacketInMessage = mock(PacketInMessage.class); + final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class); final ListenableFuture stringListenableFuture = Futures.immediateFuture(new String("dummy value")); when(mockedNotificationPublishService.offerNotification(any(PacketReceived.class))).thenReturn(stringListenableFuture); deviceContext.setNotificationPublishService(mockedNotificationPublishService); deviceContext.processPacketInMessage(mockedPacketInMessage); - verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_SUCCESS)); + verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_SUCCESS)); } @Test public void testProcessPacketInMessageFutureFailure() { - PacketInMessage mockedPacketInMessage = mock(PacketInMessage.class); - NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class); + final PacketInMessage mockedPacketInMessage = mock(PacketInMessage.class); + final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class); final ListenableFuture dummyFuture = Futures.immediateFailedFuture(new IllegalStateException()); when(mockedNotificationPublishService.offerNotification(any(PacketReceived.class))).thenReturn(dummyFuture); deviceContext.setNotificationPublishService(mockedNotificationPublishService); deviceContext.processPacketInMessage(mockedPacketInMessage); - verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_NOTIFICATION_REJECTED)); + verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_NOTIFICATION_REJECTED)); } @Test @@ -378,34 +401,24 @@ public class DeviceContextImplTest { } @Test - public void testGetTimer() { - final HashedWheelTimer pickedTimer = deviceContext.getTimer(); - assertEquals(timer, pickedTimer); - } - - @Test - public void testClose() { - ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class); - InetSocketAddress mockRemoteAddress = InetSocketAddress.createUnresolved("odl-unit.example.org",999); + 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); - NodeId dummyNodeId = new NodeId("dummyNodeId"); - when(deviceState.getNodeId()).thenReturn(dummyNodeId); - - ConnectionContext mockedAuxiliaryConnectionContext = prepareConnectionContext(); - deviceContext.addAuxiliaryConenctionContext(mockedAuxiliaryConnectionContext); - DeviceContextClosedHandler mockedDeviceContextClosedHandler = mock(DeviceContextClosedHandler.class); - deviceContext.addDeviceContextClosedHandler(mockedDeviceContextClosedHandler); - deviceContext.close(); - verify(connectionContext).closeConnection(eq(false)); -// verify(deviceState).setValid(eq(false)); -// verify(mockedAuxiliaryConnectionContext).closeConnection(eq(false)); + 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() { - Timeout mockedTimeout = mock(Timeout.class); + final Timeout mockedTimeout = mock(Timeout.class); deviceContext.setCurrentBarrierTimeout(mockedTimeout); final Timeout pickedBarrierTimeout = deviceContext.getBarrierTaskTimeout(); assertEquals(mockedTimeout, pickedBarrierTimeout); @@ -414,26 +427,17 @@ public class DeviceContextImplTest { @Test public void testGetMessageSpy() { final MessageSpy pickedMessageSpy = deviceContext.getMessageSpy(); - assertEquals(messageIntelligenceAgency, pickedMessageSpy); - } - - @Test - public void testNodeConnector() { - NodeConnectorRef mockedNodeConnectorRef = mock(NodeConnectorRef.class); - deviceContext.storeNodeConnectorRef(DUMMY_PORT_NUMBER, mockedNodeConnectorRef); - final NodeConnectorRef nodeConnectorRef = deviceContext.lookupNodeConnectorRef(DUMMY_PORT_NUMBER); - assertEquals(mockedNodeConnectorRef, nodeConnectorRef); - + assertEquals(messageSpy, pickedMessageSpy); } @Test public void testOnPublished() { final ConnectionContext auxiliaryConnectionContext = addDummyAuxiliaryConnectionContext(); - ConnectionAdapter mockedAuxConnectionAdapter = mock(ConnectionAdapter.class); + final ConnectionAdapter mockedAuxConnectionAdapter = mock(ConnectionAdapter.class); when(auxiliaryConnectionContext.getConnectionAdapter()).thenReturn(mockedAuxConnectionAdapter); - ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class); + final ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class); when(connectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter); deviceContext.onPublished(); @@ -442,22 +446,23 @@ public class DeviceContextImplTest { } @Test - public void testPortStatusMessage() { - PortStatusMessage mockedPortStatusMessage = mock(PortStatusMessage.class); - Class dummyClass = Class.class; + public void testPortStatusMessage() throws Exception{ + final PortStatusMessage mockedPortStatusMessage = mock(PortStatusMessage.class); + final Class dummyClass = Class.class; when(mockedPortStatusMessage.getImplementedInterface()).thenReturn(dummyClass); - GetFeaturesOutput mockedFeature = mock(GetFeaturesOutput.class); + final GetFeaturesOutput mockedFeature = mock(GetFeaturesOutput.class); when(mockedFeature.getDatapathId()).thenReturn(DUMMY_DATAPATH_ID); - when(deviceState.getFeatures()).thenReturn(mockedFeature); when(mockedPortStatusMessage.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3); when(mockedPortStatusMessage.getReason()).thenReturn(PortReason.OFPPRADD); + when(mockedPortStatusMessage.getPortNo()).thenReturn(42L); OpenflowPortsUtil.init(); - deviceContext.processPortStatusMessage(mockedPortStatusMessage); - verify(txChainManager).writeToTransaction(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class), any(DataObject.class)); + deviceContextSpy.processPortStatusMessage(mockedPortStatusMessage); + verify(deviceContextSpy).writeToTransaction(Mockito.any(), Mockito.any(), any()); + verify(deviceContextSpy).submitTransaction(); } @Test @@ -468,18 +473,19 @@ public class DeviceContextImplTest { .setPriority(42) .setCookie(new FlowCookie(BigInteger.ONE)) .setMatch(new MatchBuilder().build()); + final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class); - Mockito.when(messageTranslatorFlowRemoved.translate(any(Object.class), any(DeviceContext.class), any(Object.class))) + Mockito.when(messageTranslatorFlowRemoved.translate(any(Object.class), any(DeviceInfo.class), any(Object.class))) .thenReturn(flowRemovedMdsalBld.build()); // insert flow+flowId into local registry - FlowRegistryKey flowRegKey = FlowRegistryKeyFactory.create(flowRemovedMdsalBld.build()); - FlowDescriptor flowDescriptor = FlowDescriptorFactory.create((short) 0, new FlowId("ut-ofp:f456")); + final FlowRegistryKey flowRegKey = FlowRegistryKeyFactory.create(flowRemovedMdsalBld.build()); + final FlowDescriptor flowDescriptor = FlowDescriptorFactory.create((short) 0, new FlowId("ut-ofp:f456")); deviceContext.getDeviceFlowRegistry().store(flowRegKey, flowDescriptor); // plug in lifecycleListener final ItemLifecycleListener itemLifecycleListener = Mockito.mock(ItemLifecycleListener.class); - for (ItemLifeCycleSource lifeCycleSource : deviceContext.getItemLifeCycleSourceRegistry().getLifeCycleSources()) { + for (final ItemLifeCycleSource lifeCycleSource : deviceContext.getItemLifeCycleSourceRegistry().getLifeCycleSources()) { lifeCycleSource.setItemLifecycleListener(itemLifecycleListener); } @@ -487,27 +493,64 @@ public class DeviceContextImplTest { final FlowRemovedMessageBuilder flowRemovedBld = new FlowRemovedMessageBuilder(); // prepare path to flow to be removed - KeyedInstanceIdentifier flowToBeRemovedPath = nodeKeyIdent + final KeyedInstanceIdentifier flowToBeRemovedPath = nodeKeyIdent .augmentation(FlowCapableNode.class) .child(Table.class, new TableKey((short) 0)) .child(Flow.class, new FlowKey(new FlowId("ut-ofp:f456"))); + Mockito.when(deviceManager.getIsNotificationFlowRemovedOff()).thenReturn(true); + + deviceContext.setNotificationPublishService(mockedNotificationPublishService); deviceContext.processFlowRemovedMessage(flowRemovedBld.build()); + Mockito.verify(itemLifecycleListener).onRemoved(flowToBeRemovedPath); + Mockito.verify(mockedNotificationPublishService, Mockito.never()).offerNotification(Matchers.any(Notification.class)); + + Mockito.when(deviceManager.getIsNotificationFlowRemovedOff()).thenReturn(false); + deviceContext.processFlowRemovedMessage(flowRemovedBld.build()); + + Mockito.verify(mockedNotificationPublishService).offerNotification(Matchers.any(Notification.class)); + } + + @Test + public void testProcessExperimenterMessage() { + final ConvertorMessageFromOFJava mockedMessageConverter = mock(ConvertorMessageFromOFJava.class); + final ExtensionConverterProvider mockedExtensionConverterProvider = mock(ExtensionConverterProvider.class); + when(mockedExtensionConverterProvider.getMessageConverter(any(MessageTypeKey.class))).thenReturn(mockedMessageConverter); + + final ExperimenterDataOfChoice mockedExperimenterDataOfChoice = mock(ExperimenterDataOfChoice.class); + final ExperimenterMessage experimenterMessage = new ExperimenterMessageBuilder() + .setExperimenterDataOfChoice(mockedExperimenterDataOfChoice).build(); + + final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class); + + deviceContext.setNotificationPublishService(mockedNotificationPublishService); + ((DeviceContextImpl) deviceContext).setExtensionConverterProvider(mockedExtensionConverterProvider); + deviceContext.processExperimenterMessage(experimenterMessage); + + verify(mockedNotificationPublishService).offerNotification(any(ExperimenterMessageFromDev.class)); } @Test public void testOnDeviceDisconnected() throws Exception { - DeviceContextClosedHandler deviceContextClosedHandler = mock(DeviceContextClosedHandler.class); - deviceContext.addDeviceContextClosedHandler(deviceContextClosedHandler); + final DeviceTerminationPhaseHandler deviceContextClosedHandler = mock(DeviceTerminationPhaseHandler.class); - deviceContext.onDeviceDisconnected(connectionContext); + assertEquals(0, deviceContext.getDeviceFlowRegistry().getAllFlowDescriptors().size()); + assertEquals(0, deviceContext.getDeviceGroupRegistry().getAllGroupIds().size()); + assertEquals(0, deviceContext.getDeviceMeterRegistry().getAllMeterIds().size()); -// Mockito.verify(deviceState).setValid(false); -// Mockito.verify(deviceContextClosedHandler).onDeviceContextClosed(deviceContext); - Assert.assertEquals(0, deviceContext.getDeviceFlowRegistry().getAllFlowDescriptors().size()); - Assert.assertEquals(0, deviceContext.getDeviceGroupRegistry().getAllGroupIds().size()); - Assert.assertEquals(0, deviceContext.getDeviceMeterRegistry().getAllMeterIds().size()); + } + + @Test + public void replaceConnectionContext() throws Exception { + + final ConnectionContext connectionContext1 = mock(ConnectionContext.class); + Assert.assertEquals(deviceContext.getPrimaryConnectionContext(), connectionContext); + Mockito.when(connectionContext1.getConnectionAdapter()).thenReturn(connectionAdapter); + Mockito.doNothing().when(connectionAdapter).setPacketInFiltering(Mockito.anyBoolean()); + deviceContext.replaceConnectionContext(connectionContext1); + Assert.assertEquals(deviceContext.getPrimaryConnectionContext(), connectionContext1); } + }