private static Task <HelloRequest?> ReadRequestMessage(Stream requestContent)
{
return(StreamSerializationHelper.ReadMessageAsync(
requestContent,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
GrpcProtocolConstants.IdentityGrpcEncoding,
maximumMessageSize: null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage: false,
CancellationToken.None));
}
public async Task AsyncUnaryCall_CompressedResponseWithUnknownEncoding_ErrorThrown()
{
// Arrange
HttpRequestMessage?httpRequestMessage = null;
HelloRequest? helloRequest = null;
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
var requestStream = await request.Content !.ReadAsStreamAsync().DefaultTimeout();
helloRequest = await StreamSerializationHelper.ReadMessageAsync(
requestStream,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
"gzip",
maximumMessageSize: null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage: true,
CancellationToken.None);
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var compressionProvider = new GzipCompressionProvider(System.IO.Compression.CompressionLevel.Fastest);
var streamContent = await ClientTestHelpers.CreateResponseContent(reply, compressionProvider).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent, grpcEncoding: "not-supported"));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(), new HelloRequest
{
Name = "Hello"
});
// Assert
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseAsync).DefaultTimeout();
Assert.AreEqual(StatusCode.Unimplemented, ex.StatusCode);
#if NET6_0_OR_GREATER
Assert.AreEqual("Unsupported grpc-encoding value 'not-supported'. Supported encodings: identity, gzip, deflate", ex.Status.Detail);
#else
Assert.AreEqual("Unsupported grpc-encoding value 'not-supported'. Supported encodings: identity, gzip", ex.Status.Detail);
#endif
}
public async Task AsyncUnaryCall_UnknownCompressMetadataSentWithRequest_ThrowsError()
{
// Arrange
HttpRequestMessage?httpRequestMessage = null;
HelloRequest? helloRequest = null;
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
var requestStream = await request.Content !.ReadAsStreamAsync().DefaultTimeout();
helloRequest = await StreamSerializationHelper.ReadMessageAsync(
requestStream,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
"gzip",
maximumMessageSize: null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage: true,
CancellationToken.None);
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await ClientTestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var compressionMetadata = CreateClientCompressionMetadata("not-supported");
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(headers: compressionMetadata), new HelloRequest
{
Name = "Hello"
});
// Assert
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseAsync).DefaultTimeout();
Assert.AreEqual(StatusCode.Internal, ex.StatusCode);
Assert.AreEqual("Error starting gRPC call. InvalidOperationException: Could not find compression provider for 'not-supported'.", ex.Status.Detail);
Assert.AreEqual("Could not find compression provider for 'not-supported'.", ex.Status.DebugException.Message);
}
public async Task AsyncUnaryCall_CompressedResponse_ResponseMessageDecompressed()
{
// Arrange
HttpRequestMessage?httpRequestMessage = null;
HelloRequest? helloRequest = null;
var handler = TestHttpMessageHandler.Create(async request =>
{
httpRequestMessage = request;
var requestStream = await request.Content !.ReadAsStreamAsync().DefaultTimeout();
helloRequest = await StreamSerializationHelper.ReadMessageAsync(
requestStream,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
"gzip",
maximumMessageSize: null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage: true,
CancellationToken.None);
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var compressionProvider = new GzipCompressionProvider(System.IO.Compression.CompressionLevel.Fastest);
var streamContent = await ClientTestHelpers.CreateResponseContent(reply, compressionProvider).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent, grpcEncoding: "gzip"));
});
var invoker = HttpClientCallInvokerFactory.Create(handler, "http://localhost");
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(), new HelloRequest
{
Name = "Hello"
});
// Assert
var response = await call.ResponseAsync;
Assert.IsNotNull(response);
Assert.AreEqual("Hello world", response.Message);
}
public async Task AsyncUnaryCall_Success_RequestContentSent()
{
// Arrange
HttpContent?content = null;
var handler = TestHttpMessageHandler.Create(async request =>
{
content = request.Content;
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await ClientTestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = HttpClientCallInvokerFactory.Create(handler, "http://localhost");
// Act
var rs = await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(
ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(), new HelloRequest { Name = "World" }).ResponseAsync.DefaultTimeout();
// Assert
Assert.AreEqual("Hello world", rs.Message);
Assert.IsNotNull(content);
var requestContent = await content !.ReadAsStreamAsync().DefaultTimeout();
var requestMessage = await StreamSerializationHelper.ReadMessageAsync(
requestContent,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
GrpcProtocolConstants.IdentityGrpcEncoding,
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : true,
CancellationToken.None).DefaultTimeout();
Assert.AreEqual("World", requestMessage !.Name);
}
private async Task <HttpResponseMessage> HandleRequest(HttpRequestMessage request)
{
var requestStream = await request.Content !.ReadAsStreamAsync().DefaultTimeout();
var helloRequest = await StreamSerializationHelper.ReadMessageAsync(
requestStream,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
"gzip",
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : true,
CancellationToken.None).DefaultTimeout();
var reply = new HelloReply
{
Message = "Hello " + helloRequest !.Name
};
var streamContent = await ClientTestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
}
public async Task AsyncDuplexStreamingCall_MessagesStreamed_MessagesReceived()
{
// Arrange
var streamContent = new SyncPointMemoryStream();
var requestContentTcs = new TaskCompletionSource <Task <Stream> >(TaskCreationOptions.RunContinuationsAsynchronously);
PushStreamContent <HelloRequest, HelloReply>?content = null;
var handler = TestHttpMessageHandler.Create(async request =>
{
content = (PushStreamContent <HelloRequest, HelloReply>)request.Content !;
var streamTask = content.ReadAsStreamAsync();
requestContentTcs.SetResult(streamTask);
// Wait for RequestStream.CompleteAsync()
await streamTask;
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(streamContent)));
});
var invoker = HttpClientCallInvokerFactory.Create(handler, "https://localhost");
// Act
var call = invoker.AsyncDuplexStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions());
var requestStream = call.RequestStream;
var responseStream = call.ResponseStream;
// Assert
await call.RequestStream.WriteAsync(new HelloRequest { Name = "1" }).DefaultTimeout();
await call.RequestStream.WriteAsync(new HelloRequest { Name = "2" }).DefaultTimeout();
await call.RequestStream.CompleteAsync().DefaultTimeout();
var deserializationContext = new DefaultDeserializationContext();
Assert.IsNotNull(content);
var requestContent = await await requestContentTcs.Task.DefaultTimeout();
var requestMessage = await StreamSerializationHelper.ReadMessageAsync(
requestContent,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
GrpcProtocolConstants.IdentityGrpcEncoding,
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : false,
CancellationToken.None).DefaultTimeout();
Assert.AreEqual("1", requestMessage !.Name);
requestMessage = await StreamSerializationHelper.ReadMessageAsync(
requestContent,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
GrpcProtocolConstants.IdentityGrpcEncoding,
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : false,
CancellationToken.None).DefaultTimeout();
Assert.AreEqual("2", requestMessage !.Name);
Assert.IsNull(responseStream.Current);
var moveNextTask1 = responseStream.MoveNext(CancellationToken.None);
Assert.IsFalse(moveNextTask1.IsCompleted);
await streamContent.AddDataAndWait(await ClientTestHelpers.GetResponseDataAsync(new HelloReply
{
Message = "Hello world 1"
}).DefaultTimeout()).DefaultTimeout();
Assert.IsTrue(await moveNextTask1.DefaultTimeout());
Assert.IsNotNull(responseStream.Current);
Assert.AreEqual("Hello world 1", responseStream.Current.Message);
var moveNextTask2 = responseStream.MoveNext(CancellationToken.None);
Assert.IsFalse(moveNextTask2.IsCompleted);
await streamContent.AddDataAndWait(await ClientTestHelpers.GetResponseDataAsync(new HelloReply
{
Message = "Hello world 2"
}).DefaultTimeout()).DefaultTimeout();
Assert.IsTrue(await moveNextTask2.DefaultTimeout());
Assert.IsNotNull(responseStream.Current);
Assert.AreEqual("Hello world 2", responseStream.Current.Message);
var moveNextTask3 = responseStream.MoveNext(CancellationToken.None);
Assert.IsFalse(moveNextTask3.IsCompleted);
await streamContent.AddDataAndWait(Array.Empty <byte>()).DefaultTimeout();
Assert.IsFalse(await moveNextTask3.DefaultTimeout());
var moveNextTask4 = responseStream.MoveNext(CancellationToken.None);
Assert.IsTrue(moveNextTask4.IsCompleted);
Assert.IsFalse(await moveNextTask3.DefaultTimeout());
}
public async Task AsyncClientStreamingCall_Success_RequestContentSent()
{
// Arrange
var requestContentTcs = new TaskCompletionSource <Task <Stream> >(TaskCreationOptions.RunContinuationsAsynchronously);
PushStreamContent <HelloRequest, HelloReply>?content = null;
var handler = TestHttpMessageHandler.Create(async request =>
{
content = (PushStreamContent <HelloRequest, HelloReply>)request.Content !;
var streamTask = content.ReadAsStreamAsync();
requestContentTcs.SetResult(streamTask);
// Wait for RequestStream.CompleteAsync()
await streamTask;
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await ClientTestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = HttpClientCallInvokerFactory.Create(handler, "http://localhost");
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions());
var requestContentTask = await requestContentTcs.Task.DefaultTimeout();
// Assert
Assert.IsNotNull(call);
Assert.IsNotNull(content);
var responseTask = call.ResponseAsync;
Assert.IsFalse(responseTask.IsCompleted, "Response not returned until client stream is complete.");
await call.RequestStream.WriteAsync(new HelloRequest { Name = "1" }).DefaultTimeout();
await call.RequestStream.WriteAsync(new HelloRequest { Name = "2" }).DefaultTimeout();
await call.RequestStream.CompleteAsync().DefaultTimeout();
var requestContent = await requestContentTask.DefaultTimeout();
var requestMessage = await StreamSerializationHelper.ReadMessageAsync(
requestContent,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
GrpcProtocolConstants.IdentityGrpcEncoding,
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : false,
CancellationToken.None).DefaultTimeout();
Assert.AreEqual("1", requestMessage !.Name);
requestMessage = await StreamSerializationHelper.ReadMessageAsync(
requestContent,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
GrpcProtocolConstants.IdentityGrpcEncoding,
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : false,
CancellationToken.None).DefaultTimeout();
Assert.AreEqual("2", requestMessage !.Name);
var responseMessage = await responseTask.DefaultTimeout();
Assert.AreEqual("Hello world", responseMessage.Message);
}
public async Task AsyncUnaryCall_CompressMetadataSentWithRequest_RequestMessageCompressed(bool compressionDisabledOnOptions)
{
// Arrange
HttpRequestMessage?httpRequestMessage = null;
HelloRequest? helloRequest = null;
bool?isRequestNotCompressed = null;
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
var requestData = await request.Content !.ReadAsByteArrayAsync().DefaultTimeout();
isRequestNotCompressed = requestData[0] == 0;
helloRequest = await StreamSerializationHelper.ReadMessageAsync(
new MemoryStream(requestData),
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
"gzip",
maximumMessageSize: null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage: true,
CancellationToken.None);
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await ClientTestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var compressionProviders = GrpcProtocolConstants.DefaultCompressionProviders.Values.ToList();
compressionProviders.Add(new TestCompressionProvider());
var invoker = HttpClientCallInvokerFactory.Create(httpClient, configure: o => o.CompressionProviders = compressionProviders);
var compressionMetadata = CreateClientCompressionMetadata("gzip");
var callOptions = new CallOptions(headers: compressionMetadata);
if (compressionDisabledOnOptions)
{
callOptions = callOptions.WithWriteOptions(new WriteOptions(WriteFlags.NoCompress));
}
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, callOptions, new HelloRequest
{
Name = "Hello"
});
// Assert
var response = await call.ResponseAsync;
Assert.IsNotNull(response);
Assert.AreEqual("Hello world", response.Message);
CompatibilityHelpers.Assert(httpRequestMessage != null);
Assert.AreEqual("identity,gzip,test", httpRequestMessage.Headers.GetValues(GrpcProtocolConstants.MessageAcceptEncodingHeader).Single());
Assert.AreEqual("gzip", httpRequestMessage.Headers.GetValues(GrpcProtocolConstants.MessageEncodingHeader).Single());
Assert.AreEqual(false, httpRequestMessage.Headers.Contains(GrpcProtocolConstants.CompressionRequestAlgorithmHeader));
CompatibilityHelpers.Assert(helloRequest != null);
Assert.AreEqual("Hello", helloRequest.Name);
Assert.AreEqual(compressionDisabledOnOptions, isRequestNotCompressed);
}
public async Task AsyncClientStreamingCall_CompressMetadataSentWithRequest_RequestMessageCompressed()
{
// Arrange
HttpRequestMessage?httpRequestMessage = null;
HelloRequest? helloRequest1 = null;
HelloRequest? helloRequest2 = null;
bool?isRequestCompressed1 = null;
bool?isRequestCompressed2 = null;
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
var requestData = await request.Content !.ReadAsByteArrayAsync().DefaultTimeout();
var requestStream = new MemoryStream(requestData);
isRequestCompressed1 = requestData[0] == 1;
helloRequest1 = await StreamSerializationHelper.ReadMessageAsync(
requestStream,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
"gzip",
maximumMessageSize: null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage: false,
CancellationToken.None);
isRequestCompressed2 = requestData[requestStream.Position] == 1;
helloRequest2 = await StreamSerializationHelper.ReadMessageAsync(
requestStream,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
"gzip",
maximumMessageSize: null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage: false,
CancellationToken.None);
var reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await ClientTestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var compressionProviders = GrpcProtocolConstants.DefaultCompressionProviders.Values.ToList();
compressionProviders.Add(new TestCompressionProvider());
var invoker = HttpClientCallInvokerFactory.Create(httpClient, configure: o => o.CompressionProviders = compressionProviders);
var compressionMetadata = CreateClientCompressionMetadata("gzip");
var callOptions = new CallOptions(headers: compressionMetadata);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, callOptions);
await call.RequestStream.WriteAsync(new HelloRequest
{
Name = "Hello One"
}).DefaultTimeout();
call.RequestStream.WriteOptions = new WriteOptions(WriteFlags.NoCompress);
await call.RequestStream.WriteAsync(new HelloRequest
{
Name = "Hello Two"
}).DefaultTimeout();
await call.RequestStream.CompleteAsync().DefaultTimeout();
// Assert
var response = await call.ResponseAsync.DefaultTimeout();
Assert.IsNotNull(response);
Assert.AreEqual("Hello world", response.Message);
CompatibilityHelpers.Assert(httpRequestMessage != null);
#if NET6_0_OR_GREATER
Assert.AreEqual("identity,gzip,deflate,test", httpRequestMessage.Headers.GetValues(GrpcProtocolConstants.MessageAcceptEncodingHeader).Single());
#else
Assert.AreEqual("identity,gzip,test", httpRequestMessage.Headers.GetValues(GrpcProtocolConstants.MessageAcceptEncodingHeader).Single());
#endif
Assert.AreEqual("gzip", httpRequestMessage.Headers.GetValues(GrpcProtocolConstants.MessageEncodingHeader).Single());
Assert.AreEqual(false, httpRequestMessage.Headers.Contains(GrpcProtocolConstants.CompressionRequestAlgorithmHeader));
CompatibilityHelpers.Assert(helloRequest1 != null);
Assert.AreEqual("Hello One", helloRequest1.Name);
CompatibilityHelpers.Assert(helloRequest2 != null);
Assert.AreEqual("Hello Two", helloRequest2.Name);
Assert.IsTrue(isRequestCompressed1);
Assert.IsFalse(isRequestCompressed2);
}
