+ when(mockedNotificationPublishService.offerNotification(any(PacketReceived.class))).thenReturn(stringListenableFuture);
+ deviceContext.setNotificationPublishService(mockedNotificationPublishService);
+ deviceContext.processPacketInMessage(mockedPacketInMessage);
+ verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_PUBLISHED_SUCCESS));
+ }
+
+ @Test
+ public void testProcessPacketInMessageFutureFailure() {
+ final PacketInMessage mockedPacketInMessage = mock(PacketInMessage.class);
+ final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
+ final ListenableFuture dummyFuture = Futures.immediateFailedFuture(new IllegalStateException());
+
+ when(mockedNotificationPublishService.offerNotification(any(PacketReceived.class))).thenReturn(dummyFuture);
+ deviceContext.setNotificationPublishService(mockedNotificationPublishService);
+ deviceContext.processPacketInMessage(mockedPacketInMessage);
+ verify(messageIntelligenceAgency).spyMessage(any(Class.class), eq(MessageSpy.STATISTIC_GROUP.FROM_SWITCH_NOTIFICATION_REJECTED));
+ }
+
+ @Test
+ public void testTranslatorLibrary() {
+ final TranslatorLibrary pickedTranslatorLibrary = deviceContext.oook();
+ assertEquals(translatorLibrary, pickedTranslatorLibrary);
+ }
+
+ @Test
+ public void testShutdownConnection() {
+ final ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class);
+ final InetSocketAddress mockRemoteAddress = InetSocketAddress.createUnresolved("odl-unit.example.org",999);
+ when(mockedConnectionAdapter.getRemoteAddress()).thenReturn(mockRemoteAddress);
+ when(connectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter);
+
+ final NodeId dummyNodeId = new NodeId("dummyNodeId");
+ when(deviceInfo.getNodeId()).thenReturn(dummyNodeId);
+
+ final ConnectionContext mockedAuxiliaryConnectionContext = prepareConnectionContext();
+ deviceContext.addAuxiliaryConnectionContext(mockedAuxiliaryConnectionContext);
+ final DeviceTerminationPhaseHandler mockedDeviceContextClosedHandler = mock(DeviceTerminationPhaseHandler.class);
+ when(deviceState.isValid()).thenReturn(true);
+ deviceContext.shutdownConnection();
+ verify(connectionContext).closeConnection(true);
+ }
+
+ @Test
+ public void testBarrierFieldSetGet() {
+ final Timeout mockedTimeout = mock(Timeout.class);
+ deviceContext.setCurrentBarrierTimeout(mockedTimeout);
+ final Timeout pickedBarrierTimeout = deviceContext.getBarrierTaskTimeout();
+ assertEquals(mockedTimeout, pickedBarrierTimeout);
+ }
+
+ @Test
+ public void testGetMessageSpy() {
+ final MessageSpy pickedMessageSpy = deviceContext.getMessageSpy();
+ assertEquals(messageIntelligenceAgency, pickedMessageSpy);
+ }
+
+ @Test
+ public void testNodeConnector() {
+ final NodeConnectorRef mockedNodeConnectorRef = mock(NodeConnectorRef.class);
+ deviceContext.storeNodeConnectorRef(DUMMY_PORT_NUMBER, mockedNodeConnectorRef);
+ final NodeConnectorRef nodeConnectorRef = deviceContext.lookupNodeConnectorRef(DUMMY_PORT_NUMBER);
+ assertEquals(mockedNodeConnectorRef, nodeConnectorRef);
+
+ }
+
+ @Test
+ public void testOnPublished() {
+ final ConnectionContext auxiliaryConnectionContext = addDummyAuxiliaryConnectionContext();
+
+ final ConnectionAdapter mockedAuxConnectionAdapter = mock(ConnectionAdapter.class);
+ when(auxiliaryConnectionContext.getConnectionAdapter()).thenReturn(mockedAuxConnectionAdapter);
+
+ final ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class);
+ when(connectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter);
+
+ deviceContext.onPublished();
+ verify(mockedAuxConnectionAdapter).setPacketInFiltering(eq(false));
+ verify(mockedConnectionAdapter).setPacketInFiltering(eq(false));
+ }
+
+ @Test
+ public void testPortStatusMessage() throws Exception{
+ final PortStatusMessage mockedPortStatusMessage = mock(PortStatusMessage.class);
+ final Class dummyClass = Class.class;
+ when(mockedPortStatusMessage.getImplementedInterface()).thenReturn(dummyClass);
+
+
+ final GetFeaturesOutput mockedFeature = mock(GetFeaturesOutput.class);
+ when(mockedFeature.getDatapathId()).thenReturn(DUMMY_DATAPATH_ID);
+
+ when(mockedPortStatusMessage.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
+ when(mockedPortStatusMessage.getReason()).thenReturn(PortReason.OFPPRADD);
+ when(mockedPortStatusMessage.getPortNo()).thenReturn(42L);
+
+ OpenflowPortsUtil.init();
+ deviceContextSpy.processPortStatusMessage(mockedPortStatusMessage);
+ verify(deviceContextSpy).writeToTransaction(Mockito.<LogicalDatastoreType>any(), Mockito.<InstanceIdentifier>any(), any());
+ verify(deviceContextSpy).submitTransaction();
+ }
+
+ @Test
+ public void testProcessFlowRemovedMessage() throws Exception {
+ // prepare translation result
+ final FlowRemovedBuilder flowRemovedMdsalBld = new FlowRemovedBuilder()
+ .setTableId((short) 0)
+ .setPriority(42)
+ .setCookie(new FlowCookie(BigInteger.ONE))
+ .setMatch(new MatchBuilder().build());
+ final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
+
+ Mockito.when(messageTranslatorFlowRemoved.translate(any(Object.class), any(DeviceInfo.class), any(Object.class)))
+ .thenReturn(flowRemovedMdsalBld.build());
+
+ // insert flow+flowId into local registry
+ final FlowRegistryKey flowRegKey = FlowRegistryKeyFactory.create(flowRemovedMdsalBld.build());
+ final FlowDescriptor flowDescriptor = FlowDescriptorFactory.create((short) 0, new FlowId("ut-ofp:f456"));
+ deviceContext.getDeviceFlowRegistry().store(flowRegKey, flowDescriptor);
+
+ // plug in lifecycleListener
+ final ItemLifecycleListener itemLifecycleListener = Mockito.mock(ItemLifecycleListener.class);
+ for (final ItemLifeCycleSource lifeCycleSource : deviceContext.getItemLifeCycleSourceRegistry().getLifeCycleSources()) {
+ lifeCycleSource.setItemLifecycleListener(itemLifecycleListener);
+ }
+
+ // prepare empty input message
+ final FlowRemovedMessageBuilder flowRemovedBld = new FlowRemovedMessageBuilder();
+
+ // prepare path to flow to be removed
+ final KeyedInstanceIdentifier<Flow, FlowKey> flowToBeRemovedPath = nodeKeyIdent
+ .augmentation(FlowCapableNode.class)
+ .child(Table.class, new TableKey((short) 0))
+ .child(Flow.class, new FlowKey(new FlowId("ut-ofp:f456")));
+
+ deviceContext.setNotificationPublishService(mockedNotificationPublishService);
+ deviceContext.processFlowRemovedMessage(flowRemovedBld.build());
+ Mockito.verify(itemLifecycleListener).onRemoved(flowToBeRemovedPath);
+ }
+
+ @Test
+ public void testProcessExperimenterMessage() {
+ final ConvertorMessageFromOFJava mockedMessageConverter = mock(ConvertorMessageFromOFJava.class);
+ final ExtensionConverterProvider mockedExtensionConverterProvider = mock(ExtensionConverterProvider.class);
+ when(mockedExtensionConverterProvider.getMessageConverter(any(MessageTypeKey.class))).thenReturn(mockedMessageConverter);
+
+ final ExperimenterDataOfChoice mockedExperimenterDataOfChoice = mock(ExperimenterDataOfChoice.class);
+ final ExperimenterMessage experimenterMessage = new ExperimenterMessageBuilder()
+ .setExperimenterDataOfChoice(mockedExperimenterDataOfChoice).build();
+
+ final NotificationPublishService mockedNotificationPublishService = mock(NotificationPublishService.class);
+
+ deviceContext.setNotificationPublishService(mockedNotificationPublishService);
+ ((DeviceContextImpl) deviceContext).setExtensionConverterProvider(mockedExtensionConverterProvider);
+ deviceContext.processExperimenterMessage(experimenterMessage);
+
+ verify(mockedNotificationPublishService).offerNotification(any(ExperimenterMessageFromDev.class));
+ }
+
+ @Test
+ public void testOnDeviceDisconnected() throws Exception {
+ final DeviceTerminationPhaseHandler deviceContextClosedHandler = mock(DeviceTerminationPhaseHandler.class);
+
+ assertEquals(0, deviceContext.getDeviceFlowRegistry().getAllFlowDescriptors().size());
+ assertEquals(0, deviceContext.getDeviceGroupRegistry().getAllGroupIds().size());
+ assertEquals(0, deviceContext.getDeviceMeterRegistry().getAllMeterIds().size());
+
+ }
+
+ @Test
+ public void testOnClusterRoleChange() throws Exception {
+
+ // test call transactionChainManager.deactivateTransactionManager()
+ Assert.assertNull(deviceContextSpy.onClusterRoleChange(OfpRole.NOCHANGE).get());
+
+ // test call MdSalRegistrationUtils.unregisterServices(rpcContext)
+ final RpcContext rpcContext = mock(RpcContext.class);
+ deviceContextSpy.setRpcContext(rpcContext);
+ Assert.assertNull(deviceContextSpy.onClusterRoleChange(OfpRole.NOCHANGE).get());
+
+ final StatisticsContext statisticsContext = mock(StatisticsContext.class);
+ deviceContextSpy.setStatisticsContext(statisticsContext);
+
+ deviceContextSpy.onClusterRoleChange(OfpRole.BECOMEMASTER);
+ verify(deviceContextSpy).onDeviceTakeClusterLeadership();
+
+ Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ deviceContextSpy.onClusterRoleChange(OfpRole.BECOMESLAVE);
+ }