public async Task AsyncUnaryCall_Success_LogToFactory()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
// Trigger request stream serialization
await request.Content !.ReadAsStreamAsync().DefaultTimeout();
var streamContent = await ClientTestHelpers.CreateResponseContent(new HelloReply
{
Message = "Hello world"
}).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var testSink = new TestSink();
var loggerFactory = new TestLoggerFactory(testSink, true);
var invoker = HttpClientCallInvokerFactory.Create(httpClient, loggerFactory);
// Act
var rs = await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(), new HelloRequest());
// Assert
Assert.AreEqual("Hello world", rs.Message);
var log = testSink.Writes.Single(w => w.EventId.Name == "StartingCall");
Assert.AreEqual("Starting gRPC call. Method type: 'Unary', URI: 'https://localhost/ServiceName/MethodName'.", log.State.ToString());
AssertScope(log);
log = testSink.Writes.Single(w => w.EventId.Name == "SendingMessage");
Assert.AreEqual("Sending message.", log.State.ToString());
AssertScope(log);
log = testSink.Writes.Single(w => w.EventId.Name == "ReadingMessage");
Assert.AreEqual("Reading message.", log.State.ToString());
AssertScope(log);
log = testSink.Writes.Single(w => w.EventId.Name == "FinishedCall");
Assert.AreEqual("Finished gRPC call.", log.State.ToString());
AssertScope(log);
public async Task AsyncClientStreamingCall_DeadlineDuringWrite_ResponseThrowsDeadlineExceededStatus()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
var stream = new SyncPointMemoryStream();
var content = new StreamContent(stream);
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, content, grpcStatusCode: null)));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(deadline: DateTime.UtcNow.AddSeconds(0.5)));
// Assert
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.RequestStream.WriteAsync(new HelloRequest())).DefaultTimeout();
Assert.AreEqual(StatusCode.DeadlineExceeded, ex.Status.StatusCode);
}
public async Task AsyncClientStreamingCall_InvalidContentType_ResponseHeadersPopulated()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("custom", "ABC");
response.Content.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
return(Task.FromResult(response));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions());
var responseHeaders = await call.ResponseHeadersAsync.DefaultTimeout();
// Assert
Assert.AreEqual("ABC", responseHeaders.GetValue("custom"));
}
public async Task AsyncServerStreamingCall_Success_ResponseHeadersPopulated()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
var streamContent = await ClientTestHelpers.CreateResponseContent(new HelloReply()).DefaultTimeout();
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent);
response.Headers.Add("custom", "ABC");
return(response);
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncServerStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(), new HelloRequest());
var responseHeaders = await call.ResponseHeadersAsync.DefaultTimeout();
// Assert
Assert.AreEqual("ABC", responseHeaders.GetValue("custom"));
}
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);
}
private static async Task StatusReturnedCore(StatusInterceptor interceptor, StatusCode statusCode)
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
if (statusCode == StatusCode.OK)
{
var streamContent = await ClientTestHelpers.CreateResponseContent(new HelloReply {
Message = "PASS"
}).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
}
else
{
return(ResponseUtils.CreateHeadersOnlyResponse(HttpStatusCode.OK, statusCode));
}
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var callInvoker = invoker.Intercept(interceptor);
var call = callInvoker.AsyncUnaryCall(ClientTestHelpers.ServiceMethod, Host, new CallOptions(), new HelloRequest());
// Assert
if (statusCode == StatusCode.OK)
{
var result = await call.ResponseAsync.DefaultTimeout();
Assert.AreEqual("PASS", result.Message);
}
else
{
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseAsync).DefaultTimeout();
Assert.AreEqual(statusCode, ex.StatusCode);
}
var interceptorStatusCode = await interceptor.GetStatusCodeAsync().DefaultTimeout();
Assert.AreEqual(statusCode, interceptorStatusCode);
}
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();
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("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 <InvalidOperationException>(() => call.ResponseAsync).DefaultTimeout();
Assert.AreEqual("Could not find compression provider for 'not-supported'.", ex.Message);
}
public async Task AsyncUnaryCall_MessageSmallerThanSendMaxMessageSize_Success()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(HandleRequest);
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
invoker.SendMaxMessageSize = 100;
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(), new HelloRequest
{
Name = "World"
});
// Assert
var response = await call.ResponseAsync.DefaultTimeout();
Assert.AreEqual("Hello World", response.Message);
}
public async Task AsyncServerStreamingCall_DeadlineStatusResponse_ThrowOperationCanceledOnCancellation_ResponseThrowsDeadlineExceededStatus()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
return Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, new StringContent(string.Empty), StatusCode.DeadlineExceeded));
});
var testSystemClock = new TestSystemClock(DateTime.UtcNow);
var invoker = HttpClientCallInvokerFactory.Create(httpClient, systemClock: testSystemClock, configure: o => o.ThrowOperationCanceledOnCancellation = true, disableClientDeadline: true);
// Act
var call = invoker.AsyncServerStreamingCall<HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(deadline: testSystemClock.UtcNow.AddSeconds(0.5)), new HelloRequest());
// Assert
var moveNextTask = call.ResponseStream.MoveNext(CancellationToken.None);
await ExceptionAssert.ThrowsAsync<OperationCanceledException>(() => moveNextTask).DefaultTimeout();
Assert.AreEqual(StatusCode.DeadlineExceeded, call.GetStatus().StatusCode);
}
public void AsyncUnaryCall_UnfinishedCall_ThrowsError()
{
// Arrange
var tcs = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously);
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
await tcs.Task.DefaultTimeout();
throw new Exception("Test shouldn't reach here.");
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(), new HelloRequest());
var ex = Assert.Throws <InvalidOperationException>(() => call.GetTrailers());
// Assert
Assert.AreEqual("Can't get the call trailers because the call has not completed successfully.", ex.Message);
}
public async Task AsyncServerStreamingCall_NoContent_NoMessagesReturned()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, new ByteArrayContent(Array.Empty <byte>()))));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncServerStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(), new HelloRequest());
var responseStream = call.ResponseStream;
// Assert
Assert.IsNull(responseStream.Current);
Assert.IsFalse(await responseStream.MoveNext(CancellationToken.None).DefaultTimeout());
Assert.IsNull(responseStream.Current);
}
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();
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: "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 AsyncClientStreamingCall_UncompleteWriter_ThrowsError()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
var stream = new SyncPointMemoryStream();
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(stream), grpcStatusCode: null);
return(Task.FromResult(response));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions());
var ex = Assert.Throws <InvalidOperationException>(() => call.GetTrailers());
// Assert
Assert.AreEqual("Can't get the call trailers because the call has not completed successfully.", ex.Message);
}
public async Task AsyncUnaryCall_ErrorSendingRequest_ThrowsError()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
return(Task.FromException <HttpResponseMessage>(new Exception("An error!")));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(), new HelloRequest());
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseAsync).DefaultTimeout();
// Assert
Assert.AreEqual(StatusCode.Internal, ex.StatusCode);
Assert.AreEqual("Error starting gRPC call. Exception: An error!", ex.Status.Detail);
Assert.AreEqual("An error!", ex.Status.DebugException.Message);
Assert.AreEqual(StatusCode.Internal, call.GetStatus().StatusCode);
}
public async Task ClientStreamWriter_WriteAfterResponseHasFinished_ErrorThrown()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK)));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions());
var ex = await ExceptionAssert.ThrowsAsync <InvalidOperationException>(() => call.RequestStream.WriteAsync(new HelloRequest())).DefaultTimeout();
// Assert
Assert.AreEqual("Can't write the message because the call is complete.", ex.Message);
Assert.AreEqual(StatusCode.Internal, call.GetStatus().StatusCode);
Assert.AreEqual("Failed to deserialize response message.", call.GetStatus().Detail);
}
public void AsyncUnaryCall_ErrorCall_ThrowsError()
{
// Arrange
var tcs = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously);
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
return(Task.FromException <HttpResponseMessage>(new Exception("An error!")));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(), new HelloRequest());
var ex = Assert.Throws <InvalidOperationException>(() => call.GetTrailers());
// Assert
Assert.AreEqual("Can't get the call trailers because an error occured when making the request.", ex.Message);
Assert.AreEqual("An error!", ex.InnerException?.InnerException?.Message);
}
public void AsyncServerStreamingCall_DeadlineDuringWrite_ResponseThrowsDeadlineExceededStatus()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(request =>
{
var stream = new SyncPointMemoryStream();
var content = new StreamContent(stream);
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, content)));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncServerStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, string.Empty, new CallOptions(deadline: DateTime.UtcNow.AddSeconds(0.5)), new HelloRequest());
// Assert
var ex = Assert.ThrowsAsync <RpcException>(async() => await call.ResponseStream.MoveNext(CancellationToken.None));
Assert.AreEqual(StatusCode.DeadlineExceeded, ex.Status.StatusCode);
}
public async Task AsyncUnaryCall_ExceedDeadlineWithActiveCalls_Failure()
{
// Arrange
var testSink = new TestSink();
var services = new ServiceCollection();
services.AddLogging(b =>
{
b.AddProvider(new TestLoggerProvider(testSink));
});
services.AddNUnitLogger();
var provider = services.BuildServiceProvider();
var tcs = new TaskCompletionSource <HttpResponseMessage>(TaskCreationOptions.RunContinuationsAsynchronously);
var callCount = 0;
var httpClient = ClientTestHelpers.CreateTestClient(async(request, ct) =>
{
// Ensure SendAsync call doesn't hang upon cancellation by gRPC client.
using var registration = ct.Register(() => tcs.TrySetCanceled());
Interlocked.Increment(ref callCount);
return(await tcs.Task);
});
var serviceConfig = ServiceConfigHelpers.CreateHedgingServiceConfig(hedgingDelay: TimeSpan.FromMilliseconds(200));
var invoker = HttpClientCallInvokerFactory.Create(httpClient, loggerFactory: provider.GetRequiredService <ILoggerFactory>(), serviceConfig: serviceConfig);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(deadline: DateTime.UtcNow.AddMilliseconds(100)), new HelloRequest {
Name = "World"
});
// Assert
Assert.AreEqual(1, callCount);
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseAsync).DefaultTimeout();
Assert.AreEqual(StatusCode.DeadlineExceeded, ex.StatusCode);
Assert.AreEqual(StatusCode.DeadlineExceeded, call.GetStatus().StatusCode);
var write = testSink.Writes.Single(w => w.EventId.Name == "CallCommited");
Assert.AreEqual("Call commited. Reason: DeadlineExceeded", write.State.ToString());
}
public async Task AsyncClientStreamingCall_InvalidContentType_ThrowsError()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK);
response.Content.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
return(Task.FromResult(response));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions());
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseAsync).DefaultTimeout();
// Assert
Assert.AreEqual(StatusCode.Cancelled, ex.StatusCode);
Assert.AreEqual("Bad gRPC response. Invalid content-type value: text/plain", ex.Status.Detail);
}
public async Task UnaryCall_Http1Response_ThrowError()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
var streamContent = await ClientTestHelpers.CreateResponseContent(new HelloReply()).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent, version: new Version(1, 1)));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(deadline: invoker.Channel.Clock.UtcNow.AddSeconds(1)), new HelloRequest());
// Assert
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseAsync).DefaultTimeout();
Assert.AreEqual(StatusCode.Internal, ex.StatusCode);
Assert.AreEqual("Bad gRPC response. Response protocol downgraded to HTTP/1.1.", ex.Status.Detail);
}
public async Task AsyncClientStreamingCall_CompleteWriter_ReturnsTrailers()
{
// Arrange
var trailingHeadersWrittenTcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
var content = (PushStreamContent)request.Content;
var stream = new SyncPointMemoryStream();
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(stream));
_ = Task.Run(async() =>
{
// Add a response message after the client has completed
await content.PushComplete.DefaultTimeout();
var messageData = await ClientTestHelpers.GetResponseDataAsync(new HelloReply {
Message = "Hello world"
}).DefaultTimeout();
await stream.AddDataAndWait(messageData).DefaultTimeout();
await stream.AddDataAndWait(Array.Empty <byte>()).DefaultTimeout();
response.TrailingHeaders.Add("custom-header", "value");
trailingHeadersWrittenTcs.SetResult(true);
});
return(Task.FromResult(response));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions());
await call.RequestStream.CompleteAsync().DefaultTimeout();
await Task.WhenAll(call.ResponseAsync, trailingHeadersWrittenTcs.Task).DefaultTimeout();
var trailers = call.GetTrailers();
// Assert
Assert.AreEqual("value", trailers.Single(t => t.Key == "custom-header").Value);
}
public async Task CompositeCallCredentialsWithHttps_MetadataOnRequest()
{
// Arrange
HttpRequestHeaders?requestHeaders = null;
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
requestHeaders = request.Headers;
var reply = new HelloReply {
Message = "Hello world"
};
var streamContent = await ClientTestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
var first = CallCredentials.FromInterceptor(new AsyncAuthInterceptor((context, metadata) =>
{
metadata.Add("first_authorization", "FIRST_SECRET_TOKEN");
return(Task.CompletedTask);
}));
var second = CallCredentials.FromInterceptor(new AsyncAuthInterceptor((context, metadata) =>
{
metadata.Add("second_authorization", "SECOND_SECRET_TOKEN");
return(Task.CompletedTask);
}));
var third = CallCredentials.FromInterceptor(new AsyncAuthInterceptor((context, metadata) =>
{
metadata.Add("third_authorization", "THIRD_SECRET_TOKEN");
return(Task.CompletedTask);
}));
// Act
var callCredentials = CallCredentials.Compose(first, second, third);
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(credentials: callCredentials), new HelloRequest());
await call.ResponseAsync.DefaultTimeout();
// Assert
Assert.AreEqual("FIRST_SECRET_TOKEN", requestHeaders !.GetValues("first_authorization").Single());
Assert.AreEqual("SECOND_SECRET_TOKEN", requestHeaders !.GetValues("second_authorization").Single());
Assert.AreEqual("THIRD_SECRET_TOKEN", requestHeaders !.GetValues("third_authorization").Single());
}
public void Intercept_InterceptorOrder_ExecutedInReversedOrder()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
var streamContent = await ClientTestHelpers.CreateResponseContent(new HelloReply {
Message = "PASS"
}).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var stringBuilder = new StringBuilder();
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var callInvoker = invoker
.Intercept(metadata =>
{
stringBuilder.Append("interceptor1");
return(metadata);
})
.Intercept(
new CallbackInterceptor(o => stringBuilder.Append("array1")),
new CallbackInterceptor(o => stringBuilder.Append("array2")),
new CallbackInterceptor(o => stringBuilder.Append("array3")))
.Intercept(metadata =>
{
stringBuilder.Append("interceptor2");
return(metadata);
})
.Intercept(metadata =>
{
stringBuilder.Append("interceptor3");
return(metadata);
});
var result = callInvoker.BlockingUnaryCall(ClientTestHelpers.ServiceMethod, Host, new CallOptions(), new HelloRequest());
// Assert
Assert.AreEqual("PASS", result.Message);
Assert.AreEqual("interceptor3interceptor2array1array2array3interceptor1", stringBuilder.ToString());
}
public void AsyncUnaryCall_SetNonUtcDeadline_ThrowError()
{
// Arrange
HttpRequestMessage httpRequestMessage = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
var streamContent = await TestHelpers.CreateResponseContent(new HelloReply()).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var ex = Assert.ThrowsAsync <InvalidOperationException>(async() => await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(deadline: new DateTime(2000, DateTimeKind.Local)), new HelloRequest()));
// Assert
Assert.AreEqual("Deadline must have a kind DateTimeKind.Utc or be equal to DateTime.MaxValue or DateTime.MinValue.", ex.Message);
}
public async Task ClientStreamWriter_WriteWithInvalidHttpStatus_ErrorThrown()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
var streamContent = new StreamContent(new SyncPointMemoryStream());
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.NotFound, streamContent)));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions());
// Assert
var ex = await ExceptionAssert.ThrowsAsync <InvalidOperationException>(() => call.RequestStream.WriteAsync(new HelloRequest {
Name = "1"
})).DefaultTimeout();
Assert.AreEqual("Can't write the message because the call is complete.", ex.Message);
}
public void ClientStreamWriter_WriteWithInvalidHttpStatus_ErrorThrown()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(request =>
{
var streamContent = new StreamContent(new SyncPointMemoryStream());
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.NotFound, streamContent)));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions());
// Assert
var ex = Assert.ThrowsAsync <InvalidOperationException>(() => call.RequestStream.WriteAsync(new HelloRequest {
Name = "1"
}).DefaultTimeout());
Assert.AreEqual("Bad gRPC response. Expected HTTP status code 200. Got status code: 404", ex.Message);
}
public async Task AsyncClientStreamingCall_NotFoundStatus_ResponseHeadersPopulated()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
var response = ResponseUtils.CreateResponse(HttpStatusCode.NotFound);
response.Headers.Add("custom", "ABC");
return(Task.FromResult(response));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions());
var responseHeaders = await call.ResponseHeadersAsync.DefaultTimeout();
// Assert
var header = responseHeaders.Single(h => h.Key == "custom");
Assert.AreEqual("ABC", header.Value);
}
public async Task ClientStreamWriter_CallThrowsException_WriteAsyncThrowsError()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
return(Task.FromException <HttpResponseMessage>(new InvalidOperationException("Error!")));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions());
var writeException = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.RequestStream.WriteAsync(new HelloRequest())).DefaultTimeout();
var resultException = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseAsync).DefaultTimeout();
// Assert
Assert.AreEqual("Error starting gRPC call. InvalidOperationException: Error!", writeException.Status.Detail);
Assert.AreEqual("Error starting gRPC call. InvalidOperationException: Error!", resultException.Status.Detail);
Assert.AreEqual(StatusCode.Internal, call.GetStatus().StatusCode);
}
public async Task AsyncDuplexStreamingCall_MessageSmallerThanReceiveMaxMessageSize_Success()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(HandleRequest);
var invoker = HttpClientCallInvokerFactory.Create(httpClient, configure: o => o.MaxReceiveMessageSize = 100);
// Act
var call = invoker.AsyncDuplexStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions());
await call.RequestStream.WriteAsync(new HelloRequest
{
Name = "World"
});
await call.RequestStream.CompleteAsync().DefaultTimeout();
// Assert
await call.ResponseStream.MoveNext(CancellationToken.None).DefaultTimeout();
Assert.AreEqual("Hello World", call.ResponseStream.Current.Message);
}
public async Task AsyncClientStreamingCall_DeadlineStatusResponse_ResponseThrowsDeadlineExceededStatus()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
return Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, new StringContent(string.Empty), StatusCode.DeadlineExceeded));
});
var testSystemClock = new TestSystemClock(DateTime.UtcNow);
var invoker = HttpClientCallInvokerFactory.Create(httpClient, systemClock: testSystemClock, disableClientDeadline: true);
// Act
var call = invoker.AsyncClientStreamingCall<HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(deadline: testSystemClock.UtcNow.AddSeconds(0.5)));
// Assert
var responseTask = call.ResponseAsync;
var ex = await ExceptionAssert.ThrowsAsync<RpcException>(() => responseTask).DefaultTimeout();
Assert.AreEqual(StatusCode.DeadlineExceeded, ex.StatusCode);
Assert.AreEqual(StatusCode.DeadlineExceeded, call.GetStatus().StatusCode);
}