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