2 * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
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
9 package org.opendaylight.openflowplugin.impl.device;
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;
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;
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");
132 DeviceContext deviceContext;
134 TransactionChainManager txChainManager;
136 RequestContext<GetAsyncReply> requestContext;
138 RequestContext<MultipartReply> requestContextMultiReply;
140 ConnectionContext connectionContext;
142 DeviceState deviceState;
144 GetFeaturesOutput featuresOutput;
146 DataBroker dataBroker;
148 WriteTransaction wTx;
150 ReadOnlyTransaction rTx;
152 BindingTransactionChain txChainFactory;
154 HashedWheelTimer timer;
156 MessageIntelligenceAgency messageIntelligenceAgency;
158 OutboundQueueProvider outboundQueueProvider;
160 ConnectionAdapter connectionAdapter;
161 NodeId nodeId = new NodeId("h2g2:42");
162 KeyedInstanceIdentifier<Node, NodeKey> nodeKeyIdent = DeviceStateUtil.createNodeInstanceIdentifier(nodeId);
164 TranslatorLibrary translatorLibrary;
166 Registration registration;
168 MessageTranslator messageTranslatorPacketReceived;
170 MessageTranslator messageTranslatorFlowCapableNodeConnector;
172 private MessageTranslator<Object, Object> messageTranslatorFlowRemoved;
174 private LifecycleConductor lifecycleConductor;
176 private DeviceInfo deviceInfo;
178 private DeviceManager deviceManager;
180 private ConvertorExecutor convertorExecutor;
182 private InOrder inOrderDevState;
184 private final AtomicLong atomicLong = new AtomicLong(0);
186 private DeviceContext deviceContextSpy;
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]);
203 }).when(requestContext).setResult(any(RpcResult.class));
205 Mockito.when(requestContextMultiReply.getFuture()).thenReturn(settableFutureMultiReply);
206 Mockito.doAnswer(invocation -> {
207 settableFutureMultiReply.set((RpcResult<MultipartReply>) invocation.getArguments()[0]);
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));
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);
231 deviceContext = new DeviceContextImpl(
235 outboundQueueProvider,
239 deviceContextSpy = Mockito.spy(deviceContext);
241 xid = new Xid(atomicLong.incrementAndGet());
242 xidMulti = new Xid(atomicLong.incrementAndGet());
244 Mockito.doNothing().when(deviceContextSpy).writeToTransaction(Mockito.<LogicalDatastoreType>any(), Mockito.<InstanceIdentifier>any(), any());
247 @Test(expected = NullPointerException.class)
248 public void testDeviceContextImplConstructorNullDataBroker() throws Exception {
249 new DeviceContextImpl(connectionContext, null, lifecycleConductor, outboundQueueProvider, translatorLibrary, deviceManager, convertorExecutor).close();
253 @Test(expected = NullPointerException.class)
254 public void testDeviceContextImplConstructorNullTimer() throws Exception {
256 new DeviceContextImpl(null, dataBroker, lifecycleConductor, outboundQueueProvider, translatorLibrary, deviceManager, convertorExecutor).close();
260 public void testGetReadTransaction() {
261 final ReadTransaction readTx = deviceContext.getReadTransaction();
262 assertNotNull(readTx);
263 assertEquals(rTx, readTx);
270 public void testInitialSubmitTransaction() throws Exception {
271 Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
272 final InstanceIdentifier<Nodes> dummyII = InstanceIdentifier.create(Nodes.class);
273 ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ;
274 ((DeviceContextImpl) deviceContext).getTransactionChainManager().enableSubmit();
275 deviceContext.addDeleteToTxChain(LogicalDatastoreType.CONFIGURATION, dummyII);
276 ((DeviceContextImpl) deviceContext).initialSubmitTransaction();
277 verify(wTx).submit();
281 public void testGetReservedXid() {
282 deviceContext.reserveXidForDeviceMessage();
283 verify(outboundQueueProvider).reserveEntry();
287 public void testAuxiliaryConnectionContext() {
288 final ConnectionContext mockedConnectionContext = addDummyAuxiliaryConnectionContext();
289 final ConnectionContext pickedConnectiobContexts = deviceContext.getAuxiliaryConnectiobContexts(DUMMY_COOKIE);
290 assertEquals(mockedConnectionContext, pickedConnectiobContexts);
293 public void testRemoveAuxiliaryConnectionContext() {
294 final ConnectionContext mockedConnectionContext = addDummyAuxiliaryConnectionContext();
296 final ConnectionAdapter mockedAuxConnectionAdapter = mock(ConnectionAdapter.class);
297 when(mockedConnectionContext.getConnectionAdapter()).thenReturn(mockedAuxConnectionAdapter);
299 assertNotNull(deviceContext.getAuxiliaryConnectiobContexts(DUMMY_COOKIE));
300 deviceContext.removeAuxiliaryConnectionContext(mockedConnectionContext);
301 assertNull(deviceContext.getAuxiliaryConnectiobContexts(DUMMY_COOKIE));
304 private ConnectionContext addDummyAuxiliaryConnectionContext() {
305 final ConnectionContext mockedConnectionContext = prepareConnectionContext();
306 deviceContext.addAuxiliaryConnectionContext(mockedConnectionContext);
307 return mockedConnectionContext;
310 private ConnectionContext prepareConnectionContext() {
311 final ConnectionContext mockedConnectionContext = mock(ConnectionContext.class);
312 final FeaturesReply mockedFeaturesReply = mock(FeaturesReply.class);
313 when(mockedFeaturesReply.getAuxiliaryId()).thenReturn(DUMMY_AUXILIARY_ID);
314 when(mockedConnectionContext.getFeatures()).thenReturn(mockedFeaturesReply);
315 return mockedConnectionContext;
322 public void testAddDeleteToTxChain() throws Exception{
323 final InstanceIdentifier<Nodes> dummyII = InstanceIdentifier.create(Nodes.class);
324 ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ;
325 ((DeviceContextImpl) deviceContext).getTransactionChainManager().enableSubmit();
326 deviceContext.addDeleteToTxChain(LogicalDatastoreType.CONFIGURATION, dummyII);
327 verify(wTx).delete(eq(LogicalDatastoreType.CONFIGURATION), eq(dummyII));
334 public void testSubmitTransaction() throws Exception {
335 ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ;
336 ((DeviceContextImpl) deviceContext).getTransactionChainManager().enableSubmit();
337 assertTrue(deviceContext.submitTransaction());
341 public void testGetPrimaryConnectionContext() {
342 final ConnectionContext primaryConnectionContext = deviceContext.getPrimaryConnectionContext();
343 assertEquals(connectionContext, primaryConnectionContext);
347 public void testGetDeviceFlowRegistry() {
348 final DeviceFlowRegistry deviceFlowRegistry = deviceContext.getDeviceFlowRegistry();
349 assertNotNull(deviceFlowRegistry);
353 public void testGetDeviceGroupRegistry() {
354 final DeviceGroupRegistry deviceGroupRegistry = deviceContext.getDeviceGroupRegistry();
355 assertNotNull(deviceGroupRegistry);
359 public void testGetDeviceMeterRegistry() {
360 final DeviceMeterRegistry deviceMeterRegistry = deviceContext.getDeviceMeterRegistry();
361 assertNotNull(deviceMeterRegistry);
365 public void testProcessReply() {
366 final Error mockedError = mock(Error.class);
367 deviceContext.processReply(mockedError);
368 verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_FAILURE));
369 final OfHeader mockedOfHeader = mock(OfHeader.class);
370 deviceContext.processReply(mockedOfHeader);
371 verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_SUCCESS));
375 public void testProcessReply2() {
376 final MultipartReply mockedMultipartReply = mock(MultipartReply.class);
377 final Xid dummyXid = new Xid(DUMMY_XID);
378 deviceContext.processReply(dummyXid, Lists.newArrayList(mockedMultipartReply));
379 verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_FAILURE));
383 public void testProcessPacketInMessageFutureSuccess() {
384 final PacketInMessage mockedPacketInMessage = mock(PacketInMessage.class);
385 final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
386 final ListenableFuture stringListenableFuture = Futures.immediateFuture(new String("dummy value"));
388 when(mockedNotificationPublishService.offerNotification(any(PacketReceived.class))).thenReturn(stringListenableFuture);
389 deviceContext.setNotificationPublishService(mockedNotificationPublishService);
390 deviceContext.processPacketInMessage(mockedPacketInMessage);
391 verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_SUCCESS));
395 public void testProcessPacketInMessageFutureFailure() {
396 final PacketInMessage mockedPacketInMessage = mock(PacketInMessage.class);
397 final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
398 final ListenableFuture dummyFuture = Futures.immediateFailedFuture(new IllegalStateException());
400 when(mockedNotificationPublishService.offerNotification(any(PacketReceived.class))).thenReturn(dummyFuture);
401 deviceContext.setNotificationPublishService(mockedNotificationPublishService);
402 deviceContext.processPacketInMessage(mockedPacketInMessage);
403 verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_NOTIFICATION_REJECTED));
407 public void testTranslatorLibrary() {
408 final TranslatorLibrary pickedTranslatorLibrary = deviceContext.oook();
409 assertEquals(translatorLibrary, pickedTranslatorLibrary);
413 public void testShutdownConnection() {
414 final ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class);
415 final InetSocketAddress mockRemoteAddress = InetSocketAddress.createUnresolved("odl-unit.example.org",999);
416 when(mockedConnectionAdapter.getRemoteAddress()).thenReturn(mockRemoteAddress);
417 when(connectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter);
419 final NodeId dummyNodeId = new NodeId("dummyNodeId");
420 when(deviceInfo.getNodeId()).thenReturn(dummyNodeId);
422 final ConnectionContext mockedAuxiliaryConnectionContext = prepareConnectionContext();
423 deviceContext.addAuxiliaryConnectionContext(mockedAuxiliaryConnectionContext);
424 deviceContext.shutdownConnection();
425 verify(connectionContext).closeConnection(true);
429 public void testBarrierFieldSetGet() {
430 final Timeout mockedTimeout = mock(Timeout.class);
431 deviceContext.setCurrentBarrierTimeout(mockedTimeout);
432 final Timeout pickedBarrierTimeout = deviceContext.getBarrierTaskTimeout();
433 assertEquals(mockedTimeout, pickedBarrierTimeout);
437 public void testGetMessageSpy() {
438 final MessageSpy pickedMessageSpy = deviceContext.getMessageSpy();
439 assertEquals(messageIntelligenceAgency, pickedMessageSpy);
443 public void testOnPublished() {
444 final ConnectionContext auxiliaryConnectionContext = addDummyAuxiliaryConnectionContext();
446 final ConnectionAdapter mockedAuxConnectionAdapter = mock(ConnectionAdapter.class);
447 when(auxiliaryConnectionContext.getConnectionAdapter()).thenReturn(mockedAuxConnectionAdapter);
449 final ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class);
450 when(connectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter);
452 deviceContext.onPublished();
453 verify(mockedAuxConnectionAdapter).setPacketInFiltering(eq(false));
454 verify(mockedConnectionAdapter).setPacketInFiltering(eq(false));
458 public void testPortStatusMessage() throws Exception{
459 final PortStatusMessage mockedPortStatusMessage = mock(PortStatusMessage.class);
460 final Class dummyClass = Class.class;
461 when(mockedPortStatusMessage.getImplementedInterface()).thenReturn(dummyClass);
464 final GetFeaturesOutput mockedFeature = mock(GetFeaturesOutput.class);
465 when(mockedFeature.getDatapathId()).thenReturn(DUMMY_DATAPATH_ID);
467 when(mockedPortStatusMessage.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
468 when(mockedPortStatusMessage.getReason()).thenReturn(PortReason.OFPPRADD);
469 when(mockedPortStatusMessage.getPortNo()).thenReturn(42L);
471 OpenflowPortsUtil.init();
472 deviceContextSpy.processPortStatusMessage(mockedPortStatusMessage);
473 verify(deviceContextSpy).writeToTransaction(Mockito.<LogicalDatastoreType>any(), Mockito.<InstanceIdentifier>any(), any());
474 verify(deviceContextSpy).submitTransaction();
478 public void testProcessFlowRemovedMessage() throws Exception {
479 // prepare translation result
480 final FlowRemovedBuilder flowRemovedMdsalBld = new FlowRemovedBuilder()
481 .setTableId((short) 0)
483 .setCookie(new FlowCookie(BigInteger.ONE))
484 .setMatch(new MatchBuilder().build());
485 final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
487 Mockito.when(messageTranslatorFlowRemoved.translate(any(Object.class), any(DeviceInfo.class), any(Object.class)))
488 .thenReturn(flowRemovedMdsalBld.build());
490 // insert flow+flowId into local registry
491 final FlowRegistryKey flowRegKey = FlowRegistryKeyFactory.create(flowRemovedMdsalBld.build());
492 final FlowDescriptor flowDescriptor = FlowDescriptorFactory.create((short) 0, new FlowId("ut-ofp:f456"));
493 deviceContext.getDeviceFlowRegistry().store(flowRegKey, flowDescriptor);
495 // plug in lifecycleListener
496 final ItemLifecycleListener itemLifecycleListener = Mockito.mock(ItemLifecycleListener.class);
497 for (final ItemLifeCycleSource lifeCycleSource : deviceContext.getItemLifeCycleSourceRegistry().getLifeCycleSources()) {
498 lifeCycleSource.setItemLifecycleListener(itemLifecycleListener);
501 // prepare empty input message
502 final FlowRemovedMessageBuilder flowRemovedBld = new FlowRemovedMessageBuilder();
504 // prepare path to flow to be removed
505 final KeyedInstanceIdentifier<Flow, FlowKey> flowToBeRemovedPath = nodeKeyIdent
506 .augmentation(FlowCapableNode.class)
507 .child(Table.class, new TableKey((short) 0))
508 .child(Flow.class, new FlowKey(new FlowId("ut-ofp:f456")));
510 Mockito.when(deviceManager.getIsNotificationFlowRemovedOff()).thenReturn(true);
512 deviceContext.setNotificationPublishService(mockedNotificationPublishService);
513 deviceContext.processFlowRemovedMessage(flowRemovedBld.build());
515 Mockito.verify(itemLifecycleListener).onRemoved(flowToBeRemovedPath);
516 Mockito.verify(mockedNotificationPublishService, Mockito.never()).offerNotification(Matchers.any(Notification.class));
518 Mockito.when(deviceManager.getIsNotificationFlowRemovedOff()).thenReturn(false);
519 deviceContext.processFlowRemovedMessage(flowRemovedBld.build());
521 Mockito.verify(mockedNotificationPublishService).offerNotification(Matchers.any(Notification.class));
525 public void testProcessExperimenterMessage() {
526 final ConvertorMessageFromOFJava mockedMessageConverter = mock(ConvertorMessageFromOFJava.class);
527 final ExtensionConverterProvider mockedExtensionConverterProvider = mock(ExtensionConverterProvider.class);
528 when(mockedExtensionConverterProvider.getMessageConverter(any(MessageTypeKey.class))).thenReturn(mockedMessageConverter);
530 final ExperimenterDataOfChoice mockedExperimenterDataOfChoice = mock(ExperimenterDataOfChoice.class);
531 final ExperimenterMessage experimenterMessage = new ExperimenterMessageBuilder()
532 .setExperimenterDataOfChoice(mockedExperimenterDataOfChoice).build();
534 final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
536 deviceContext.setNotificationPublishService(mockedNotificationPublishService);
537 ((DeviceContextImpl) deviceContext).setExtensionConverterProvider(mockedExtensionConverterProvider);
538 deviceContext.processExperimenterMessage(experimenterMessage);
540 verify(mockedNotificationPublishService).offerNotification(any(ExperimenterMessageFromDev.class));
544 public void testOnDeviceDisconnected() throws Exception {
545 final DeviceTerminationPhaseHandler deviceContextClosedHandler = mock(DeviceTerminationPhaseHandler.class);
547 assertEquals(0, deviceContext.getDeviceFlowRegistry().getAllFlowDescriptors().size());
548 assertEquals(0, deviceContext.getDeviceGroupRegistry().getAllGroupIds().size());
549 assertEquals(0, deviceContext.getDeviceMeterRegistry().getAllMeterIds().size());