public async Task ReadSingleMessageAsync_OneByteMessage_ReturnData()
{
// Arrange
var ms = new MemoryStream(new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x01, // length = 1
0x10
});
var pipeReader = PipeReader.Create(ms);
// Act
var messageData = await pipeReader.ReadSingleMessageAsync(HttpContextServerCallContextHelper.CreateServerCallContext(), TestDataMarshaller.ContextualDeserializer);
// Assert
Assert.AreEqual(1, messageData.Span.Length);
Assert.AreEqual(0x10, messageData.Span[0]);
}
public async Task WriteAsync_DefaultWriteOptions_Flushes()
{
// Arrange
var ms = new MemoryStream();
var httpContext = new DefaultHttpContext();
httpContext.Features.Set <IHttpResponseBodyFeature>(new TestResponseBodyFeature(PipeWriter.Create(ms)));
var serverCallContext = HttpContextServerCallContextHelper.CreateServerCallContext(httpContext);
var writer = new HttpContextStreamWriter <HelloReply>(serverCallContext, MessageHelpers.ServiceMethod.ResponseMarshaller.ContextualSerializer);
// Act 1
await writer.WriteAsync(new HelloReply
{
Message = "Hello world 1"
});
// Assert 1
Assert.AreEqual(20, ms.Length);
// Act 2
await writer.WriteAsync(new HelloReply
{
Message = "Hello world 2"
});
// Assert 2
Assert.AreEqual(40, ms.Length);
ms.Seek(0, SeekOrigin.Begin);
var pipeReader = PipeReader.Create(ms);
var writtenMessage1 = await MessageHelpers.AssertReadStreamMessageAsync <HelloReply>(pipeReader);
Assert.AreEqual("Hello world 1", writtenMessage1 !.Message);
var writtenMessage2 = await MessageHelpers.AssertReadStreamMessageAsync <HelloReply>(pipeReader);
Assert.AreEqual("Hello world 2", writtenMessage2 !.Message);
}
public async Task WriteAsync_DefaultWriteOptions_Flushes()
{
// Arrange
var ms = new MemoryStream();
var httpContext = new DefaultHttpContext();
httpContext.Response.BodyPipe = new StreamPipeWriter(ms);
var serverCallContext = HttpContextServerCallContextHelper.CreateServerCallContext(httpContext);
var writer = new HttpContextStreamWriter <HelloReply>(serverCallContext, (message) => message.ToByteArray());
// Act 1
await writer.WriteAsync(new HelloReply
{
Message = "Hello world 1"
});
// Assert 1
Assert.AreEqual(20, ms.Length);
// Act 2
await writer.WriteAsync(new HelloReply
{
Message = "Hello world 2"
});
// Assert 2
Assert.AreEqual(40, ms.Length);
ms.Seek(0, SeekOrigin.Begin);
var pipeReader = new StreamPipeReader(ms);
var writtenMessage1 = await MessageHelpers.AssertReadStreamMessageAsync <HelloReply>(pipeReader);
Assert.AreEqual("Hello world 1", writtenMessage1.Message);
var writtenMessage2 = await MessageHelpers.AssertReadStreamMessageAsync <HelloReply>(pipeReader);
Assert.AreEqual("Hello world 2", writtenMessage2.Message);
}
public async Task WriteMessageAsync_HasCustomCompressionLevel_WriteCompressedDataWithLevel()
{
// Arrange
var mockCompressionProvider = new MockCompressionProvider();
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers[GrpcProtocolConstants.MessageAcceptEncodingHeader] = "Mock";
var context = HttpContextServerCallContextHelper.CreateServerCallContext(
httpContext,
responseCompressionAlgorithm: "Mock",
responseCompressionLevel: System.IO.Compression.CompressionLevel.Optimal,
compressionProviders: new List <ICompressionProvider>
{
mockCompressionProvider
});
context.Initialize();
var ms = new MemoryStream();
var pipeWriter = PipeWriter.Create(ms);
// Act
await pipeWriter.WriteMessageAsync(new TestData(new byte[] { 0x10 }), context, TestDataMarshaller.ContextualSerializer, canFlush : true);
// Assert
Assert.AreEqual(System.IO.Compression.CompressionLevel.Optimal, mockCompressionProvider.ArgumentCompression);
var messageData = ms.ToArray();
Assert.AreEqual(1, messageData[0]); // compression
Assert.AreEqual(21, messageData[4]); // message length
byte[] result = Decompress(mockCompressionProvider, messageData);
Assert.AreEqual(1, result.Length);
Assert.AreEqual(0x10, result[0]);
}
public async Task MoveNext_TokenCancelledDuringMoveNext_CancelTask()
{
// Arrange
var ms = new SyncPointMemoryStream();
var testSink = new TestSink();
var testLoggerFactory = new TestLoggerFactory(testSink, enabled: true);
var httpContext = new DefaultHttpContext();
httpContext.Features.Set <IRequestBodyPipeFeature>(new TestRequestBodyPipeFeature(PipeReader.Create(ms)));
var serverCallContext = HttpContextServerCallContextHelper.CreateServerCallContext(httpContext, logger: testLoggerFactory.CreateLogger("Test"));
var reader = new HttpContextStreamReader <HelloReply>(serverCallContext, MessageHelpers.ServiceMethod.ResponseMarshaller.ContextualDeserializer);
var cts = new CancellationTokenSource();
var nextTask = reader.MoveNext(cts.Token);
Assert.IsFalse(nextTask.IsCompleted);
Assert.IsFalse(nextTask.IsCanceled);
cts.Cancel();
try
{
await nextTask;
Assert.Fail();
}
catch (TaskCanceledException)
{
}
Assert.IsTrue(nextTask.IsCompleted);
Assert.IsTrue(nextTask.IsCanceled);
Assert.AreEqual(1, testSink.Writes.Count);
Assert.AreEqual("ReadingMessage", testSink.Writes.First().EventId.Name);
}
public async Task WriteMessageAsync_EmptyMessage_WriteMessageWithNoData()
{
// Arrange
var ms = new MemoryStream();
var pipeWriter = PipeWriter.Create(ms);
// Act
await pipeWriter.WriteMessageAsync(new TestData(Array.Empty <byte>()), HttpContextServerCallContextHelper.CreateServerCallContext(), TestDataMarshaller.ContextualSerializer, canFlush : true);
// Assert
var messageData = ms.ToArray();
CollectionAssert.AreEqual(
new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x00, // length = 0
},
messageData);
}
public async Task ReadStreamMessageAsync_MessageDataIncomplete_ThrowError()
{
// Arrange
var ms = new MemoryStream(new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x02, // length = 2
0x10
});
var pipeReader = PipeReader.Create(ms);
// Act
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(
() => pipeReader.ReadStreamMessageAsync(HttpContextServerCallContextHelper.CreateServerCallContext(), TestDataMarshaller.ContextualDeserializer).AsTask()).DefaultTimeout();
// Assert
Assert.AreEqual("Incomplete message.", ex.Status.Detail);
Assert.AreEqual(StatusCode.Internal, ex.StatusCode);
}
public async Task Invoke_SuccessAwaitedRelease_ReleaseCalled()
{
// Arrange
var releaseTcs = new TaskCompletionSource <object?>(TaskCreationOptions.RunContinuationsAsynchronously);
var serviceActivator = new TcsGrpcServiceActivator <TestService>(releaseTcs);
var invoker = new UnaryServerMethodInvoker <TestService, TestMessage, TestMessage>(
(service, reader, context) => Task.FromResult(new TestMessage()),
new Method <TestMessage, TestMessage>(MethodType.Unary, "test", "test", _marshaller, _marshaller),
HttpContextServerCallContextHelper.CreateMethodOptions(),
serviceActivator);
var httpContext = HttpContextHelpers.CreateContext();
// Act
var task = invoker.Invoke(httpContext, HttpContextServerCallContextHelper.CreateServerCallContext(), new TestMessage());
Assert.False(task.IsCompleted);
releaseTcs.SetResult(null);
await task;
// Assert
Assert.True(serviceActivator.Released);
}
public async Task MoveNext_TokenCancelledDuringMoveNext_CancelTask()
{
// Arrange
var ms = new SyncPointMemoryStream();
var httpContext = new DefaultHttpContext();
httpContext.Request.BodyReader = new StreamPipeReader(ms);
var serverCallContext = HttpContextServerCallContextHelper.CreateServerCallContext(httpContext);
var reader = new HttpContextStreamReader <HelloReply>(serverCallContext, (data) =>
{
var message = new HelloReply();
message.MergeFrom(data);
return(message);
});
var cts = new CancellationTokenSource();
var nextTask = reader.MoveNext(cts.Token);
Assert.IsFalse(nextTask.IsCompleted);
Assert.IsFalse(nextTask.IsCanceled);
cts.Cancel();
try
{
await nextTask;
Assert.Fail();
}
catch (TaskCanceledException)
{
}
Assert.IsTrue(nextTask.IsCompleted);
Assert.IsTrue(nextTask.IsCanceled);
}
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);
}
public async Task WriteMessageAsync_HasCustomCompressionLevel_WriteCompressedDataWithLevel()
{
// Arrange
var mockCompressionProvider = new MockCompressionProvider();
var serviceOptions = new GrpcServiceOptions
{
ResponseCompressionAlgorithm = "Mock",
ResponseCompressionLevel = System.IO.Compression.CompressionLevel.Optimal,
CompressionProviders =
{
mockCompressionProvider
}
};
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers[GrpcProtocolConstants.MessageAcceptEncodingHeader] = "Mock";
var context = HttpContextServerCallContextHelper.CreateServerCallContext(httpContext, serviceOptions);
context.Initialize();
var ms = new MemoryStream();
var pipeWriter = PipeWriter.Create(ms);
// Act
await pipeWriter.WriteMessageAsync(new byte[] { 0x10 }, context, flush : true);
// Assert
Assert.AreEqual(System.IO.Compression.CompressionLevel.Optimal, mockCompressionProvider.ArgumentCompression);
var messageData = ms.ToArray();
Assert.AreEqual(1, messageData[0]); // compression
Assert.AreEqual(21, messageData[4]); // message length
}
public async Task ReadSingleMessageAsync_ExceedReceiveSize_ReturnData()
{
// Arrange
var context = HttpContextServerCallContextHelper.CreateServerCallContext(maxReceiveMessageSize: 1);
var ms = new MemoryStream(new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x02, // length = 1
0x10,
0x10
});
var pipeReader = PipeReader.Create(ms);
// Act
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => pipeReader.ReadSingleMessageAsync(context, TestDataMarshaller.ContextualDeserializer).AsTask()).DefaultTimeout();
// Assert
Assert.AreEqual("Received message exceeds the maximum configured message size.", ex.Status.Detail);
Assert.AreEqual(StatusCode.ResourceExhausted, ex.StatusCode);
}
public async Task WriteMessageAsync_NoFlush_WriteNoData()
{
// Arrange
var ms = new MemoryStream();
var pipeWriter = PipeWriter.Create(ms);
// Act
await pipeWriter.WriteMessageAsync(new TestData(Encoding.UTF8.GetBytes("Hello world")), HttpContextServerCallContextHelper.CreateServerCallContext(), TestDataMarshaller.ContextualSerializer, canFlush : false);
// Assert
var messageData = ms.ToArray();
Assert.AreEqual(0, messageData.Length);
}
public async Task WriteStreamedMessageAsync_OneByteMessage_WriteData()
{
// Arrange
var ms = new MemoryStream();
var pipeWriter = PipeWriter.Create(ms);
// Act
await pipeWriter.WriteStreamedMessageAsync(new TestData(new byte[] { 0x10 }), HttpContextServerCallContextHelper.CreateServerCallContext(), TestDataMarshaller.ContextualSerializer);
// Assert
var messageData = ms.ToArray();
CollectionAssert.AreEqual(
new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x01, // length = 1
0x10
},
messageData);
}