X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=openflowplugin-impl%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fopenflowplugin%2Fimpl%2Fdevice%2FDeviceManagerImplTest.java;h=287740303b07a6ba7c8b3b97227e54e207e0b967;hb=3bd017a79f37bd70ecf3795ad3f6ac73b7585e4b;hp=0d61ca0c7bb3633579f80899ac5b4720fdd153bd;hpb=18dc690ea2106eea6c2111d998581e8ded03231c;p=openflowplugin.git diff --git a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/DeviceManagerImplTest.java b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/DeviceManagerImplTest.java index 0d61ca0c7b..287740303b 100644 --- a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/DeviceManagerImplTest.java +++ b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/DeviceManagerImplTest.java @@ -1,140 +1,88 @@ /* + * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. * - * * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. - * * - * * This program and the accompanying materials are made available under the - * * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * * and is available at http://www.eclipse.org/legal/epl-v10.html - * - * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html */ package org.opendaylight.openflowplugin.impl.device; import static org.mockito.Matchers.any; -import static org.mockito.Mockito.doThrow; -import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import com.google.common.util.concurrent.CheckedFuture; -import com.google.common.util.concurrent.FutureCallback; +import io.netty.util.HashedWheelTimer; import java.lang.reflect.Field; import java.math.BigInteger; -import java.util.Collections; import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.TimeUnit; - -import com.google.common.util.concurrent.Futures; -import io.netty.util.TimerTask; import org.junit.Assert; 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.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.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener; import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter; -import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueue; -import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueueHandler; -import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueueHandlerRegistration; -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.DeviceState; -import org.opendaylight.openflowplugin.api.openflow.device.MessageTranslator; -import org.opendaylight.openflowplugin.api.openflow.device.TranslatorLibrary; -import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceInitializationPhaseHandler; -import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceTerminationPhaseHandler; -import org.opendaylight.openflowplugin.api.openflow.lifecycle.LifecycleConductor; -import org.opendaylight.openflowplugin.api.openflow.md.core.TranslatorKey; +import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo; import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageIntelligenceAgency; -import org.opendaylight.openflowplugin.openflow.md.util.OpenflowPortsUtil; +import org.opendaylight.openflowplugin.impl.device.initialization.DeviceInitializerProviderFactory; +import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId; 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.CapabilitiesV10; import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FeaturesReply; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartRequestInput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.features.reply.PhyPortBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.role.service.rev150727.OfpRole; @RunWith(MockitoJUnitRunner.class) public class DeviceManagerImplTest { - private static final long TEST_VALUE_GLOBAL_NOTIFICATION_QUOTA = 2000l; + private static final long TEST_VALUE_GLOBAL_NOTIFICATION_QUOTA = 2000L; private static final int barrierCountLimit = 25600; private static final int barrierIntervalNanos = 500; + private static final NodeId DUMMY_NODE_ID = new NodeId("dummyNodeId"); @Mock - CheckedFuture mockedFuture; + private CheckedFuture mockedFuture; @Mock private FeaturesReply mockFeatures; @Mock - private OutboundQueue outboundQueueProvider; - @Mock - private DeviceInitializationPhaseHandler deviceInitPhaseHandler; - @Mock - private DeviceTerminationPhaseHandler deviceTerminationPhaseHandler; - @Mock - private TranslatorLibrary translatorLibrary; - @Mock private ConnectionContext mockConnectionContext; @Mock private ConnectionAdapter mockedConnectionAdapter; @Mock private DeviceContextImpl mockedDeviceContext; @Mock - private NodeId mockedNodeId; + private MessageIntelligenceAgency messageIntelligenceAgency; @Mock - private LifecycleConductor lifecycleConductor; + private DeviceInfo deviceInfo; @Mock - private MessageIntelligenceAgency messageIntelligenceAgency; - + private ConvertorExecutor convertorExecutor; @Before public void setUp() throws Exception { - OpenflowPortsUtil.init(); - - when(mockConnectionContext.getNodeId()).thenReturn(new NodeId("dummyNodeId")); + when(mockConnectionContext.getNodeId()).thenReturn(DUMMY_NODE_ID); when(mockConnectionContext.getFeatures()).thenReturn(mockFeatures); when(mockConnectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter); + when(mockConnectionContext.getDeviceInfo()).thenReturn(deviceInfo); when(mockedDeviceContext.getPrimaryConnectionContext()).thenReturn(mockConnectionContext); + when(deviceInfo.getNodeId()).thenReturn(DUMMY_NODE_ID); final Capabilities capabilitiesV13 = mock(Capabilities.class); final CapabilitiesV10 capabilitiesV10 = mock(CapabilitiesV10.class); when(mockFeatures.getCapabilities()).thenReturn(capabilitiesV13); when(mockFeatures.getCapabilitiesV10()).thenReturn(capabilitiesV10); when(mockFeatures.getDatapathId()).thenReturn(BigInteger.valueOf(21L)); - - when(lifecycleConductor.getMessageIntelligenceAgency()).thenReturn(messageIntelligenceAgency); - } - - @Test(expected = IllegalStateException.class) - public void onDeviceContextLevelUpFailTest() throws Exception { - onDeviceContextLevelUp(true); - } - - @Test - public void onDeviceContextLevelUpSuccessTest() throws Exception { - onDeviceContextLevelUp(false); } private DeviceManagerImpl prepareDeviceManager() { - return prepareDeviceManager(false); - } - - private DeviceManagerImpl prepareDeviceManager(final boolean withException) { final DataBroker mockedDataBroker = mock(DataBroker.class); final WriteTransaction mockedWriteTransaction = mock(WriteTransaction.class); @@ -147,137 +95,31 @@ public class DeviceManagerImplTest { when(mockedWriteTransaction.submit()).thenReturn(mockedFuture); - final DeviceManagerImpl deviceManager = new DeviceManagerImpl(mockedDataBroker, - TEST_VALUE_GLOBAL_NOTIFICATION_QUOTA, false, barrierIntervalNanos, barrierCountLimit, lifecycleConductor); - - deviceManager.setDeviceInitializationPhaseHandler(deviceInitPhaseHandler); - deviceManager.setDeviceTerminationPhaseHandler(deviceTerminationPhaseHandler); + final DeviceManagerImpl deviceManager = new DeviceManagerImpl( + mockedDataBroker, + messageIntelligenceAgency, + null, + new HashedWheelTimer(), + convertorExecutor, + DeviceInitializerProviderFactory.createDefaultProvider()); + + deviceManager.setBarrierCountLimit(barrierCountLimit); + deviceManager.setBarrierInterval(barrierIntervalNanos); + deviceManager.setGlobalNotificationQuota(TEST_VALUE_GLOBAL_NOTIFICATION_QUOTA); + deviceManager.setSwitchFeaturesMandatory(false); + deviceManager.setFlowRemovedNotificationOn(true); + deviceManager.setSkipTableFeatures(false); + deviceManager.setUseSingleLayerSerialization(false); return deviceManager; } - public void onDeviceContextLevelUp(final boolean withException) throws Exception { - final DeviceManagerImpl deviceManager = prepareDeviceManager(withException); - final DeviceState mockedDeviceState = mock(DeviceState.class); - when(mockedDeviceContext.getDeviceState()).thenReturn(mockedDeviceState); - when(mockedDeviceState.getNodeId()).thenReturn(mockedNodeId); - - if (withException) { - doThrow(new IllegalStateException("dummy")).when(mockedDeviceContext).initialSubmitTransaction(); - } - deviceManager.addDeviceContextToMap(mockedNodeId, mockedDeviceContext); - deviceManager.onDeviceContextLevelUp(mockedDeviceContext.getDeviceState().getNodeId()); - if (withException) { - verify(mockedDeviceContext).close(); - } else { - verify(mockedDeviceContext).initialSubmitTransaction(); - verify(mockedDeviceContext).onPublished(); - } - } - - @Test - public void deviceConnectedTest() throws Exception{ - final DeviceManagerImpl deviceManager = prepareDeviceManager(); - injectMockTranslatorLibrary(deviceManager); - final ConnectionContext mockConnectionContext = buildMockConnectionContext(OFConstants.OFP_VERSION_1_3); - - deviceManager.deviceConnected(mockConnectionContext); - - final InOrder order = inOrder(mockConnectionContext); - order.verify(mockConnectionContext).getFeatures(); - order.verify(mockConnectionContext).setOutboundQueueProvider(any(OutboundQueueProvider.class)); - order.verify(mockConnectionContext).setOutboundQueueHandleRegistration( - Mockito.>any()); - order.verify(mockConnectionContext).getNodeId(); - verify(deviceInitPhaseHandler).onDeviceContextLevelUp(Matchers.any()); - } - - @Test - public void deviceConnectedV10Test() throws Exception{ - final DeviceManagerImpl deviceManager = prepareDeviceManager(); - injectMockTranslatorLibrary(deviceManager); - final ConnectionContext mockConnectionContext = buildMockConnectionContext(OFConstants.OFP_VERSION_1_0); - - final PhyPortBuilder phyPort = new PhyPortBuilder() - .setPortNo(41L); - when(mockFeatures.getPhyPort()).thenReturn(Collections.singletonList(phyPort.build())); - final MessageTranslator mockedTranslator = mock(MessageTranslator.class); - when(mockedTranslator.translate(Matchers.any(), Matchers.any(), Matchers.any())) - .thenReturn(null); - when(translatorLibrary.lookupTranslator(Matchers.any())).thenReturn(mockedTranslator); - - deviceManager.deviceConnected(mockConnectionContext); - - final InOrder order = inOrder(mockConnectionContext); - order.verify(mockConnectionContext).getFeatures(); - order.verify(mockConnectionContext).setOutboundQueueProvider(any(OutboundQueueProvider.class)); - order.verify(mockConnectionContext).setOutboundQueueHandleRegistration( - Mockito.>any()); - order.verify(mockConnectionContext).getNodeId(); - verify(deviceInitPhaseHandler).onDeviceContextLevelUp(Matchers.any()); - } - - @Test - public void deviceDisconnectedTest() throws Exception { - final DeviceState deviceState = mock(DeviceState.class); - - final DeviceManagerImpl deviceManager = prepareDeviceManager(); - injectMockTranslatorLibrary(deviceManager); - - final ConnectionContext connectionContext = buildMockConnectionContext(OFConstants.OFP_VERSION_1_3); - when(connectionContext.getNodeId()).thenReturn(mockedNodeId); - - final DeviceContext deviceContext = mock(DeviceContext.class); - when(deviceContext.shuttingDownDataStoreTransactions()).thenReturn(Futures.immediateCheckedFuture(null)); - when(deviceContext.getPrimaryConnectionContext()).thenReturn(connectionContext); - when(deviceContext.getDeviceState()).thenReturn(deviceState); - - final ConcurrentHashMap deviceContexts = getContextsCollection(deviceManager); - deviceContexts.put(mockedNodeId, deviceContext); - - deviceManager.onDeviceDisconnected(connectionContext); - - verify(lifecycleConductor).newTimeout(Mockito.any(), Mockito.anyLong(), Mockito.any()); - } - - protected ConnectionContext buildMockConnectionContext(final short ofpVersion) { - when(mockFeatures.getVersion()).thenReturn(ofpVersion); - when(outboundQueueProvider.reserveEntry()).thenReturn(43L); - Mockito.doAnswer(new Answer() { - @Override - public Void answer(final InvocationOnMock invocation) throws Throwable { - final FutureCallback callBack = (FutureCallback) invocation.getArguments()[2]; - callBack.onSuccess(null); - return null; - } - }) - .when(outboundQueueProvider) - .commitEntry(Matchers.anyLong(), Matchers.any(), Matchers.>any()); - - when(mockedConnectionAdapter.registerOutboundQueueHandler(Matchers.any(), Matchers.anyInt(), Matchers.anyLong())) - .thenAnswer(new Answer>() { - @Override - public OutboundQueueHandlerRegistration answer(final InvocationOnMock invocation) throws Throwable { - final OutboundQueueHandler handler = (OutboundQueueHandler) invocation.getArguments()[0]; - handler.onConnectionQueueChanged(outboundQueueProvider); - return null; - } - }); - - when(mockConnectionContext.getOutboundQueueProvider()).thenReturn(outboundQueueProvider); - return mockConnectionContext; - } - - private void injectMockTranslatorLibrary(final DeviceManagerImpl deviceManager) { - deviceManager.setTranslatorLibrary(translatorLibrary); - } - @Test public void testClose() throws Exception { final DeviceContext deviceContext = mock(DeviceContext.class); final DeviceManagerImpl deviceManager = prepareDeviceManager(); - final ConcurrentHashMap deviceContexts = getContextsCollection(deviceManager); - deviceContexts.put(mockedNodeId, deviceContext); + final ConcurrentHashMap deviceContexts = getContextsCollection(deviceManager); + deviceContexts.put(deviceInfo, deviceContext); Assert.assertEquals(1, deviceContexts.size()); deviceManager.close(); @@ -286,12 +128,12 @@ public class DeviceManagerImplTest { verify(deviceContext, Mockito.never()).close(); } - private static ConcurrentHashMap getContextsCollection(final DeviceManagerImpl deviceManager) throws NoSuchFieldException, IllegalAccessException { + private static ConcurrentHashMap getContextsCollection(final DeviceManagerImpl deviceManager) throws NoSuchFieldException, IllegalAccessException { // HACK: contexts collection for testing shall be accessed in some more civilized way final Field contextsField = DeviceManagerImpl.class.getDeclaredField("deviceContexts"); Assert.assertNotNull(contextsField); contextsField.setAccessible(true); - return (ConcurrentHashMap) contextsField.get(deviceManager); + return (ConcurrentHashMap) contextsField.get(deviceManager); } }