public async Task HandleCallAsync_SuccessfulResponse_DefaultValuesInResponseJson()
{
// Arrange
HelloRequest?request = null;
UnaryServerMethod <HttpApiGreeterService, HelloRequest, HelloReply> invoker = (s, r, c) =>
{
request = r;
return(Task.FromResult(new HelloReply()));
};
var unaryServerCallHandler = CreateCallHandler(invoker);
var httpContext = TestHelpers.CreateHttpContext();
httpContext.Request.Query = new QueryCollection(new Dictionary <string, StringValues>
{
["name"] = "TestName!"
});
// Act
await unaryServerCallHandler.HandleCallAsync(httpContext);
// Assert
Assert.NotNull(request);
Assert.Equal("TestName!", request !.Name);
httpContext.Response.Body.Seek(0, SeekOrigin.Begin);
using var responseJson = JsonDocument.Parse(httpContext.Response.Body);
Assert.Equal("", responseJson.RootElement.GetProperty("message").GetString());
}
public async Task HandleCallAsync_RootBodySet_SetOnRequestMessage()
{
// Arrange
HelloRequest?request = null;
UnaryServerMethod <HttpApiGreeterService, HelloRequest, HelloReply> invoker = (s, r, c) =>
{
request = r;
return(Task.FromResult(new HelloReply {
Message = $"Hello {r.Name}"
}));
};
var unaryServerCallHandler = CreateCallHandler(
invoker,
bodyDescriptor: HelloRequest.Descriptor);
var httpContext = CreateHttpContext();
httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(JsonFormatter.Default.Format(new HelloRequest
{
Name = "TestName!"
})));
httpContext.Request.Query = new QueryCollection(new Dictionary <string, StringValues>
{
["name"] = "QueryStringTestName!",
["sub.subfield"] = "QueryStringTestSubfield!"
});
// Act
await unaryServerCallHandler.HandleCallAsync(httpContext);
// Assert
Assert.IsNotNull(request);
Assert.AreEqual("TestName!", request !.Name);
Assert.AreEqual(null, request !.Sub);
}
public async Task HandleCallAsync_MatchingQueryStringValues_SetOnRequestMessage()
{
// Arrange
HelloRequest?request = null;
UnaryServerMethod <HttpApiGreeterService, HelloRequest, HelloReply> invoker = (s, r, c) =>
{
request = r;
return(Task.FromResult(new HelloReply()));
};
var unaryServerCallHandler = CreateCallHandler(invoker);
var httpContext = TestHelpers.CreateHttpContext();
httpContext.Request.Query = new QueryCollection(new Dictionary <string, StringValues>
{
["name"] = "TestName!",
["sub.subfield"] = "TestSubfield!"
});
// Act
await unaryServerCallHandler.HandleCallAsync(httpContext);
// Assert
Assert.NotNull(request);
Assert.Equal("TestName!", request !.Name);
Assert.Equal("TestSubfield!", request !.Sub.Subfield);
}
public async Task HandleCallAsync_ResponseBodySetToRepeatedField_ArrayReturned()
{
// Arrange
HelloRequest?request = null;
UnaryServerMethod <HttpApiGreeterService, HelloRequest, HelloReply> invoker = (s, r, c) =>
{
request = r;
return(Task.FromResult(new HelloReply {
Values = { "One", "Two", "Three" }
}));
};
var unaryServerCallHandler = CreateCallHandler(
invoker,
HelloReply.Descriptor.FindFieldByNumber(HelloReply.ValuesFieldNumber));
var httpContext = CreateHttpContext();
// Act
await unaryServerCallHandler.HandleCallAsync(httpContext);
// Assert
Assert.IsNotNull(request);
httpContext.Response.Body.Seek(0, SeekOrigin.Begin);
using var responseJson = JsonDocument.Parse(httpContext.Response.Body);
Assert.AreEqual(JsonValueKind.Array, responseJson.RootElement.ValueKind);
Assert.AreEqual("One", responseJson.RootElement[0].GetString());
Assert.AreEqual("Two", responseJson.RootElement[1].GetString());
Assert.AreEqual("Three", responseJson.RootElement[2].GetString());
}
public async Task HandleCallAsync_MatchingRepeatedQueryStringValues_SetOnRequestMessage()
{
// Arrange
HelloRequest?request = null;
UnaryServerMethod <HttpApiGreeterService, HelloRequest, HelloReply> invoker = (s, r, c) =>
{
request = r;
return(Task.FromResult(new HelloReply()));
};
var unaryServerCallHandler = CreateCallHandler(invoker);
var httpContext = CreateHttpContext();
httpContext.Request.Query = new QueryCollection(new Dictionary <string, StringValues>
{
["sub.subfields"] = new StringValues(new[] { "TestSubfields1!", "TestSubfields2!" })
});
// Act
await unaryServerCallHandler.HandleCallAsync(httpContext);
// Assert
Assert.IsNotNull(request);
Assert.AreEqual(2, request !.Sub.Subfields.Count);
Assert.AreEqual("TestSubfields1!", request !.Sub.Subfields[0]);
Assert.AreEqual("TestSubfields2!", request !.Sub.Subfields[1]);
}
public async Task HandleCallAsync_ResponseBodySet_ResponseReturned()
{
// Arrange
HelloRequest?request = null;
UnaryServerMethod <HttpApiGreeterService, HelloRequest, HelloReply> invoker = (s, r, c) =>
{
request = r;
return(Task.FromResult(new HelloReply {
Message = $"Hello {r.Name}"
}));
};
var routeParameterDescriptors = new Dictionary <string, List <FieldDescriptor> >
{
["name"] = new List <FieldDescriptor>(new[] { HelloRequest.Descriptor.FindFieldByNumber(HelloRequest.NameFieldNumber) })
};
var unaryServerCallHandler = CreateCallHandler(
invoker,
HelloReply.Descriptor.FindFieldByNumber(HelloReply.MessageFieldNumber),
routeParameterDescriptors);
var httpContext = CreateHttpContext();
httpContext.Request.RouteValues["name"] = "TestName!";
// Act
await unaryServerCallHandler.HandleCallAsync(httpContext);
// Assert
Assert.IsNotNull(request);
Assert.AreEqual("TestName!", request !.Name);
httpContext.Response.Body.Seek(0, SeekOrigin.Begin);
using var responseJson = JsonDocument.Parse(httpContext.Response.Body);
Assert.AreEqual("Hello TestName!", responseJson.RootElement.GetString());
}
public override async Task SayStream(IAsyncStreamReader <HelloRequest> requestStream, IServerStreamWriter <HelloReply> responseStream, ServerCallContext context)
{
var authToken = context.RequestHeaders.Single(h => h.Key == "authentication").Value;
Console.WriteLine($"authToken:{authToken}");
// Read incoming messages in a background task
HelloRequest?lastMessageReceived = null;
var readTask = Task.Run(async() =>
{
if (!PlayerStreams.ContainsKey(authToken))
{
PlayerStreams.Add(authToken, responseStream);
}
await foreach (var message in requestStream.ReadAllAsync())
{
lastMessageReceived = message;
Console.WriteLine($"lastMessageReceived: {lastMessageReceived}");
await PlayerStreams[authToken].WriteAsync(new HelloReply {
Message = "hello" + message.Name
});
if (message.Name == "stop")
{
break;
}
}
PlayerStreams.Remove(authToken);
return("");
});
await readTask;
}
public static bool Equals(HelloRequest?left, HelloRequest?right)
{
bool result = Request.Equals(left, right);
result &= (result ? EqualityComparer <Subscriber?> .Default.Equals(left?.Subscriber, right?.Subscriber) : false);
return(result);
}
public async Task HandleCallAsync_DataTypes_SetOnRequestMessage()
{
// Arrange
HelloRequest?request = null;
UnaryServerMethod <HttpApiGreeterService, HelloRequest, HelloReply> invoker = (s, r, c) =>
{
request = r;
return(Task.FromResult(new HelloReply()));
};
var unaryServerCallHandler = CreateCallHandler(invoker);
var httpContext = CreateHttpContext();
httpContext.Request.Query = new QueryCollection(new Dictionary <string, StringValues>
{
["data.single_int32"] = "1",
["data.single_int64"] = "2",
["data.single_uint32"] = "3",
["data.single_uint64"] = "4",
["data.single_sint32"] = "5",
["data.single_sint64"] = "6",
["data.single_fixed32"] = "7",
["data.single_fixed64"] = "8",
["data.single_sfixed32"] = "9",
["data.single_sfixed64"] = "10",
["data.single_float"] = "11.1",
["data.single_double"] = "12.1",
["data.single_bool"] = "true",
["data.single_string"] = "A string",
["data.single_bytes"] = Convert.ToBase64String(new byte[] { 1, 2, 3 }),
["data.single_enum"] = "FOO",
["data.single_message.subfield"] = "Nested string"
});
// Act
await unaryServerCallHandler.HandleCallAsync(httpContext);
// Assert
Assert.IsNotNull(request);
Assert.AreEqual(1, request !.Data.SingleInt32);
Assert.AreEqual(2, request !.Data.SingleInt64);
Assert.AreEqual(3, request !.Data.SingleUint32);
Assert.AreEqual(4, request !.Data.SingleUint64);
Assert.AreEqual(5, request !.Data.SingleSint32);
Assert.AreEqual(6, request !.Data.SingleSint64);
Assert.AreEqual(7, request !.Data.SingleFixed32);
Assert.AreEqual(8, request !.Data.SingleFixed64);
Assert.AreEqual(9, request !.Data.SingleSfixed32);
Assert.AreEqual(10, request !.Data.SingleSfixed64);
Assert.AreEqual(11.1, request !.Data.SingleFloat, 0.001);
Assert.AreEqual(12.1, request !.Data.SingleDouble, 0.001);
Assert.AreEqual(true, request !.Data.SingleBool);
Assert.AreEqual("A string", request !.Data.SingleString);
Assert.AreEqual(new byte[] { 1, 2, 3 }, request !.Data.SingleBytes.ToByteArray());
Assert.AreEqual(HelloRequest.Types.DataTypes.Types.NestedEnum.Foo, request !.Data.SingleEnum);
Assert.AreEqual("Nested string", request !.Data.SingleMessage.Subfield);
}
public async Task HandleCallAsync_Any_Success()
{
// Arrange
HelloRequest?request = null;
UnaryServerMethod <HttpApiGreeterService, HelloRequest, HelloReply> invoker = (s, r, c) =>
{
request = r;
return(Task.FromResult(new HelloReply
{
AnyMessage = Any.Pack(new StringValue {
Value = "A value!"
})
}));
};
var typeRegistry = TypeRegistry.FromMessages(StringValue.Descriptor, Int32Value.Descriptor);
var jsonFormatter = new JsonFormatter(new JsonFormatter.Settings(formatDefaultValues: true, typeRegistry));
var unaryServerCallHandler = CreateCallHandler(
invoker,
descriptorInfo: TestHelpers.CreateDescriptorInfo(bodyDescriptor: HelloRequest.Descriptor),
httpApiOptions: new GrpcHttpApiOptions
{
JsonSettings = new JsonSettings
{
TypeRegistry = typeRegistry
}
});
var httpContext = TestHelpers.CreateHttpContext();
var requestJson = jsonFormatter.Format(new HelloRequest
{
Name = "Test",
AnyMessage = Any.Pack(new Int32Value {
Value = 123
})
});
httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(requestJson));
httpContext.Request.ContentType = "application/json";
// Act
await unaryServerCallHandler.HandleCallAsync(httpContext);
// Assert
Assert.NotNull(request);
Assert.Equal("Test", request !.Name);
Assert.Equal("type.googleapis.com/google.protobuf.Int32Value", request !.AnyMessage.TypeUrl);
httpContext.Response.Body.Seek(0, SeekOrigin.Begin);
using var responseJson = JsonDocument.Parse(httpContext.Response.Body);
var anyMessage = responseJson.RootElement.GetProperty("anyMessage");
Assert.Equal("type.googleapis.com/google.protobuf.StringValue", anyMessage.GetProperty("@type").GetString());
Assert.Equal("A value!", anyMessage.GetProperty("value").GetString());
}
public async Task HandleCallAsync_SubRepeatedBodySet_SetOnRequestMessage()
{
// Arrange
HelloRequest?request = null;
UnaryServerMethod <HttpApiGreeterService, HelloRequest, HelloReply> invoker = (s, r, c) =>
{
request = r;
return(Task.FromResult(new HelloReply {
Message = $"Hello {r.Name}"
}));
};
ServiceDescriptorHelpers.TryResolveDescriptors(HelloRequest.Descriptor, "repeated_strings", out var bodyFieldDescriptors);
var descriptorInfo = TestHelpers.CreateDescriptorInfo(
bodyDescriptor: HelloRequest.Types.SubMessage.Descriptor,
bodyDescriptorRepeated: true,
bodyFieldDescriptors: bodyFieldDescriptors);
var unaryServerCallHandler = CreateCallHandler(
invoker,
descriptorInfo);
var httpContext = TestHelpers.CreateHttpContext();
var sdf = new RepeatedField <string>
{
"One",
"Two",
"Three"
};
var sw = new StringWriter();
JsonFormatter.Default.WriteValue(sw, sdf);
httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(sw.ToString()));
httpContext.Request.Query = new QueryCollection(new Dictionary <string, StringValues>
{
["name"] = "QueryStringTestName!",
["sub.subfield"] = "QueryStringTestSubfield!",
["sub.subfields"] = "QueryStringTestSubfields!"
});
httpContext.Request.ContentType = "application/json";
// Act
await unaryServerCallHandler.HandleCallAsync(httpContext);
// Assert
Assert.NotNull(request);
Assert.Equal("QueryStringTestName!", request !.Name);
Assert.Equal("QueryStringTestSubfield!", request !.Sub.Subfield);
Assert.Equal(3, request !.RepeatedStrings.Count);
Assert.Equal("One", request !.RepeatedStrings[0]);
Assert.Equal("Two", request !.RepeatedStrings[1]);
Assert.Equal("Three", request !.RepeatedStrings[2]);
}
public async Task AsyncUnaryCall_CompressMetadataSentWithRequest_RequestMessageCompressed()
{
// Arrange
HttpRequestMessage?httpRequestMessage = null;
HelloRequest? helloRequest = null;
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
var requestStream = await request.Content.ReadAsStreamAsync();
helloRequest = await StreamExtensions.ReadSingleMessageAsync(
requestStream,
NullLogger.Instance,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
"gzip",
maximumMessageSize: null,
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("gzip");
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(headers: compressionMetadata), new HelloRequest
{
Name = "Hello"
});
// Assert
var response = await call.ResponseAsync;
Assert.IsNotNull(response);
Assert.AreEqual("Hello world", response.Message);
Debug.Assert(httpRequestMessage != null);
Assert.AreEqual("gzip", httpRequestMessage.Headers.GetValues(GrpcProtocolConstants.MessageEncodingHeader).Single());
Assert.AreEqual(false, httpRequestMessage.Headers.Contains(GrpcProtocolConstants.CompressionRequestAlgorithmHeader));
Debug.Assert(helloRequest != null);
Assert.AreEqual("Hello", helloRequest.Name);
}
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 StreamExtensions.ReadMessageAsync(
requestStream,
new DefaultDeserializationContext(),
NullLogger.Instance,
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 httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
var requestStream = await request.Content !.ReadAsStreamAsync().DefaultTimeout();
helloRequest = await StreamExtensions.ReadMessageAsync(
requestStream,
new DefaultDeserializationContext(),
NullLogger.Instance,
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(httpClient);
// 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 void AsyncUnaryCall_CompressedResponseWithUnknownEncoding_ErrorThrown()
{
// Arrange
HttpRequestMessage?httpRequestMessage = null;
HelloRequest? helloRequest = null;
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
var requestStream = await request.Content.ReadAsStreamAsync();
helloRequest = await StreamExtensions.ReadSingleMessageAsync(
requestStream,
NullLogger.Instance,
ClientTestHelpers.ServiceMethod.RequestMarshaller.Deserializer,
"gzip",
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 = Assert.ThrowsAsync <RpcException>(async() => await call.ResponseAsync.DefaultTimeout());
Assert.AreEqual(StatusCode.Unimplemented, ex.StatusCode);
Assert.AreEqual("Unsupported grpc-encoding value 'not-supported'. Supported encodings: gzip", ex.Status.Detail);
}
public void AsyncUnaryCall_UnknownCompressMetadataSentWithRequest_ThrowsError()
{
// Arrange
HttpRequestMessage?httpRequestMessage = null;
HelloRequest? helloRequest = null;
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
var requestStream = await request.Content.ReadAsStreamAsync();
helloRequest = await StreamExtensions.ReadSingleMessageAsync(
requestStream,
NullLogger.Instance,
ClientTestHelpers.ServiceMethod.RequestMarshaller.Deserializer,
"gzip",
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 = Assert.ThrowsAsync <InvalidOperationException>(async() => await call.ResponseAsync.DefaultTimeout());
Assert.AreEqual("Could not find compression provider for 'not-supported'.", ex.Message);
}
public async Task HandleCallAsync_SubBodySet_SetOnRequestMessage()
{
// Arrange
HelloRequest?request = null;
UnaryServerMethod <HttpApiGreeterService, HelloRequest, HelloReply> invoker = (s, r, c) =>
{
request = r;
return(Task.FromResult(new HelloReply {
Message = $"Hello {r.Name}"
}));
};
ServiceDescriptorHelpers.TryResolveDescriptors(HelloRequest.Descriptor, "sub", out var bodyFieldDescriptors);
var unaryServerCallHandler = CreateCallHandler(
invoker,
bodyDescriptor: HelloRequest.Types.SubMessage.Descriptor,
bodyFieldDescriptors: bodyFieldDescriptors);
var httpContext = CreateHttpContext();
httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(JsonFormatter.Default.Format(new HelloRequest.Types.SubMessage
{
Subfield = "Subfield!"
})));
httpContext.Request.Query = new QueryCollection(new Dictionary <string, StringValues>
{
["name"] = "QueryStringTestName!",
["sub.subfield"] = "QueryStringTestSubfield!",
["sub.subfields"] = "QueryStringTestSubfields!"
});
httpContext.Request.ContentType = "application/json";
// Act
await unaryServerCallHandler.HandleCallAsync(httpContext);
// Assert
Assert.IsNotNull(request);
Assert.AreEqual("QueryStringTestName!", request !.Name);
Assert.AreEqual("Subfield!", request !.Sub.Subfield);
Assert.AreEqual(0, request !.Sub.Subfields.Count);
}
public async Task HandleCallAsync_Wrappers_SetOnRequestMessage()
{
// Arrange
HelloRequest?request = null;
UnaryServerMethod <HttpApiGreeterService, HelloRequest, HelloReply> invoker = (s, r, c) =>
{
request = r;
return(Task.FromResult(new HelloReply()));
};
var unaryServerCallHandler = CreateCallHandler(invoker);
var httpContext = CreateHttpContext();
httpContext.Request.Query = new QueryCollection(new Dictionary <string, StringValues>
{
["wrappers.string_value"] = "1",
["wrappers.int32_value"] = "2",
["wrappers.int64_value"] = "3",
["wrappers.float_value"] = "4.1",
["wrappers.double_value"] = "5.1",
["wrappers.bool_value"] = "true",
["wrappers.uint32_value"] = "7",
["wrappers.uint64_value"] = "8",
["wrappers.bytes_value"] = Convert.ToBase64String(new byte[] { 1, 2, 3 })
});
// Act
await unaryServerCallHandler.HandleCallAsync(httpContext);
// Assert
Assert.IsNotNull(request);
Assert.AreEqual("1", request !.Wrappers.StringValue);
Assert.AreEqual(2, request !.Wrappers.Int32Value);
Assert.AreEqual(3, request !.Wrappers.Int64Value);
Assert.AreEqual(4.1, request !.Wrappers.FloatValue, 0.001);
Assert.AreEqual(5.1, request !.Wrappers.DoubleValue, 0.001);
Assert.AreEqual(true, request !.Wrappers.BoolValue);
Assert.AreEqual(7, request !.Wrappers.Uint32Value);
Assert.AreEqual(8, request !.Wrappers.Uint64Value);
Assert.AreEqual(new byte[] { 1, 2, 3 }, request !.Wrappers.BytesValue.ToByteArray());
}
public async Task HandleCallAsync_MatchingRouteValue_SetOnRequestMessage()
{
// Arrange
HelloRequest?request = null;
UnaryServerMethod <HttpApiGreeterService, HelloRequest, HelloReply> invoker = (s, r, c) =>
{
request = r;
return(Task.FromResult(new HelloReply {
Message = $"Hello {r.Name}"
}));
};
var routeParameterDescriptors = new Dictionary <string, List <FieldDescriptor> >
{
["name"] = new List <FieldDescriptor>(new[] { HelloRequest.Descriptor.FindFieldByNumber(HelloRequest.NameFieldNumber) }),
["sub.subfield"] = new List <FieldDescriptor>(new[]
{
HelloRequest.Descriptor.FindFieldByNumber(HelloRequest.SubFieldNumber),
HelloRequest.Types.SubMessage.Descriptor.FindFieldByNumber(HelloRequest.Types.SubMessage.SubfieldFieldNumber)
})
};
var descriptorInfo = TestHelpers.CreateDescriptorInfo(routeParameterDescriptors: routeParameterDescriptors);
var unaryServerCallHandler = CreateCallHandler(invoker, descriptorInfo: descriptorInfo);
var httpContext = TestHelpers.CreateHttpContext();
httpContext.Request.RouteValues["name"] = "TestName!";
httpContext.Request.RouteValues["sub.subfield"] = "Subfield!";
// Act
await unaryServerCallHandler.HandleCallAsync(httpContext);
// Assert
Assert.NotNull(request);
Assert.Equal("TestName!", request !.Name);
Assert.Equal("Subfield!", request !.Sub.Subfield);
httpContext.Response.Body.Seek(0, SeekOrigin.Begin);
using var responseJson = JsonDocument.Parse(httpContext.Response.Body);
Assert.Equal("Hello TestName!", responseJson.RootElement.GetProperty("message").GetString());
}
private async Task <HelloRequest> ExecuteUnaryHandler(
Action <HttpContext>?configureHttpContext = null,
Func <HelloRequest, ServerCallContext, Task <HelloReply> >?handler = null)
{
// Arrange
HelloRequest?request = null;
UnaryServerMethod <HttpApiGreeterService, HelloRequest, HelloReply> invoker = (s, r, c) =>
{
request = r;
return(handler != null?handler(r, c) : Task.FromResult(new HelloReply()));
};
var unaryServerCallHandler = CreateCallHandler(invoker);
var httpContext = TestHelpers.CreateHttpContext();
configureHttpContext?.Invoke(httpContext);
// Act
await unaryServerCallHandler.HandleCallAsync(httpContext);
return(request !);
}
public bool Equals(HelloRequest?other)
{
return(HelloRequest.Equals(this, other));
}
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();
isRequestNotCompressed = requestData[0] == 0;
helloRequest = await StreamExtensions.ReadSingleMessageAsync(
new MemoryStream(requestData),
NullLogger.Instance,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
"gzip",
maximumMessageSize: null,
GrpcProtocolConstants.DefaultCompressionProviders,
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);
Debug.Assert(httpRequestMessage != null);
Assert.AreEqual("identity,gzip,deflate,test", httpRequestMessage.Headers.GetValues(GrpcProtocolConstants.MessageAcceptEncodingHeader).Single());
Assert.AreEqual("gzip", httpRequestMessage.Headers.GetValues(GrpcProtocolConstants.MessageEncodingHeader).Single());
Assert.AreEqual(false, httpRequestMessage.Headers.Contains(GrpcProtocolConstants.CompressionRequestAlgorithmHeader));
Debug.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);
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(helloRequest1 != null);
Assert.AreEqual("Hello One", helloRequest1.Name);
CompatibilityHelpers.Assert(helloRequest2 != null);
Assert.AreEqual("Hello Two", helloRequest2.Name);
Assert.IsTrue(isRequestCompressed1);
Assert.IsFalse(isRequestCompressed2);
}