* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.nettyutil.handler.ssh.client;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyBoolean;
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Matchers.anyString;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyObject;
+import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.EventLoop;
import java.io.IOException;
import java.net.SocketAddress;
-import org.apache.sshd.ClientChannel;
-import org.apache.sshd.ClientSession;
-import org.apache.sshd.SshClient;
+import org.apache.sshd.client.SshClient;
import org.apache.sshd.client.channel.ChannelSubsystem;
+import org.apache.sshd.client.channel.ClientChannel;
import org.apache.sshd.client.future.AuthFuture;
import org.apache.sshd.client.future.ConnectFuture;
import org.apache.sshd.client.future.OpenFuture;
+import org.apache.sshd.client.session.ClientSession;
import org.apache.sshd.common.future.CloseFuture;
import org.apache.sshd.common.future.SshFuture;
import org.apache.sshd.common.future.SshFutureListener;
import org.apache.sshd.common.io.IoOutputStream;
import org.apache.sshd.common.io.IoReadFuture;
import org.apache.sshd.common.io.IoWriteFuture;
-import org.apache.sshd.common.util.Buffer;
+import org.apache.sshd.common.util.buffer.Buffer;
+import org.apache.sshd.common.util.buffer.ByteArrayBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
-import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
public class AsyncSshHandlerTest {
public void onSuccess(final SshFutureListener<AuthFuture> result) {
sshAuthListener = result;
}
- });
+ }, MoreExecutors.directExecutor());
doReturn(authFuture).when(authHandler).authenticate(any(ClientSession.class));
}
private static <T extends SshFuture<T>> ListenableFuture<SshFutureListener<T>> stubAddListener(final T future) {
final SettableFuture<SshFutureListener<T>> listenerSettableFuture = SettableFuture.create();
- doAnswer(new Answer<Object>() {
- @Override
- public Object answer(final InvocationOnMock invocation) throws Throwable {
- listenerSettableFuture.set((SshFutureListener<T>) invocation.getArguments()[0]);
- return null;
- }
+ doAnswer(invocation -> {
+ listenerSettableFuture.set((SshFutureListener<T>) invocation.getArguments()[0]);
+ return null;
}).when(future).addListener(any(SshFutureListener.class));
return listenerSettableFuture;
doReturn(Boolean.TRUE).when(eventLoop).inEventLoop();
}
- private void stubSshClient() {
+ private void stubSshClient() throws IOException {
doNothing().when(sshClient).start();
final ConnectFuture connectFuture = mock(ConnectFuture.class);
Futures.addCallback(stubAddListener(connectFuture), new SuccessFutureListener<ConnectFuture>() {
public void onSuccess(final SshFutureListener<ConnectFuture> result) {
sshConnectListener = result;
}
- });
+ }, MoreExecutors.directExecutor());
doReturn(connectFuture).when(sshClient).connect("usr", remoteAddress);
}
@Override
public void onSuccess(final SshFutureListener<IoReadFuture> result) {
doReturn(new IllegalStateException()).when(mockedReadFuture).getException();
- doReturn(mockedReadFuture).when(mockedReadFuture)
- .removeListener(Matchers.<SshFutureListener<IoReadFuture>>any());
+ doReturn(mockedReadFuture).when(mockedReadFuture).removeListener(any());
doReturn(true).when(asyncOut).isClosing();
doReturn(true).when(asyncOut).isClosed();
result.operationComplete(mockedReadFuture);
}
- });
+ }, MoreExecutors.directExecutor());
final IoOutputStream asyncIn = getMockedIoOutputStream();
final ChannelSubsystem subsystemChannel = getMockedSubsystemChannel(asyncOut, asyncIn);
@Override
public void onSuccess(final SshFutureListener<IoReadFuture> result) {
doReturn(new IllegalStateException()).when(mockedReadFuture).getException();
- doReturn(mockedReadFuture).when(mockedReadFuture)
- .removeListener(Matchers.<SshFutureListener<IoReadFuture>>any());
+ doReturn(mockedReadFuture).when(mockedReadFuture).removeListener(any());
result.operationComplete(mockedReadFuture);
}
- });
+ }, MoreExecutors.directExecutor());
final IoOutputStream asyncIn = getMockedIoOutputStream();
final ChannelSubsystem subsystemChannel = getMockedSubsystemChannel(asyncOut, asyncIn);
final IoInputStream asyncOut = getMockedIoInputStream();
final IoOutputStream asyncIn = getMockedIoOutputStream();
- final IoWriteFuture ioWriteFuture = asyncIn.write(null);
+ final IoWriteFuture ioWriteFuture = asyncIn.writePacket(new ByteArrayBuffer());
Futures.addCallback(stubAddListener(ioWriteFuture), new SuccessFutureListener<IoWriteFuture>() {
@Override
doReturn(true).when(asyncIn).isClosed();
result.operationComplete(ioWriteFuture);
}
- });
+ }, MoreExecutors.directExecutor());
final ChannelSubsystem subsystemChannel = getMockedSubsystemChannel(asyncOut, asyncIn);
final ClientSession sshSession = getMockedSshSession(subsystemChannel);
final IoInputStream asyncOut = getMockedIoInputStream();
final IoOutputStream asyncIn = getMockedIoOutputStream();
- final IoWriteFuture ioWriteFuture = asyncIn.write(null);
+ final IoWriteFuture ioWriteFuture = asyncIn.writePacket(new ByteArrayBuffer());
final ChannelSubsystem subsystemChannel = getMockedSubsystemChannel(asyncOut, asyncIn);
final ClientSession sshSession = getMockedSshSession(subsystemChannel);
final ChannelPromise secondWritePromise = getMockedPromise();
// now make write throw pending exception
- doThrow(org.apache.sshd.common.io.WritePendingException.class).when(asyncIn).write(any(Buffer.class));
+ doThrow(org.apache.sshd.common.io.WritePendingException.class).when(asyncIn).writePacket(any(Buffer.class));
asyncSshHandler.write(ctx, Unpooled.copiedBuffer(new byte[]{0, 1, 2, 3, 4, 5}), secondWritePromise);
- doReturn(ioWriteFuture).when(asyncIn).write(any(Buffer.class));
+ doReturn(ioWriteFuture).when(asyncIn).writePacket(any(Buffer.class));
verifyZeroInteractions(firstWritePromise, secondWritePromise);
final IoInputStream asyncOut = getMockedIoInputStream();
final IoOutputStream asyncIn = getMockedIoOutputStream();
- final IoWriteFuture ioWriteFuture = asyncIn.write(null);
+ final IoWriteFuture ioWriteFuture = asyncIn.writePacket(new ByteArrayBuffer());
final ChannelSubsystem subsystemChannel = getMockedSubsystemChannel(asyncOut, asyncIn);
final ClientSession sshSession = getMockedSshSession(subsystemChannel);
final ChannelPromise secondWritePromise = getMockedPromise();
// now make write throw pending exception
- doThrow(org.apache.sshd.common.io.WritePendingException.class).when(asyncIn).write(any(Buffer.class));
+ doThrow(org.apache.sshd.common.io.WritePendingException.class).when(asyncIn).writePacket(any(Buffer.class));
for (int i = 0; i < 1001; i++) {
asyncSshHandler.write(ctx, Unpooled.copiedBuffer(new byte[]{0, 1, 2, 3, 4, 5}), secondWritePromise);
}
doReturn(true).when(closeFuture).isClosed();
result.operationComplete(closeFuture);
}
- });
+ }, MoreExecutors.directExecutor());
doReturn(closeFuture).when(sshSession).close(false);
doReturn(subsystemChannel).when(sshSession).createSubsystemChannel(anyString());
public void onSuccess(final SshFutureListener<OpenFuture> result) {
sshChannelOpenListener = result;
}
- });
+ }, MoreExecutors.directExecutor());
doReturn(asyncOut).when(subsystemChannel).getAsyncOut();
return subsystemChannel;
}
- private static IoOutputStream getMockedIoOutputStream() {
+ private static IoOutputStream getMockedIoOutputStream() throws IOException {
final IoOutputStream mock = mock(IoOutputStream.class);
final IoWriteFuture ioWriteFuture = mock(IoWriteFuture.class);
- doReturn(ioWriteFuture).when(ioWriteFuture).addListener(Matchers.<SshFutureListener<IoWriteFuture>>any());
+ doReturn(ioWriteFuture).when(ioWriteFuture).addListener(any());
doReturn(true).when(ioWriteFuture).isWritten();
Futures.addCallback(stubAddListener(ioWriteFuture), new SuccessFutureListener<IoWriteFuture>() {
public void onSuccess(final SshFutureListener<IoWriteFuture> result) {
result.operationComplete(ioWriteFuture);
}
- });
+ }, MoreExecutors.directExecutor());
- doReturn(ioWriteFuture).when(mock).write(any(Buffer.class));
+ doReturn(ioWriteFuture).when(mock).writePacket(any(Buffer.class));
doReturn(false).when(mock).isClosed();
doReturn(false).when(mock).isClosing();
return mock;
final IoInputStream mock = mock(IoInputStream.class);
final IoReadFuture ioReadFuture = mock(IoReadFuture.class);
doReturn(null).when(ioReadFuture).getException();
- doReturn(ioReadFuture).when(ioReadFuture).removeListener(Matchers.<SshFutureListener<IoReadFuture>>any());
+ doReturn(ioReadFuture).when(ioReadFuture).removeListener(any());
+ doReturn(ioReadFuture).when(mock).read(any());
doReturn(5).when(ioReadFuture).getRead();
- doReturn(new Buffer(new byte[]{0, 1, 2, 3, 4})).when(ioReadFuture).getBuffer();
- doReturn(ioReadFuture).when(ioReadFuture).addListener(Matchers.<SshFutureListener<IoReadFuture>>any());
+ doReturn(new ByteArrayBuffer(new byte[]{0, 1, 2, 3, 4})).when(ioReadFuture).getBuffer();
+ doReturn(ioReadFuture).when(ioReadFuture).addListener(any());
// Always success for read
Futures.addCallback(stubAddListener(ioReadFuture), new SuccessFutureListener<IoReadFuture>() {
public void onSuccess(final SshFutureListener<IoReadFuture> result) {
result.operationComplete(ioReadFuture);
}
- });
+ }, MoreExecutors.directExecutor());
doReturn(ioReadFuture).when(mock).read(any(Buffer.class));
doReturn(false).when(mock).isClosed();