public async Task ReadSingleMessageAsync_EmptyMessage_ReturnNoData()
{
// Arrange
var base64 = Convert.ToBase64String(
new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x00, // length = 0
});
var data = Encoding.UTF8.GetBytes(base64);
var ms = new MemoryStream(data);
var pipeReader = new TestPipeReader(new Base64PipeReader(PipeReader.Create(ms)));
// Act
var messageData = await pipeReader.ReadSingleMessageAsync(HttpContextServerCallContextHelper.CreateServerCallContext(), MarshallerEchoRequest.ContextualDeserializer);
// Assert
Assert.AreEqual(string.Empty, messageData.Message);
Assert.AreEqual(5, pipeReader.Consumed);
}
public void AsStreamReturnsSameInstance()
{
var pipeReader = new TestPipeReader();
Stream stream = pipeReader.AsStream();
Assert.Same(stream, pipeReader.AsStream());
}
public TestDuplexPipe(bool writerForceAsync = false)
{
_input = new TestPipeReader();
Output = new TestPipeWriter
{
ForceAsync = writerForceAsync
};
}
public async Task DefaultPipeReaderImplementationReturnsPipeReaderStream()
{
var pipeReader = new TestPipeReader();
Stream stream = pipeReader.AsStream();
await stream.ReadAsync(new byte[10]);
Assert.True(pipeReader.ReadCalled);
Assert.True(pipeReader.AdvanceToCalled);
}
public async Task ReadStreamMessageAsync_MessageSplitAcrossReadsWithAdditionalData_ExamineMessageOnly()
{
// Arrange
var emptyMessage = new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x00, // length = 0
0x00, // compression = 0
};
var followingMessage = new byte[]
{
0x00,
0x00,
0x00,
0x00, // length = 0
0x00, // extra data
};
var requestStream = new SyncPointMemoryStream(runContinuationsAsynchronously: false);
var pipeReader = new TestPipeReader(PipeReader.Create(requestStream));
var testServerCallContext = HttpContextServerCallContextHelper.CreateServerCallContext();
// Act 1
var messageData1Task = pipeReader.ReadStreamMessageAsync(testServerCallContext, TestDataMarshaller.ContextualDeserializer).AsTask();
await requestStream.AddDataAndWait(emptyMessage).DefaultTimeout();
// Assert 1
Assert.AreEqual(0, (await messageData1Task.DefaultTimeout()) !.Span.Length);
Assert.AreEqual(5, pipeReader.Consumed);
Assert.AreEqual(5, pipeReader.Examined);
// Act 2
var messageData2Task = pipeReader.ReadStreamMessageAsync(testServerCallContext, TestDataMarshaller.ContextualDeserializer).AsTask();
await requestStream.AddDataAndWait(followingMessage).DefaultTimeout();
// Assert 2
Assert.AreEqual(0, (await messageData2Task.DefaultTimeout()) !.Span.Length);
Assert.AreEqual(10, pipeReader.Consumed);
Assert.AreEqual(10, pipeReader.Examined);
// Act 3
var messageData3Task = pipeReader.ReadStreamMessageAsync(testServerCallContext, TestDataMarshaller.ContextualDeserializer).AsTask();
await requestStream.AddDataAndWait(Array.Empty <byte>()).DefaultTimeout();
// Assert 3
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => messageData3Task).DefaultTimeout();
Assert.AreEqual("Incomplete message.", ex.Status.Detail);
Assert.AreEqual(10, pipeReader.Consumed);
Assert.AreEqual(11, pipeReader.Examined); // Examined ahead to ask for more data
}
public async Task ReadSingleMessageAsync_MessageInMultiplePipeReads_ReadMessageData()
{
// Arrange
var messageData = new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x01, // length = 1
0x10
};
// Run continuations without async so ReadSingleMessageAsync immediately consumes added data
var requestStream = new SyncPointMemoryStream(runContinuationsAsynchronously: false);
var pipeReader = new TestPipeReader(PipeReader.Create(requestStream));
// Act
var readTask = pipeReader.ReadSingleMessageAsync(TestServerCallContext, Marshaller.ContextualDeserializer).AsTask();
// Assert
for (var i = 0; i < messageData.Length; i++)
{
var b = messageData[i];
var isLast = i == messageData.Length - 1;
Assert.IsFalse(readTask.IsCompleted, "Still waiting for data");
await requestStream.AddDataAndWait(new[] { b }).DefaultTimeout();
if (!isLast)
{
Assert.AreEqual(0, pipeReader.Consumed);
Assert.AreEqual(i + 1, pipeReader.Examined);
}
else
{
Assert.AreEqual(messageData.Length, pipeReader.Consumed); // Consumed message
Assert.AreEqual(messageData.Length, pipeReader.Examined);
}
}
await requestStream.AddDataAndWait(Array.Empty <byte>()).DefaultTimeout();
var readMessageData = await readTask.DefaultTimeout();
// Assert
CollectionAssert.AreEqual(new byte[] { 0x10 }, readMessageData);
}
public async Task ReadStreamMessageAsync_MultipleMessages_Success()
{
// Arrange
var data = Encoding.UTF8.GetBytes("AAAAAAYKBHRlc3Q=AAAAAAYKBHRlc3Q=AAAAAAYKBHRlc3Q=AAAAAAYKBHRlc3Q=AAAAAAYKBHRlc3Q=");
var ms = new MemoryStream(data);
var pipeReader = new TestPipeReader(new Base64PipeReader(PipeReader.Create(ms)));
// Act 1
var messageData = await pipeReader.ReadStreamMessageAsync(HttpContextServerCallContextHelper.CreateServerCallContext(), MarshallerEchoResponse.ContextualDeserializer);
// Assert 1
Assert.AreEqual("test", messageData !.Message);
Assert.AreEqual(11, pipeReader.Consumed);
// Act 2
messageData = await pipeReader.ReadStreamMessageAsync(HttpContextServerCallContextHelper.CreateServerCallContext(), MarshallerEchoResponse.ContextualDeserializer);
// Assert 2
Assert.AreEqual("test", messageData !.Message);
Assert.AreEqual(22, pipeReader.Consumed);
// Act 3
messageData = await pipeReader.ReadStreamMessageAsync(HttpContextServerCallContextHelper.CreateServerCallContext(), MarshallerEchoResponse.ContextualDeserializer);
// Assert 3
Assert.AreEqual("test", messageData !.Message);
Assert.AreEqual(33, pipeReader.Consumed);
// Act 4
messageData = await pipeReader.ReadStreamMessageAsync(HttpContextServerCallContextHelper.CreateServerCallContext(), MarshallerEchoResponse.ContextualDeserializer);
// Assert 4
Assert.AreEqual("test", messageData !.Message);
Assert.AreEqual(44, pipeReader.Consumed);
// Act 5
messageData = await pipeReader.ReadStreamMessageAsync(HttpContextServerCallContextHelper.CreateServerCallContext(), MarshallerEchoResponse.ContextualDeserializer);
// Assert 5
Assert.AreEqual("test", messageData !.Message);
Assert.AreEqual(55, pipeReader.Consumed);
// Act 6
messageData = await pipeReader.ReadStreamMessageAsync(HttpContextServerCallContextHelper.CreateServerCallContext(), MarshallerEchoResponse.ContextualDeserializer);
// Assert 6
Assert.IsNull(messageData);
}
public async Task ReadSingleMessageAsync_SmallMessage_Success()
{
// Arrange
var data = Encoding.UTF8.GetBytes("AAAAAAYKBHRlc3Q=");
var ms = new MemoryStream(data);
var pipeReader = new TestPipeReader(new Base64PipeReader(PipeReader.Create(ms)));
// Act
var messageData = await pipeReader.ReadSingleMessageAsync(HttpContextServerCallContextHelper.CreateServerCallContext(), MarshallerEchoRequest.ContextualDeserializer);
// Assert
Assert.AreEqual("test", messageData.Message);
Assert.AreEqual(11, pipeReader.Consumed);
}
public void GlobalSetup()
{
var marshaller = Marshallers.Create((arg) => MessageExtensions.ToByteArray(arg), bytes => new ChatMessage());
var method = new Method <ChatMessage, ChatMessage>(MethodType.Unary, typeof(TestService).FullName, nameof(TestService.SayHello), marshaller, marshaller);
var result = Task.FromResult(new ChatMessage());
_callHandler = new UnaryServerCallHandler <TestService, ChatMessage, ChatMessage>(
method,
(service, request, context) => result,
ServiceOptions,
NullLoggerFactory.Instance);
_trailers = new HeaderDictionary();
var message = new ChatMessage
{
Name = "Joe"
};
var ms = new MemoryStream();
MessageHelpers.WriteMessage(ms, message);
_requestMessage = ms.ToArray();
_requestPipe = new TestPipeReader();
var services = new ServiceCollection();
services.TryAddSingleton <IGrpcServiceActivator <TestService> >(new TestGrpcServiceActivator <TestService>(new TestService()));
services.TryAddSingleton <IGrpcInterceptorActivator <UnaryAwaitInterceptor> >(new TestGrpcInterceptorActivator <UnaryAwaitInterceptor>(new UnaryAwaitInterceptor()));
_requestServices = services.BuildServiceProvider();
_httpContext = new DefaultHttpContext();
_httpContext.RequestServices = _requestServices;
_httpContext.Request.BodyReader = _requestPipe;
_httpContext.Request.ContentType = GrpcProtocolConstants.GrpcContentType;
_httpContext.Response.BodyWriter = new TestPipeWriter();
_httpContext.Features.Set <IHttpResponseTrailersFeature>(new TestHttpResponseTrailersFeature
{
Trailers = _trailers
});
}
public async Task ReadSingleMessageAsync_EmptyMessage_ReturnNoData()
{
// Arrange
var ms = new MemoryStream(new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x00 // length = 0
});
var pipeReader = new TestPipeReader(PipeReader.Create(ms));
// Act
var messageData = await pipeReader.ReadSingleMessageAsync(TestServerCallContext, Marshaller.ContextualDeserializer);
// Assert
Assert.AreEqual(0, messageData.Length);
Assert.AreEqual(5, pipeReader.Consumed);
}
public async Task ThrowingFromStreamCallsAdvanceToWithStartOfLastReadResult(int throwAfterNWrites)
{
var wrappedPipeReader = new TestPipeReader(PipeReader);
var stream = new ThrowAfterNWritesStream(throwAfterNWrites);
Task task = wrappedPipeReader.CopyToAsync(stream);
Pipe.Writer.WriteEmpty(10);
await Pipe.Writer.FlushAsync();
// Write twice for the test case where the stream throws on the second write.
Pipe.Writer.WriteEmpty(10);
await Pipe.Writer.FlushAsync();
await Assert.ThrowsAsync <InvalidOperationException>(() => task);
SequencePosition startPosition = wrappedPipeReader.LastReadResult.Buffer.Start;
Assert.NotNull(startPosition.GetObject());
Assert.True(startPosition.Equals(wrappedPipeReader.LastConsumed));
Assert.True(startPosition.Equals(wrappedPipeReader.LastExamined));
}
public async Task ReadStreamMessageAsync_MultipleEmptyMessages_ReturnNoDataMessageThenComplete()
{
// Arrange
var emptyMessage = new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x00 // length = 0
};
var ms = new MemoryStream(emptyMessage.Concat(emptyMessage).ToArray());
var pipeReader = new TestPipeReader(PipeReader.Create(ms));
var testServerCallContext = HttpContextServerCallContextHelper.CreateServerCallContext();
// Act 1
var messageData1 = await pipeReader.ReadStreamMessageAsync(testServerCallContext, TestDataMarshaller.ContextualDeserializer);
// Assert 1
Assert.AreEqual(0, messageData1 !.Span.Length);
Assert.AreEqual(emptyMessage.Length, pipeReader.Consumed);
// Act 2
var messageData2 = await pipeReader.ReadStreamMessageAsync(testServerCallContext, TestDataMarshaller.ContextualDeserializer);
// Assert 2
Assert.AreEqual(0, messageData2 !.Span.Length);
Assert.AreEqual(emptyMessage.Length * 2, pipeReader.Consumed);
// Act 3
var messageData3 = await pipeReader.ReadStreamMessageAsync(testServerCallContext, TestDataMarshaller.ContextualDeserializer);
// Assert 3
Assert.IsNull(messageData3);
Assert.AreEqual(emptyMessage.Length * 2, pipeReader.Consumed);
}
