public async Task DisconnectedEvent_ClientDisconnects_GetsFired()
{
EpoxyTransport transport = MakeTransport();
var listener = transport.MakeListener(localhostEndpoint);
var disconnectedEventDone = new ManualResetEventSlim(initialState: false);
EpoxyConnection disconnectedConnection = null;
listener.Disconnected += (sender, args) =>
{
disconnectedConnection = (EpoxyConnection)args.Connection;
disconnectedEventDone.Set();
};
await listener.StartAsync();
var connection = await transport.ConnectToAsync(localhostAddress);
await connection.StopAsync();
bool wasSignaled = disconnectedEventDone.Wait(TimeSpan.FromSeconds(10));
Assert.IsTrue(wasSignaled, "Timed out waiting for Disconnected event to complete");
Assert.IsNotNull(disconnectedConnection);
Assert.AreEqual(connection.LocalEndPoint, disconnectedConnection.RemoteEndPoint);
}
public async Task ConnectedEvent_HasRightRemoteEndpointDetails()
{
EpoxyTransport transport = MakeTransport();
var listener = transport.MakeListener(localhostEndpoint);
EpoxyConnection remoteConnection = null;
var connectedEventDone = new ManualResetEventSlim(initialState: false);
listener.Connected += (sender, args) =>
{
Assert.AreSame(listener, sender);
remoteConnection = (EpoxyConnection)args.Connection;
connectedEventDone.Set();
};
await listener.StartAsync();
var connection = await transport.ConnectToAsync(localhostAddress);
bool wasSignaled = connectedEventDone.Wait(TimeSpan.FromSeconds(10));
Assert.IsTrue(wasSignaled, "Timed out waiting for Connected event to complete");
Assert.AreEqual(connection.LocalEndPoint, remoteConnection.RemoteEndPoint);
Assert.AreEqual(connection.RemoteEndPoint, remoteConnection.LocalEndPoint);
}
static Task StartServiceListenersAsync(EpoxyTransport transport)
{
// On some systems, "localhost" resolves to an IPv4 address, while
// on others it resolves to an IPv6 address. To make this work on
// both kinds of systems, we create a listener for both loopback
// addresses.
var service = new SimpleService();
EpoxyListener listenerIpv4 = transport.MakeListener(serviceEndpointIpv4);
listenerIpv4.AddService(service);
EpoxyListener listenerIpv6 = transport.MakeListener(serviceEndpointIpv6);
listenerIpv6.AddService(service);
return(Task.WhenAll(listenerIpv4.StartAsync(), listenerIpv6.StartAsync()));
}
public async Task ListenOnPortZero_ActuallyListensOnSomeOtherPort()
{
EpoxyTransport transport = MakeTransport();
var listener = transport.MakeListener(localhostEndpoint);
await listener.StartAsync();
Assert.AreNotEqual(0, listener.ListenEndpoint.Port);
}
public async Task StopAsync_ClosesAllOutstandingConnections()
{
EpoxyTransport transport = MakeTransport();
var listener = transport.MakeListener(localhostEndpoint);
await listener.StartAsync();
var clientConnection = await transport.ConnectToAsync(localhostAddress);
await listener.StopAsync();
Assert.Throws <InvalidOperationException>(
async() => await clientConnection.RequestResponseAsync <Dummy, Dummy>(
AnyServiceName, AnyMethodName, AnyMessage, CancellationToken.None));
}
public async Task OneConnectionStalledDuringHandshake_CanAcceptAnother()
{
EpoxyTransport transport = MakeTransport();
var listener = transport.MakeListener(localhostEndpoint);
await listener.StartAsync();
var noHandshakeConnection = new TcpClient();
// This will just establish a TCP connection. It won't perform the Epoxy handshake, so
// the listener will just be sitting there waiting for the client to send some data.
await noHandshakeConnection.ConnectAsync(localhostEndpoint.Address, localhostEndpoint.Port);
var connectTask = transport.ConnectToAsync(localhostAddress);
bool didConnect = connectTask.Wait(TimeSpan.FromSeconds(10));
Assert.IsTrue(didConnect, "Timed out waiting for connection to be established.");
}
public async Task ConnectedEvent_SetDisconnectError_DisconnectsConnection()
{
const int DisconnectErrorCode = 100;
const string DisconnectMessage = "Go away!";
EpoxyTransport transport = MakeTransport();
listener = transport.MakeListener(localhostEndpoint);
var connectedEventDone = new ManualResetEventSlim(initialState: false);
listener.Connected += (sender, args) =>
{
args.DisconnectError = new Error {
error_code = DisconnectErrorCode, message = DisconnectMessage
};
connectedEventDone.Set();
};
var disconnectedEventDone = new ManualResetEventSlim(initialState: false);
listener.Disconnected += (sender, args) =>
{
disconnectedEventDone.Set();
};
await listener.StartAsync();
try
{
await transport.ConnectToAsync(localhostAddress);
Assert.Fail("Expected exception to be thrown.");
}
catch (EpoxyProtocolErrorException pex)
{
Assert.That(pex.Message, Is.StringContaining("rejected"));
Assert.IsNotNull(pex.Details);
var errorDetails = pex.Details.Deserialize();
Assert.AreEqual(DisconnectErrorCode, errorDetails.error_code);
Assert.AreEqual(DisconnectMessage, errorDetails.message);
}
}