public void Dispose_disposes_created_proxies()
{
var stream = new LoopbackTcpStream(
5,
1,
0,
5,
(byte)CommandType.Connect,
0,
(byte)AddressType.Ipv4,
1,
2,
3,
4,
0,
255);
var proxyFactory = new FakeProxyFactory();
var proxy = new FakeProxy();
proxyFactory.NextTcpProxyToReturn = proxy;
using (var connection = new SocksConnection(
stream,
proxyFactory,
ArrayPool <byte> .Shared,
new NullLoggerFactory()))
{
connection.StartHandlingClient();
proxy.WaitForRunAsyncCall();
}
proxy.IsDisposed.Should().BeTrue();
}
public void Proxy_terminates_with_dispose()
{
using (var clientStream = new LoopbackTcpStream())
{
var boundUdpClient = new FakeUdpClient();
var relayingUdpClient = new FakeUdpClient();
var timerFactory = new ManuallyInvokedTimerFactory();
var bufferPool = new DebugArrayPool <byte>();
var interceptor = A.Fake <IDatagramInterceptor>();
using (var proxy = new UdpProxy(
clientStream,
new FakeUdpClientFactory(boundUdpClient, relayingUdpClient),
interceptor,
bufferPool,
timerFactory,
new NullLoggerFactory()))
{
var task = proxy.RunAsync(CancellationToken.None);
proxy.Dispose();
task.Awaiting(x => x).Should().Throw <Exception>();
}
A.CallTo(() => interceptor.Dispose()).MustHaveHappenedOnceExactly();
}
}
public void Dispose_aborts_pending_read()
{
var stream = new LoopbackTcpStream();
var readTask = stream.ReadAsync(new byte[1], 0, 1);
stream.Dispose();
readTask.Awaiting(t => t).Should().Throw <Exception>();
}
public async Task Written_bytes_can_be_retrieved()
{
using (var stream = new LoopbackTcpStream())
{
var bytes = new byte[] { 1, 2, 3, 4, 5 };
await stream.WriteAsync(bytes, 0, bytes.Length).ConfigureAwait(true);
stream.GetAllWrittenBytes().Should().Equal(1, 2, 3, 4, 5);
}
}
public void Staging_bytes_makes_them_available_in_sync_read()
{
using (var stream = new LoopbackTcpStream())
{
stream.StageReadBytes(1, 2, 3);
var buffer = new byte[10];
stream.Read(buffer, 0, 3).Should().Be(3);
buffer.Take(3).Should().Equal(1, 2, 3);
}
}
public async Task Staging_bytes_makes_them_available_in_async_read()
{
using (var stream = new LoopbackTcpStream())
{
stream.StageReadBytes(1, 2, 3);
var buffer = new byte[10];
var readBytes = await stream.ReadAsync(buffer, 0, 3).ConfigureAwait(true);
readBytes.Should().Be(3);
buffer.Take(3).Should().Equal(1, 2, 3);
}
}
public void Responds_to_unsupported_authentication_method_with_failure()
{
using (var stream = new LoopbackTcpStream(5, 1, 254))
using (var connection = new SocksConnection(
stream,
new FakeProxyFactory(),
ArrayPool <byte> .Shared,
new NullLoggerFactory()))
{
connection.StartHandlingClient();
stream.WaitForWrittenBytes(2).Should().Equal(5, 255);
}
}
public void Assumes_ownership_of_stream_and_disposes_it()
{
var stream = new LoopbackTcpStream(5, 1, 254);
using (var connection = new SocksConnection(
stream,
new FakeProxyFactory(),
ArrayPool <byte> .Shared,
new NullLoggerFactory()))
{
connection.StartHandlingClient();
stream.WaitForWrittenBytes(2).Should().Equal(5, 255);
}
stream.IsDisposed.Should().BeTrue();
}
public void Proxy_terminates_with_client_stream_termination()
{
using (var clientStream = new LoopbackTcpStream())
{
var boundUdpClient = new FakeUdpClient();
var relayingUdpClient = new FakeUdpClient();
var timerFactory = new ManuallyInvokedTimerFactory();
var bufferPool = new DebugArrayPool <byte>();
using (var proxy = new UdpProxy(
clientStream,
new FakeUdpClientFactory(boundUdpClient, relayingUdpClient),
new PassthroughInterceptor(),
bufferPool,
timerFactory,
new NullLoggerFactory()))
{
var task = proxy.RunAsync(CancellationToken.None);
clientStream.Dispose();
task.Awaiting(x => x).Should().Throw <Exception>();
}
}
}
public void Responds_to_invalid_address_type_with_failure()
{
using (var stream = new LoopbackTcpStream(
5,
1,
0,
5,
(byte)CommandType.Connect,
0,
254,
1,
2,
3,
4,
0,
255))
using (var connection = new SocksConnection(
stream,
new FakeProxyFactory(),
ArrayPool <byte> .Shared,
new NullLoggerFactory()))
{
connection.StartHandlingClient();
stream.WaitForWrittenBytes(2).Should().Equal(5, 0);
stream.WaitForWrittenBytes(10).Should().Equal(
5,
(byte)CommandReplyType.AddressTypeNotSupported,
0,
1,
0,
0,
0,
0,
0,
0);
}
}
public async Task Proxy_streams_in_both_directions()
{
using (var clientStream = new LoopbackTcpStream(1, 2, 3, 4, 5))
using (var remoteStream = new LoopbackTcpStream(10, 9, 8, 7, 6))
{
var connector = remoteStream.GetConnector();
clientStream.Write(200, 199, 198, 197, 196);
remoteStream.Write(100, 99, 98, 97, 96);
clientStream.CloseStagedBytesSender();
remoteStream.CloseStagedBytesSender();
using (var proxy = new TcpProxy(
clientStream,
FakeEndPoints.CreateRemote(),
connector,
this._bufferPool))
{
await proxy.RunAsync(CancellationToken.None).ConfigureAwait(true);
}
clientStream.GetAllWrittenBytes().Should().Equal(200, 199, 198, 197, 196, 10, 9, 8, 7, 6);
remoteStream.GetAllWrittenBytes().Should().Equal(100, 99, 98, 97, 96, 1, 2, 3, 4, 5);
}
}
