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); }