public async Task MessagesExchanged_CorrectNumberReported(int read, int written, int messageSize)
{
var telemetry = await TestAsync(
async uri =>
{
using var client = new ClientWebSocket();
await client.ConnectAsync(uri, CancellationToken.None);
var webSocket = new WebSocketAdapter(client);
await Task.WhenAll(
SendMessagesAndCloseAsync(webSocket, read, messageSize),
ReceiveAllMessagesAsync(webSocket));
},
async (context, webSocket) =>
{
await Task.WhenAll(
SendMessagesAndCloseAsync(webSocket, written, messageSize),
ReceiveAllMessagesAsync(webSocket));
},
new ManualClock(new TimeSpan(42)));
Assert.NotNull(telemetry);
Assert.Equal(42, telemetry !.EstablishedTime.Ticks);
Assert.Contains(telemetry.CloseReason, new[] { WebSocketCloseReason.ClientGracefulClose, WebSocketCloseReason.ServerGracefulClose });
Assert.Equal(read, telemetry !.MessagesRead);
Assert.Equal(written, telemetry.MessagesWritten);
}
static async Task ProcessAsync(WebSocketAdapter webSocket, Behavior behavior, ClientWebSocket?client = null, HttpContext?context = null)
{
if (behavior == Behavior.SendsClose_WaitsForClose ||
behavior == Behavior.SendsClose_ClosesConnection)
{
await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "Bye");
}
if (behavior == Behavior.SendsClose_WaitsForClose ||
behavior == Behavior.WaitsForClose_SendsClose ||
behavior == Behavior.WaitsForClose_ClosesConnection)
{
await ReceiveAllMessagesAsync(webSocket);
}
if (behavior == Behavior.WaitsForClose_SendsClose)
{
await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "Bye");
}
if (behavior.HasFlag(Behavior.ClosesConnection))
{
client?.Abort();
if (context is not null)
{
await context.Response.Body.FlushAsync();
context.Abort();
}
}
}
/// <summary>
/// Build a new socket with conditional compilation on the adapter.
/// </summary>
/// <param name="client">The client object.</param>
/// <returns>A new socket.</returns>
public static ISocket NewSocket(this IClient client)
{
#if UNITY_WEBGL && !UNITY_EDITOR
ISocketAdapter adapter = new JsWebSocketAdapter();
#else
ISocketAdapter adapter = new WebSocketAdapter();
#endif
return(Socket.From(client, adapter));
}
public async Task <WebSocketAdapter> GetExchangeClient()
{
var baseClient = new ClientWebSocket();
var factory = new LoggerFactory();
var client = new WebSocketAdapter(factory.CreateLogger <WebSocketAdapter>(), baseClient);
baseClient.Options.KeepAliveInterval = new TimeSpan(0, 0, 5);
await baseClient.ConnectAsync(new Uri(BitstampApi), CancellationToken.None);
return(client);
}
public async Task <WebSocketAdapter> CreateExchangeClientAsync()
{
var client = new ClientWebSocket();
var factory = new LoggerFactory();
var adapter = new WebSocketAdapter(factory.CreateLogger <WebSocketAdapter>(), client);
client.Options.KeepAliveInterval = new TimeSpan(0, 0, 5);
await client.ConnectAsync(new Uri(SocketClientApi), CancellationToken.None);
adapter.TimeStarted = DateTime.UtcNow;
adapter.Markets = new List <IOrderbook>();
Client = adapter;
Exchange.ActiveClients.Add(Client);
return(adapter);
}
public async Task <WebSocketAdapter> CreateExchangeClientAsync()
{
var client = new ClientWebSocket();
var factory = new LoggerFactory();
var adapter = new WebSocketAdapter(factory.CreateLogger <WebSocketAdapter>(), client);
client.Options.KeepAliveInterval = new TimeSpan(0, 0, 5);
await client.ConnectAsync(new Uri(SocketClientApi), CancellationToken.None);
adapter.TimeStarted = DateTime.UtcNow;
adapter.Markets = new List <IOrderbook>();
Client = adapter;
Exchange.ActiveClients.Add(Client);
await Task.Delay(250); // clients with zero subscriptions are being aborted; give 1/4 second to ensure connection is complete
return(adapter);
}
public async Task ConnectionClosed_BlameAttributedCorrectly(Behavior clientBehavior, Behavior serverBehavior, params WebSocketCloseReason[] expectedReasons)
{
var telemetry = await TestAsync(
async uri =>
{
using var client = new ClientWebSocket();
// Keep sending messages from the client in order to observe a server disconnect sooner
client.Options.KeepAliveInterval = TimeSpan.FromMilliseconds(10);
await client.ConnectAsync(uri, CancellationToken.None);
var webSocket = new WebSocketAdapter(client);
try
{
await ProcessAsync(webSocket, clientBehavior, client: client);
}
catch
{
Assert.True(serverBehavior.HasFlag(Behavior.ClosesConnection));
}
},
async (context, webSocket) =>
{
try
{
await ProcessAsync(webSocket, serverBehavior, context: context);
}
catch
{
Assert.True(clientBehavior.HasFlag(Behavior.ClosesConnection));
}
});
Assert.NotNull(telemetry);
Assert.Contains(telemetry !.CloseReason, expectedReasons);
