public async Task WriteMessageAsync_GzipCompressed_WriteCompressedData()
{
// Arrange
var compressionProviders = new List <ICompressionProvider>
{
new GzipCompressionProvider(System.IO.Compression.CompressionLevel.Fastest)
};
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers[GrpcProtocolConstants.MessageAcceptEncodingHeader] = "gzip";
var context = HttpContextServerCallContextHelper.CreateServerCallContext(
httpContext,
responseCompressionAlgorithm: "gzip",
compressionProviders: compressionProviders);
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
var messageData = ms.ToArray();
Assert.AreEqual(1, messageData[0]); // compression
Assert.AreEqual(21, messageData[4]); // message length
byte[] result = Decompress(compressionProviders.Single(), messageData);
Assert.AreEqual(1, result.Length);
Assert.AreEqual(0x10, result[0]);
}
public async Task Invoke_AwaitedSuccess_ReleaseCalled()
{
// Arrange
var methodTcs = new TaskCompletionSource <TestMessage>(TaskCreationOptions.RunContinuationsAsynchronously);
var methodResult = new TestMessage();
var serviceActivator = new TestGrpcServiceActivator <TestService>();
var invoker = new UnaryServerMethodInvoker <TestService, TestMessage, TestMessage>(
(service, reader, context) => methodTcs.Task,
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);
methodTcs.SetResult(methodResult);
var awaitedResult = await task;
// Assert
Assert.AreEqual(methodResult, awaitedResult);
Assert.True(serviceActivator.Released);
}
public async Task ReadSingleMessageAsync_ExceedReceiveSize_ReturnData()
{
// Arrange
var context = HttpContextServerCallContextHelper.CreateServerCallContext(serviceOptions: new GrpcServiceOptions {
ReceiveMaxMessageSize = 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, Marshaller.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 ReadSingleMessageAsync_AdditionalDataInSeparatePipeRead_ThrowError()
{
// Arrange
var requestStream = new SyncPointMemoryStream();
var pipeReader = PipeReader.Create(requestStream);
// Act
var readTask = pipeReader.ReadSingleMessageAsync(HttpContextServerCallContextHelper.CreateServerCallContext(), TestDataMarshaller.ContextualDeserializer).AsTask();
// Assert
Assert.IsFalse(readTask.IsCompleted, "Still waiting for data");
await requestStream.AddDataAndWait(new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x01, // length = 1
0x10
}).DefaultTimeout();
Assert.IsFalse(readTask.IsCompleted, "Still waiting for data");
await requestStream.AddDataAndWait(new byte[] { 0x00 }).DefaultTimeout();
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => readTask).DefaultTimeout();
// Assert
Assert.AreEqual("Additional data after the message received.", ex.Status.Detail);
Assert.AreEqual(StatusCode.Internal, ex.StatusCode);
}
public async Task WriteMessageAsync_GzipCompressed_WriteCompressedData()
{
// Arrange
var serviceOptions = new GrpcServiceOptions
{
ResponseCompressionAlgorithm = "gzip",
CompressionProviders =
{
new GzipCompressionProvider(System.IO.Compression.CompressionLevel.Fastest)
}
};
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers[GrpcProtocolConstants.MessageAcceptEncodingHeader] = "gzip";
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, Marshaller.ContextualSerializer, canFlush : true);
// Assert
var messageData = ms.ToArray();
Assert.AreEqual(1, messageData[0]); // compression
Assert.AreEqual(21, messageData[4]); // message length
}
public async Task WriteMessageAsync_UnderSendSize_WriteData()
{
// Arrange
var context = HttpContextServerCallContextHelper.CreateServerCallContext(serviceOptions: new GrpcServiceOptions {
SendMaxMessageSize = 1
});
var ms = new MemoryStream();
var pipeWriter = PipeWriter.Create(ms);
// Act
await pipeWriter.WriteMessageAsync(new byte[] { 0x10 }, context, Marshaller.ContextualSerializer, canFlush : true);
// Assert
var messageData = ms.ToArray();
CollectionAssert.AreEqual(
new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x01, // length = 1
0x10
},
messageData);
}
public async Task WriteAsync_WriteInProgress_Error()
{
// Arrange
var tcs = new TaskCompletionSource <object?>(TaskCreationOptions.RunContinuationsAsynchronously);
var httpContext = new DefaultHttpContext();
httpContext.Features.Set <IHttpResponseBodyFeature>(new TestResponseBodyFeature(PipeWriter.Create(new MemoryStream()), startAsyncTask: tcs.Task));
var serverCallContext = HttpContextServerCallContextHelper.CreateServerCallContext(httpContext);
var writer = new HttpContextStreamWriter <HelloReply>(serverCallContext, MessageHelpers.ServiceMethod.ResponseMarshaller.ContextualSerializer);
// Act
_ = writer.WriteAsync(new HelloReply
{
Message = "Hello world 1"
});
var ex = await ExceptionAssert.ThrowsAsync <InvalidOperationException>(() =>
{
return(writer.WriteAsync(new HelloReply
{
Message = "Hello world 2"
}));
});
// Assert
Assert.AreEqual("Can't write the message because the previous write is in progress.", ex.Message);
}
public async Task ReadSingleMessageAsync_UnderReceiveSize_ReturnData()
{
// Arrange
var context = HttpContextServerCallContextHelper.CreateServerCallContext(serviceOptions: new GrpcServiceOptions {
SendMaxMessageSize = 1
});
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(context, Marshaller.ContextualDeserializer);
// Assert
Assert.AreEqual(1, messageData.Length);
Assert.AreEqual(0x10, messageData[0]);
}
public async Task WriteStreamedMessageAsync_UnderSendSize_WriteData()
{
// Arrange
var context = HttpContextServerCallContextHelper.CreateServerCallContext(maxSendMessageSize: 1);
var ms = new MemoryStream();
var pipeWriter = PipeWriter.Create(ms);
// Act
await pipeWriter.WriteStreamedMessageAsync(new TestData(new byte[] { 0x10 }), context, TestDataMarshaller.ContextualSerializer);
// Assert
var messageData = ms.ToArray();
CollectionAssert.AreEqual(
new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x01, // length = 1
0x10
},
messageData);
}
public async Task Invoke_ThrowExceptionAwaitedRelease_ReleaseCalledAndErrorThrown()
{
// Arrange
var releaseTcs = new TaskCompletionSource <object?>(TaskCreationOptions.RunContinuationsAsynchronously);
var serviceActivator = new TcsGrpcServiceActivator <TestService>(releaseTcs);
var thrownException = new Exception("Exception!");
var invoker = new UnaryServerMethodInvoker <TestService, TestMessage, TestMessage>(
(service, reader, context) => throw thrownException,
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);
try
{
await task;
Assert.Fail();
}
catch (Exception ex)
{
// Assert
Assert.True(serviceActivator.Released);
Assert.AreEqual(thrownException, ex);
}
}
public async Task MoveNext_TokenCancelledDuringMoveNext_CancelTask()
{
// Arrange
var ms = new SyncPointMemoryStream();
var httpContext = new DefaultHttpContext();
httpContext.Features.Set <IRequestBodyPipeFeature>(new TestRequestBodyPipeFeature(PipeReader.Create(ms)));
var serverCallContext = HttpContextServerCallContextHelper.CreateServerCallContext(httpContext);
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);
}
public async Task WriteMessageAsync_LongMessage_WriteData()
{
// Arrange
var ms = new MemoryStream();
var pipeWriter = PipeWriter.Create(ms);
var content = Encoding.UTF8.GetBytes("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam varius nibh a blandit mollis. "
+ "In hac habitasse platea dictumst. Proin non quam nec neque convallis commodo. Orci varius natoque penatibus et magnis dis "
+ "parturient montes, nascetur ridiculus mus. Mauris commodo est vehicula, semper arcu eu, ornare urna. Mauris malesuada nisl "
+ "nisl, vitae tincidunt purus vestibulum sit amet. Interdum et malesuada fames ac ante ipsum primis in faucibus.");
// Act
await pipeWriter.WriteMessageAsync(new TestData(content), HttpContextServerCallContextHelper.CreateServerCallContext(), TestDataMarshaller.ContextualSerializer, canFlush : true);
// Assert
var messageData = ms.ToArray();
CollectionAssert.AreEqual(
new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x01,
0xC1, // length = 449
}.Concat(content).ToArray(),
messageData);
}
private HttpContextServerCallContext CreateServerCallContext(HttpContext httpContext, ILogger?logger = null)
{
return(HttpContextServerCallContextHelper.CreateServerCallContext(
httpContext: httpContext,
logger: logger,
initialize: false));
}
public void GetHttpContext_HttpContextServerCallContext_Success()
{
var httpContext = new DefaultHttpContext();
var serverCallContext = HttpContextServerCallContextHelper.CreateServerCallContext(httpContext);
Assert.AreEqual(httpContext, serverCallContext.GetHttpContext());
}
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(HttpContextServerCallContextHelper.CreateServerCallContext(), TestDataMarshaller.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.Span.ToArray());
}
public async Task WriteMessageAsync_ExceedSendSize_ThrowError()
{
// Arrange
var context = HttpContextServerCallContextHelper.CreateServerCallContext(maxSendMessageSize: 1);
var ms = new MemoryStream();
var pipeWriter = PipeWriter.Create(ms);
// Act
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => pipeWriter.WriteMessageAsync(new TestData(new byte[] { 0x10, 0x10 }), context, TestDataMarshaller.ContextualSerializer, canFlush: true)).DefaultTimeout();
// Assert
Assert.AreEqual("Sending message exceeds the maximum configured message size.", ex.Status.Detail);
Assert.AreEqual(StatusCode.ResourceExhausted, ex.StatusCode);
}
public void MoveNext_AlreadyCancelledToken_CancelReturnImmediately()
{
// Arrange
var ms = new SyncPointMemoryStream();
var httpContext = new DefaultHttpContext();
var serverCallContext = HttpContextServerCallContextHelper.CreateServerCallContext(httpContext);
var reader = new HttpContextStreamReader <HelloReply>(serverCallContext, MessageHelpers.ServiceMethod.ResponseMarshaller.ContextualDeserializer);
// Act
var nextTask = reader.MoveNext(new CancellationToken(true));
// Assert
Assert.IsTrue(nextTask.IsCompleted);
Assert.IsTrue(nextTask.IsCanceled);
}
public void WriteMessageAsync_ExceedSendSize_ThrowError()
{
// Arrange
var context = HttpContextServerCallContextHelper.CreateServerCallContext(serviceOptions: new GrpcServiceOptions {
SendMaxMessageSize = 1
});
var ms = new MemoryStream();
var pipeWriter = new StreamPipeWriter(ms);
// Act
var ex = Assert.ThrowsAsync <RpcException>(() => pipeWriter.WriteMessageAsync(new byte[] { 0x10, 0x10 }, context, flush: true));
// Assert
Assert.AreEqual("Sending message exceeds the maximum configured message size.", ex.Status.Detail);
Assert.AreEqual(StatusCode.ResourceExhausted, ex.StatusCode);
}
private static ServerCallHandlerBase <TestService, TestMessage, TestMessage> CreateHandler(MethodType methodType, ILoggerFactory?loggerFactory = null)
{
var method = new Method <TestMessage, TestMessage>(methodType, "test", "test", _marshaller, _marshaller);
switch (methodType)
{
case MethodType.Unary:
return(new UnaryServerCallHandler <TestService, TestMessage, TestMessage>(
method,
(service, reader, context) => Task.FromResult(new TestMessage()),
HttpContextServerCallContextHelper.CreateMethodContext(),
loggerFactory ?? NullLoggerFactory.Instance,
new TestGrpcServiceActivator <TestService>(),
TestServiceProvider.Instance));
case MethodType.ClientStreaming:
return(new ClientStreamingServerCallHandler <TestService, TestMessage, TestMessage>(
method,
(service, reader, context) => Task.FromResult(new TestMessage()),
HttpContextServerCallContextHelper.CreateMethodContext(),
loggerFactory ?? NullLoggerFactory.Instance,
new TestGrpcServiceActivator <TestService>(),
TestServiceProvider.Instance));
case MethodType.ServerStreaming:
return(new ServerStreamingServerCallHandler <TestService, TestMessage, TestMessage>(
method,
(service, request, writer, context) => Task.FromResult(new TestMessage()),
HttpContextServerCallContextHelper.CreateMethodContext(),
loggerFactory ?? NullLoggerFactory.Instance,
new TestGrpcServiceActivator <TestService>(),
TestServiceProvider.Instance));
case MethodType.DuplexStreaming:
return(new DuplexStreamingServerCallHandler <TestService, TestMessage, TestMessage>(
method,
(service, reader, writer, context) => Task.CompletedTask,
HttpContextServerCallContextHelper.CreateMethodContext(),
loggerFactory ?? NullLoggerFactory.Instance,
new TestGrpcServiceActivator <TestService>(),
TestServiceProvider.Instance));
default:
throw new ArgumentException();
}
}
public async Task WriteMessageAsync_MultipleOneByteMessages_WriteData()
{
// Arrange
var ms = new MemoryStream();
var pipeWriter = PipeWriter.Create(ms);
var context = HttpContextServerCallContextHelper.CreateServerCallContext();
// Act 1
await pipeWriter.WriteMessageAsync(new TestData(new byte[] { 0x10 }), context, TestDataMarshaller.ContextualSerializer, canFlush : true);
// Assert 1
var messageData = ms.ToArray();
CollectionAssert.AreEqual(
new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x01, // length = 1
0x10
},
messageData);
ms.Seek(0, SeekOrigin.Begin);
// Act 2
await pipeWriter.WriteMessageAsync(new TestData(new byte[] { 0x20 }), context, TestDataMarshaller.ContextualSerializer, canFlush : true);
// Assert 2
messageData = ms.ToArray();
CollectionAssert.AreEqual(
new byte[]
{
0x00, // compression = 0
0x00,
0x00,
0x00,
0x01, // length = 1
0x20
},
messageData);
}
public async Task WriteAsync_BufferHintWriteOptions_DoesNotFlush()
{
// 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);
serverCallContext.WriteOptions = new WriteOptions(WriteFlags.BufferHint);
// Act 1
await writer.WriteAsync(new HelloReply
{
Message = "Hello world 1"
});
// Assert 1
Assert.AreEqual(0, ms.Length);
// Act 2
await writer.WriteAsync(new HelloReply
{
Message = "Hello world 2"
});
// Assert 2
Assert.AreEqual(0, ms.Length);
await httpContext.Response.BodyWriter.FlushAsync();
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_BufferHintWriteOptions_DoesNotFlush()
{
// 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());
serverCallContext.WriteOptions = new WriteOptions(WriteFlags.BufferHint);
// Act 1
await writer.WriteAsync(new HelloReply
{
Message = "Hello world 1"
});
// Assert 1
Assert.AreEqual(0, ms.Length);
// Act 2
await writer.WriteAsync(new HelloReply
{
Message = "Hello world 2"
});
// Assert 2
Assert.AreEqual(0, ms.Length);
await httpContext.Response.BodyPipe.FlushAsync();
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 void Invoke_ThrowException_ReleaseCalledAndErrorThrown()
{
// Arrange
var serviceActivator = new TestGrpcServiceActivator <TestService>();
var ex = new Exception("Exception!");
var invoker = new UnaryServerMethodInvoker <TestService, TestMessage, TestMessage>(
(service, reader, context) => throw ex,
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
Assert.True(serviceActivator.Released);
Assert.True(task.IsFaulted);
Assert.AreEqual(ex, task.Exception !.InnerException);
}
public async Task ReadMessageStreamAsync_HeaderIncomplete_ThrowError()
{
// Arrange
var ms = new MemoryStream(new byte[]
{
0x00, // compression = 0
0x00,
0x00
});
var pipeReader = PipeReader.Create(ms);
// Act
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(
() => pipeReader.ReadSingleMessageAsync(HttpContextServerCallContextHelper.CreateServerCallContext(), TestDataMarshaller.ContextualDeserializer).AsTask()).DefaultTimeout();
// Assert
Assert.AreEqual("Incomplete message.", ex.Status.Detail);
Assert.AreEqual(StatusCode.Internal, ex.StatusCode);
}
public void MoveNext_AlreadyCancelledToken_CancelReturnImmediately()
{
// Arrange
var ms = new SyncPointMemoryStream();
var httpContext = new DefaultHttpContext();
var serverCallContext = HttpContextServerCallContextHelper.CreateServerCallContext(httpContext);
var reader = new HttpContextStreamReader <HelloReply>(serverCallContext, (data) =>
{
var message = new HelloReply();
message.MergeFrom(data);
return(message);
});
// Act
var nextTask = reader.MoveNext(new CancellationToken(true));
// Assert
Assert.IsTrue(nextTask.IsCompleted);
Assert.IsTrue(nextTask.IsCanceled);
}
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(HttpContextServerCallContextHelper.CreateServerCallContext(), TestDataMarshaller.ContextualDeserializer);
// Assert
Assert.AreEqual(0, messageData.Span.Length);
Assert.AreEqual(5, pipeReader.Consumed);
}
public async Task WriteAsync_DefaultWriteOptions_Flushes()
{
// Arrange
var ms = new MemoryStream();
var httpContext = new DefaultHttpContext();
httpContext.Features.Set <IResponseBodyPipeFeature>(new TestResponseBodyPipeFeature(PipeWriter.Create(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 = 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 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 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]);
}
