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 package org.opendaylight.openflowplugin.impl.device;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertTrue;
  13 import static org.mockito.ArgumentMatchers.any;
  14 import static org.mockito.ArgumentMatchers.eq;
  15 import static org.mockito.Mockito.lenient;
  16 import static org.mockito.Mockito.mock;
  17 import static org.mockito.Mockito.verify;
  18 import static org.mockito.Mockito.when;
  19
  20 import com.google.common.collect.Lists;
  21 import com.google.common.util.concurrent.FluentFuture;
  22 import com.google.common.util.concurrent.Futures;
  23 import com.google.common.util.concurrent.ListenableFuture;
  24 import com.google.common.util.concurrent.SettableFuture;
  25 import io.netty.util.HashedWheelTimer;
  26 import java.util.Optional;
  27 import java.util.concurrent.atomic.AtomicLong;
  28 import org.junit.Before;
  29 import org.junit.Test;
  30 import org.junit.runner.RunWith;
  31 import org.mockito.Mock;
  32 import org.mockito.Mockito;
  33 import org.mockito.junit.MockitoJUnitRunner;
  34 import org.opendaylight.mdsal.binding.api.DataBroker;
  35 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
  36 import org.opendaylight.mdsal.binding.api.ReadTransaction;
  37 import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
  38 import org.opendaylight.mdsal.binding.api.TransactionChain;
  39 import org.opendaylight.mdsal.common.api.CommitInfo;
  40 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  41 import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
  42 import org.opendaylight.openflowjava.protocol.api.keys.MessageTypeKey;
  43 import org.opendaylight.openflowplugin.api.OFConstants;
  44 import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
  45 import org.opendaylight.openflowplugin.api.openflow.connection.OutboundQueueProvider;
  46 import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
  47 import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
  48 import org.opendaylight.openflowplugin.api.openflow.device.MessageTranslator;
  49 import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
  50 import org.opendaylight.openflowplugin.api.openflow.device.TranslatorLibrary;
  51 import org.opendaylight.openflowplugin.api.openflow.device.Xid;
  52 import org.opendaylight.openflowplugin.api.openflow.lifecycle.ContextChain;
  53 import org.opendaylight.openflowplugin.api.openflow.lifecycle.ContextChainHolder;
  54 import org.opendaylight.openflowplugin.api.openflow.lifecycle.ContextChainMastershipState;
  55 import org.opendaylight.openflowplugin.api.openflow.md.core.TranslatorKey;
  56 import org.opendaylight.openflowplugin.api.openflow.registry.flow.DeviceFlowRegistry;
  57 import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowDescriptor;
  58 import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowRegistryKey;
  59 import org.opendaylight.openflowplugin.api.openflow.registry.group.DeviceGroupRegistry;
  60 import org.opendaylight.openflowplugin.api.openflow.registry.meter.DeviceMeterRegistry;
  61 import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageSpy;
  62 import org.opendaylight.openflowplugin.common.txchain.TransactionChainManager;
  63 import org.opendaylight.openflowplugin.extension.api.ConvertorMessageFromOFJava;
  64 import org.opendaylight.openflowplugin.extension.api.core.extension.ExtensionConverterProvider;
  65 import org.opendaylight.openflowplugin.impl.device.initialization.AbstractDeviceInitializer;
  66 import org.opendaylight.openflowplugin.impl.device.initialization.DeviceInitializerProvider;
  67 import org.opendaylight.openflowplugin.impl.registry.flow.FlowDescriptorFactory;
  68 import org.opendaylight.openflowplugin.impl.registry.flow.FlowRegistryKeyFactory;
  69 import org.opendaylight.openflowplugin.impl.services.sal.SalRoleRpc;
  70 import org.opendaylight.openflowplugin.impl.util.DeviceStateUtil;
  71 import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.experimenter.message.service.rev151020.ExperimenterMessageFromDev;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowRemovedBuilder;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.Capabilities;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.PortReason;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.Error;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterMessage;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterMessageBuilder;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FeaturesReply;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FlowRemoved;
  95 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FlowRemovedMessageBuilder;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetAsyncReply;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesOutput;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartReply;
  99 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
 100 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketIn;
 101 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketInMessage;
 102 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortGrouping;
 103 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortStatusMessage;
 104 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.experimenter.core.ExperimenterDataOfChoice;
 105 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
 106 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceivedBuilder;
 107 import org.opendaylight.yang.gen.v1.urn.opendaylight.role.service.rev150727.SetRole;
 108 import org.opendaylight.yangtools.util.concurrent.FluentFutures;
 109 import org.opendaylight.yangtools.util.concurrent.NotificationManager;
 110 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 111 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
 112 import org.opendaylight.yangtools.yang.common.RpcResult;
 113 import org.opendaylight.yangtools.yang.common.Uint16;
 114 import org.opendaylight.yangtools.yang.common.Uint32;
 115 import org.opendaylight.yangtools.yang.common.Uint64;
 116 import org.opendaylight.yangtools.yang.common.Uint8;
 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.getLogger(DeviceContextImplTest.class);
 123     private static final Uint8 DUMMY_AUXILIARY_ID = Uint8.valueOf(33);
 124     private static final Uint64 DUMMY_COOKIE = Uint64.valueOf("33");
 125     private static final Uint32 DUMMY_XID = Uint32.valueOf(544L);
 126     private static final Long DUMMY_PORT_NUMBER = 159L;
 127     private static final Uint64 DUMMY_DATAPATH_ID = Uint64.valueOf("55");
 128     private Xid xid;
 129     private Xid xidMulti;
 130
 131     private DeviceContext deviceContext;
 132     @Mock
 133     private RequestContext<GetAsyncReply> requestContext;
 134     @Mock
 135     private RequestContext<MultipartReply> requestContextMultiReply;
 136     @Mock
 137     private ConnectionContext connectionContext;
 138     @Mock
 139     private GetFeaturesOutput featuresOutput;
 140     @Mock
 141     private DataBroker dataBroker;
 142     @Mock
 143     private ReadWriteTransaction writeTx;
 144     @Mock
 145     private ReadTransaction readTx;
 146     @Mock
 147     private TransactionChain txChainFactory;
 148     @Mock
 149     private HashedWheelTimer timer;
 150     @Mock
 151     private OutboundQueueProvider outboundQueueProvider;
 152     @Mock
 153     private ConnectionAdapter connectionAdapter;
 154     private final NodeId nodeId = new NodeId("h2g2:42");
 155     private final KeyedInstanceIdentifier<Node, NodeKey> nodeKeyIdent =
 156             DeviceStateUtil.createNodeInstanceIdentifier(nodeId);
 157     @Mock
 158     private TranslatorLibrary translatorLibrary;
 159     @Mock
 160     MessageTranslator messageTranslatorPacketReceived;
 161     @Mock
 162     private MessageTranslator messageTranslatorFlowCapableNodeConnector;
 163     @Mock
 164     private MessageTranslator<Object, Object> messageTranslatorFlowRemoved;
 165     @Mock
 166     private DeviceInfo deviceInfo;
 167     @Mock
 168     private ConvertorExecutor convertorExecutor;
 169     @Mock
 170     private MessageSpy messageSpy;
 171     @Mock
 172     private DeviceInitializerProvider deviceInitializerProvider;
 173     @Mock
 174     private AbstractDeviceInitializer abstractDeviceInitializer;
 175     @Mock
 176     private SalRoleRpc salRoleRpc;
 177     @Mock
 178     private SetRole setRole;
 179     @Mock
 180     private ContextChainHolder contextChainHolder;
 181     @Mock
 182     private ContextChain contextChain;
 183     @Mock
 184     private NotificationManager queuedNotificationManager;
 185
 186     private final AtomicLong atomicLong = new AtomicLong(0);
 187
 188     private DeviceContext deviceContextSpy;
 189
 190     @Before
 191     public void setUp() {
 192         final FluentFuture<Optional<Node>> noExistNodeFuture =
 193                 FluentFutures.immediateFluentFuture(Optional.<Node>empty());
 194         Mockito.lenient().when(readTx.read(LogicalDatastoreType.OPERATIONAL, nodeKeyIdent))
 195                 .thenReturn(noExistNodeFuture);
 196         Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(readTx);
 197         Mockito.when(dataBroker.createTransactionChain(any(TransactionChainManager.class)))
 198                 .thenReturn(txChainFactory);
 199         Mockito.when(deviceInfo.getNodeInstanceIdentifier()).thenReturn(nodeKeyIdent);
 200         Mockito.when(deviceInfo.getNodeId()).thenReturn(nodeId);
 201         Mockito.when(deviceInfo.getDatapathId()).thenReturn(Uint64.ONE);
 202         final SettableFuture<RpcResult<GetAsyncReply>> settableFuture = SettableFuture.create();
 203         final SettableFuture<RpcResult<MultipartReply>> settableFutureMultiReply = SettableFuture.create();
 204         Mockito.lenient().when(requestContext.getFuture()).thenReturn(settableFuture);
 205         Mockito.lenient().doAnswer(invocation -> {
 206             settableFuture.set((RpcResult<GetAsyncReply>) invocation.getArguments()[0]);
 207             return null;
 208         }).when(requestContext).setResult(Mockito.<RpcResult>any());
 209
 210         Mockito.lenient().when(requestContextMultiReply.getFuture()).thenReturn(settableFutureMultiReply);
 211         Mockito.lenient().doAnswer(invocation -> {
 212             settableFutureMultiReply.set((RpcResult<MultipartReply>) invocation.getArguments()[0]);
 213             return null;
 214         }).when(requestContextMultiReply).setResult(any(RpcResult.class));
 215         Mockito.when(txChainFactory.newReadWriteTransaction()).thenReturn(writeTx);
 216         Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(readTx);
 217         Mockito.lenient().when(connectionContext.getOutboundQueueProvider()).thenReturn(outboundQueueProvider);
 218         Mockito.when(connectionContext.getConnectionAdapter()).thenReturn(connectionAdapter);
 219         Mockito.when(connectionContext.getDeviceInfo()).thenReturn(deviceInfo);
 220         final FeaturesReply mockedFeaturesReply = mock(FeaturesReply.class);
 221         lenient().when(connectionContext.getFeatures()).thenReturn(mockedFeaturesReply);
 222         lenient().when(connectionContext.getFeatures().getCapabilities()).thenReturn(mock(Capabilities.class));
 223
 224         Mockito.lenient().when(deviceInfo.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
 225         Mockito.lenient().when(featuresOutput.getDatapathId()).thenReturn(DUMMY_DATAPATH_ID);
 226         Mockito.lenient().when(featuresOutput.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
 227         Mockito.when(contextChainHolder.getContextChain(deviceInfo)).thenReturn(contextChain);
 228         Mockito.when(contextChain.isMastered(ContextChainMastershipState.CHECK, false)).thenReturn(true);
 229
 230         final PacketReceived packetReceived = new PacketReceivedBuilder()
 231                 .setMatch(new org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.packet.received
 232                         .MatchBuilder()
 233                         .setInPort(new NodeConnectorId("openflow:1:LOCAL"))
 234                         .build())
 235                 .build();
 236
 237         Mockito.when(messageTranslatorPacketReceived.translate(Mockito.any(), Mockito.any(),
 238                 Mockito.any())).thenReturn(packetReceived);
 239         lenient().when(messageTranslatorFlowCapableNodeConnector.translate(Mockito.any(),
 240                 Mockito.any(),
 241                 Mockito.any())).thenReturn(mock(FlowCapableNodeConnector.class));
 242         Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3,
 243                 PacketIn.class.getName())))).thenReturn(messageTranslatorPacketReceived);
 244         Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3,
 245                 PortGrouping.class.getName())))).thenReturn(messageTranslatorFlowCapableNodeConnector);
 246         Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3,
 247                 FlowRemoved.class.getName())))).thenReturn(messageTranslatorFlowRemoved);
 248
 249         final java.util.Optional<AbstractDeviceInitializer> deviceInitializer = java.util.Optional
 250                 .of(abstractDeviceInitializer);
 251
 252         Mockito.lenient().when(deviceInitializerProvider.lookup(OFConstants.OFP_VERSION_1_3))
 253                 .thenReturn(deviceInitializer);
 254         Mockito.lenient().when(salRoleRpc.invoke(any())).thenReturn(Futures.immediateFuture(null));
 255
 256         deviceContext = new DeviceContextImpl(
 257                 connectionContext,
 258                 dataBroker,
 259                 messageSpy,
 260                 translatorLibrary,
 261                 convertorExecutor,
 262                 false, timer, false,
 263                 deviceInitializerProvider,
 264                 true, false,
 265                 contextChainHolder,
 266                 queuedNotificationManager,
 267                 false);
 268         ((DeviceContextImpl) deviceContext).lazyTransactionManagerInitialization();
 269         deviceContextSpy = Mockito.spy(deviceContext);
 270
 271         xid = new Xid(Uint32.valueOf(atomicLong.incrementAndGet()));
 272         xidMulti = new Xid(Uint32.valueOf(atomicLong.incrementAndGet()));
 273         lenient().doNothing().when(deviceContextSpy).writeToTransaction(any(), any(), any());
 274     }
 275
 276     @Test
 277     public void testGetReadTransaction() {
 278         readTx = deviceContext.getReadTransaction();
 279         assertNotNull(readTx);
 280         assertEquals(readTx, readTx);
 281     }
 282
 283     @Test
 284     public void testInitialSubmitTransaction() {
 285         Mockito.doReturn(CommitInfo.emptyFluentFuture()).when(writeTx).commit();
 286         final InstanceIdentifier<Nodes> dummyII = InstanceIdentifier.create(Nodes.class);
 287         ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ;
 288         ((DeviceContextImpl) deviceContext).getTransactionChainManager().initialSubmitWriteTransaction();
 289         deviceContext.addDeleteToTxChain(LogicalDatastoreType.CONFIGURATION, dummyII);
 290         deviceContext.initialSubmitTransaction();
 291         verify(writeTx).commit();
 292     }
 293
 294     private static ConnectionContext prepareConnectionContext() {
 295         final ConnectionContext mockedConnectionContext = mock(ConnectionContext.class);
 296         final FeaturesReply mockedFeaturesReply = mock(FeaturesReply.class);
 297         when(mockedFeaturesReply.getAuxiliaryId()).thenReturn(DUMMY_AUXILIARY_ID);
 298         when(mockedConnectionContext.getFeatures()).thenReturn(mockedFeaturesReply);
 299         return mockedConnectionContext;
 300     }
 301
 302     @Test
 303     public void testAddDeleteToTxChain() {
 304         final InstanceIdentifier<Nodes> dummyII = InstanceIdentifier.create(Nodes.class);
 305         ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ;
 306         ((DeviceContextImpl) deviceContext).getTransactionChainManager().initialSubmitWriteTransaction();
 307         deviceContext.addDeleteToTxChain(LogicalDatastoreType.CONFIGURATION, dummyII);
 308         verify(writeTx).delete(eq(LogicalDatastoreType.CONFIGURATION), eq(dummyII));
 309     }
 310
 311     @Test
 312     public void testSubmitTransaction() {
 313         ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ;
 314         ((DeviceContextImpl) deviceContext).getTransactionChainManager().initialSubmitWriteTransaction();
 315         assertTrue(deviceContext.submitTransaction());
 316     }
 317
 318     @Test
 319     public void testGetPrimaryConnectionContext() {
 320         final ConnectionContext primaryConnectionContext = deviceContext.getPrimaryConnectionContext();
 321         assertEquals(connectionContext, primaryConnectionContext);
 322     }
 323
 324     @Test
 325     public void testGetDeviceFlowRegistry() {
 326         final DeviceFlowRegistry deviceFlowRegistry = deviceContext.getDeviceFlowRegistry();
 327         assertNotNull(deviceFlowRegistry);
 328     }
 329
 330     @Test
 331     public void testGetDeviceGroupRegistry() {
 332         final DeviceGroupRegistry deviceGroupRegistry = deviceContext.getDeviceGroupRegistry();
 333         assertNotNull(deviceGroupRegistry);
 334     }
 335
 336     @Test
 337     public void testGetDeviceMeterRegistry() {
 338         final DeviceMeterRegistry deviceMeterRegistry = deviceContext.getDeviceMeterRegistry();
 339         assertNotNull(deviceMeterRegistry);
 340     }
 341
 342     @Test
 343     public void testProcessReply() {
 344         final Error mockedError = mock(Error.class);
 345         deviceContext.processReply(mockedError);
 346         verify(messageSpy).spyMessage(Mockito.<Class>any(),
 347                 eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_FAILURE));
 348         final OfHeader mockedOfHeader = mock(OfHeader.class);
 349         deviceContext.processReply(mockedOfHeader);
 350         verify(messageSpy).spyMessage(Mockito.<Class>any(),
 351                 eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_SUCCESS));
 352     }
 353
 354     @Test
 355     public void testProcessReply2() {
 356         final Xid dummyXid = new Xid(DUMMY_XID);
 357
 358         final Error mockedError = mock(Error.class);
 359         deviceContext.processReply(dummyXid, Lists.newArrayList(mockedError));
 360         verify(messageSpy).spyMessage(Mockito.<Class>any(),
 361                 eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_FAILURE));
 362
 363         final MultipartReply mockedMultipartReply = mock(MultipartReply.class);
 364         deviceContext.processReply(dummyXid, Lists.newArrayList(mockedMultipartReply));
 365         verify(messageSpy).spyMessage(Mockito.<Class>any(),
 366                 eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_SUCCESS));
 367     }
 368
 369     @Test
 370     public void testProcessPacketInMessageFutureSuccess() {
 371         final PacketInMessage mockedPacketInMessage = mock(PacketInMessage.class);
 372         final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
 373         final ListenableFuture stringListenableFuture = Futures.immediateFuture("dummy value");
 374
 375         when(mockedNotificationPublishService.offerNotification(any(PacketReceived.class)))
 376                 .thenReturn(stringListenableFuture);
 377         deviceContext.setNotificationPublishService(mockedNotificationPublishService);
 378         deviceContext.processPacketInMessage(mockedPacketInMessage);
 379         verify(messageSpy).spyMessage(Mockito.<Class>any(), eq(MessageSpy.StatisticsGroup.FROM_SWITCH));
 380         verify(messageSpy).spyMessage(Mockito.<Class>any(),
 381                 eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_SUCCESS));
 382     }
 383
 384     @Test
 385     public void testProcessPacketInMessageFutureFailure() {
 386         final PacketInMessage mockedPacketInMessage = mock(PacketInMessage.class);
 387         final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
 388         final ListenableFuture dummyFuture = Futures.immediateFailedFuture(new IllegalStateException());
 389
 390         when(mockedNotificationPublishService.offerNotification(Mockito.<PacketReceived>any())).thenReturn(dummyFuture);
 391         deviceContext.setNotificationPublishService(mockedNotificationPublishService);
 392         deviceContext.processPacketInMessage(mockedPacketInMessage);
 393         verify(messageSpy).spyMessage(Mockito.<Class>any(),
 394                 eq(MessageSpy.StatisticsGroup.FROM_SWITCH_NOTIFICATION_REJECTED));
 395     }
 396
 397     @Test
 398     public void testTranslatorLibrary() {
 399         final TranslatorLibrary pickedTranslatorLibrary = deviceContext.oook();
 400         assertEquals(translatorLibrary, pickedTranslatorLibrary);
 401     }
 402
 403     @Test
 404     public void testGetMessageSpy() {
 405         final MessageSpy pickedMessageSpy = deviceContext.getMessageSpy();
 406         assertEquals(messageSpy, pickedMessageSpy);
 407     }
 408
 409     @Test
 410     public void testOnPublished() {
 411         final ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class);
 412         when(connectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter);
 413
 414         deviceContext.onPublished();
 415         verify(mockedConnectionAdapter).setPacketInFiltering(eq(false));
 416     }
 417
 418     @Test
 419     public void testPortStatusMessage() {
 420         final PortStatusMessage mockedPortStatusMessage = mock(PortStatusMessage.class);
 421         final Class dummyClass = Class.class;
 422         when(mockedPortStatusMessage.implementedInterface()).thenReturn(dummyClass);
 423
 424         final GetFeaturesOutput mockedFeature = mock(GetFeaturesOutput.class);
 425         lenient().when(mockedFeature.getDatapathId()).thenReturn(DUMMY_DATAPATH_ID);
 426
 427         lenient().when(mockedPortStatusMessage.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
 428         lenient().when(mockedPortStatusMessage.getReason()).thenReturn(PortReason.OFPPRADD);
 429         lenient().when(mockedPortStatusMessage.getPortNo()).thenReturn(Uint32.valueOf(42L));
 430         deviceContextSpy.processPortStatusMessage(mockedPortStatusMessage);
 431         verify(messageSpy).spyMessage(any(), any());
 432     }
 433
 434     @Test
 435     public void testProcessFlowRemovedMessage() {
 436         // prepare translation result
 437         final FlowRemovedBuilder flowRemovedMdsalBld = new FlowRemovedBuilder()
 438                 .setTableId(Uint8.ZERO)
 439                 .setPriority(Uint16.valueOf(42))
 440                 .setCookie(new FlowCookie(Uint64.ONE))
 441                 .setMatch(new MatchBuilder().build());
 442         final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
 443
 444         Mockito.lenient().when(messageTranslatorFlowRemoved
 445                 .translate(any(Object.class), any(DeviceInfo.class), any(Object.class)))
 446                 .thenReturn(flowRemovedMdsalBld.build());
 447
 448         // insert flow+flowId into local registry
 449         final FlowRegistryKey flowRegKey = FlowRegistryKeyFactory.VERSION_1_3.create(flowRemovedMdsalBld.build());
 450         final FlowDescriptor flowDescriptor = FlowDescriptorFactory.create(Uint8.ZERO, new FlowId("ut-ofp:f456"));
 451         deviceContext.getDeviceFlowRegistry().storeDescriptor(flowRegKey, flowDescriptor);
 452
 453         // prepare empty input message
 454         final FlowRemovedMessageBuilder flowRemovedBld = new FlowRemovedMessageBuilder();
 455
 456         // prepare path to flow to be removed
 457         final KeyedInstanceIdentifier<Flow, FlowKey> flowToBeRemovedPath = nodeKeyIdent
 458                 .augmentation(FlowCapableNode.class)
 459                 .child(Table.class, new TableKey(Uint8.ZERO))
 460                 .child(Flow.class, new FlowKey(new FlowId("ut-ofp:f456")));
 461
 462         deviceContext.setNotificationPublishService(mockedNotificationPublishService);
 463         deviceContext.processFlowRemovedMessage(flowRemovedBld.build());
 464     }
 465
 466     @Test
 467     public void testProcessExperimenterMessage() {
 468         final ConvertorMessageFromOFJava mockedMessageConverter = mock(ConvertorMessageFromOFJava.class);
 469         final ExtensionConverterProvider mockedExtensionConverterProvider = mock(ExtensionConverterProvider.class);
 470         when(mockedExtensionConverterProvider.getMessageConverter(any(MessageTypeKey.class)))
 471                 .thenReturn(mockedMessageConverter);
 472
 473         final ExperimenterDataOfChoice mockedExperimenterDataOfChoice = mock(ExperimenterDataOfChoice.class);
 474         final ExperimenterMessage experimenterMessage = new ExperimenterMessageBuilder()
 475                 .setExperimenterDataOfChoice(mockedExperimenterDataOfChoice).build();
 476
 477         final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
 478
 479         deviceContext.setNotificationPublishService(mockedNotificationPublishService);
 480         ((DeviceContextImpl) deviceContext).setExtensionConverterProvider(mockedExtensionConverterProvider);
 481         deviceContext.processExperimenterMessage(experimenterMessage);
 482
 483         verify(mockedNotificationPublishService).offerNotification(any(ExperimenterMessageFromDev.class));
 484     }
 485
 486     @Test
 487     public void instantiateServiceInstance() {
 488         deviceContext.instantiateServiceInstance();
 489     }
 490
 491     @Test
 492     public void close() {
 493         deviceContext.close();
 494     }
 495
 496     @Test
 497     public void closeServiceInstance() {
 498         deviceContext.closeServiceInstance();
 499     }
 500
 501 }