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.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;
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.WriteTransaction;
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.extension.api.ConvertorMessageFromOFJava;
65 import org.opendaylight.openflowplugin.extension.api.core.extension.ExtensionConverterProvider;
66 import org.opendaylight.openflowplugin.impl.device.initialization.AbstractDeviceInitializer;
67 import org.opendaylight.openflowplugin.impl.device.initialization.DeviceInitializerProvider;
68 import org.opendaylight.openflowplugin.impl.registry.flow.FlowDescriptorFactory;
69 import org.opendaylight.openflowplugin.impl.registry.flow.FlowRegistryKeyFactory;
70 import org.opendaylight.openflowplugin.impl.util.DeviceStateUtil;
71 import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.experimenter.message.service.rev151020.ExperimenterMessageFromDev;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowRemovedBuilder;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie;
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
84 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
85 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
86 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
87 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
88 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.Capabilities;
89 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.PortReason;
90 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.Error;
91 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterMessage;
92 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ExperimenterMessageBuilder;
93 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FeaturesReply;
94 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FlowRemoved;
95 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FlowRemovedMessageBuilder;
96 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetAsyncReply;
97 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesOutput;
98 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartReply;
99 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
100 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketIn;
101 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketInMessage;
102 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortGrouping;
103 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortStatusMessage;
104 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.experimenter.core.ExperimenterDataOfChoice;
105 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
106 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceivedBuilder;
107 import org.opendaylight.yang.gen.v1.urn.opendaylight.role.service.rev150727.SalRoleService;
108 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
109 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
110 import org.opendaylight.yangtools.yang.common.RpcResult;
111 import org.slf4j.Logger;
112 import org.slf4j.LoggerFactory;
114 @RunWith(MockitoJUnitRunner.class)
115 public class DeviceContextImplTest {
116 private static final Logger LOG = LoggerFactory
117 .getLogger(DeviceContextImplTest.class);
118 private static final short DUMMY_AUXILIARY_ID = 33;
119 private static final BigInteger DUMMY_COOKIE = new BigInteger("33");
120 private static final Long DUMMY_XID = 544L;
121 private static final Long DUMMY_PORT_NUMBER = 159L;
122 private static final BigInteger DUMMY_DATAPATH_ID = new BigInteger("55");
126 DeviceContext deviceContext;
128 RequestContext<GetAsyncReply> requestContext;
130 RequestContext<MultipartReply> requestContextMultiReply;
132 ConnectionContext connectionContext;
134 GetFeaturesOutput featuresOutput;
136 DataBroker dataBroker;
138 WriteTransaction writeTx;
140 ReadOnlyTransaction readTx;
142 BindingTransactionChain txChainFactory;
144 HashedWheelTimer timer;
146 OutboundQueueProvider outboundQueueProvider;
148 ConnectionAdapter connectionAdapter;
149 NodeId nodeId = new NodeId("h2g2:42");
150 KeyedInstanceIdentifier<Node, NodeKey> nodeKeyIdent = DeviceStateUtil.createNodeInstanceIdentifier(nodeId);
152 TranslatorLibrary translatorLibrary;
154 MessageTranslator messageTranslatorPacketReceived;
156 MessageTranslator messageTranslatorFlowCapableNodeConnector;
158 private MessageTranslator<Object, Object> messageTranslatorFlowRemoved;
160 private DeviceInfo deviceInfo;
162 private ConvertorExecutor convertorExecutor;
164 private MessageSpy messageSpy;
166 private DeviceInitializerProvider deviceInitializerProvider;
168 private AbstractDeviceInitializer abstractDeviceInitializer;
170 private SalRoleService salRoleService;
172 private final AtomicLong atomicLong = new AtomicLong(0);
174 private DeviceContext deviceContextSpy;
177 public void setUp() throws Exception {
178 final CheckedFuture<Optional<Node>, ReadFailedException> noExistNodeFuture =
179 Futures.immediateCheckedFuture(Optional.<Node>absent());
180 Mockito.when(readTx.read(LogicalDatastoreType.OPERATIONAL, nodeKeyIdent)).thenReturn(noExistNodeFuture);
181 Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(readTx);
182 Mockito.when(dataBroker.createTransactionChain(Mockito.any(TransactionChainManager.class)))
183 .thenReturn(txChainFactory);
184 Mockito.when(deviceInfo.getNodeInstanceIdentifier()).thenReturn(nodeKeyIdent);
185 Mockito.when(deviceInfo.getNodeId()).thenReturn(nodeId);
186 Mockito.when(deviceInfo.getDatapathId()).thenReturn(BigInteger.ONE);
187 final SettableFuture<RpcResult<GetAsyncReply>> settableFuture = SettableFuture.create();
188 final SettableFuture<RpcResult<MultipartReply>> settableFutureMultiReply = SettableFuture.create();
189 Mockito.when(requestContext.getFuture()).thenReturn(settableFuture);
190 Mockito.doAnswer(invocation -> {
191 settableFuture.set((RpcResult<GetAsyncReply>) invocation.getArguments()[0]);
193 }).when(requestContext).setResult(any(RpcResult.class));
195 Mockito.when(requestContextMultiReply.getFuture()).thenReturn(settableFutureMultiReply);
196 Mockito.doAnswer(invocation -> {
197 settableFutureMultiReply.set((RpcResult<MultipartReply>) invocation.getArguments()[0]);
199 }).when(requestContextMultiReply).setResult(any(RpcResult.class));
200 Mockito.when(txChainFactory.newWriteOnlyTransaction()).thenReturn(writeTx);
201 Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(readTx);
202 Mockito.when(connectionContext.getOutboundQueueProvider()).thenReturn(outboundQueueProvider);
203 Mockito.when(connectionContext.getConnectionAdapter()).thenReturn(connectionAdapter);
204 Mockito.when(connectionContext.getDeviceInfo()).thenReturn(deviceInfo);
205 final FeaturesReply mockedFeaturesReply = mock(FeaturesReply.class);
206 when(connectionContext.getFeatures()).thenReturn(mockedFeaturesReply);
207 when(connectionContext.getFeatures().getCapabilities()).thenReturn(mock(Capabilities.class));
209 Mockito.when(deviceInfo.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
210 Mockito.when(featuresOutput.getDatapathId()).thenReturn(DUMMY_DATAPATH_ID);
211 Mockito.when(featuresOutput.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
213 final PacketReceived packetReceived = new PacketReceivedBuilder()
214 .setMatch(new org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.packet.received
216 .setInPort(new NodeConnectorId("openflow:1:LOCAL"))
220 Mockito.when(messageTranslatorPacketReceived.translate(any(Object.class), any(DeviceInfo.class),
221 any(Object.class))).thenReturn(packetReceived);
222 Mockito.when(messageTranslatorFlowCapableNodeConnector.translate(any(Object.class), any(DeviceInfo.class),
223 any(Object.class))).thenReturn(mock(FlowCapableNodeConnector.class));
224 Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3,
225 PacketIn.class.getName())))).thenReturn(messageTranslatorPacketReceived);
226 Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3,
227 PortGrouping.class.getName())))).thenReturn(messageTranslatorFlowCapableNodeConnector);
228 Mockito.when(translatorLibrary.lookupTranslator(eq(new TranslatorKey(OFConstants.OFP_VERSION_1_3,
229 FlowRemoved.class.getName())))).thenReturn(messageTranslatorFlowRemoved);
231 Mockito.when(abstractDeviceInitializer.initialize(any(), anyBoolean(), anyBoolean(), any(), any()))
232 .thenReturn(Futures.immediateFuture(null));
234 final java.util.Optional<AbstractDeviceInitializer> deviceInitializer = java.util.Optional
235 .of(this.abstractDeviceInitializer);
237 Mockito.when(deviceInitializerProvider.lookup(OFConstants.OFP_VERSION_1_3)).thenReturn(deviceInitializer);
238 Mockito.when(salRoleService.setRole(any())).thenReturn(Futures.immediateFuture(null));
240 deviceContext = new DeviceContextImpl(
247 deviceInitializerProvider,
250 ((DeviceContextImpl) deviceContext).lazyTransactionManagerInitialization();
251 deviceContextSpy = Mockito.spy(deviceContext);
253 xid = new Xid(atomicLong.incrementAndGet());
254 xidMulti = new Xid(atomicLong.incrementAndGet());
256 Mockito.doNothing().when(deviceContextSpy).writeToTransaction(any(), any(), any());
261 public void testGetReadTransaction() {
262 final ReadTransaction readTx = deviceContext.getReadTransaction();
263 assertNotNull(readTx);
264 assertEquals(this.readTx, readTx);
268 public void testInitialSubmitTransaction() throws Exception {
269 Mockito.when(writeTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
270 final InstanceIdentifier<Nodes> dummyII = InstanceIdentifier.create(Nodes.class);
271 ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ;
272 ((DeviceContextImpl) deviceContext).getTransactionChainManager().enableSubmit();
273 deviceContext.addDeleteToTxChain(LogicalDatastoreType.CONFIGURATION, dummyII);
274 deviceContext.initialSubmitTransaction();
275 verify(writeTx).submit();
278 private ConnectionContext prepareConnectionContext() {
279 final ConnectionContext mockedConnectionContext = mock(ConnectionContext.class);
280 final FeaturesReply mockedFeaturesReply = mock(FeaturesReply.class);
281 when(mockedFeaturesReply.getAuxiliaryId()).thenReturn(DUMMY_AUXILIARY_ID);
282 when(mockedConnectionContext.getFeatures()).thenReturn(mockedFeaturesReply);
283 return mockedConnectionContext;
287 public void testAddDeleteToTxChain() throws Exception {
288 final InstanceIdentifier<Nodes> dummyII = InstanceIdentifier.create(Nodes.class);
289 ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ;
290 ((DeviceContextImpl) deviceContext).getTransactionChainManager().enableSubmit();
291 deviceContext.addDeleteToTxChain(LogicalDatastoreType.CONFIGURATION, dummyII);
292 verify(writeTx).delete(eq(LogicalDatastoreType.CONFIGURATION), eq(dummyII));
296 public void testSubmitTransaction() throws Exception {
297 ((DeviceContextImpl) deviceContext).getTransactionChainManager().activateTransactionManager() ;
298 ((DeviceContextImpl) deviceContext).getTransactionChainManager().enableSubmit();
299 assertTrue(deviceContext.submitTransaction());
303 public void testGetPrimaryConnectionContext() {
304 final ConnectionContext primaryConnectionContext = deviceContext.getPrimaryConnectionContext();
305 assertEquals(connectionContext, primaryConnectionContext);
309 public void testGetDeviceFlowRegistry() {
310 final DeviceFlowRegistry deviceFlowRegistry = deviceContext.getDeviceFlowRegistry();
311 assertNotNull(deviceFlowRegistry);
315 public void testGetDeviceGroupRegistry() {
316 final DeviceGroupRegistry deviceGroupRegistry = deviceContext.getDeviceGroupRegistry();
317 assertNotNull(deviceGroupRegistry);
321 public void testGetDeviceMeterRegistry() {
322 final DeviceMeterRegistry deviceMeterRegistry = deviceContext.getDeviceMeterRegistry();
323 assertNotNull(deviceMeterRegistry);
327 public void testProcessReply() {
328 final Error mockedError = mock(Error.class);
329 deviceContext.processReply(mockedError);
330 verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_FAILURE));
331 final OfHeader mockedOfHeader = mock(OfHeader.class);
332 deviceContext.processReply(mockedOfHeader);
333 verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_SUCCESS));
337 public void testProcessReply2() {
338 final Xid dummyXid = new Xid(DUMMY_XID);
340 final Error mockedError = mock(Error.class);
341 deviceContext.processReply(dummyXid, Lists.newArrayList(mockedError));
342 verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_FAILURE));
344 final MultipartReply mockedMultipartReply = mock(MultipartReply.class);
345 deviceContext.processReply(dummyXid, Lists.newArrayList(mockedMultipartReply));
346 verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_SUCCESS));
350 public void testProcessPacketInMessageFutureSuccess() {
351 final PacketInMessage mockedPacketInMessage = mock(PacketInMessage.class);
352 final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
353 final ListenableFuture stringListenableFuture = Futures.immediateFuture("dummy value");
355 when(mockedNotificationPublishService.offerNotification(any(PacketReceived.class)))
356 .thenReturn(stringListenableFuture);
357 deviceContext.setNotificationPublishService(mockedNotificationPublishService);
358 deviceContext.processPacketInMessage(mockedPacketInMessage);
359 verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.StatisticsGroup.FROM_SWITCH));
360 verify(messageSpy).spyMessage(any(Class.class), eq(MessageSpy.StatisticsGroup.FROM_SWITCH_PUBLISHED_SUCCESS));
364 public void testProcessPacketInMessageFutureFailure() {
365 final PacketInMessage mockedPacketInMessage = mock(PacketInMessage.class);
366 final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
367 final ListenableFuture dummyFuture = Futures.immediateFailedFuture(new IllegalStateException());
369 when(mockedNotificationPublishService.offerNotification(any(PacketReceived.class))).thenReturn(dummyFuture);
370 deviceContext.setNotificationPublishService(mockedNotificationPublishService);
371 deviceContext.processPacketInMessage(mockedPacketInMessage);
372 verify(messageSpy).spyMessage(any(Class.class),
373 eq(MessageSpy.StatisticsGroup.FROM_SWITCH_NOTIFICATION_REJECTED));
377 public void testTranslatorLibrary() {
378 final TranslatorLibrary pickedTranslatorLibrary = deviceContext.oook();
379 assertEquals(translatorLibrary, pickedTranslatorLibrary);
383 public void testGetMessageSpy() {
384 final MessageSpy pickedMessageSpy = deviceContext.getMessageSpy();
385 assertEquals(messageSpy, pickedMessageSpy);
389 public void testOnPublished() {
390 final ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class);
391 when(connectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter);
393 deviceContext.onPublished();
394 verify(mockedConnectionAdapter).setPacketInFiltering(eq(false));
398 public void testPortStatusMessage() throws Exception {
399 final PortStatusMessage mockedPortStatusMessage = mock(PortStatusMessage.class);
400 final Class dummyClass = Class.class;
401 when(mockedPortStatusMessage.getImplementedInterface()).thenReturn(dummyClass);
404 final GetFeaturesOutput mockedFeature = mock(GetFeaturesOutput.class);
405 when(mockedFeature.getDatapathId()).thenReturn(DUMMY_DATAPATH_ID);
407 when(mockedPortStatusMessage.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
408 when(mockedPortStatusMessage.getReason()).thenReturn(PortReason.OFPPRADD);
409 when(mockedPortStatusMessage.getPortNo()).thenReturn(42L);
411 deviceContextSpy.processPortStatusMessage(mockedPortStatusMessage);
412 verify(messageSpy).spyMessage(any(), any());
416 public void testProcessFlowRemovedMessage() throws Exception {
417 // prepare translation result
418 final FlowRemovedBuilder flowRemovedMdsalBld = new FlowRemovedBuilder()
419 .setTableId((short) 0)
421 .setCookie(new FlowCookie(BigInteger.ONE))
422 .setMatch(new MatchBuilder().build());
423 final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
425 Mockito.when(messageTranslatorFlowRemoved
426 .translate(any(Object.class), any(DeviceInfo.class), any(Object.class)))
427 .thenReturn(flowRemovedMdsalBld.build());
429 // insert flow+flowId into local registry
430 final FlowRegistryKey flowRegKey =
431 FlowRegistryKeyFactory.create(deviceInfo.getVersion(), flowRemovedMdsalBld.build());
432 final FlowDescriptor flowDescriptor = FlowDescriptorFactory.create((short) 0, new FlowId("ut-ofp:f456"));
433 deviceContext.getDeviceFlowRegistry().storeDescriptor(flowRegKey, flowDescriptor);
435 // plug in lifecycleListener
436 final ItemLifecycleListener itemLifecycleListener = Mockito.mock(ItemLifecycleListener.class);
437 for (final ItemLifeCycleSource lifeCycleSource : deviceContext.getItemLifeCycleSourceRegistry()
438 .getLifeCycleSources()) {
439 lifeCycleSource.setItemLifecycleListener(itemLifecycleListener);
442 // prepare empty input message
443 final FlowRemovedMessageBuilder flowRemovedBld = new FlowRemovedMessageBuilder();
445 // prepare path to flow to be removed
446 final KeyedInstanceIdentifier<Flow, FlowKey> flowToBeRemovedPath = nodeKeyIdent
447 .augmentation(FlowCapableNode.class)
448 .child(Table.class, new TableKey((short) 0))
449 .child(Flow.class, new FlowKey(new FlowId("ut-ofp:f456")));
451 deviceContext.setNotificationPublishService(mockedNotificationPublishService);
452 deviceContext.processFlowRemovedMessage(flowRemovedBld.build());
454 Mockito.verify(itemLifecycleListener).onRemoved(flowToBeRemovedPath);
458 public void testProcessExperimenterMessage() {
459 final ConvertorMessageFromOFJava mockedMessageConverter = mock(ConvertorMessageFromOFJava.class);
460 final ExtensionConverterProvider mockedExtensionConverterProvider = mock(ExtensionConverterProvider.class);
461 when(mockedExtensionConverterProvider.getMessageConverter(any(MessageTypeKey.class)))
462 .thenReturn(mockedMessageConverter);
464 final ExperimenterDataOfChoice mockedExperimenterDataOfChoice = mock(ExperimenterDataOfChoice.class);
465 final ExperimenterMessage experimenterMessage = new ExperimenterMessageBuilder()
466 .setExperimenterDataOfChoice(mockedExperimenterDataOfChoice).build();
468 final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
470 deviceContext.setNotificationPublishService(mockedNotificationPublishService);
471 ((DeviceContextImpl) deviceContext).setExtensionConverterProvider(mockedExtensionConverterProvider);
472 deviceContext.processExperimenterMessage(experimenterMessage);
474 verify(mockedNotificationPublishService).offerNotification(any(ExperimenterMessageFromDev.class));
478 public void instantiateServiceInstance() throws Exception {
479 deviceContext.instantiateServiceInstance();
483 public void close() throws Exception {
484 deviceContext.close();
488 public void closeServiceInstance() throws Exception {
489 deviceContext.closeServiceInstance();