- Use final var for variables.
- Move variables closer to their actual usage.
- Use Exception in tests.
- Move class attributes to local variable if it is possible.
- Use 4 tab continuation indent.
Change-Id: Icdae07a71d0f24e38f12bcebb7ea74438e0b11a4
Signed-off-by: Peter Suna <peter.suna@pantheon.tech>
import org.opendaylight.netconf.shaded.sshd.client.session.ClientSessionImpl;
public class CallHomeAuthorizationTest {
+
@Test
public void anAuthorizationOfRejectedIsNotAllowed() {
// given
- CallHomeAuthorization auth = CallHomeAuthorization.rejected();
+ final var auth = CallHomeAuthorization.rejected();
// expect
assertFalse(auth.isServerAllowed());
}
@Test
public void anAuthorizationOfRejectedCannotBeAppliedToASession() {
// given
- CallHomeAuthorization auth = CallHomeAuthorization.rejected();
+ final var auth = CallHomeAuthorization.rejected();
// when
final var ex = assertThrows(IllegalStateException.class, () -> auth.applyTo(mock(ClientSession.class)));
assertEquals("Server is not allowed.", ex.getMessage());
@Test
public void anAuthorizationOfAcceptanceIsAllowed() {
// given
- String session = "some-session";
- String user = "some-user-name";
- ClientSessionImpl mockSession = mock(ClientSessionImpl.class);
+ final var session = "some-session";
+ final var user = "some-user-name";
+ final var mockSession = mock(ClientSessionImpl.class);
doNothing().when(mockSession).setUsername(user);
// and
- CallHomeAuthorization auth = CallHomeAuthorization.serverAccepted(session, user).build();
+ final var auth = CallHomeAuthorization.serverAccepted(session, user).build();
// when
auth.applyTo(mockSession);
// then
@Test
public void anAuthorizationOfAcceptanceCanBeAppliedToASession() {
// given
- String session = "some-session";
- String user = "some-user-name";
- String pwd = "pwd1";
- KeyPair pair = new KeyPair(mock(PublicKey.class), mock(PrivateKey.class));
- ClientSessionImpl mockSession = mock(ClientSessionImpl.class);
+ final var session = "some-session";
+ final var user = "some-user-name";
+ final var pwd = "pwd1";
+ final var mockSession = mock(ClientSessionImpl.class);
doNothing().when(mockSession).setUsername(user);
doNothing().when(mockSession).addPasswordIdentity(pwd);
+ final var pair = new KeyPair(mock(PublicKey.class), mock(PrivateKey.class));
doNothing().when(mockSession).addPublicKeyIdentity(pair);
// and
- CallHomeAuthorization auth = CallHomeAuthorization.serverAccepted(session, user)
- .addPassword(pwd)
- .addClientKeys(pair)
- .build();
+ final var auth = CallHomeAuthorization.serverAccepted(session, user)
+ .addPassword(pwd)
+ .addClientKeys(pair)
+ .build();
// when
auth.applyTo(mockSession);
// then
import io.netty.channel.ChannelPipeline;
import io.netty.channel.DefaultChannelPipeline;
import io.netty.channel.EventLoopGroup;
-import java.io.IOException;
import java.net.InetSocketAddress;
import java.security.PublicKey;
import org.junit.Before;
import org.junit.Test;
+import org.opendaylight.netconf.callhome.protocol.CallHomeSessionContext.Factory;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
import org.opendaylight.netconf.client.NetconfClientSessionNegotiatorFactory;
import org.opendaylight.netconf.nettyutil.handler.ssh.client.NetconfClientSessionImpl;
private NetconfClientSessionImpl mockSession;
private CallHomeAuthorization mockAuth;
private ClientChannel mockChannel;
- private InetSocketAddress address;
-
- private ReverseSshChannelInitializer mockChannelInitializer;
- private CallHomeNetconfSubsystemListener subListener;
private EventLoopGroup mockNettyGroup;
- private CallHomeSessionContext.Factory realFactory;
+ private Factory realFactory;
private CallHomeSessionContext instance;
- private NetconfClientSessionNegotiatorFactory mockNegotiatior;
@Before
public void setup() {
mockSession = mock(NetconfClientSessionImpl.class);
mockAuth = mock(CallHomeAuthorization.class);
mockChannel = mock(ClientChannel.class);
- address = mock(InetSocketAddress.class);
- mockNegotiatior = mock(NetconfClientSessionNegotiatorFactory.class);
- subListener = mock(CallHomeNetconfSubsystemListener.class);
+ final var mockNegotiatior = mock(NetconfClientSessionNegotiatorFactory.class);
+ final var subListener = mock(CallHomeNetconfSubsystemListener.class);
mockNettyGroup = mock(EventLoopGroup.class);
+ realFactory = new Factory(mockNettyGroup, mockNegotiatior, subListener);
- realFactory = new CallHomeSessionContext.Factory(mockNettyGroup, mockNegotiatior, subListener);
-
- KeyExchange kexMock = mock(KeyExchange.class);
+ final var kexMock = mock(KeyExchange.class);
doReturn(kexMock).when(mockSession).getKex();
-
- PublicKey keyMock = mock(PublicKey.class);
+ final var keyMock = mock(PublicKey.class);
doReturn(keyMock).when(mockSession).getServerKey();
- IoReadFuture mockFuture = mock(IoReadFuture.class);
- IoInputStream mockIn = mock(IoInputStream.class);
- doReturn(mockFuture).when(mockIn).read(any(Buffer.class));
- IoOutputStream mockOut = mock(IoOutputStream.class);
+ final var mockFuture = mock(IoReadFuture.class);
+ final var mockIn = mock(IoInputStream.class);
+ doReturn(mockFuture).when(mockIn).read(any(Buffer.class));
+ final var mockOut = mock(IoOutputStream.class);
doReturn(mockIn).when(mockChannel).getAsyncOut();
doReturn(mockOut).when(mockChannel).getAsyncIn();
- doReturn(true).when(mockAuth).isServerAllowed();
-
- IoSession ioSession = mock(IoSession.class);
+ final var ioSession = mock(IoSession.class);
doReturn(ioSession).when(mockSession).getIoSession();
+ final var address = mock(InetSocketAddress.class);
doReturn(address).when(ioSession).getRemoteAddress();
doReturn(null).when(mockSession).setAttribute(any(AttributeKey.class), any());
doReturn(null).when(mockSession).getAttribute(any(AttributeKey.class));
doReturn("testSession").when(mockSession).toString();
+ doReturn(true).when(mockAuth).isServerAllowed();
doNothing().when(mockAuth).applyTo(mockSession);
doReturn("test").when(mockAuth).getSessionName();
}
}
@Test
- public void anAuthorizeActionShouldApplyToTheBoundSession() throws IOException {
+ public void anAuthorizeActionShouldApplyToTheBoundSession() throws Exception {
instance = realFactory.createIfNotExists(mockSession, mockAuth);
// when
doReturn(null).when(mockSession).auth();
}
@Test
- public void creatingAChannelSuccessfullyShouldResultInAnAttachedListener() throws IOException {
+ public void creatingAChannelSuccessfullyShouldResultInAnAttachedListener() throws Exception {
// given
- OpenFuture mockFuture = mock(OpenFuture.class);
- NettyPipelineAwareChannelSubsystem mockChannelSubsystem = mock(NettyPipelineAwareChannelSubsystem.class);
+ final var mockFuture = mock(OpenFuture.class);
+ final var mockChannelSubsystem = mock(NettyPipelineAwareChannelSubsystem.class);
doReturn(mockFuture).when(mockChannelSubsystem).open();
doReturn(mockChannelSubsystem).when(mockSession).createSubsystemChannel(anyString(),
- any(DefaultChannelPipeline.class));
+ any(DefaultChannelPipeline.class));
doReturn(null).when(mockFuture).addListener(any(SshFutureListener.class));
doNothing().when(mockChannelSubsystem).setStreaming(any(StreamingChannel.Streaming.class));
@Test
public void openingTheChannelSuccessfullyNotifyTheChannelListener() {
// given
- MinaSshNettyChannel mockMinaChannel = mock(MinaSshNettyChannel.class);
- CallHomeSessionContext.Factory mockFactory = mock(CallHomeSessionContext.Factory.class);
-
- CallHomeNetconfSubsystemListener mockListener = mock(CallHomeNetconfSubsystemListener.class);
+ final var mockListener = mock(CallHomeNetconfSubsystemListener.class);
doNothing().when(mockListener).onNetconfSubsystemOpened(any(CallHomeProtocolSessionContext.class),
- any(CallHomeChannelActivator.class));
+ any(CallHomeChannelActivator.class));
- ChannelFuture mockChanFuture = mock(ChannelFuture.class);
+ final var mockChanFuture = mock(ChannelFuture.class);
doReturn(mockChanFuture).when(mockNettyGroup).register(any(Channel.class));
+ final var mockFactory = mock(Factory.class);
doReturn(mockNettyGroup).when(mockFactory).getNettyGroup();
+ final var mockChannelInitializer = mock(ReverseSshChannelInitializer.class);
doReturn(mockChannelInitializer).when(mockFactory)
- .getChannelInitializer(any(NetconfClientSessionListener.class));
+ .getChannelInitializer(any(NetconfClientSessionListener.class));
doReturn(mockListener).when(mockFactory).getChannelOpenListener();
- ChannelPipeline mockPipeline = mock(ChannelPipeline.class);
+ final var mockPipeline = mock(ChannelPipeline.class);
+ final var mockMinaChannel = mock(MinaSshNettyChannel.class);
doReturn(mockPipeline).when(mockMinaChannel).pipeline();
- OpenFuture mockFuture = mock(OpenFuture.class);
+ final var mockFuture = mock(OpenFuture.class);
doReturn(true).when(mockFuture).isOpened();
instance = spy(new CallHomeSessionContext(mockSession, mockAuth, mockFactory));
doReturn(mockMinaChannel).when(instance).newMinaSshNettyChannel();
- SshFutureListener<OpenFuture> listener = instance.newSshFutureListener(mockChannel, mockMinaChannel);
+ final var listener = instance.newSshFutureListener(mockChannel, mockMinaChannel);
// when
listener.operationComplete(mockFuture);
// then
verify(mockListener, times(1)).onNetconfSubsystemOpened(any(CallHomeProtocolSessionContext.class),
- any(CallHomeChannelActivator.class));
+ any(CallHomeChannelActivator.class));
}
@Test
public void failureToOpenTheChannelShouldCauseTheSessionToClose() {
// given
instance = realFactory.createIfNotExists(mockSession, mockAuth);
- OpenFuture mockFuture = mock(OpenFuture.class);
+ final var mockFuture = mock(OpenFuture.class);
doReturn(false).when(mockFuture).isOpened();
doReturn(new RuntimeException("test")).when(mockFuture).getException();
-
doReturn(null).when(mockSession).close(anyBoolean());
// when
- SshFutureListener<OpenFuture> listener = instance.newSshFutureListener(mockChannel, null);
+ final var listener = instance.newSshFutureListener(mockChannel, null);
listener.operationComplete(mockFuture);
// then
// You'll see an error message logged to the console - it is expected.
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.buffer.EmptyByteBuf;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelOutboundHandlerAdapter;
import io.netty.channel.ChannelPromise;
-import java.io.IOException;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.netconf.callhome.protocol.CallHomeSessionContext.SshWriteAsyncHandlerAdapter;
private MinaSshNettyChannel instance;
@Before
- public void setup() throws IOException {
- IoReadFuture mockFuture = mock(IoReadFuture.class);
- IoInputStream mockIn = mock(IoInputStream.class);
+ public void setup() throws Exception {
+ final var mockFuture = mock(IoReadFuture.class);
+ final var mockIn = mock(IoInputStream.class);
doReturn(mockFuture).when(mockIn).read(any(Buffer.class));
+ doReturn(mockFuture).when(mockFuture).addListener(any());
mockContext = mock(CallHomeSessionContext.class);
mockSession = mock(ClientSession.class);
mockChannel = mock(ClientChannel.class);
doReturn(mockIn).when(mockChannel).getAsyncOut();
- IoOutputStream mockOut = mock(IoOutputStream.class);
+ final var mockOut = mock(IoOutputStream.class);
doReturn(mockOut).when(mockChannel).getAsyncIn();
-
- IoWriteFuture mockWrFuture = mock(IoWriteFuture.class);
doReturn(false).when(mockOut).isClosed();
doReturn(false).when(mockOut).isClosing();
+
+ final var mockWrFuture = mock(IoWriteFuture.class);
doReturn(mockWrFuture).when(mockOut).writeBuffer(any(Buffer.class));
doReturn(null).when(mockWrFuture).addListener(any());
- doReturn(mockFuture).when(mockFuture).addListener(any());
-
instance = new MinaSshNettyChannel(mockContext, mockSession);
}
@Test
public void ourChannelHandlerShouldForwardWrites() throws Exception {
- ChannelHandler mockHandler = mock(ChannelHandler.class);
- ChannelHandlerContext ctx = mock(ChannelHandlerContext.class);
+ final var mockHandler = mock(ChannelHandler.class);
+ final var ctx = mock(ChannelHandlerContext.class);
doReturn(mockHandler).when(ctx).handler();
- ChannelPromise promise = mock(ChannelPromise.class);
+ final var promise = mock(ChannelPromise.class);
// we would really like to just verify that the async handler write() was
// called but it is a final class, so no mocking. instead we set up the
instance.pipeline().addFirst(new SshWriteAsyncHandlerAdapter(mockChannel));
// when
- ChannelOutboundHandlerAdapter outadapter = (ChannelOutboundHandlerAdapter) instance.pipeline().first();
- ByteBufAllocator mockAlloc = mock(ByteBufAllocator.class);
- ByteBuf bytes = new EmptyByteBuf(mockAlloc);
+ final var outadapter = (ChannelOutboundHandlerAdapter) instance.pipeline().first();
+ final var mockAlloc = mock(ByteBufAllocator.class);
+ final var bytes = new EmptyByteBuf(mockAlloc);
outadapter.write(ctx, bytes, promise);
// then
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
-import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.security.PublicKey;
}
@Test
- public void sessionListenerShouldHandleEventsOfKeyEstablishedAndAuthenticated() throws IOException {
+ public void sessionListenerShouldHandleEventsOfKeyEstablishedAndAuthenticated() throws Exception {
// Weird - IJ was ok but command line compile failed using the usual array initializer syntax ????
- SessionListener.Event[] evt = new SessionListener.Event[2];
+ final var evt = new SessionListener.Event[2];
evt[0] = SessionListener.Event.KeyEstablished;
evt[1] = SessionListener.Event.Authenticated;
- int[] hitOpen = new int[2];
+ final var hitOpen = new int[2];
hitOpen[0] = 0;
hitOpen[1] = 1;
- int[] hitAuth = new int[2];
+ final var hitAuth = new int[2];
hitAuth[0] = 1;
hitAuth[1] = 0;
- for (int pass = 0; pass < evt.length; pass++) {
+ for (var pass = 0; pass < evt.length; pass++) {
// given
- AuthFuture mockAuthFuture = mock(AuthFuture.class);
+ final var mockAuthFuture = mock(AuthFuture.class);
doReturn(null).when(mockAuthFuture).addListener(any(SshFutureListener.class));
- CallHomeSessionContext mockContext = mock(CallHomeSessionContext.class);
+ final var mockContext = mock(CallHomeSessionContext.class);
doNothing().when(mockContext).openNetconfChannel();
doReturn(mockContext).when(mockSession).getAttribute(any(Session.AttributeKey.class));
- final PublicKey serverKey = mock(PublicKey.class);
+ final var serverKey = mock(PublicKey.class);
doReturn(serverKey).when(mockSession).getServerKey();
- final SessionListener listener = instance.createSessionListener();
+ final var listener = instance.createSessionListener();
doReturn(mockAuthFuture).when(mockContext).authorize();
doReturn(false).when(mockSession).isAuthenticated();
// when
@Test
public void verificationOfTheServerKeyShouldBeSuccessfulForServerIsAllowed() {
// given
- ClientSessionImpl mockClientSession = mock(ClientSessionImpl.class);
+ final var mockClientSession = mock(ClientSessionImpl.class);
doReturn("test").when(mockClientSession).toString();
- SocketAddress mockSocketAddr = mock(SocketAddress.class);
- PublicKey mockPublicKey = mock(PublicKey.class);
+ final var mockSocketAddr = mock(SocketAddress.class);
+ final var mockPublicKey = mock(PublicKey.class);
doReturn(true).when(mockAuth).isServerAllowed();
doReturn("some-session-name").when(mockAuth).getSessionName();
public void verificationOfTheServerKeyShouldFailIfTheServerIsNotAllowed() {
// given
- ClientSessionImpl mockClientSession = mock(ClientSessionImpl.class);
- SocketAddress mockSocketAddr = mock(SocketAddress.class);
- PublicKey mockPublicKey = mock(PublicKey.class);
+ final var mockClientSession = mock(ClientSessionImpl.class);
+ final var mockSocketAddr = mock(SocketAddress.class);
+ final var mockPublicKey = mock(PublicKey.class);
doReturn(false).when(mockAuth).isServerAllowed();
doReturn(mockAuth).when(mockCallHomeAuthProv).provideAuth(mockSocketAddr, mockPublicKey);
}
@Test
- public void bindShouldStartTheClientAndBindTheAddress() throws IOException {
+ public void bindShouldStartTheClientAndBindTheAddress() throws Exception {
// given
- IoAcceptor mockAcceptor = mock(IoAcceptor.class);
- IoServiceFactory mockMinaFactory = mock(IoServiceFactory.class);
+ final var mockAcceptor = mock(IoAcceptor.class);
+ final var mockMinaFactory = mock(IoServiceFactory.class);
doReturn(mockAcceptor).when(mockMinaFactory).createAcceptor(any(IoHandler.class));
doNothing().when(mockAcceptor).bind(any(SocketAddress.class));
- NetconfSshClient mockClient = mock(NetconfSshClient.class);
+ final var mockClient = mock(NetconfSshClient.class);
doNothing().when(mockClient).start();
doNothing().when(mockClient).setServerKeyVerifier(any());
doNothing().when(mockClient).addSessionListener(any());
- NetconfCallHomeServer server = new NetconfCallHomeServer(
- mockClient, mockCallHomeAuthProv, mockFactory, MOCK_ADDRESS, mockStatusRecorder, mockMinaFactory);
+ final var server = new NetconfCallHomeServer(mockClient, mockCallHomeAuthProv, mockFactory, MOCK_ADDRESS,
+ mockStatusRecorder, mockMinaFactory);
// when
server.bind();
// then
Code Review / netconf.git / commitdiff