public void CanSeek_ReturnsFalse()
{
using (var stream = new BlockingMemoryStream())
{
Assert.IsFalse(stream.CanSeek);
}
}
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 void LengthnGet_ThrowsNotSupportedException()
{
using (var stream = new BlockingMemoryStream())
{
Assert.Throws <NotSupportedException>(() => { var temp = stream.Length; });
}
}
public void SetLength_ThrowsNotSupportedException()
{
using (var stream = new BlockingMemoryStream())
{
Assert.Throws <NotSupportedException>(() => { stream.SetLength(0); });
}
}
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 PositionSet_ThrowsNotSupportedException()
{
using (var stream = new BlockingMemoryStream())
{
Assert.Throws <NotSupportedException>(() => { stream.Position = 0; });
}
}
public void DisposeThenWrite_ThrowsObjectDisposedException()
{
var stream = new BlockingMemoryStream();
stream.Dispose();
Assert.Throws <ObjectDisposedException>(() => stream.Write(new byte[1], 0, 1));
}
public void CanRead_ReturnsTrue()
{
using (var stream = new BlockingMemoryStream())
{
Assert.IsTrue(stream.CanRead);
}
}
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 receivedTask11 = _subject.ReceiveMessageAsync(11, BsonDocumentSerializer.Instance, _messageEncoderSettings, CancellationToken.None);
var receivedTask10 = _subject.ReceiveMessageAsync(10, BsonDocumentSerializer.Instance, _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.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 Seek_ThrowsNotSupportedException()
{
using (var stream = new BlockingMemoryStream())
{
Assert.Throws <NotSupportedException>(() => stream.Seek(0, SeekOrigin.Begin));
}
}
public void WriteAfterCompleteWriting_ThrowsInvalidOperationException()
{
using (var stream = new BlockingMemoryStream())
{
stream.CompleteWriting();
Assert.Throws <InvalidOperationException>(() => stream.Write(new byte[1], 0, 1));
}
}
public void CanWriteAfterCompleteWriting_ReturnsFalse()
{
using (var stream = new BlockingMemoryStream())
{
stream.CompleteWriting();
Assert.IsFalse(stream.CanWrite);
}
}
public void Flush_DoesNothing()
{
using (var stream = new BlockingMemoryStream())
{
// Just to make sure this doesn't throw an exception or anything like that.
stream.Flush();
}
}
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 WriteThenGetConsumingEnumerable_StopsBlockingWhenCompleteWriting()
{
var buffer = new byte[] { 1, 2, 3 };
using (var stream = new BlockingMemoryStream())
{
stream.Write(buffer, 0, buffer.Length);
var readToListTask = new TaskFactory().StartNew(() => stream.GetConsumingEnumerable().ToList());
Assert.IsFalse(readToListTask.Wait(millisecondsTimeout: 100));
stream.CompleteWriting();
Assert.IsTrue(readToListTask.Wait(millisecondsTimeout: 1000));
CollectionAssert.AreEqual(buffer, readToListTask.Result);
}
}
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 void WriteThenRead_Timeout()
{
var buffer = new byte[] { 1, 2, 3 };
using (var stream = new BlockingMemoryStream())
{
stream.Write(buffer, 0, 3);
// If we try to read too much, then it should stop blocking and return once we hit the timout.
var readBuffer = new byte[4];
var readTask = new TaskFactory().StartNew(() =>
stream.Read(readBuffer, offset: 0, count: 4, timeout: TimeSpan.FromMilliseconds(10), cancellationToken: CancellationToken.None)
);
Assert.IsTrue(readTask.Wait(millisecondsTimeout: 100));
var readCount = readTask.Result;
Assert.AreEqual(3, readCount);
CollectionAssert.AreEqual(buffer, readBuffer.Take(3));
}
}
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 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();
var messageToReceive = MessageHelper.BuildSuccessReply <BsonDocument>(new BsonDocument(), BsonDocumentSerializer.Instance, responseTo: 10);
MessageHelper.WriteRepliesToStream(stream, new[] { messageToReceive });
var received = _subject.ReceiveMessageAsync(10, BsonDocumentSerializer.Instance, _messageEncoderSettings, CancellationToken.None).Result;
var expected = MessageHelper.TranslateMessagesToBsonDocuments(new[] { messageToReceive });
var actual = MessageHelper.TranslateMessagesToBsonDocuments(new[] { received });
actual.Should().BeEquivalentTo(expected);
_listener.ReceivedWithAnyArgs().ConnectionBeforeReceivingMessage(default(ConnectionBeforeReceivingMessageEvent));
_listener.ReceivedWithAnyArgs().ConnectionAfterReceivingMessage <BsonDocument>(default(ConnectionAfterReceivingMessageEvent <BsonDocument>));
}
}
public void Write_TimeoutUntilRead()
{
var buffer = new byte[] { 1, 2, 3 };
using (var stream = new BlockingMemoryStream(boundedCapacity: 2))
{
// Write one byte more than the capacity, should cause the write to block.
var writeTask = new TaskFactory().StartNew(() =>
stream.Write(buffer, 0, 3)
);
Assert.IsFalse(writeTask.Wait(millisecondsTimeout: 100));
// Read one byte
var readByteTask = new TaskFactory().StartNew(() =>
stream.ReadByte()
);
Assert.IsTrue(readByteTask.Wait(millisecondsTimeout: 1000));
Assert.AreEqual(1, readByteTask.Result);
// Now there should be enough buffer space to finish the write task.
Assert.IsTrue(writeTask.Wait(millisecondsTimeout: 1000));
}
}
public void WriteThenReadToEnd_StopsBlockingWhenCompleteWriting()
{
var buffer = new byte[] { 1, 2, 3 };
using (var stream = new BlockingMemoryStream())
{
stream.Write(buffer, 0, buffer.Length);
// We can read a byte without hitting any blocking
var readByteTask = new TaskFactory().StartNew(() => stream.ReadByte());
Assert.IsTrue(readByteTask.Wait(millisecondsTimeout: 1000));
Assert.AreEqual(1, readByteTask.Result);
// If we try to read to the end, then we should block until we call CompleteWriting
var readToEndTask = new TaskFactory().StartNew(() => StreamUtils.ReadToEnd(stream));
Assert.IsFalse(readToEndTask.Wait(millisecondsTimeout: 100));
stream.CompleteWriting();
Assert.IsTrue(readToEndTask.Wait(millisecondsTimeout: 1000));
CollectionAssert.AreEqual(buffer.Skip(1), readToEndTask.Result);
}
}
public SoapActionSearchBuffer()
{
this.stream = new BlockingMemoryStream();
this.waitHandle = new ManualResetEventSlim(false);
}
