public async Task <WriteConcernResult> ExecuteAsync(IConnection connection, CancellationToken cancellationToken)
{
var messages = new List <RequestMessage>();
var writeMessage = CreateWriteMessage(connection);
messages.Add(writeMessage);
BsonDocument getLastErrorCommand = null;
QueryMessage getLastErrorMessage = null;
if (_writeConcern.IsAcknowledged)
{
getLastErrorCommand = CreateGetLastErrorCommand();
getLastErrorMessage = CreateGetLastErrorMessage(getLastErrorCommand);
messages.Add(getLastErrorMessage);
}
await connection.SendMessagesAsync(messages, _messageEncoderSettings, cancellationToken).ConfigureAwait(false);
if (getLastErrorMessage != null && getLastErrorMessage.WasSent)
{
var encoderSelector = new ReplyMessageEncoderSelector <BsonDocument>(BsonDocumentSerializer.Instance);
var reply = await connection.ReceiveMessageAsync(getLastErrorMessage.RequestId, encoderSelector, _messageEncoderSettings, cancellationToken).ConfigureAwait(false);
return(ProcessReply(connection.ConnectionId, getLastErrorCommand, (ReplyMessage <BsonDocument>)reply));
}
else
{
return(null);
}
}
public void ReceiveMessageAsync_should_complete_when_reply_is_not_already_on_the_stream()
{
using (var stream = new BlockingMemoryStream())
{
_streamFactory.CreateStreamAsync(null, CancellationToken.None)
.ReturnsForAnyArgs(Task.FromResult <Stream>(stream));
_subject.OpenAsync(CancellationToken.None).Wait();
var encoderSelector = new ReplyMessageEncoderSelector <BsonDocument>(BsonDocumentSerializer.Instance);
var receivedTask = _subject.ReceiveMessageAsync(10, encoderSelector, _messageEncoderSettings, CancellationToken.None);
receivedTask.IsCompleted.Should().BeFalse();
var messageToReceive = MessageHelper.BuildSuccessReply <BsonDocument>(new BsonDocument(), BsonDocumentSerializer.Instance, responseTo: 10);
MessageHelper.WriteResponsesToStream(stream, new[] { messageToReceive });
var received = receivedTask.Result;
var expected = MessageHelper.TranslateMessagesToBsonDocuments(new[] { messageToReceive });
var actual = MessageHelper.TranslateMessagesToBsonDocuments(new[] { received });
actual.Should().BeEquivalentTo(expected);
}
}
public void ReceiveMessageAsync_should_handle_out_of_order_replies()
{
using (var stream = new BlockingMemoryStream())
{
_streamFactory.CreateStreamAsync(null, CancellationToken.None)
.ReturnsForAnyArgs(Task.FromResult <Stream>(stream));
_subject.OpenAsync(CancellationToken.None).Wait();
var encoderSelector = new ReplyMessageEncoderSelector <BsonDocument>(BsonDocumentSerializer.Instance);
var receivedTask11 = _subject.ReceiveMessageAsync(11, encoderSelector, _messageEncoderSettings, CancellationToken.None);
var receivedTask10 = _subject.ReceiveMessageAsync(10, encoderSelector, _messageEncoderSettings, CancellationToken.None);
var messageToReceive10 = MessageHelper.BuildSuccessReply <BsonDocument>(new BsonDocument(), BsonDocumentSerializer.Instance, responseTo: 10);
var messageToReceive11 = MessageHelper.BuildSuccessReply <BsonDocument>(new BsonDocument(), BsonDocumentSerializer.Instance, responseTo: 11);
MessageHelper.WriteResponsesToStream(stream, new[] { messageToReceive10, messageToReceive11 });
var received11 = receivedTask11.Result;
var received10 = receivedTask10.Result;
var expected = MessageHelper.TranslateMessagesToBsonDocuments(new[] { messageToReceive11, messageToReceive10 });
var actual = MessageHelper.TranslateMessagesToBsonDocuments(new[] { received11, received10 });
actual.Should().BeEquivalentTo(expected);
}
}
public void ReceiveMessage_should_not_produce_unobserved_task_exceptions_on_fail(
[Values(false, true)] bool async)
{
var unobservedTaskExceptionRaised = false;
var mockStream = new Mock <Stream>();
EventHandler <UnobservedTaskExceptionEventArgs> eventHandler = (s, args) =>
{
if (args.Exception.InnerException is MongoConnectionException)
{
unobservedTaskExceptionRaised = true;
}
};
try
{
TaskScheduler.UnobservedTaskException += eventHandler;
var encoderSelector = new ReplyMessageEncoderSelector <BsonDocument>(BsonDocumentSerializer.Instance);
_mockStreamFactory
.Setup(f => f.CreateStream(_endPoint, CancellationToken.None))
.Returns(mockStream.Object);
if (async)
{
mockStream
.Setup(s => s.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Throws(new SocketException());
}
else
{
mockStream
.Setup(s => s.Read(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>()))
.Throws(new SocketException());
}
_subject.Open(CancellationToken.None);
Exception exception;
if (async)
{
exception = Record.Exception(() => _subject.ReceiveMessageAsync(1, encoderSelector, _messageEncoderSettings, CancellationToken.None).GetAwaiter().GetResult());
}
else
{
exception = Record.Exception(() => _subject.ReceiveMessage(1, encoderSelector, _messageEncoderSettings, CancellationToken.None));
}
exception.Should().BeOfType <MongoConnectionException>();
GC.Collect(); // Collects the unobserved tasks
GC.WaitForPendingFinalizers(); // Assures finilizers are executed
unobservedTaskExceptionRaised.Should().BeFalse();
}
finally
{
TaskScheduler.UnobservedTaskException -= eventHandler;
mockStream.Object?.Dispose();
}
}
public void ReceiveMessage_should_handle_out_of_order_replies(
[Values(false, true)]
bool async1,
[Values(false, true)]
bool async2)
{
using (var stream = new BlockingMemoryStream())
{
_streamFactory.CreateStream(null, CancellationToken.None)
.ReturnsForAnyArgs(stream);
_subject.Open(CancellationToken.None);
_capturedEvents.Clear();
var encoderSelector = new ReplyMessageEncoderSelector <BsonDocument>(BsonDocumentSerializer.Instance);
Task <ResponseMessage> receivedTask10;
if (async1)
{
receivedTask10 = _subject.ReceiveMessageAsync(10, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
else
{
var receivedTask10IsRunning = false;
receivedTask10 = Task.Run(() => { receivedTask10IsRunning = true; return(_subject.ReceiveMessage(10, encoderSelector, _messageEncoderSettings, CancellationToken.None)); });
SpinWait.SpinUntil(() => receivedTask10IsRunning);
}
Task <ResponseMessage> receivedTask11;
if (async2)
{
receivedTask11 = _subject.ReceiveMessageAsync(11, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
else
{
var receivedTask11IsRunning = false;
receivedTask11 = Task.Run(() => { receivedTask11IsRunning = true; return(_subject.ReceiveMessage(11, encoderSelector, _messageEncoderSettings, CancellationToken.None)); });
SpinWait.SpinUntil(() => receivedTask11IsRunning);
}
var messageToReceive10 = MessageHelper.BuildReply <BsonDocument>(new BsonDocument("_id", 10), BsonDocumentSerializer.Instance, responseTo: 10);
var messageToReceive11 = MessageHelper.BuildReply <BsonDocument>(new BsonDocument("_id", 11), BsonDocumentSerializer.Instance, responseTo: 11);
MessageHelper.WriteResponsesToStream(stream, new[] { messageToReceive11, messageToReceive10 }); // out of order
var received10 = receivedTask10.GetAwaiter().GetResult();
var received11 = receivedTask11.GetAwaiter().GetResult();
var expected = MessageHelper.TranslateMessagesToBsonDocuments(new[] { messageToReceive10, messageToReceive11 });
var actual = MessageHelper.TranslateMessagesToBsonDocuments(new[] { received10, received11 });
actual.Should().BeEquivalentTo(expected);
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionReceivedMessageEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionReceivedMessageEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
public void ReceiveMessage_should_throw_MongoConnectionClosedException_when_connection_has_failed(
[Values(false, true)]
bool async1,
[Values(false, true)]
bool async2)
{
var mockStream = new Mock <Stream>();
using (mockStream.Object)
{
_mockStreamFactory.Setup(f => f.CreateStream(_endPoint, CancellationToken.None))
.Returns(mockStream.Object);
var readTcs = new TaskCompletionSource <int>();
readTcs.SetException(new SocketException());
mockStream.Setup(s => s.Read(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>()))
.Returns(() => readTcs.Task.GetAwaiter().GetResult());
mockStream.Setup(s => s.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Returns(readTcs.Task);
_subject.Open(CancellationToken.None);
_capturedEvents.Clear();
var encoderSelector = new ReplyMessageEncoderSelector <BsonDocument>(BsonDocumentSerializer.Instance);
Action act1;
if (async1)
{
act1 = () => _subject.ReceiveMessageAsync(1, encoderSelector, _messageEncoderSettings, CancellationToken.None).GetAwaiter().GetResult();
}
else
{
act1 = () => _subject.ReceiveMessage(1, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
Action act2;
if (async2)
{
act2 = () => _subject.ReceiveMessageAsync(2, encoderSelector, _messageEncoderSettings, CancellationToken.None).GetAwaiter().GetResult();
}
else
{
act2 = () => _subject.ReceiveMessage(2, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
act1.ShouldThrow <MongoConnectionException>()
.WithInnerException <SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
act2.ShouldThrow <MongoConnectionClosedException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionFailedEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageFailedEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
private void ReceiveMessages(params ReplyMessage <BsonDocument>[] messages)
{
MessageHelper.WriteResponsesToStream(_stream, messages);
var encoderSelector = new ReplyMessageEncoderSelector <BsonDocument>(BsonDocumentSerializer.Instance);
foreach (var message in messages)
{
_subject.ReceiveMessageAsync(message.ResponseTo, encoderSelector, _messageEncoderSettings, CancellationToken.None).Wait();
}
}
public CursorBatch <TDocument> Execute(IConnection connection, CancellationToken cancellationToken)
{
var message = CreateMessage();
connection.SendMessage(message, _messageEncoderSettings, cancellationToken);
var encoderSelector = new ReplyMessageEncoderSelector <TDocument>(_serializer);
var reply = connection.ReceiveMessage(message.RequestId, encoderSelector, _messageEncoderSettings, cancellationToken);
return(ProcessReply(connection.ConnectionId, (ReplyMessage <TDocument>)reply));
}
public async Task <TCommandResult> ExecuteAsync(IConnection connection, CancellationToken cancellationToken)
{
var message = CreateMessage();
await connection.SendMessageAsync(message, _messageEncoderSettings, cancellationToken).ConfigureAwait(false);
var encoderSelector = new ReplyMessageEncoderSelector <RawBsonDocument>(RawBsonDocumentSerializer.Instance);
var reply = await connection.ReceiveMessageAsync(message.RequestId, encoderSelector, _messageEncoderSettings, cancellationToken).ConfigureAwait(false);
return(ProcessReply(connection.ConnectionId, (ReplyMessage <RawBsonDocument>)reply));
}
public async Task <CursorBatch <TDocument> > ExecuteAsync(IConnection connection, CancellationToken cancellationToken)
{
var message = CreateMessage();
await connection.SendMessageAsync(message, _messageEncoderSettings, cancellationToken).ConfigureAwait(false);
var encoderSelector = new ReplyMessageEncoderSelector <TDocument>(_serializer);
var reply = await connection.ReceiveMessageAsync(message.RequestId, encoderSelector, _messageEncoderSettings, cancellationToken).ConfigureAwait(false);
return(ProcessReply(connection.ConnectionId, (ReplyMessage <TDocument>)reply));
}
public void ReceiveMessage_should_throw_MongoConnectionClosedException_when_connection_has_failed(
[Values(false, true)]
bool async1,
[Values(false, true)]
bool async2)
{
using (var stream = Substitute.For <Stream>())
{
_streamFactory.CreateStream(null, CancellationToken.None)
.ReturnsForAnyArgs(stream);
var readTcs = new TaskCompletionSource <int>();
readTcs.SetException(new SocketException());
stream.Read(null, 0, 0)
.ReturnsForAnyArgs(_ => readTcs.Task.GetAwaiter().GetResult());
stream.ReadAsync(null, 0, 0, CancellationToken.None)
.ReturnsForAnyArgs(readTcs.Task);
_subject.Open(CancellationToken.None);
_capturedEvents.Clear();
var encoderSelector = new ReplyMessageEncoderSelector <BsonDocument>(BsonDocumentSerializer.Instance);
Action act1;
if (async1)
{
act1 = () => _subject.ReceiveMessageAsync(1, encoderSelector, _messageEncoderSettings, CancellationToken.None).GetAwaiter().GetResult();
}
else
{
act1 = () => _subject.ReceiveMessage(1, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
Action act2;
if (async2)
{
act2 = () => _subject.ReceiveMessageAsync(2, encoderSelector, _messageEncoderSettings, CancellationToken.None).GetAwaiter().GetResult();
}
else
{
act2 = () => _subject.ReceiveMessage(2, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
act1.ShouldThrow <MongoConnectionException>()
.WithInnerException <SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
act2.ShouldThrow <MongoConnectionClosedException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionFailedEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageFailedEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
public WriteConcernResult Execute(IConnection connection, CancellationToken cancellationToken)
{
QueryMessage getLastErrorMessage;
var messages = CreateMessages(connection, out getLastErrorMessage);
connection.SendMessages(messages, _messageEncoderSettings, cancellationToken);
if (getLastErrorMessage != null && getLastErrorMessage.WasSent)
{
var encoderSelector = new ReplyMessageEncoderSelector <BsonDocument>(BsonDocumentSerializer.Instance);
var reply = connection.ReceiveMessage(getLastErrorMessage.RequestId, encoderSelector, _messageEncoderSettings, cancellationToken);
return(ProcessReply(connection.ConnectionId, getLastErrorMessage.Query, (ReplyMessage <BsonDocument>)reply));
}
else
{
return(null);
}
}
public void ReceiveMessage_should_complete_when_reply_is_not_already_on_the_stream(
[Values(false, true)]
bool async)
{
using (var stream = new BlockingMemoryStream())
{
var encoderSelector = new ReplyMessageEncoderSelector <BsonDocument>(BsonDocumentSerializer.Instance);
Task <ResponseMessage> receiveMessageTask;
if (async)
{
_streamFactory.CreateStreamAsync(null, CancellationToken.None)
.ReturnsForAnyArgs(Task.FromResult <Stream>(stream));
_subject.OpenAsync(CancellationToken.None).GetAwaiter().GetResult();
_capturedEvents.Clear();
receiveMessageTask = _subject.ReceiveMessageAsync(10, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
else
{
_streamFactory.CreateStream(null, CancellationToken.None)
.ReturnsForAnyArgs(stream);
_subject.Open(CancellationToken.None);
_capturedEvents.Clear();
receiveMessageTask = Task.Run(() => _subject.ReceiveMessage(10, encoderSelector, _messageEncoderSettings, CancellationToken.None));
}
receiveMessageTask.IsCompleted.Should().BeFalse();
var messageToReceive = MessageHelper.BuildReply <BsonDocument>(new BsonDocument(), BsonDocumentSerializer.Instance, responseTo: 10);
MessageHelper.WriteResponsesToStream(stream, new[] { messageToReceive });
var received = receiveMessageTask.GetAwaiter().GetResult();
var expected = MessageHelper.TranslateMessagesToBsonDocuments(new[] { messageToReceive });
var actual = MessageHelper.TranslateMessagesToBsonDocuments(new[] { received });
actual.Should().BeEquivalentTo(expected);
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionReceivedMessageEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
public TCommandResult Execute(IConnection connection, CancellationToken cancellationToken)
{
var message = CreateMessage();
connection.SendMessage(message, _messageEncoderSettings, cancellationToken);
switch (_responseHandling())
{
case CommandResponseHandling.Ignore:
IgnoreResponse(connection, message, cancellationToken);
return(default(TCommandResult));
default:
var encoderSelector = new ReplyMessageEncoderSelector <RawBsonDocument>(RawBsonDocumentSerializer.Instance);
var reply = connection.ReceiveMessage(message.RequestId, encoderSelector, _messageEncoderSettings, cancellationToken);
return(ProcessReply(connection.ConnectionId, (ReplyMessage <RawBsonDocument>)reply));
}
}
public async Task ReceiveMessageAsync_should_throw_network_exception_to_all_awaiters()
{
using (var stream = Substitute.For <Stream>())
{
_streamFactory.CreateStreamAsync(null, CancellationToken.None)
.ReturnsForAnyArgs(Task.FromResult <Stream>(stream));
var readTcs = new TaskCompletionSource <int>();
stream.ReadAsync(null, 0, 0, CancellationToken.None)
.ReturnsForAnyArgs(readTcs.Task);
var writeTcs = new TaskCompletionSource <int>();
stream.WriteAsync(null, 0, 0, CancellationToken.None)
.ReturnsForAnyArgs(writeTcs.Task);
await _subject.OpenAsync(CancellationToken.None);
_capturedEvents.Clear();
var encoderSelector = new ReplyMessageEncoderSelector <BsonDocument>(BsonDocumentSerializer.Instance);
var task1 = _subject.ReceiveMessageAsync(1, encoderSelector, _messageEncoderSettings, CancellationToken.None);
var task2 = _subject.ReceiveMessageAsync(2, encoderSelector, _messageEncoderSettings, CancellationToken.None);
readTcs.SetException(new SocketException());
Func <Task> act1 = () => task1;
act1.ShouldThrow <MongoConnectionException>()
.WithInnerException <SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
Func <Task> act2 = () => task2;
act2.ShouldThrow <MongoConnectionException>()
.WithInnerException <SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionFailedEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageFailedEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageFailedEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
public void ReceiveMessage_should_throw_a_FormatException_when_message_is_an_invalid_size(
[Values(-1, 48000001)]
int length,
[Values(false, true)]
bool async)
{
using (var stream = new BlockingMemoryStream())
{
var bytes = BitConverter.GetBytes(length);
stream.Write(bytes, 0, bytes.Length);
stream.Seek(0, SeekOrigin.Begin);
var encoderSelector = new ReplyMessageEncoderSelector <BsonDocument>(BsonDocumentSerializer.Instance);
Exception exception;
if (async)
{
_mockStreamFactory
.Setup(f => f.CreateStreamAsync(_endPoint, CancellationToken.None))
.ReturnsAsync(stream);
_subject.OpenAsync(CancellationToken.None).GetAwaiter().GetResult();
exception = Record
.Exception(() => _subject.ReceiveMessageAsync(10, encoderSelector, _messageEncoderSettings, CancellationToken.None)
.GetAwaiter()
.GetResult());
}
else
{
_mockStreamFactory.Setup(f => f.CreateStream(_endPoint, CancellationToken.None))
.Returns(stream);
_subject.Open(CancellationToken.None);
exception = Record.Exception(() => _subject.ReceiveMessage(10, encoderSelector, _messageEncoderSettings, CancellationToken.None));
}
exception.Should().BeOfType <MongoConnectionException>();
var e = exception.InnerException.Should().BeOfType <FormatException>().Subject;
e.Message.Should().Be("The size of the message is invalid.");
}
}
public async Task ReceiveMessageAsync_should_throw_MongoConnectionClosedException_when_connection_has_failed()
{
using (var stream = Substitute.For <Stream>())
{
_streamFactory.CreateStreamAsync(null, CancellationToken.None)
.ReturnsForAnyArgs(Task.FromResult <Stream>(stream));
var readTcs = new TaskCompletionSource <int>();
stream.ReadAsync(null, 0, 0, CancellationToken.None)
.ReturnsForAnyArgs(readTcs.Task);
var writeTcs = new TaskCompletionSource <int>();
stream.WriteAsync(null, 0, 0, CancellationToken.None)
.ReturnsForAnyArgs(writeTcs.Task);
await _subject.OpenAsync(CancellationToken.None);
var encoderSelector = new ReplyMessageEncoderSelector <BsonDocument>(BsonDocumentSerializer.Instance);
var task1 = _subject.ReceiveMessageAsync(1, encoderSelector, _messageEncoderSettings, CancellationToken.None);
readTcs.SetException(new SocketException());
Func <Task> act1 = () => task1;
act1.ShouldThrow <MongoConnectionException>()
.WithInnerException <SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
var task2 = _subject.ReceiveMessageAsync(2, encoderSelector, _messageEncoderSettings, CancellationToken.None);
Func <Task> act2 = () => task2;
act2.ShouldThrow <MongoConnectionClosedException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
_listener.ReceivedWithAnyArgs().ConnectionBeforeReceivingMessage(default(ConnectionBeforeReceivingMessageEvent));
_listener.ReceivedWithAnyArgs().ConnectionErrorReceivingMessage(default(ConnectionErrorReceivingMessageEvent));
}
}
public async Task <TCommandResult> ExecuteAsync(IConnection connection, CancellationToken cancellationToken)
{
bool messageContainsSessionId;
var message = CreateMessage(connection.Description, out messageContainsSessionId);
await connection.SendMessageAsync(message, _messageEncoderSettings, cancellationToken).ConfigureAwait(false);
if (messageContainsSessionId)
{
_session.WasUsed();
}
switch (_responseHandling())
{
case CommandResponseHandling.Ignore:
IgnoreResponse(connection, message, cancellationToken);
return(default(TCommandResult));
default:
var encoderSelector = new ReplyMessageEncoderSelector <RawBsonDocument>(RawBsonDocumentSerializer.Instance);
var reply = await connection.ReceiveMessageAsync(message.RequestId, encoderSelector, _messageEncoderSettings, cancellationToken).ConfigureAwait(false);
return(ProcessReply(connection.ConnectionId, (ReplyMessage <RawBsonDocument>)reply));
}
}
public void ReceiveMessage_should_throw_network_exception_to_all_awaiters(
[Values(false, true)]
bool async1,
[Values(false, true)]
bool async2)
{
using (var stream = Substitute.For<Stream>())
{
var encoderSelector = new ReplyMessageEncoderSelector<BsonDocument>(BsonDocumentSerializer.Instance);
_streamFactory.CreateStream(null, CancellationToken.None)
.ReturnsForAnyArgs(stream);
var readTcs = new TaskCompletionSource<int>();
stream.Read(null, 0, 0)
.ReturnsForAnyArgs(_ => readTcs.Task.GetAwaiter().GetResult());
stream.ReadAsync(null, 0, 0, CancellationToken.None)
.ReturnsForAnyArgs(readTcs.Task);
_subject.Open(CancellationToken.None);
_capturedEvents.Clear();
Task task1;
if (async1)
{
task1 = _subject.ReceiveMessageAsync(1, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
else
{
var task1IsRunning = false;
task1 = Task.Run(() => { task1IsRunning = true; return _subject.ReceiveMessage(1, encoderSelector, _messageEncoderSettings, CancellationToken.None); });
SpinWait.SpinUntil(() => task1IsRunning, 100);
}
Task task2;
if (async2)
{
task2 = _subject.ReceiveMessageAsync(2, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
else
{
var task2IsRunning = false;
task2 = Task.Run(() => { task2IsRunning = true; return _subject.ReceiveMessage(2, encoderSelector, _messageEncoderSettings, CancellationToken.None); });
SpinWait.SpinUntil(() => task2IsRunning);
}
readTcs.SetException(new SocketException());
Func<Task> act1 = () => task1;
act1.ShouldThrow<MongoConnectionException>()
.WithInnerException<SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
Func<Task> act2 = () => task2;
act2.ShouldThrow<MongoConnectionException>()
.WithInnerException<SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionFailedEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageFailedEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageFailedEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
private void ReceiveMessages(params ReplyMessage<BsonDocument>[] messages)
{
MessageHelper.WriteResponsesToStream(_stream, messages);
var encoderSelector = new ReplyMessageEncoderSelector<BsonDocument>(BsonDocumentSerializer.Instance);
foreach (var message in messages)
{
_subject.ReceiveMessageAsync(message.ResponseTo, encoderSelector, _messageEncoderSettings, CancellationToken.None).Wait();
}
}
public void ReceiveMessage_should_complete_when_reply_is_not_already_on_the_stream(
[Values(false, true)]
bool async)
{
using (var stream = new BlockingMemoryStream())
{
var encoderSelector = new ReplyMessageEncoderSelector<BsonDocument>(BsonDocumentSerializer.Instance);
Task<ResponseMessage> receiveMessageTask;
if (async)
{
_mockStreamFactory.Setup(f => f.CreateStreamAsync(_endPoint, CancellationToken.None))
.Returns(Task.FromResult<Stream>(stream));
_subject.OpenAsync(CancellationToken.None).GetAwaiter().GetResult();
_capturedEvents.Clear();
receiveMessageTask = _subject.ReceiveMessageAsync(10, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
else
{
_mockStreamFactory.Setup(f => f.CreateStream(_endPoint, CancellationToken.None))
.Returns(stream);
_subject.Open(CancellationToken.None);
_capturedEvents.Clear();
receiveMessageTask = Task.Run(() => _subject.ReceiveMessage(10, encoderSelector, _messageEncoderSettings, CancellationToken.None));
}
receiveMessageTask.IsCompleted.Should().BeFalse();
var messageToReceive = MessageHelper.BuildReply<BsonDocument>(new BsonDocument(), BsonDocumentSerializer.Instance, responseTo: 10);
MessageHelper.WriteResponsesToStream(stream, new[] { messageToReceive });
var received = receiveMessageTask.GetAwaiter().GetResult();
var expected = MessageHelper.TranslateMessagesToBsonDocuments(new[] { messageToReceive });
var actual = MessageHelper.TranslateMessagesToBsonDocuments(new[] { received });
actual.Should().BeEquivalentTo(expected);
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivedMessageEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
private void IgnoreResponse(IConnection connection, QueryMessage message, CancellationToken cancellationToken)
{
var encoderSelector = new ReplyMessageEncoderSelector <IgnoredReply>(IgnoredReplySerializer.Instance);
connection.ReceiveMessageAsync(message.RequestId, encoderSelector, _messageEncoderSettings, cancellationToken).IgnoreExceptions();
}
public void ReceiveMessage_should_handle_out_of_order_replies(
[Values(false, true)]
bool async1,
[Values(false, true)]
bool async2)
{
using (var stream = new BlockingMemoryStream())
{
_mockStreamFactory.Setup(f => f.CreateStream(_endPoint, CancellationToken.None))
.Returns(stream);
_subject.Open(CancellationToken.None);
_capturedEvents.Clear();
var encoderSelector = new ReplyMessageEncoderSelector<BsonDocument>(BsonDocumentSerializer.Instance);
Task<ResponseMessage> receivedTask10;
if (async1)
{
receivedTask10 = _subject.ReceiveMessageAsync(10, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
else
{
var receivedTask10IsRunning = 0;
receivedTask10 = Task.Run(() => { Interlocked.Exchange(ref receivedTask10IsRunning, 1); return _subject.ReceiveMessage(10, encoderSelector, _messageEncoderSettings, CancellationToken.None); });
SpinWait.SpinUntil(() => Interlocked.CompareExchange(ref receivedTask10IsRunning, 0, 0) == 1, 1000).Should().BeTrue();
}
Task<ResponseMessage> receivedTask11;
if (async2)
{
receivedTask11 = _subject.ReceiveMessageAsync(11, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
else
{
var receivedTask11IsRunning = 0;
receivedTask11 = Task.Run(() => { Interlocked.Exchange(ref receivedTask11IsRunning, 1); return _subject.ReceiveMessage(11, encoderSelector, _messageEncoderSettings, CancellationToken.None); });
SpinWait.SpinUntil(() => Interlocked.CompareExchange(ref receivedTask11IsRunning, 0, 0) == 1, 1000).Should().BeTrue();
}
var messageToReceive10 = MessageHelper.BuildReply<BsonDocument>(new BsonDocument("_id", 10), BsonDocumentSerializer.Instance, responseTo: 10);
var messageToReceive11 = MessageHelper.BuildReply<BsonDocument>(new BsonDocument("_id", 11), BsonDocumentSerializer.Instance, responseTo: 11);
MessageHelper.WriteResponsesToStream(stream, new[] { messageToReceive11, messageToReceive10 }); // out of order
var received10 = receivedTask10.GetAwaiter().GetResult();
var received11 = receivedTask11.GetAwaiter().GetResult();
var expected = MessageHelper.TranslateMessagesToBsonDocuments(new[] { messageToReceive10, messageToReceive11 });
var actual = MessageHelper.TranslateMessagesToBsonDocuments(new[] { received10, received11 });
actual.Should().BeEquivalentTo(expected);
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivedMessageEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivedMessageEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
public void ReceiveMessage_should_throw_network_exception_to_all_awaiters(
[Values(false, true)]
bool async1,
[Values(false, true)]
bool async2)
{
using (var stream = Substitute.For <Stream>())
{
var encoderSelector = new ReplyMessageEncoderSelector <BsonDocument>(BsonDocumentSerializer.Instance);
_streamFactory.CreateStream(null, CancellationToken.None)
.ReturnsForAnyArgs(stream);
var readTcs = new TaskCompletionSource <int>();
stream.Read(null, 0, 0)
.ReturnsForAnyArgs(_ => readTcs.Task.GetAwaiter().GetResult());
stream.ReadAsync(null, 0, 0, CancellationToken.None)
.ReturnsForAnyArgs(readTcs.Task);
_subject.Open(CancellationToken.None);
_capturedEvents.Clear();
Task task1;
if (async1)
{
task1 = _subject.ReceiveMessageAsync(1, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
else
{
var task1IsRunning = false;
task1 = Task.Run(() => { task1IsRunning = true; return(_subject.ReceiveMessage(1, encoderSelector, _messageEncoderSettings, CancellationToken.None)); });
SpinWait.SpinUntil(() => task1IsRunning, 100);
}
Task task2;
if (async2)
{
task2 = _subject.ReceiveMessageAsync(2, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
else
{
var task2IsRunning = false;
task2 = Task.Run(() => { task2IsRunning = true; return(_subject.ReceiveMessage(2, encoderSelector, _messageEncoderSettings, CancellationToken.None)); });
SpinWait.SpinUntil(() => task2IsRunning);
}
readTcs.SetException(new SocketException());
Func <Task> act1 = () => task1;
act1.ShouldThrow <MongoConnectionException>()
.WithInnerException <SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
Func <Task> act2 = () => task2;
act2.ShouldThrow <MongoConnectionException>()
.WithInnerException <SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionFailedEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageFailedEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageFailedEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
public void ReceiveMessage_should_throw_network_exception_to_all_awaiters(
[Values(false, true)]
bool async1,
[Values(false, true)]
bool async2)
{
var mockStream = new Mock <Stream>();
using (mockStream.Object)
{
var encoderSelector = new ReplyMessageEncoderSelector <BsonDocument>(BsonDocumentSerializer.Instance);
_mockStreamFactory.Setup(f => f.CreateStream(_endPoint, CancellationToken.None))
.Returns(mockStream.Object);
var readTcs = new TaskCompletionSource <int>();
mockStream.Setup(s => s.Read(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>()))
.Returns(() => readTcs.Task.GetAwaiter().GetResult());
mockStream.Setup(s => s.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Returns(readTcs.Task);
_subject.Open(CancellationToken.None);
_capturedEvents.Clear();
Task task1;
if (async1)
{
task1 = _subject.ReceiveMessageAsync(1, encoderSelector, _messageEncoderSettings, It.IsAny <CancellationToken>());
}
else
{
task1 = Task.Run(() => _subject.ReceiveMessage(1, encoderSelector, _messageEncoderSettings, CancellationToken.None));
}
Task task2;
if (async2)
{
task2 = _subject.ReceiveMessageAsync(2, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
else
{
task2 = Task.Run(() => _subject.ReceiveMessage(2, encoderSelector, _messageEncoderSettings, CancellationToken.None));
}
SpinWait.SpinUntil(() => _capturedEvents.Count >= 2, TimeSpan.FromSeconds(5)).Should().BeTrue();
readTcs.SetException(new SocketException());
Func <Task> act1 = () => task1;
act1.ShouldThrow <MongoConnectionException>()
.WithInnerException <SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
Func <Task> act2 = () => task2;
act2.ShouldThrow <MongoConnectionException>()
.WithInnerException <SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionFailedEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageFailedEvent>();
_capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageFailedEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
public void ReceiveMessage_should_throw_network_exception_to_all_awaiters(
[Values(false, true)]
bool async1,
[Values(false, true)]
bool async2)
{
var mockStream = new Mock<Stream>();
using (mockStream.Object)
{
var encoderSelector = new ReplyMessageEncoderSelector<BsonDocument>(BsonDocumentSerializer.Instance);
_mockStreamFactory.Setup(f => f.CreateStream(_endPoint, CancellationToken.None))
.Returns(mockStream.Object);
var readTcs = new TaskCompletionSource<int>();
mockStream.Setup(s => s.Read(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>()))
.Returns(() => readTcs.Task.GetAwaiter().GetResult());
mockStream.Setup(s => s.ReadAsync(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
.Returns(readTcs.Task);
_subject.Open(CancellationToken.None);
_capturedEvents.Clear();
Task task1;
if (async1)
{
task1 = _subject.ReceiveMessageAsync(1, encoderSelector, _messageEncoderSettings, It.IsAny<CancellationToken>());
}
else
{
var task1IsRunning = 0;
task1 = Task.Run(() => { Interlocked.Exchange(ref task1IsRunning, 1); return _subject.ReceiveMessage(1, encoderSelector, _messageEncoderSettings, CancellationToken.None); });
SpinWait.SpinUntil(() => Interlocked.CompareExchange(ref task1IsRunning, 0, 0) == 1, 1000).Should().BeTrue();
}
Task task2;
if (async2)
{
task2 = _subject.ReceiveMessageAsync(2, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
else
{
var task2IsRunning = 0;
task2 = Task.Run(() => { Interlocked.Exchange(ref task2IsRunning, 1); return _subject.ReceiveMessage(2, encoderSelector, _messageEncoderSettings, CancellationToken.None); });
SpinWait.SpinUntil(() => Interlocked.CompareExchange(ref task2IsRunning, 0, 0) == 1, 1000).Should().BeTrue();
}
readTcs.SetException(new SocketException());
Func<Task> act1 = () => task1;
act1.ShouldThrow<MongoConnectionException>()
.WithInnerException<SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
Func<Task> act2 = () => task2;
act2.ShouldThrow<MongoConnectionException>()
.WithInnerException<SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionFailedEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageFailedEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageFailedEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
public void ReceiveMessage_should_throw_MongoConnectionClosedException_when_connection_has_failed(
[Values(false, true)]
bool async1,
[Values(false, true)]
bool async2)
{
using (var stream = Substitute.For<Stream>())
{
_streamFactory.CreateStream(null, CancellationToken.None)
.ReturnsForAnyArgs(stream);
var readTcs = new TaskCompletionSource<int>();
readTcs.SetException(new SocketException());
stream.Read(null, 0, 0)
.ReturnsForAnyArgs(_ => readTcs.Task.GetAwaiter().GetResult());
stream.ReadAsync(null, 0, 0, CancellationToken.None)
.ReturnsForAnyArgs(readTcs.Task);
_subject.Open(CancellationToken.None);
_capturedEvents.Clear();
var encoderSelector = new ReplyMessageEncoderSelector<BsonDocument>(BsonDocumentSerializer.Instance);
Action act1;
if (async1)
{
act1 = () => _subject.ReceiveMessageAsync(1, encoderSelector, _messageEncoderSettings, CancellationToken.None).GetAwaiter().GetResult();
}
else
{
act1 = () => _subject.ReceiveMessage(1, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
Action act2;
if (async2)
{
act2 = () => _subject.ReceiveMessageAsync(2, encoderSelector, _messageEncoderSettings, CancellationToken.None).GetAwaiter().GetResult();
}
else
{
act2 = () => _subject.ReceiveMessage(2, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
act1.ShouldThrow<MongoConnectionException>()
.WithInnerException<SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
act2.ShouldThrow<MongoConnectionClosedException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionFailedEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageFailedEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
public async Task ReceiveMessageAsync_should_throw_MongoConnectionClosedException_when_connection_has_failed()
{
using (var stream = Substitute.For<Stream>())
{
_streamFactory.CreateStreamAsync(null, CancellationToken.None)
.ReturnsForAnyArgs(Task.FromResult<Stream>(stream));
var readTcs = new TaskCompletionSource<int>();
stream.ReadAsync(null, 0, 0, CancellationToken.None)
.ReturnsForAnyArgs(readTcs.Task);
var writeTcs = new TaskCompletionSource<int>();
stream.WriteAsync(null, 0, 0, CancellationToken.None)
.ReturnsForAnyArgs(writeTcs.Task);
await _subject.OpenAsync(CancellationToken.None);
_capturedEvents.Clear();
var encoderSelector = new ReplyMessageEncoderSelector<BsonDocument>(BsonDocumentSerializer.Instance);
var task1 = _subject.ReceiveMessageAsync(1, encoderSelector, _messageEncoderSettings, CancellationToken.None);
readTcs.SetException(new SocketException());
Func<Task> act1 = () => task1;
act1.ShouldThrow<MongoConnectionException>()
.WithInnerException<SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
var task2 = _subject.ReceiveMessageAsync(2, encoderSelector, _messageEncoderSettings, CancellationToken.None);
Func<Task> act2 = () => task2;
act2.ShouldThrow<MongoConnectionClosedException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionFailedEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageFailedEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
public void ReceiveMessageAsync_should_handle_out_of_order_replies()
{
using (var stream = new BlockingMemoryStream())
{
_streamFactory.CreateStreamAsync(null, CancellationToken.None)
.ReturnsForAnyArgs(Task.FromResult<Stream>(stream));
_subject.OpenAsync(CancellationToken.None).Wait();
_capturedEvents.Clear();
var encoderSelector = new ReplyMessageEncoderSelector<BsonDocument>(BsonDocumentSerializer.Instance);
var receivedTask11 = _subject.ReceiveMessageAsync(11, encoderSelector, _messageEncoderSettings, CancellationToken.None);
var receivedTask10 = _subject.ReceiveMessageAsync(10, encoderSelector, _messageEncoderSettings, CancellationToken.None);
var messageToReceive10 = MessageHelper.BuildSuccessReply<BsonDocument>(new BsonDocument(), BsonDocumentSerializer.Instance, responseTo: 10);
var messageToReceive11 = MessageHelper.BuildSuccessReply<BsonDocument>(new BsonDocument(), BsonDocumentSerializer.Instance, responseTo: 11);
MessageHelper.WriteResponsesToStream(stream, new[] { messageToReceive10, messageToReceive11 });
var received11 = receivedTask11.Result;
var received10 = receivedTask10.Result;
var expected = MessageHelper.TranslateMessagesToBsonDocuments(new[] { messageToReceive11, messageToReceive10 });
var actual = MessageHelper.TranslateMessagesToBsonDocuments(new[] { received11, received10 });
actual.Should().BeEquivalentTo(expected);
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivedMessageEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivedMessageEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
public void ReceiveMessageAsync_should_complete_when_reply_is_not_already_on_the_stream()
{
using (var stream = new BlockingMemoryStream())
{
_streamFactory.CreateStreamAsync(null, CancellationToken.None)
.ReturnsForAnyArgs(Task.FromResult<Stream>(stream));
_subject.OpenAsync(CancellationToken.None).Wait();
_capturedEvents.Clear();
var encoderSelector = new ReplyMessageEncoderSelector<BsonDocument>(BsonDocumentSerializer.Instance);
var receivedTask = _subject.ReceiveMessageAsync(10, encoderSelector, _messageEncoderSettings, CancellationToken.None);
receivedTask.IsCompleted.Should().BeFalse();
var messageToReceive = MessageHelper.BuildReply<BsonDocument>(new BsonDocument(), BsonDocumentSerializer.Instance, responseTo: 10);
MessageHelper.WriteResponsesToStream(stream, new[] { messageToReceive });
var received = receivedTask.Result;
var expected = MessageHelper.TranslateMessagesToBsonDocuments(new[] { messageToReceive });
var actual = MessageHelper.TranslateMessagesToBsonDocuments(new[] { received });
actual.Should().BeEquivalentTo(expected);
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivedMessageEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
public void ReceiveMessage_should_throw_MongoConnectionClosedException_when_connection_has_failed(
[Values(false, true)]
bool async1,
[Values(false, true)]
bool async2)
{
var mockStream = new Mock<Stream>();
using (mockStream.Object)
{
_mockStreamFactory.Setup(f => f.CreateStream(_endPoint, CancellationToken.None))
.Returns(mockStream.Object);
var readTcs = new TaskCompletionSource<int>();
readTcs.SetException(new SocketException());
mockStream.Setup(s => s.Read(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>()))
.Returns(() => readTcs.Task.GetAwaiter().GetResult());
mockStream.Setup(s => s.ReadAsync(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
.Returns(readTcs.Task);
_subject.Open(CancellationToken.None);
_capturedEvents.Clear();
var encoderSelector = new ReplyMessageEncoderSelector<BsonDocument>(BsonDocumentSerializer.Instance);
Action act1;
if (async1)
{
act1 = () => _subject.ReceiveMessageAsync(1, encoderSelector, _messageEncoderSettings, CancellationToken.None).GetAwaiter().GetResult();
}
else
{
act1 = () => _subject.ReceiveMessage(1, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
Action act2;
if (async2)
{
act2 = () => _subject.ReceiveMessageAsync(2, encoderSelector, _messageEncoderSettings, CancellationToken.None).GetAwaiter().GetResult();
}
else
{
act2 = () => _subject.ReceiveMessage(2, encoderSelector, _messageEncoderSettings, CancellationToken.None);
}
act1.ShouldThrow<MongoConnectionException>()
.WithInnerException<SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
act2.ShouldThrow<MongoConnectionClosedException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionFailedEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionReceivingMessageFailedEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
