openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/DeviceContextImplTest.java

   1 /*
   2  * Copyright (c) 2015 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
   9 package org.opendaylight.openflowplugin.impl.device;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertNull;
  14 import static org.junit.Assert.assertTrue;
  15 import static org.mockito.Matchers.any;
  16 import static org.mockito.Matchers.eq;
  17 import static org.mockito.Mockito.mock;
  18 import static org.mockito.Mockito.verify;
  19 import static org.mockito.Mockito.when;
  20
  21 import com.google.common.base.Optional;
  22 import com.google.common.collect.Lists;
  23 import com.google.common.util.concurrent.CheckedFuture;
  24 import com.google.common.util.concurrent.Futures;
  25 import com.google.common.util.concurrent.ListenableFuture;
  26 import com.google.common.util.concurrent.SettableFuture;
  27 import io.netty.util.HashedWheelTimer;
  28 import io.netty.util.Timeout;
  29 import java.math.BigInteger;
  30 import java.net.InetSocketAddress;
  31 import java.util.concurrent.atomic.AtomicLong;
  32 import org.junit.Before;
  33 import org.junit.Test;
  34 import org.junit.runner.RunWith;
  35 import org.mockito.InOrder;
  36 import org.mockito.Matchers;
  37 import org.mockito.Mock;
  38 import org.mockito.Mockito;
  39 import org.mockito.runners.MockitoJUnitRunner;
  40 import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
  41 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  42 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
  43 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  44 import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
  45 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  46 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  47 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  48 import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
  49 import org.opendaylight.openflowjava.protocol.api.keys.MessageTypeKey;
  50 import org.opendaylight.openflowplugin.api.OFConstants;
  51 import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
  52 import org.opendaylight.openflowplugin.api.openflow.connection.OutboundQueueProvider;
  53 import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
  54 import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
  55 import org.opendaylight.openflowplugin.api.openflow.device.DeviceManager;
  56 import org.opendaylight.openflowplugin.api.openflow.device.DeviceState;
  57 import org.opendaylight.openflowplugin.api.openflow.device.MessageTranslator;
  58 import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
  59 import org.opendaylight.openflowplugin.api.openflow.device.TranslatorLibrary;
  60 import org.opendaylight.openflowplugin.api.openflow.device.Xid;
  61 import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceTerminationPhaseHandler;
  62 import org.opendaylight.openflowplugin.api.openflow.lifecycle.LifecycleConductor;
  63 import org.opendaylight.openflowplugin.api.openflow.md.core.TranslatorKey;
  64 import org.opendaylight.openflowplugin.api.openflow.registry.flow.DeviceFlowRegistry;
  65 import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowDescriptor;
  66 import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowRegistryKey;
  67 import org.opendaylight.openflowplugin.api.openflow.registry.group.DeviceGroupRegistry;
  68 import org.opendaylight.openflowplugin.api.openflow.registry.meter.DeviceMeterRegistry;
  69 import org.opendaylight.openflowplugin.api.openflow.rpc.ItemLifeCycleSource;
  70 import org.opendaylight.openflowplugin.api.openflow.rpc.listener.ItemLifecycleListener;
  71 import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageIntelligenceAgency;
  72 import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageSpy;
  73 import org.opendaylight.openflowplugin.extension.api.ConvertorMessageFromOFJava;
  74 import org.opendaylight.openflowplugin.extension.api.core.extension.ExtensionConverterProvider;
  75 import org.opendaylight.openflowplugin.impl.registry.flow.FlowDescriptorFactory;
  76 import org.opendaylight.openflowplugin.impl.registry.flow.FlowRegistryKeyFactory;
  77 import org.opendaylight.openflowplugin.impl.util.DeviceStateUtil;
  78 import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
  79 import org.opendaylight.openflowplugin.openflow.md.util.OpenflowPortsUtil;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.experimenter.message.service.rev151020.ExperimenterMessageFromDev;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowRemovedBuilder;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  95 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.Capabilities;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.PortReason;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.Error;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterMessage;
  99 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterMessageBuilder;
 100 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FeaturesReply;
 101 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FlowRemovedMessageBuilder;
 102 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetAsyncReply;
 103 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesOutput;
 104 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartReply;
 105 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
 106 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketIn;
 107 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketInMessage;
 108 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortGrouping;
 109 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortStatusMessage;
 110 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.experimenter.core.ExperimenterDataOfChoice;
 111 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
 112 import org.opendaylight.yangtools.concepts.Registration;
 113 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 114 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
 115 import org.opendaylight.yangtools.yang.binding.Notification;
 116 import org.opendaylight.yangtools.yang.common.RpcResult;
 117 import org.slf4j.Logger;
 118 import org.slf4j.LoggerFactory;
 119
 120 @RunWith(MockitoJUnitRunner.class)
 121 public class DeviceContextImplTest {
 122     private static final Logger LOG = LoggerFactory
 123             .getLogger(DeviceContextImplTest.class);
 124     private static final short DUMMY_AUXILIARY_ID = 33;
 125     private static final BigInteger DUMMY_COOKIE = new BigInteger("33");
 126     private static final Long DUMMY_XID = 544L;
 127     private static final Long DUMMY_PORT_NUMBER = 159L;
 128     private static final BigInteger DUMMY_DATAPATH_ID = new BigInteger("55");
 129     Xid xid;
 130     Xid xidMulti;
 131
 132     DeviceContext deviceContext;
 133     @Mock
 134     TransactionChainManager txChainManager;
 135     @Mock
 136     RequestContext<GetAsyncReply> requestContext;
 137     @Mock
 138     RequestContext<MultipartReply> requestContextMultiReply;
 139     @Mock
 140     ConnectionContext connectionContext;
 141     @Mock
 142     DeviceState deviceState;
 143     @Mock
 144     GetFeaturesOutput featuresOutput;
 145     @Mock
 146     DataBroker dataBroker;
 147     @Mock
 148     WriteTransaction wTx;
 149     @Mock
 150     ReadOnlyTransaction rTx;
 151     @Mock
 152     BindingTransactionChain txChainFactory;
 153     @Mock
 154     HashedWheelTimer timer;
 155     @Mock
 156     MessageIntelligenceAgency messageIntelligenceAgency;
 157     @Mock
 158     OutboundQueueProvider outboundQueueProvider;
 159     @Mock
 160     ConnectionAdapter connectionAdapter;
 161     NodeId nodeId = new NodeId("h2g2:42");
 162     KeyedInstanceIdentifier<Node, NodeKey> nodeKeyIdent = DeviceStateUtil.createNodeInstanceIdentifier(nodeId);
 163     @Mock
 164     TranslatorLibrary translatorLibrary;
 165     @Mock
 166     Registration registration;
 167     @Mock
 168     MessageTranslator messageTranslatorPacketReceived;
 169     @Mock
 170     MessageTranslator messageTranslatorFlowCapableNodeConnector;
 171     @Mock
 172     private MessageTranslator<Object, Object> messageTranslatorFlowRemoved;
 173     @Mock
 174     private LifecycleConductor lifecycleConductor;
 175     @Mock
 176     private DeviceInfo deviceInfo;
 177     @Mock
 178     private DeviceManager deviceManager;
 179     @Mock
 180     private ConvertorExecutor convertorExecutor;
 181
 182     private InOrder inOrderDevState;
 183
 184     private final AtomicLong atomicLong = new AtomicLong(0);
 185
 186     private DeviceContext deviceContextSpy;
 187
 188     @Before
 189     public void setUp() throws Exception{
 190         final CheckedFuture<Optional<Node>, ReadFailedException> noExistNodeFuture = Futures.immediateCheckedFuture(Optional.<Node>absent());
 191         Mockito.when(rTx.read(LogicalDatastoreType.OPERATIONAL, nodeKeyIdent)).thenReturn(noExistNodeFuture);
 192         Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(rTx);
 193         Mockito.when(dataBroker.createTransactionChain(Mockito.any(TransactionChainManager.class))).thenReturn(txChainFactory);
 194         Mockito.when(deviceInfo.getNodeInstanceIdentifier()).thenReturn(nodeKeyIdent);
 195         Mockito.when(deviceInfo.getNodeId()).thenReturn(nodeId);
 196         Mockito.when(deviceInfo.getDatapathId()).thenReturn(BigInteger.ONE);
 197         final SettableFuture<RpcResult<GetAsyncReply>> settableFuture = SettableFuture.create();
 198         final SettableFuture<RpcResult<MultipartReply>> settableFutureMultiReply = SettableFuture.create();
 199         Mockito.when(requestContext.getFuture()).thenReturn(settableFuture);
 200         Mockito.doAnswer(invocation -> {
 201             settableFuture.set((RpcResult<GetAsyncReply>) invocation.getArguments()[0]);
 202             return null;
 203         }).when(requestContext).setResult(any(RpcResult.class));
 204
 205         Mockito.when(requestContextMultiReply.getFuture()).thenReturn(settableFutureMultiReply);
 206         Mockito.doAnswer(invocation -> {
 207             settableFutureMultiReply.set((RpcResult<MultipartReply>) invocation.getArguments()[0]);
 208             return null;
 209         }).when(requestContextMultiReply).setResult(any(RpcResult.class));
 210         Mockito.when(txChainFactory.newWriteOnlyTransaction()).thenReturn(wTx);
 211         Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(rTx);
 212         Mockito.when(connectionContext.getOutboundQueueProvider()).thenReturn(outboundQueueProvider);
 213         Mockito.when(connectionContext.getConnectionAdapter()).thenReturn(connectionAdapter);
 214         Mockito.when(connectionContext.getDeviceInfo()).thenReturn(deviceInfo);
 215         final FeaturesReply mockedFeaturesReply = mock(FeaturesReply.class);
 216         when(connectionContext.getFeatures()).thenReturn(mockedFeaturesReply);
 217         when(connectionContext.getFeatures().getCapabilities()).thenReturn(mock(Capabilities.class));
 218
 219         Mockito.when(deviceInfo.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
 220         Mockito.when(featuresOutput.getDatapathId()).thenReturn(DUMMY_DATAPATH_ID);
 221         Mockito.when(featuresOutput.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
 222         Mockito.when(messageTranslatorPacketReceived.translate(any(Object.class), any(DeviceInfo.class), any(Object.class))).thenReturn(mock(PacketReceived.class));
 223         Mockito.when(messageTranslatorFlowCapableNodeConnector.translate(any(Object.class), any(DeviceInfo.class), any(Object.class))).thenReturn(mock(FlowCapableNodeConnector.class));
 224         Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3, PacketIn.class.getName())))).thenReturn(messageTranslatorPacketReceived);
 225         Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3, PortGrouping.class.getName())))).thenReturn(messageTranslatorFlowCapableNodeConnector);
 226         Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3,
 227                 org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FlowRemoved.class.getName()))))
 228                 .thenReturn(messageTranslatorFlowRemoved);
 229         Mockito.when(lifecycleConductor.getMessageIntelligenceAgency()).thenReturn(messageIntelligenceAgency);
 230
 231         deviceContext = new DeviceContextImpl(
 232                 connectionContext,
 233                 deviceState,
 234                 dataBroker,
 235                 lifecycleConductor,
 236                 outboundQueueProvider,
 237                 translatorLibrary,
 238                         deviceManager,
 239                 deviceInfo,
 240                 convertorExecutor);
 241         deviceContextSpy = Mockito.spy(deviceContext);
 242
 243         xid = new Xid(atomicLong.incrementAndGet());
 244         xidMulti = new Xid(atomicLong.incrementAndGet());
 245
 246         Mockito.doNothing().when(deviceContextSpy).writeToTransaction(Mockito.<LogicalDatastoreType>any(), Mockito.<InstanceIdentifier>any(), any());
 247     }
 248
 249     @Test(expected = NullPointerException.class)
 250     public void testDeviceContextImplConstructorNullDataBroker() throws Exception {
 251         new DeviceContextImpl(connectionContext, deviceState, null, lifecycleConductor, outboundQueueProvider, translatorLibrary, deviceManager, deviceInfo, convertorExecutor).close();
 252     }
 253
 254     @Test(expected = NullPointerException.class)
 255     public void testDeviceContextImplConstructorNullDeviceState() throws Exception {
 256         new DeviceContextImpl(connectionContext, null, dataBroker, lifecycleConductor, outboundQueueProvider, translatorLibrary, deviceManager, deviceInfo, convertorExecutor).close();
 257     }
 258
 259     @Test(expected = NullPointerException.class)
 260     public void testDeviceContextImplConstructorNullTimer() throws Exception {
 261         new DeviceContextImpl(null, deviceState, dataBroker, lifecycleConductor, outboundQueueProvider, translatorLibrary, deviceManager, deviceInfo, convertorExecutor).close();
 262     }
 263
 264     @Test
 265     public void testGetDeviceState() {
 266         final DeviceState deviceSt = deviceContext.getDeviceState();
 267         assertNotNull(deviceSt);
 268         assertEquals(deviceState, deviceSt);
 269     }
 270
 271     @Test
 272     public void testGetReadTransaction() {
 273         final ReadTransaction readTx = deviceContext.getReadTransaction();
 274         assertNotNull(readTx);
 275         assertEquals(rTx, readTx);
 276     }
 277
 278     /**
 279      * @throws Exception
 280      */
 281     @Test
 282     public void testInitialSubmitTransaction() throws Exception {
 283         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 284         final InstanceIdentifier<Nodes> dummyII = InstanceIdentifier.create(Nodes.class);
 285         ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ;
 286         ((DeviceContextImpl) deviceContext).getTransactionChainManager().enableSubmit();
 287         deviceContext.addDeleteToTxChain(LogicalDatastoreType.CONFIGURATION, dummyII);
 288         ((DeviceContextImpl) deviceContext).initialSubmitTransaction();
 289         verify(wTx).submit();
 290     }
 291
 292     @Test
 293     public void testGetReservedXid() {
 294         deviceContext.reserveXidForDeviceMessage();
 295         verify(outboundQueueProvider).reserveEntry();
 296     }
 297
 298     @Test
 299     public void testAuxiliaryConnectionContext() {
 300         final ConnectionContext mockedConnectionContext = addDummyAuxiliaryConnectionContext();
 301         final ConnectionContext pickedConnectiobContexts = deviceContext.getAuxiliaryConnectiobContexts(DUMMY_COOKIE);
 302         assertEquals(mockedConnectionContext, pickedConnectiobContexts);
 303     }
 304     @Test
 305     public void testRemoveAuxiliaryConnectionContext() {
 306         final ConnectionContext mockedConnectionContext = addDummyAuxiliaryConnectionContext();
 307
 308         final ConnectionAdapter mockedAuxConnectionAdapter = mock(ConnectionAdapter.class);
 309         when(mockedConnectionContext.getConnectionAdapter()).thenReturn(mockedAuxConnectionAdapter);
 310
 311         assertNotNull(deviceContext.getAuxiliaryConnectiobContexts(DUMMY_COOKIE));
 312         deviceContext.removeAuxiliaryConnectionContext(mockedConnectionContext);
 313         assertNull(deviceContext.getAuxiliaryConnectiobContexts(DUMMY_COOKIE));
 314     }
 315
 316     private ConnectionContext addDummyAuxiliaryConnectionContext() {
 317         final ConnectionContext mockedConnectionContext = prepareConnectionContext();
 318         deviceContext.addAuxiliaryConnectionContext(mockedConnectionContext);
 319         return mockedConnectionContext;
 320     }
 321
 322     private ConnectionContext prepareConnectionContext() {
 323         final ConnectionContext mockedConnectionContext = mock(ConnectionContext.class);
 324         final FeaturesReply mockedFeaturesReply = mock(FeaturesReply.class);
 325         when(mockedFeaturesReply.getAuxiliaryId()).thenReturn(DUMMY_AUXILIARY_ID);
 326         when(mockedConnectionContext.getFeatures()).thenReturn(mockedFeaturesReply);
 327         return mockedConnectionContext;
 328     }
 329
 330     /**
 331      * @throws Exception
 332      */
 333     @Test
 334     public void testAddDeleteToTxChain() throws Exception{
 335         final InstanceIdentifier<Nodes> dummyII = InstanceIdentifier.create(Nodes.class);
 336         ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ;
 337         ((DeviceContextImpl) deviceContext).getTransactionChainManager().enableSubmit();
 338         deviceContext.addDeleteToTxChain(LogicalDatastoreType.CONFIGURATION, dummyII);
 339         verify(wTx).delete(eq(LogicalDatastoreType.CONFIGURATION), eq(dummyII));
 340     }
 341
 342     /**
 343      * @throws Exception
 344      */
 345     @Test
 346     public void testSubmitTransaction() throws Exception {
 347         ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ;
 348         ((DeviceContextImpl) deviceContext).getTransactionChainManager().enableSubmit();
 349         assertTrue(deviceContext.submitTransaction());
 350     }
 351
 352     @Test
 353     public void testGetPrimaryConnectionContext() {
 354         final ConnectionContext primaryConnectionContext = deviceContext.getPrimaryConnectionContext();
 355         assertEquals(connectionContext, primaryConnectionContext);
 356     }
 357
 358     @Test
 359     public void testGetDeviceFlowRegistry() {
 360         final DeviceFlowRegistry deviceFlowRegistry = deviceContext.getDeviceFlowRegistry();
 361         assertNotNull(deviceFlowRegistry);
 362     }
 363
 364     @Test
 365     public void testGetDeviceGroupRegistry() {
 366         final DeviceGroupRegistry deviceGroupRegistry = deviceContext.getDeviceGroupRegistry();
 367         assertNotNull(deviceGroupRegistry);
 368     }
 369
 370     @Test
 371     public void testGetDeviceMeterRegistry() {
 372         final DeviceMeterRegistry deviceMeterRegistry = deviceContext.getDeviceMeterRegistry();
 373         assertNotNull(deviceMeterRegistry);
 374     }
 375
 376     @Test
 377     public void testProcessReply() {
 378         final Error mockedError = mock(Error.class);
 379         deviceContext.processReply(mockedError);
 380         verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_FAILURE));
 381         final OfHeader mockedOfHeader = mock(OfHeader.class);
 382         deviceContext.processReply(mockedOfHeader);
 383         verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_SUCCESS));
 384     }
 385
 386     @Test
 387     public void testProcessReply2() {
 388         final MultipartReply mockedMultipartReply = mock(MultipartReply.class);
 389         final Xid dummyXid = new Xid(DUMMY_XID);
 390         deviceContext.processReply(dummyXid, Lists.newArrayList(mockedMultipartReply));
 391         verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_FAILURE));
 392     }
 393
 394     @Test
 395     public void testProcessPacketInMessageFutureSuccess() {
 396         final PacketInMessage mockedPacketInMessage = mock(PacketInMessage.class);
 397         final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
 398         final ListenableFuture stringListenableFuture = Futures.immediateFuture(new String("dummy value"));
 399
 400         when(mockedNotificationPublishService.offerNotification(any(PacketReceived.class))).thenReturn(stringListenableFuture);
 401         deviceContext.setNotificationPublishService(mockedNotificationPublishService);
 402         deviceContext.processPacketInMessage(mockedPacketInMessage);
 403         verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_SUCCESS));
 404     }
 405
 406     @Test
 407     public void testProcessPacketInMessageFutureFailure() {
 408         final PacketInMessage mockedPacketInMessage = mock(PacketInMessage.class);
 409         final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
 410         final ListenableFuture dummyFuture = Futures.immediateFailedFuture(new IllegalStateException());
 411
 412         when(mockedNotificationPublishService.offerNotification(any(PacketReceived.class))).thenReturn(dummyFuture);
 413         deviceContext.setNotificationPublishService(mockedNotificationPublishService);
 414         deviceContext.processPacketInMessage(mockedPacketInMessage);
 415         verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_NOTIFICATION_REJECTED));
 416     }
 417
 418     @Test
 419     public void testTranslatorLibrary() {
 420         final TranslatorLibrary pickedTranslatorLibrary = deviceContext.oook();
 421         assertEquals(translatorLibrary, pickedTranslatorLibrary);
 422     }
 423
 424     @Test
 425     public void testShutdownConnection() {
 426         final ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class);
 427         final InetSocketAddress mockRemoteAddress = InetSocketAddress.createUnresolved("odl-unit.example.org",999);
 428         when(mockedConnectionAdapter.getRemoteAddress()).thenReturn(mockRemoteAddress);
 429         when(connectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter);
 430
 431         final NodeId dummyNodeId = new NodeId("dummyNodeId");
 432         when(deviceInfo.getNodeId()).thenReturn(dummyNodeId);
 433
 434         final ConnectionContext mockedAuxiliaryConnectionContext = prepareConnectionContext();
 435         deviceContext.addAuxiliaryConnectionContext(mockedAuxiliaryConnectionContext);
 436         final DeviceTerminationPhaseHandler mockedDeviceContextClosedHandler = mock(DeviceTerminationPhaseHandler.class);
 437         when(deviceState.isValid()).thenReturn(true);
 438         deviceContext.shutdownConnection();
 439         verify(connectionContext).closeConnection(true);
 440     }
 441
 442     @Test
 443     public void testBarrierFieldSetGet() {
 444         final Timeout mockedTimeout = mock(Timeout.class);
 445         deviceContext.setCurrentBarrierTimeout(mockedTimeout);
 446         final Timeout pickedBarrierTimeout = deviceContext.getBarrierTaskTimeout();
 447         assertEquals(mockedTimeout, pickedBarrierTimeout);
 448     }
 449
 450     @Test
 451     public void testGetMessageSpy() {
 452         final MessageSpy pickedMessageSpy = deviceContext.getMessageSpy();
 453         assertEquals(messageIntelligenceAgency, pickedMessageSpy);
 454     }
 455
 456     @Test
 457     public void testOnPublished() {
 458         final ConnectionContext auxiliaryConnectionContext = addDummyAuxiliaryConnectionContext();
 459
 460         final ConnectionAdapter mockedAuxConnectionAdapter = mock(ConnectionAdapter.class);
 461         when(auxiliaryConnectionContext.getConnectionAdapter()).thenReturn(mockedAuxConnectionAdapter);
 462
 463         final ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class);
 464         when(connectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter);
 465
 466         deviceContext.onPublished();
 467         verify(mockedAuxConnectionAdapter).setPacketInFiltering(eq(false));
 468         verify(mockedConnectionAdapter).setPacketInFiltering(eq(false));
 469     }
 470
 471     @Test
 472     public void testPortStatusMessage() throws Exception{
 473         final PortStatusMessage mockedPortStatusMessage = mock(PortStatusMessage.class);
 474         final Class dummyClass = Class.class;
 475         when(mockedPortStatusMessage.getImplementedInterface()).thenReturn(dummyClass);
 476
 477
 478         final GetFeaturesOutput mockedFeature = mock(GetFeaturesOutput.class);
 479         when(mockedFeature.getDatapathId()).thenReturn(DUMMY_DATAPATH_ID);
 480
 481         when(mockedPortStatusMessage.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
 482         when(mockedPortStatusMessage.getReason()).thenReturn(PortReason.OFPPRADD);
 483         when(mockedPortStatusMessage.getPortNo()).thenReturn(42L);
 484
 485         OpenflowPortsUtil.init();
 486         deviceContextSpy.processPortStatusMessage(mockedPortStatusMessage);
 487         verify(deviceContextSpy).writeToTransaction(Mockito.<LogicalDatastoreType>any(), Mockito.<InstanceIdentifier>any(), any());
 488         verify(deviceContextSpy).submitTransaction();
 489     }
 490
 491     @Test
 492     public void testProcessFlowRemovedMessage() throws Exception {
 493         // prepare translation result
 494         final FlowRemovedBuilder flowRemovedMdsalBld = new FlowRemovedBuilder()
 495                 .setTableId((short) 0)
 496                 .setPriority(42)
 497                 .setCookie(new FlowCookie(BigInteger.ONE))
 498                 .setMatch(new MatchBuilder().build());
 499         final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
 500
 501         Mockito.when(messageTranslatorFlowRemoved.translate(any(Object.class), any(DeviceInfo.class), any(Object.class)))
 502                 .thenReturn(flowRemovedMdsalBld.build());
 503
 504         // insert flow+flowId into local registry
 505         final FlowRegistryKey flowRegKey = FlowRegistryKeyFactory.create(flowRemovedMdsalBld.build());
 506         final FlowDescriptor flowDescriptor = FlowDescriptorFactory.create((short) 0, new FlowId("ut-ofp:f456"));
 507         deviceContext.getDeviceFlowRegistry().store(flowRegKey, flowDescriptor);
 508
 509         // plug in lifecycleListener
 510         final ItemLifecycleListener itemLifecycleListener = Mockito.mock(ItemLifecycleListener.class);
 511         for (final ItemLifeCycleSource lifeCycleSource : deviceContext.getItemLifeCycleSourceRegistry().getLifeCycleSources()) {
 512             lifeCycleSource.setItemLifecycleListener(itemLifecycleListener);
 513         }
 514
 515         // prepare empty input message
 516         final FlowRemovedMessageBuilder flowRemovedBld = new FlowRemovedMessageBuilder();
 517
 518         // prepare path to flow to be removed
 519         final KeyedInstanceIdentifier<Flow, FlowKey> flowToBeRemovedPath = nodeKeyIdent
 520                 .augmentation(FlowCapableNode.class)
 521                 .child(Table.class, new TableKey((short) 0))
 522                 .child(Flow.class, new FlowKey(new FlowId("ut-ofp:f456")));
 523
 524         Mockito.when(deviceManager.getIsNotificationFlowRemovedOff()).thenReturn(true);
 525
 526         deviceContext.setNotificationPublishService(mockedNotificationPublishService);
 527         deviceContext.processFlowRemovedMessage(flowRemovedBld.build());
 528
 529         Mockito.verify(itemLifecycleListener).onRemoved(flowToBeRemovedPath);
 530         Mockito.verify(mockedNotificationPublishService, Mockito.never()).offerNotification(Matchers.any(Notification.class));
 531
 532         Mockito.when(deviceManager.getIsNotificationFlowRemovedOff()).thenReturn(false);
 533         deviceContext.processFlowRemovedMessage(flowRemovedBld.build());
 534
 535         Mockito.verify(mockedNotificationPublishService).offerNotification(Matchers.any(Notification.class));
 536     }
 537
 538     @Test
 539     public void testProcessExperimenterMessage() {
 540         final ConvertorMessageFromOFJava mockedMessageConverter = mock(ConvertorMessageFromOFJava.class);
 541         final ExtensionConverterProvider mockedExtensionConverterProvider = mock(ExtensionConverterProvider.class);
 542         when(mockedExtensionConverterProvider.getMessageConverter(any(MessageTypeKey.class))).thenReturn(mockedMessageConverter);
 543
 544         final ExperimenterDataOfChoice mockedExperimenterDataOfChoice = mock(ExperimenterDataOfChoice.class);
 545         final ExperimenterMessage experimenterMessage = new ExperimenterMessageBuilder()
 546                 .setExperimenterDataOfChoice(mockedExperimenterDataOfChoice).build();
 547
 548         final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
 549
 550         deviceContext.setNotificationPublishService(mockedNotificationPublishService);
 551         ((DeviceContextImpl) deviceContext).setExtensionConverterProvider(mockedExtensionConverterProvider);
 552         deviceContext.processExperimenterMessage(experimenterMessage);
 553
 554         verify(mockedNotificationPublishService).offerNotification(any(ExperimenterMessageFromDev.class));
 555     }
 556
 557     @Test
 558     public void testOnDeviceDisconnected() throws Exception {
 559         final DeviceTerminationPhaseHandler deviceContextClosedHandler = mock(DeviceTerminationPhaseHandler.class);
 560
 561         assertEquals(0, deviceContext.getDeviceFlowRegistry().getAllFlowDescriptors().size());
 562         assertEquals(0, deviceContext.getDeviceGroupRegistry().getAllGroupIds().size());
 563         assertEquals(0, deviceContext.getDeviceMeterRegistry().getAllMeterIds().size());
 564
 565     }
 566 }