public BinaryConnection_CommandEventTests()
{
_capturedEvents = new EventCapturer()
.Capture<CommandStartedEvent>()
.Capture<CommandSucceededEvent>()
.Capture<CommandFailedEvent>();
_mockStreamFactory = new Mock<IStreamFactory>();
_endPoint = new DnsEndPoint("localhost", 27017);
var serverId = new ServerId(new ClusterId(), _endPoint);
_mockConnectionInitializer = new Mock<IConnectionInitializer>();
_mockConnectionInitializer.Setup(i => i.InitializeConnectionAsync(It.IsAny<IConnection>(), CancellationToken.None))
.Returns(() => Task.FromResult(new ConnectionDescription(
new ConnectionId(serverId),
new IsMasterResult(new BsonDocument()),
new BuildInfoResult(new BsonDocument("version", "2.6.3")))));
_subject = new BinaryConnection(
serverId: serverId,
endPoint: _endPoint,
settings: new ConnectionSettings(),
streamFactory: _mockStreamFactory.Object,
connectionInitializer: _mockConnectionInitializer.Object,
eventSubscriber: _capturedEvents);
_stream = new BlockingMemoryStream();
_mockStreamFactory.Setup(f => f.CreateStreamAsync(_endPoint, CancellationToken.None))
.Returns(Task.FromResult<Stream>(_stream));
_subject.OpenAsync(CancellationToken.None).Wait();
_capturedEvents.Clear();
_operationIdDisposer = EventContext.BeginOperation();
}
public static void WriteResponsesToStream(BlockingMemoryStream stream, IEnumerable <ResponseMessage> responses)
{
lock (stream.Lock)
{
var startPosition = stream.Position;
foreach (var response in responses)
{
var encoderFactory = new BinaryMessageEncoderFactory(stream, null);
var encoder = response.GetEncoder(encoderFactory);
encoder.WriteMessage(response);
}
stream.Position = startPosition;
}
}
public void ReceiveMessageAsync_should_handle_out_of_order_replies()
{
using (var stream = new BlockingMemoryStream())
{
_streamFactory.CreateStreamAsync(null, Timeout.InfiniteTimeSpan, CancellationToken.None)
.ReturnsForAnyArgs(Task.FromResult<Stream>(stream));
_subject.OpenAsync(Timeout.InfiniteTimeSpan, CancellationToken.None).Wait();
var receivedTask11 = _subject.ReceiveMessageAsync(11, BsonDocumentSerializer.Instance, _messageEncoderSettings, Timeout.InfiniteTimeSpan, CancellationToken.None);
var receivedTask10 = _subject.ReceiveMessageAsync(10, BsonDocumentSerializer.Instance, _messageEncoderSettings, Timeout.InfiniteTimeSpan, 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.WriteRepliesToStream(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 ReceiveMessageAsync_should_complete_when_reply_is_not_already_on_the_stream()
{
using (var stream = new BlockingMemoryStream())
{
_streamFactory.CreateStreamAsync(null, Timeout.InfiniteTimeSpan, CancellationToken.None)
.ReturnsForAnyArgs(Task.FromResult<Stream>(stream));
_subject.OpenAsync(Timeout.InfiniteTimeSpan, CancellationToken.None).Wait();
var receivedTask = _subject.ReceiveMessageAsync(10, BsonDocumentSerializer.Instance, _messageEncoderSettings, Timeout.InfiniteTimeSpan, CancellationToken.None);
receivedTask.IsCompleted.Should().BeFalse();
var messageToReceive = MessageHelper.BuildSuccessReply<BsonDocument>(new BsonDocument(), BsonDocumentSerializer.Instance, responseTo: 10);
MessageHelper.WriteRepliesToStream(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_complete_when_reply_is_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 messageToReceive = MessageHelper.BuildSuccessReply<BsonDocument>(new BsonDocument(), BsonDocumentSerializer.Instance, responseTo: 10);
MessageHelper.WriteResponsesToStream(stream, new[] { messageToReceive });
var encoderSelector = new ReplyMessageEncoderSelector<BsonDocument>(BsonDocumentSerializer.Instance);
var received = _subject.ReceiveMessageAsync(10, encoderSelector, _messageEncoderSettings, CancellationToken.None).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_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_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();
}
}
public void ReceiveMessageAsync_should_complete_when_reply_is_already_on_the_stream()
{
using (var stream = new BlockingMemoryStream())
{
_streamFactory.CreateStreamAsync(null, Timeout.InfiniteTimeSpan, CancellationToken.None)
.ReturnsForAnyArgs(Task.FromResult<Stream>(stream));
_subject.OpenAsync(Timeout.InfiniteTimeSpan, CancellationToken.None).Wait();
var messageToReceive = MessageHelper.BuildSuccessReply<BsonDocument>(new BsonDocument(), BsonDocumentSerializer.Instance, responseTo: 10);
MessageHelper.WriteRepliesToStream(stream, new[] { messageToReceive });
var received = _subject.ReceiveMessageAsync(10, BsonDocumentSerializer.Instance, Timeout.InfiniteTimeSpan, CancellationToken.None).Result;
var expected = MessageHelper.TranslateMessagesToBsonDocuments(new[] { messageToReceive });
var actual = MessageHelper.TranslateMessagesToBsonDocuments(new[] { received });
actual.Should().BeEquivalentTo(expected);
_listener.ReceivedWithAnyArgs().ConnectionBeforeReceivingMessage(null, default(int));
_listener.ReceivedWithAnyArgs().ConnectionAfterReceivingMessage<BsonDocument>(null, null, default(int), default(TimeSpan));
}
}
