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
8 package org.opendaylight.openflowplugin.impl.device;
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;
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.extension.api.ConvertorMessageFromOFJava;
63 import org.opendaylight.openflowplugin.extension.api.core.extension.ExtensionConverterProvider;
64 import org.opendaylight.openflowplugin.impl.device.initialization.AbstractDeviceInitializer;
65 import org.opendaylight.openflowplugin.impl.device.initialization.DeviceInitializerProvider;
66 import org.opendaylight.openflowplugin.impl.registry.flow.FlowDescriptorFactory;
67 import org.opendaylight.openflowplugin.impl.registry.flow.FlowRegistryKeyFactory;
68 import org.opendaylight.openflowplugin.impl.services.sal.SalRoleRpc;
69 import org.opendaylight.openflowplugin.impl.util.DeviceStateUtil;
70 import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.experimenter.message.service.rev151020.ExperimenterMessageFromDev;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowRemovedBuilder;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
84 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
85 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
86 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
87 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.Capabilities;
88 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.PortReason;
89 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.Error;
90 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterMessage;
91 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterMessageBuilder;
92 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FeaturesReply;
93 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FlowRemoved;
94 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FlowRemovedMessageBuilder;
95 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetAsyncReply;
96 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesOutput;
97 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartReply;
98 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
99 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketIn;
100 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketInMessage;
101 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortGrouping;
102 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortStatusMessage;
103 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.experimenter.core.ExperimenterDataOfChoice;
104 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
105 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceivedBuilder;
106 import org.opendaylight.yang.gen.v1.urn.opendaylight.role.service.rev150727.SetRole;
107 import org.opendaylight.yangtools.util.concurrent.FluentFutures;
108 import org.opendaylight.yangtools.util.concurrent.NotificationManager;
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.opendaylight.yangtools.yang.common.Uint16;
113 import org.opendaylight.yangtools.yang.common.Uint32;
114 import org.opendaylight.yangtools.yang.common.Uint64;
115 import org.opendaylight.yangtools.yang.common.Uint8;
116 import org.slf4j.Logger;
117 import org.slf4j.LoggerFactory;
119 @RunWith(MockitoJUnitRunner.class)
120 public class DeviceContextImplTest {
121 private static final Logger LOG = LoggerFactory.getLogger(DeviceContextImplTest.class);
122 private static final Uint8 DUMMY_AUXILIARY_ID = Uint8.valueOf(33);
123 private static final Uint64 DUMMY_COOKIE = Uint64.valueOf("33");
124 private static final Uint32 DUMMY_XID = Uint32.valueOf(544L);
125 private static final Long DUMMY_PORT_NUMBER = 159L;
126 private static final Uint64 DUMMY_DATAPATH_ID = Uint64.valueOf("55");
128 private Xid xidMulti;
130 private DeviceContext deviceContext;
132 private RequestContext<GetAsyncReply> requestContext;
134 private RequestContext<MultipartReply> requestContextMultiReply;
136 private ConnectionContext connectionContext;
138 private GetFeaturesOutput featuresOutput;
140 private DataBroker dataBroker;
142 private ReadWriteTransaction writeTx;
144 private ReadTransaction readTx;
146 private TransactionChain txChainFactory;
148 private HashedWheelTimer timer;
150 private OutboundQueueProvider outboundQueueProvider;
152 private ConnectionAdapter connectionAdapter;
153 private final NodeId nodeId = new NodeId("h2g2:42");
154 private final KeyedInstanceIdentifier<Node, NodeKey> nodeKeyIdent =
155 DeviceStateUtil.createNodeInstanceIdentifier(nodeId);
157 private TranslatorLibrary translatorLibrary;
159 MessageTranslator messageTranslatorPacketReceived;
161 private MessageTranslator messageTranslatorFlowCapableNodeConnector;
163 private MessageTranslator<Object, Object> messageTranslatorFlowRemoved;
165 private DeviceInfo deviceInfo;
167 private ConvertorExecutor convertorExecutor;
169 private MessageSpy messageSpy;
171 private DeviceInitializerProvider deviceInitializerProvider;
173 private AbstractDeviceInitializer abstractDeviceInitializer;
175 private SalRoleRpc salRoleRpc;
177 private SetRole setRole;
179 private ContextChainHolder contextChainHolder;
181 private ContextChain contextChain;
183 private NotificationManager queuedNotificationManager;
185 private final AtomicLong atomicLong = new AtomicLong(0);
187 private DeviceContext deviceContextSpy;
190 public void setUp() {
191 final FluentFuture<Optional<Node>> noExistNodeFuture =
192 FluentFutures.immediateFluentFuture(Optional.<Node>empty());
193 Mockito.lenient().when(readTx.read(LogicalDatastoreType.OPERATIONAL, nodeKeyIdent))
194 .thenReturn(noExistNodeFuture);
195 Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(readTx);
196 Mockito.when(dataBroker.createTransactionChain()).thenReturn(txChainFactory);
197 Mockito.when(deviceInfo.getNodeInstanceIdentifier()).thenReturn(nodeKeyIdent);
198 Mockito.when(deviceInfo.getNodeId()).thenReturn(nodeId);
199 Mockito.when(deviceInfo.getDatapathId()).thenReturn(Uint64.ONE);
200 final SettableFuture<RpcResult<GetAsyncReply>> settableFuture = SettableFuture.create();
201 final SettableFuture<RpcResult<MultipartReply>> settableFutureMultiReply = SettableFuture.create();
202 Mockito.lenient().when(requestContext.getFuture()).thenReturn(settableFuture);
203 Mockito.lenient().doAnswer(invocation -> {
204 settableFuture.set((RpcResult<GetAsyncReply>) invocation.getArguments()[0]);
206 }).when(requestContext).setResult(Mockito.<RpcResult>any());
208 Mockito.lenient().when(requestContextMultiReply.getFuture()).thenReturn(settableFutureMultiReply);
209 Mockito.lenient().doAnswer(invocation -> {
210 settableFutureMultiReply.set((RpcResult<MultipartReply>) invocation.getArguments()[0]);
212 }).when(requestContextMultiReply).setResult(any(RpcResult.class));
213 Mockito.when(txChainFactory.newReadWriteTransaction()).thenReturn(writeTx);
214 Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(readTx);
215 Mockito.lenient().when(connectionContext.getOutboundQueueProvider()).thenReturn(outboundQueueProvider);
216 Mockito.when(connectionContext.getConnectionAdapter()).thenReturn(connectionAdapter);
217 Mockito.when(connectionContext.getDeviceInfo()).thenReturn(deviceInfo);
218 final FeaturesReply mockedFeaturesReply = mock(FeaturesReply.class);
219 lenient().when(connectionContext.getFeatures()).thenReturn(mockedFeaturesReply);
220 lenient().when(connectionContext.getFeatures().getCapabilities()).thenReturn(mock(Capabilities.class));
222 Mockito.lenient().when(deviceInfo.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
223 Mockito.lenient().when(featuresOutput.getDatapathId()).thenReturn(DUMMY_DATAPATH_ID);
224 Mockito.lenient().when(featuresOutput.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
225 Mockito.when(contextChainHolder.getContextChain(deviceInfo)).thenReturn(contextChain);
226 Mockito.when(contextChain.isMastered(ContextChainMastershipState.CHECK, false)).thenReturn(true);
228 final PacketReceived packetReceived = new PacketReceivedBuilder()
229 .setMatch(new org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.packet.received
231 .setInPort(new NodeConnectorId("openflow:1:LOCAL"))
235 Mockito.when(messageTranslatorPacketReceived.translate(Mockito.any(), Mockito.any(),
236 Mockito.any())).thenReturn(packetReceived);
237 lenient().when(messageTranslatorFlowCapableNodeConnector.translate(Mockito.any(),
239 Mockito.any())).thenReturn(mock(FlowCapableNodeConnector.class));
240 Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3,
241 PacketIn.class.getName())))).thenReturn(messageTranslatorPacketReceived);
242 Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3,
243 PortGrouping.class.getName())))).thenReturn(messageTranslatorFlowCapableNodeConnector);
244 Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3,
245 FlowRemoved.class.getName())))).thenReturn(messageTranslatorFlowRemoved);
247 final java.util.Optional<AbstractDeviceInitializer> deviceInitializer = java.util.Optional
248 .of(abstractDeviceInitializer);
250 Mockito.lenient().when(deviceInitializerProvider.lookup(OFConstants.OFP_VERSION_1_3))
251 .thenReturn(deviceInitializer);
252 Mockito.lenient().when(salRoleRpc.invoke(any())).thenReturn(Futures.immediateFuture(null));
254 deviceContext = new DeviceContextImpl(
261 deviceInitializerProvider,
264 queuedNotificationManager,
266 ((DeviceContextImpl) deviceContext).lazyTransactionManagerInitialization();
267 deviceContextSpy = Mockito.spy(deviceContext);
269 xid = new Xid(Uint32.valueOf(atomicLong.incrementAndGet()));
270 xidMulti = new Xid(Uint32.valueOf(atomicLong.incrementAndGet()));
271 lenient().doNothing().when(deviceContextSpy).writeToTransaction(any(), any(), any());
275 public void testGetReadTransaction() {
276 readTx = deviceContext.getReadTransaction();
277 assertNotNull(readTx);
278 assertEquals(readTx, readTx);
282 public void testInitialSubmitTransaction() {
283 Mockito.doReturn(CommitInfo.emptyFluentFuture()).when(writeTx).commit();
284 final InstanceIdentifier<Nodes> dummyII = InstanceIdentifier.create(Nodes.class);
285 ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ;
286 ((DeviceContextImpl) deviceContext).getTransactionChainManager().initialSubmitWriteTransaction();
287 deviceContext.addDeleteToTxChain(LogicalDatastoreType.CONFIGURATION, dummyII);
288 deviceContext.initialSubmitTransaction();
289 verify(writeTx).commit();
292 private static ConnectionContext prepareConnectionContext() {
293 final ConnectionContext mockedConnectionContext = mock(ConnectionContext.class);
294 final FeaturesReply mockedFeaturesReply = mock(FeaturesReply.class);
295 when(mockedFeaturesReply.getAuxiliaryId()).thenReturn(DUMMY_AUXILIARY_ID);
296 when(mockedConnectionContext.getFeatures()).thenReturn(mockedFeaturesReply);
297 return mockedConnectionContext;
301 public void testAddDeleteToTxChain() {
302 final InstanceIdentifier<Nodes> dummyII = InstanceIdentifier.create(Nodes.class);
303 ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ;
304 ((DeviceContextImpl) deviceContext).getTransactionChainManager().initialSubmitWriteTransaction();
305 deviceContext.addDeleteToTxChain(LogicalDatastoreType.CONFIGURATION, dummyII);
306 verify(writeTx).delete(eq(LogicalDatastoreType.CONFIGURATION), eq(dummyII));
310 public void testSubmitTransaction() {
311 ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ;
312 ((DeviceContextImpl) deviceContext).getTransactionChainManager().initialSubmitWriteTransaction();
313 assertTrue(deviceContext.submitTransaction());
317 public void testGetPrimaryConnectionContext() {
318 final ConnectionContext primaryConnectionContext = deviceContext.getPrimaryConnectionContext();
319 assertEquals(connectionContext, primaryConnectionContext);
323 public void testGetDeviceFlowRegistry() {
324 final DeviceFlowRegistry deviceFlowRegistry = deviceContext.getDeviceFlowRegistry();
325 assertNotNull(deviceFlowRegistry);
329 public void testGetDeviceGroupRegistry() {
330 final DeviceGroupRegistry deviceGroupRegistry = deviceContext.getDeviceGroupRegistry();
331 assertNotNull(deviceGroupRegistry);
335 public void testGetDeviceMeterRegistry() {
336 final DeviceMeterRegistry deviceMeterRegistry = deviceContext.getDeviceMeterRegistry();
337 assertNotNull(deviceMeterRegistry);
341 public void testProcessReply() {
342 final Error mockedError = mock(Error.class);
343 deviceContext.processReply(mockedError);
344 verify(messageSpy).spyMessage(Mockito.<Class>any(),
345 eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_FAILURE));
346 final OfHeader mockedOfHeader = mock(OfHeader.class);
347 deviceContext.processReply(mockedOfHeader);
348 verify(messageSpy).spyMessage(Mockito.<Class>any(),
349 eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_SUCCESS));
353 public void testProcessReply2() {
354 final Xid dummyXid = new Xid(DUMMY_XID);
356 final Error mockedError = mock(Error.class);
357 deviceContext.processReply(dummyXid, Lists.newArrayList(mockedError));
358 verify(messageSpy).spyMessage(Mockito.<Class>any(),
359 eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_FAILURE));
361 final MultipartReply mockedMultipartReply = mock(MultipartReply.class);
362 deviceContext.processReply(dummyXid, Lists.newArrayList(mockedMultipartReply));
363 verify(messageSpy).spyMessage(Mockito.<Class>any(),
364 eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_SUCCESS));
368 public void testProcessPacketInMessageFutureSuccess() {
369 final PacketInMessage mockedPacketInMessage = mock(PacketInMessage.class);
370 final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
371 final ListenableFuture stringListenableFuture = Futures.immediateFuture("dummy value");
373 when(mockedNotificationPublishService.offerNotification(any(PacketReceived.class)))
374 .thenReturn(stringListenableFuture);
375 deviceContext.setNotificationPublishService(mockedNotificationPublishService);
376 deviceContext.processPacketInMessage(mockedPacketInMessage);
377 verify(messageSpy).spyMessage(Mockito.<Class>any(), eq(MessageSpy.StatisticsGroup.FROM_SWITCH));
378 verify(messageSpy).spyMessage(Mockito.<Class>any(),
379 eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_SUCCESS));
383 public void testProcessPacketInMessageFutureFailure() {
384 final PacketInMessage mockedPacketInMessage = mock(PacketInMessage.class);
385 final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
386 final ListenableFuture dummyFuture = Futures.immediateFailedFuture(new IllegalStateException());
388 when(mockedNotificationPublishService.offerNotification(Mockito.<PacketReceived>any())).thenReturn(dummyFuture);
389 deviceContext.setNotificationPublishService(mockedNotificationPublishService);
390 deviceContext.processPacketInMessage(mockedPacketInMessage);
391 verify(messageSpy).spyMessage(Mockito.<Class>any(),
392 eq(MessageSpy.StatisticsGroup.FROM_SWITCH_NOTIFICATION_REJECTED));
396 public void testTranslatorLibrary() {
397 final TranslatorLibrary pickedTranslatorLibrary = deviceContext.oook();
398 assertEquals(translatorLibrary, pickedTranslatorLibrary);
402 public void testGetMessageSpy() {
403 final MessageSpy pickedMessageSpy = deviceContext.getMessageSpy();
404 assertEquals(messageSpy, pickedMessageSpy);
408 public void testOnPublished() {
409 final ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class);
410 when(connectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter);
412 deviceContext.onPublished();
413 verify(mockedConnectionAdapter).setPacketInFiltering(eq(false));
417 public void testPortStatusMessage() {
418 final PortStatusMessage mockedPortStatusMessage = mock(PortStatusMessage.class);
419 final Class dummyClass = Class.class;
420 when(mockedPortStatusMessage.implementedInterface()).thenReturn(dummyClass);
422 final GetFeaturesOutput mockedFeature = mock(GetFeaturesOutput.class);
423 lenient().when(mockedFeature.getDatapathId()).thenReturn(DUMMY_DATAPATH_ID);
425 lenient().when(mockedPortStatusMessage.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
426 lenient().when(mockedPortStatusMessage.getReason()).thenReturn(PortReason.OFPPRADD);
427 lenient().when(mockedPortStatusMessage.getPortNo()).thenReturn(Uint32.valueOf(42L));
428 deviceContextSpy.processPortStatusMessage(mockedPortStatusMessage);
429 verify(messageSpy).spyMessage(any(), any());
433 public void testProcessFlowRemovedMessage() {
434 // prepare translation result
435 final FlowRemovedBuilder flowRemovedMdsalBld = new FlowRemovedBuilder()
436 .setTableId(Uint8.ZERO)
437 .setPriority(Uint16.valueOf(42))
438 .setCookie(new FlowCookie(Uint64.ONE))
439 .setMatch(new MatchBuilder().build());
440 final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
442 Mockito.lenient().when(messageTranslatorFlowRemoved
443 .translate(any(Object.class), any(DeviceInfo.class), any(Object.class)))
444 .thenReturn(flowRemovedMdsalBld.build());
446 // insert flow+flowId into local registry
447 final FlowRegistryKey flowRegKey = FlowRegistryKeyFactory.VERSION_1_3.create(flowRemovedMdsalBld.build());
448 final FlowDescriptor flowDescriptor = FlowDescriptorFactory.create(Uint8.ZERO, new FlowId("ut-ofp:f456"));
449 deviceContext.getDeviceFlowRegistry().storeDescriptor(flowRegKey, flowDescriptor);
451 // prepare empty input message
452 final FlowRemovedMessageBuilder flowRemovedBld = new FlowRemovedMessageBuilder();
454 // prepare path to flow to be removed
455 final KeyedInstanceIdentifier<Flow, FlowKey> flowToBeRemovedPath = nodeKeyIdent
456 .augmentation(FlowCapableNode.class)
457 .child(Table.class, new TableKey(Uint8.ZERO))
458 .child(Flow.class, new FlowKey(new FlowId("ut-ofp:f456")));
460 deviceContext.setNotificationPublishService(mockedNotificationPublishService);
461 deviceContext.processFlowRemovedMessage(flowRemovedBld.build());
465 public void testProcessExperimenterMessage() {
466 final ConvertorMessageFromOFJava mockedMessageConverter = mock(ConvertorMessageFromOFJava.class);
467 final ExtensionConverterProvider mockedExtensionConverterProvider = mock(ExtensionConverterProvider.class);
468 when(mockedExtensionConverterProvider.getMessageConverter(any(MessageTypeKey.class)))
469 .thenReturn(mockedMessageConverter);
471 final ExperimenterDataOfChoice mockedExperimenterDataOfChoice = mock(ExperimenterDataOfChoice.class);
472 final ExperimenterMessage experimenterMessage = new ExperimenterMessageBuilder()
473 .setExperimenterDataOfChoice(mockedExperimenterDataOfChoice).build();
475 final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
477 deviceContext.setNotificationPublishService(mockedNotificationPublishService);
478 ((DeviceContextImpl) deviceContext).setExtensionConverterProvider(mockedExtensionConverterProvider);
479 deviceContext.processExperimenterMessage(experimenterMessage);
481 verify(mockedNotificationPublishService).offerNotification(any(ExperimenterMessageFromDev.class));
485 public void instantiateServiceInstance() {
486 deviceContext.instantiateServiceInstance();
490 public void close() {
491 deviceContext.close();
495 public void closeServiceInstance() {
496 deviceContext.closeServiceInstance();