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