public async Task ConnectAsync_HandshakeNegotiatesHighestCompatibleProtocolVersion()
{
var localToRemoteOptions = new ConnectionOptions(
new SemanticVersion(2, 0, 0),
new SemanticVersion(1, 0, 0),
TimeSpan.FromSeconds(10),
TimeSpan.FromSeconds(10));
var remoteToLocalOptions = new ConnectionOptions(
new SemanticVersion(3, 0, 0),
new SemanticVersion(1, 0, 0),
TimeSpan.FromSeconds(10),
TimeSpan.FromSeconds(10));
using (var test = new ConnectAsyncTest(localToRemoteOptions, remoteToLocalOptions))
{
await Task.WhenAll(
test.RemoteToLocalConnection.ConnectAsync(test.CancellationToken),
test.LocalToRemoteConnection.ConnectAsync(test.CancellationToken));
Assert.NotNull(test.RemoteToLocalConnection.ProtocolVersion);
Assert.NotNull(test.LocalToRemoteConnection.ProtocolVersion);
Assert.Equal(test.RemoteToLocalConnection.ProtocolVersion, test.LocalToRemoteConnection.ProtocolVersion);
Assert.Equal(test.RemoteToLocalConnection.ProtocolVersion, localToRemoteOptions.ProtocolVersion);
}
}
public async Task ConnectAsync_HandshakeFailsToNegotiateProtocolVersionIfVersionRangesDoNotOverlap()
{
var localToRemoteOptions = new ConnectionOptions(
new SemanticVersion(2, 0, 0),
new SemanticVersion(2, 0, 0),
TimeSpan.FromSeconds(10),
TimeSpan.FromSeconds(10));
var remoteToLocalOptions = new ConnectionOptions(
new SemanticVersion(1, 0, 0),
new SemanticVersion(1, 0, 0),
TimeSpan.FromSeconds(10),
TimeSpan.FromSeconds(10));
using (var test = new ConnectAsyncTest(localToRemoteOptions, remoteToLocalOptions))
{
var tasks = new[]
{
test.RemoteToLocalConnection.ConnectAsync(test.CancellationToken),
test.LocalToRemoteConnection.ConnectAsync(test.CancellationToken)
};
await Assert.ThrowsAsync <ProtocolException>(() => Task.WhenAll(tasks));
Assert.NotNull(tasks[0].Exception);
Assert.NotNull(tasks[1].Exception);
Assert.Null(test.RemoteToLocalConnection.ProtocolVersion);
Assert.Equal(ConnectionState.FailedToHandshake, test.RemoteToLocalConnection.State);
Assert.Null(test.LocalToRemoteConnection.ProtocolVersion);
Assert.Equal(ConnectionState.FailedToHandshake, test.LocalToRemoteConnection.State);
}
}
public async Task ConnectAsync_HandshakeNegotiatesProtocolVersionForIdenticalVersionRanges()
{
using (var test = new ConnectAsyncTest())
{
await test.ConnectAsync();
Assert.NotNull(test.RemoteToLocalConnection.ProtocolVersion);
Assert.NotNull(test.LocalToRemoteConnection.ProtocolVersion);
Assert.Equal(test.RemoteToLocalConnection.ProtocolVersion, test.LocalToRemoteConnection.ProtocolVersion);
}
}
public async Task ConnectAsync_HandshakeNegotiatesProtocolVersionForIdenticalVersionRanges()
{
using (var test = new ConnectAsyncTest(ConnectionOptions.CreateDefault(), ConnectionOptions.CreateDefault()))
{
await Task.WhenAll(
test.RemoteToLocalConnection.ConnectAsync(test.CancellationToken),
test.LocalToRemoteConnection.ConnectAsync(test.CancellationToken));
Assert.NotNull(test.RemoteToLocalConnection.ProtocolVersion);
Assert.NotNull(test.LocalToRemoteConnection.ProtocolVersion);
Assert.Equal(test.RemoteToLocalConnection.ProtocolVersion, test.LocalToRemoteConnection.ProtocolVersion);
}
}
public async Task SendRequestAndReceiveResponseAsync_ThrowsIfCancelled()
{
using (var test = new ConnectAsyncTest())
{
await test.ConnectAsync();
await Assert.ThrowsAsync <OperationCanceledException>(
() => test.LocalToRemoteConnection.SendRequestAndReceiveResponseAsync <LogRequest, LogResponse>(
MessageMethod.Log,
new LogRequest(LogLevel.Debug, "a"),
new CancellationToken(canceled: true)));
}
}
public async Task Close_SetsStateToClosed()
{
using (var test = new ConnectAsyncTest())
{
await test.ConnectAsync();
Assert.Equal(ConnectionState.Connected, test.LocalToRemoteConnection.State);
test.LocalToRemoteConnection.Close();
Assert.Equal(ConnectionState.Closed, test.LocalToRemoteConnection.State);
}
}
public async Task Close_SetsStateToClosed()
{
using (var test = new ConnectAsyncTest(ConnectionOptions.CreateDefault(), ConnectionOptions.CreateDefault()))
{
await Task.WhenAll(
test.RemoteToLocalConnection.ConnectAsync(test.CancellationToken),
test.LocalToRemoteConnection.ConnectAsync(test.CancellationToken));
Assert.Equal(ConnectionState.Connected, test.LocalToRemoteConnection.State);
test.LocalToRemoteConnection.Close();
Assert.Equal(ConnectionState.Closed, test.LocalToRemoteConnection.State);
}
}
public async Task Faulted_RaisedForProtocolError()
{
using (var test = new ConnectAsyncTest(ConnectionOptions.CreateDefault(), ConnectionOptions.CreateDefault()))
{
await Task.WhenAll(
test.RemoteToLocalConnection.ConnectAsync(test.CancellationToken),
test.LocalToRemoteConnection.ConnectAsync(test.CancellationToken));
using (var faultedEvent = new ManualResetEventSlim(initialState: false))
{
ProtocolErrorEventArgs args = null;
test.LocalToRemoteConnection.Faulted += (object sender, ProtocolErrorEventArgs e) =>
{
args = e;
faultedEvent.Set();
};
test.LocalToRemoteConnection.MessageDispatcher.RequestHandlers.TryAdd(
MessageMethod.Initialize,
new RequestHandler <InitializeResponse>(new InitializeResponse(MessageResponseCode.Success)));
var message = new Message(
requestId: "a",
type: MessageType.Response,
method: MessageMethod.Initialize);
await test.RemoteToLocalConnection.SendAsync(message, test.CancellationToken);
faultedEvent.Wait();
Assert.NotNull(args);
Assert.IsType <ProtocolException>(args.Exception);
Assert.NotNull(args.Message);
Assert.Equal(message.RequestId, args.Message.RequestId);
Assert.Equal(message.Type, args.Message.Type);
Assert.Equal(message.Method, args.Message.Method);
}
}
}
public async Task MessageReceived_RaisedForInboundMessage()
{
using (var test = new ConnectAsyncTest())
{
await test.ConnectAsync();
using (var messageReceivedEvent = new ManualResetEventSlim(initialState: false))
{
MessageEventArgs args = null;
test.LocalToRemoteConnection.MessageReceived += (object sender, MessageEventArgs e) =>
{
args = e;
messageReceivedEvent.Set();
};
test.LocalToRemoteConnection.MessageDispatcher.RequestHandlers.TryAdd(
MessageMethod.Initialize,
new RequestHandler <InitializeResponse>(new InitializeResponse(MessageResponseCode.Success)));
var message = new Message(
requestId: "a",
type: MessageType.Request,
method: MessageMethod.Initialize);
await test.RemoteToLocalConnection.SendAsync(message, test.CancellationToken);
messageReceivedEvent.Wait();
Assert.NotNull(args);
Assert.NotNull(args.Message);
Assert.Equal(message.RequestId, args.Message.RequestId);
Assert.Equal(message.Type, args.Message.Type);
Assert.Equal(message.Method, args.Message.Method);
}
}
}
public async Task ConnectAsync_HandshakeFailsToNegotiateProtocolVersionIfOnePartyFailsToRespondWithinTimeoutPeriod()
{
var protocolVersion = new SemanticVersion(1, 0, 0);
var localToRemoteOptions = new ConnectionOptions(
protocolVersion,
protocolVersion,
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(10));
var remoteToLocalOptions = new ConnectionOptions(
protocolVersion,
protocolVersion,
TimeSpan.FromSeconds(10),
TimeSpan.FromSeconds(10));
using (var test = new ConnectAsyncTest(localToRemoteOptions, remoteToLocalOptions))
{
await Assert.ThrowsAsync <TaskCanceledException>(
() => test.LocalToRemoteConnection.ConnectAsync(test.CancellationToken));
Assert.Null(test.LocalToRemoteConnection.ProtocolVersion);
Assert.Equal(ConnectionState.FailedToHandshake, test.LocalToRemoteConnection.State);
}
}
