From f3c8035f326d31b86f8759bf2cff6536ac55f401 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Thu, 11 Nov 2021 11:30:47 +0100 Subject: [PATCH] Cleanup AbstractNetconfSessionNegotiatorTest We have stubbing errors and various warnings here, fix them up. Change-Id: I24b2e45583190c93a26cdf25d066505bef911492 Signed-off-by: Robert Varga --- .../AbstractNetconfSessionNegotiatorTest.java | 92 ++++++++++++------- 1 file changed, 60 insertions(+), 32 deletions(-) diff --git a/netconf/netconf-netty-util/src/test/java/org/opendaylight/netconf/nettyutil/AbstractNetconfSessionNegotiatorTest.java b/netconf/netconf-netty-util/src/test/java/org/opendaylight/netconf/nettyutil/AbstractNetconfSessionNegotiatorTest.java index 0bce72c65b..a5a4a2395c 100644 --- a/netconf/netconf-netty-util/src/test/java/org/opendaylight/netconf/nettyutil/AbstractNetconfSessionNegotiatorTest.java +++ b/netconf/netconf-netty-util/src/test/java/org/opendaylight/netconf/nettyutil/AbstractNetconfSessionNegotiatorTest.java @@ -7,12 +7,16 @@ */ package org.opendaylight.netconf.nettyutil; +import static org.hamcrest.CoreMatchers.instanceOf; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.timeout; +import static org.mockito.Mockito.spy; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.opendaylight.netconf.nettyutil.AbstractChannelInitializer.NETCONF_MESSAGE_AGGREGATOR; @@ -27,19 +31,21 @@ import io.netty.channel.ChannelOutboundHandlerAdapter; import io.netty.channel.ChannelPromise; import io.netty.channel.embedded.EmbeddedChannel; import io.netty.handler.ssl.SslHandler; -import io.netty.util.HashedWheelTimer; +import io.netty.util.Timeout; +import io.netty.util.Timer; +import io.netty.util.TimerTask; import io.netty.util.concurrent.Future; import io.netty.util.concurrent.Promise; import java.util.ArrayList; -import java.util.Collections; import java.util.List; import java.util.Optional; -import org.junit.Assert; +import java.util.Set; +import java.util.concurrent.TimeUnit; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; import org.mockito.Mock; -import org.mockito.Mockito; import org.mockito.junit.MockitoJUnitRunner; import org.opendaylight.netconf.api.NetconfSessionListener; import org.opendaylight.netconf.api.NetconfSessionPreferences; @@ -56,22 +62,25 @@ import org.opendaylight.netconf.util.messages.FramingMechanism; @RunWith(MockitoJUnitRunner.StrictStubs.class) public class AbstractNetconfSessionNegotiatorTest { - @Mock private NetconfSessionListener listener; @Mock private Promise promise; @Mock private SslHandler sslHandler; + @Mock + private Timer timer; + @Mock + private Timeout timeout; private EmbeddedChannel channel; - private AbstractNetconfSessionNegotiator negotiator; + private TestSessionNegotiator negotiator; private NetconfHelloMessage hello; private NetconfHelloMessage helloBase11; private NetconfXMLToHelloMessageDecoder xmlToHello; private NetconfSessionPreferences prefs; @Before - public void setUp() throws Exception { + public void setUp() { channel = new EmbeddedChannel(); xmlToHello = new NetconfXMLToHelloMessageDecoder(); channel.pipeline().addLast(AbstractChannelInitializer.NETCONF_MESSAGE_ENCODER, @@ -80,18 +89,19 @@ public class AbstractNetconfSessionNegotiatorTest { channel.pipeline().addLast(NETCONF_MESSAGE_FRAME_ENCODER, FramingMechanismHandlerFactory.createHandler(FramingMechanism.EOM)); channel.pipeline().addLast(NETCONF_MESSAGE_AGGREGATOR, new NetconfEOMAggregator()); - hello = NetconfHelloMessage.createClientHello(Collections.emptySet(), Optional.empty()); - helloBase11 = NetconfHelloMessage.createClientHello(Collections - .singleton(XmlNetconfConstants.URN_IETF_PARAMS_NETCONF_BASE_1_1), Optional.empty()); + hello = NetconfHelloMessage.createClientHello(Set.of(), Optional.empty()); + helloBase11 = NetconfHelloMessage.createClientHello( + Set.of(XmlNetconfConstants.URN_IETF_PARAMS_NETCONF_BASE_1_1), Optional.empty()); prefs = new NetconfSessionPreferences(helloBase11); doReturn(promise).when(promise).setFailure(any()); - negotiator = new TestSessionNegotiator(prefs, promise, channel, new HashedWheelTimer(), listener, 100L); + negotiator = new TestSessionNegotiator(prefs, promise, channel, timer, listener, 100L); } @Test - public void testStartNegotiation() throws Exception { + public void testStartNegotiation() { + enableTimerTask(); negotiator.startNegotiation(); - Assert.assertEquals(helloBase11, channel.readOutbound()); + assertEquals(helloBase11, channel.readOutbound()); } @Test @@ -101,44 +111,53 @@ public class AbstractNetconfSessionNegotiatorTest { doNothing().when(sslHandler).write(any(), any(), any()); final Future handshakeFuture = channel.eventLoop().newSucceededFuture(channel); doReturn(handshakeFuture).when(sslHandler).handshakeFuture(); + doNothing().when(sslHandler).flush(any()); channel.pipeline().addLast(sslHandler); - negotiator.startNegotiation(); - verify(sslHandler, timeout(1000)).write(any(), eq(helloBase11), any()); + enableTimerTask(); + negotiator.startNegotiation(); + verify(sslHandler).write(any(), eq(helloBase11), any()); } @Test public void testStartNegotiationNotEstablished() throws Exception { - final ChannelOutboundHandler closedDetector = Mockito.spy(new CloseDetector()); + final ChannelOutboundHandler closedDetector = spy(new CloseDetector()); channel.pipeline().addLast("closedDetector", closedDetector); doReturn(false).when(promise).isDone(); doReturn(false).when(promise).isCancelled(); + + final ArgumentCaptor captor = ArgumentCaptor.forClass(TimerTask.class); + doReturn(timeout).when(timer).newTimeout(captor.capture(), eq(100L), eq(TimeUnit.MILLISECONDS)); negotiator.startNegotiation(); - verify(closedDetector, timeout(2000)).close(any(), any()); + + captor.getValue().run(timeout); + verify(closedDetector).close(any(), any()); } @Test - public void testGetSessionPreferences() throws Exception { - Assert.assertEquals(prefs, negotiator.getSessionPreferences()); + public void testGetSessionPreferences() { + assertEquals(prefs, negotiator.getSessionPreferences()); } @Test public void testGetSessionForHelloMessage() throws Exception { + enableTimerTask(); negotiator.startNegotiation(); - final AbstractNetconfSession session = negotiator.getSessionForHelloMessage(hello); - Assert.assertNotNull(session); - Assert.assertTrue(channel.pipeline().get(NETCONF_MESSAGE_AGGREGATOR) instanceof NetconfEOMAggregator); - Assert.assertTrue(channel.pipeline().get(NETCONF_MESSAGE_FRAME_ENCODER) instanceof EOMFramingMechanismEncoder); + final TestingNetconfSession session = negotiator.getSessionForHelloMessage(hello); + assertNotNull(session); + assertThat(channel.pipeline().get(NETCONF_MESSAGE_AGGREGATOR), instanceOf(NetconfEOMAggregator.class)); + assertThat(channel.pipeline().get(NETCONF_MESSAGE_FRAME_ENCODER), instanceOf(EOMFramingMechanismEncoder.class)); } @Test public void testGetSessionForHelloMessageBase11() throws Exception { + enableTimerTask(); negotiator.startNegotiation(); - final AbstractNetconfSession session = negotiator.getSessionForHelloMessage(helloBase11); - Assert.assertNotNull(session); - Assert.assertTrue(channel.pipeline().get(NETCONF_MESSAGE_AGGREGATOR) instanceof NetconfChunkAggregator); - Assert.assertTrue(channel.pipeline().get(NETCONF_MESSAGE_FRAME_ENCODER) - instanceof ChunkedFramingMechanismEncoder); + final TestingNetconfSession session = negotiator.getSessionForHelloMessage(helloBase11); + assertNotNull(session); + assertThat(channel.pipeline().get(NETCONF_MESSAGE_AGGREGATOR), instanceOf(NetconfChunkAggregator.class)); + assertThat(channel.pipeline().get(NETCONF_MESSAGE_FRAME_ENCODER), + instanceOf(ChunkedFramingMechanismEncoder.class)); } @Test @@ -147,26 +166,35 @@ public class AbstractNetconfSessionNegotiatorTest { final byte[] msg = "".getBytes(); final ByteBuf msgBuf = Unpooled.wrappedBuffer(msg); final ByteBuf helloBuf = Unpooled.wrappedBuffer(XmlUtil.toString(hello.getDocument()).getBytes()); + + enableTimerTask(); negotiator.startNegotiation(); + xmlToHello.decode(null, helloBuf, out); xmlToHello.decode(null, msgBuf, out); - final AbstractNetconfSession session = mock(AbstractNetconfSession.class); + final TestingNetconfSession session = mock(TestingNetconfSession.class); doNothing().when(session).handleMessage(any()); negotiator.replaceHelloMessageInboundHandler(session); verify(session, times(1)).handleMessage(any()); } @Test - public void testNegotiationFail() throws Exception { + public void testNegotiationFail() { + enableTimerTask(); + doReturn(true).when(timeout).cancel(); negotiator.startNegotiation(); final RuntimeException cause = new RuntimeException("failure cause"); channel.pipeline().fireExceptionCaught(cause); verify(promise).setFailure(cause); } + private void enableTimerTask() { + doReturn(timeout).when(timer).newTimeout(any(), eq(100L), eq(TimeUnit.MILLISECONDS)); + } + private static class CloseDetector extends ChannelOutboundHandlerAdapter { @Override - public void close(ChannelHandlerContext ctx, ChannelPromise promise) { + public void close(final ChannelHandlerContext ctx, final ChannelPromise promise) { // Override needed so @Skip from superclass is not effective } } -- 2.36.6