public async Task CanSendData()
{
var data = new byte[] { 1, 1, 2, 3, 5, 8 };
var sendTcs = new TaskCompletionSource <byte[]>();
var mockHttpHandler = new Mock <HttpMessageHandler>();
mockHttpHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) =>
{
await Task.Yield();
if (request.Method == HttpMethod.Post)
{
sendTcs.SetResult(await request.Content.ReadAsByteArrayAsync());
}
return(request.Method == HttpMethod.Options
? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse())
: ResponseUtils.CreateResponse(HttpStatusCode.OK));
});
var connection = new HttpConnection(new Uri("http://fakeuri.org/"), TransportType.LongPolling, loggerFactory: null, httpMessageHandler: mockHttpHandler.Object);
try
{
await connection.StartAsync();
await connection.SendAsync(data);
Assert.Equal(data, await sendTcs.Task.OrTimeout());
}
finally
{
await connection.DisposeAsync();
}
}
public async Task ResolverReturnsNoAddresses_DisposeWhileWaitForReady_Error()
{
// Arrange
var testMessageHandler = TestHttpMessageHandler.Create(async request =>
{
var reply = new HelloReply {
Message = "Hello world"
};
var streamContent = await ClientTestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var services = new ServiceCollection();
services.AddSingleton <TestResolver>();
services.AddSingleton <ResolverFactory, TestResolverFactory>();
services.AddSingleton <ISubchannelTransportFactory>(new TestSubchannelTransportFactory());
var invoker = HttpClientCallInvokerFactory.Create(testMessageHandler, "test:///localhost", configure: o =>
{
o.Credentials = ChannelCredentials.Insecure;
o.ServiceProvider = services.BuildServiceProvider();
});
// Act
var callOptions = new CallOptions().WithWaitForReady();
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, callOptions, new HelloRequest());
var exTask = ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseAsync);
call.Dispose();
var ex = await exTask.DefaultTimeout();
Assert.AreEqual(StatusCode.Cancelled, ex.StatusCode);
Assert.AreEqual("gRPC call disposed.", ex.Status.Detail);
}
public async Task AsyncServerStreamingCall_MessagesReturnedTogether_MessagesReceived()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
var streamContent = await ClientTestHelpers.CreateResponsesContent(
new HelloReply
{
Message = "Hello world 1"
},
new HelloReply
{
Message = "Hello world 2"
}).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
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.IsTrue(await responseStream.MoveNext(CancellationToken.None).DefaultTimeout());
Assert.IsNotNull(responseStream.Current);
Assert.AreEqual("Hello world 1", responseStream.Current.Message);
Assert.IsTrue(await responseStream.MoveNext(CancellationToken.None).DefaultTimeout());
Assert.IsNotNull(responseStream.Current);
Assert.AreEqual("Hello world 2", responseStream.Current.Message);
Assert.IsFalse(await responseStream.MoveNext(CancellationToken.None).DefaultTimeout());
}
public async Task HttpConnectionSetsRequestedWithOnAllRequests(HttpTransportType transportType)
{
var testHttpHandler = new TestHttpMessageHandler(autoNegotiate: false);
var requestsExecuted = false;
testHttpHandler.OnNegotiate((_, cancellationToken) =>
{
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationContent()));
});
testHttpHandler.OnRequest(async(request, next, token) =>
{
var requestedWithHeader = request.Headers.GetValues(HeaderNames.XRequestedWith);
var requestedWithValue = Assert.Single(requestedWithHeader);
Assert.Equal("XMLHttpRequest", requestedWithValue);
requestsExecuted = true;
return(await next());
});
testHttpHandler.OnRequest((request, next, token) =>
{
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.NoContent)));
});
await WithConnectionAsync(
CreateConnection(testHttpHandler, transportType : transportType),
async (connection) =>
{
await connection.StartAsync().DefaultTimeout();
await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello World"));
});
// Fail safe in case the code is modified and some requests don't execute as a result
Assert.True(requestsExecuted);
}
public async Task Intercept_WrapClientStream_ClientStreamWrapperExecuted()
{
// Arrange
var serviceMethod = new Method <string, string>(MethodType.Unary, "ServiceName", "Unary", Marshallers.StringMarshaller, Marshallers.StringMarshaller);
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
var requestContent = await request.Content.ReadAsStreamAsync();
await requestContent.CopyToAsync(new MemoryStream());
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(new ClientStreamingCountingInterceptor());
var call = callInvoker.AsyncClientStreamingCall(serviceMethod, Host, new CallOptions());
await call.RequestStream.WriteAsync("A");
await call.RequestStream.WriteAsync("B");
await call.RequestStream.WriteAsync("C");
await call.RequestStream.CompleteAsync();
// Assert
Assert.AreEqual("3", await call.ResponseAsync);
Assert.AreEqual(StatusCode.OK, call.GetStatus().StatusCode);
Assert.IsNotNull(call.GetTrailers());
}
public async Task MoveNextAsync_MultipleMessages_MessagesReceived()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
var streamContent = await ClientTestHelpers.CreateResponsesContent(
new HelloReply
{
Message = "Hello world 1"
},
new HelloReply
{
Message = "Hello world 2"
}).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncServerStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(), new HelloRequest());
var enumerator = call.ResponseStream.ReadAllAsync().GetAsyncEnumerator();
// Assert
Assert.IsNull(enumerator.Current);
Assert.IsTrue(await enumerator.MoveNextAsync().AsTask().DefaultTimeout());
Assert.IsNotNull(enumerator.Current);
Assert.AreEqual("Hello world 1", enumerator.Current.Message);
Assert.IsTrue(await enumerator.MoveNextAsync().AsTask().DefaultTimeout());
Assert.IsNotNull(enumerator.Current);
Assert.AreEqual("Hello world 2", enumerator.Current.Message);
Assert.IsFalse(await enumerator.MoveNextAsync().AsTask().DefaultTimeout());
}
public async Task MoveNextAsync_CancelCall_ThrowOperationCanceledOnCancellation_EnumeratorThrows()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
var streamContent = await ClientTestHelpers.CreateResponsesContent(
new HelloReply
{
Message = "Hello world 1"
},
new HelloReply
{
Message = "Hello world 2"
}).DefaultTimeout();
return ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent);
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient, configure: o => o.ThrowOperationCanceledOnCancellation = true);
var cts = new CancellationTokenSource();
// Act
var call = invoker.AsyncServerStreamingCall<HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(cancellationToken: cts.Token), new HelloRequest());
var enumerator = call.ResponseStream.ReadAllAsync().GetAsyncEnumerator();
// Assert
Assert.IsNull(enumerator.Current);
Assert.IsTrue(await enumerator.MoveNextAsync().AsTask().DefaultTimeout());
Assert.IsNotNull(enumerator.Current);
Assert.AreEqual("Hello world 1", enumerator.Current.Message);
cts.Cancel();
await ExceptionAssert.ThrowsAsync<OperationCanceledException>(() => enumerator.MoveNextAsync().AsTask()).DefaultTimeout();
Assert.AreEqual(StatusCode.Cancelled, call.GetStatus().StatusCode);
}
public void AsyncClientStreamingCall_DeadlineDuringSend_ResponseThrowsDeadlineExceededStatus()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(async request =>
{
var content = (PushStreamContent)request.Content;
await content.PushComplete.DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, string.Empty, new CallOptions(deadline: DateTime.UtcNow.AddSeconds(0.5)));
// Assert
var responseTask = call.ResponseAsync;
Assert.IsFalse(responseTask.IsCompleted, "Response not returned until client stream is complete.");
var ex = Assert.ThrowsAsync <RpcException>(async() => await responseTask.DefaultTimeout());
Assert.AreEqual(StatusCode.DeadlineExceeded, ex.Status.StatusCode);
}
public async Task AsyncClientStreamingCall_WriteAfterResult_Error()
{
// Arrange
var requestContent = new MemoryStream();
var callCount = 0;
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
Interlocked.Increment(ref callCount);
_ = request.Content !.ReadAsStreamAsync();
var reply = new HelloReply {
Message = "Hello world"
};
var streamContent = await ClientTestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var serviceConfig = ServiceConfigHelpers.CreateHedgingServiceConfig();
var invoker = HttpClientCallInvokerFactory.Create(httpClient, serviceConfig: serviceConfig);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.GetServiceMethod(MethodType.ClientStreaming), string.Empty, new CallOptions());
// Assert
var responseMessage = await call.ResponseAsync.DefaultTimeout();
Assert.AreEqual("Hello world", responseMessage.Message);
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.RequestStream.WriteAsync(new HelloRequest {
Name = "1"
})).DefaultTimeout();
Assert.AreEqual(StatusCode.OK, ex.StatusCode);
}
public async Task NegotiateThatReturnsRedirectUrlForeverThrowsAfter100Tries()
{
var testHttpHandler = new TestHttpMessageHandler(autoNegotiate: false);
testHttpHandler.OnNegotiate((request, cancellationToken) =>
{
return(ResponseUtils.CreateResponse(HttpStatusCode.OK,
JsonConvert.SerializeObject(new
{
url = "https://another.domain.url/chat"
})));
});
using (var noErrorScope = new VerifyNoErrorsScope())
{
await WithConnectionAsync(
CreateConnection(testHttpHandler, loggerFactory : noErrorScope.LoggerFactory),
async (connection) =>
{
var exception = await Assert.ThrowsAsync <InvalidOperationException>(() => connection.StartAsync().DefaultTimeout());
Assert.Equal("Negotiate redirection limit exceeded.", exception.Message);
});
}
}
public async Task NegotiateCanHaveNewFields()
{
string connectionId = null;
var testHttpHandler = new TestHttpMessageHandler(autoNegotiate: false);
testHttpHandler.OnNegotiate((request, cancellationToken) => ResponseUtils.CreateResponse(HttpStatusCode.OK,
JsonConvert.SerializeObject(new
{
connectionId = "0rge0d00-0040-0030-0r00-000q00r00e00",
availableTransports = new object[]
{
new
{
transport = "LongPolling",
transferFormats = new[] { "Text" }
},
},
newField = "ignore this",
})));
testHttpHandler.OnLongPoll(cancellationToken => ResponseUtils.CreateResponse(HttpStatusCode.NoContent));
testHttpHandler.OnLongPollDelete((token) => ResponseUtils.CreateResponse(HttpStatusCode.Accepted));
using (var noErrorScope = new VerifyNoErrorsScope())
{
await WithConnectionAsync(
CreateConnection(testHttpHandler, loggerFactory : noErrorScope.LoggerFactory),
async (connection) =>
{
await connection.StartAsync().DefaultTimeout();
connectionId = connection.ConnectionId;
});
}
Assert.Equal("0rge0d00-0040-0030-0r00-000q00r00e00", connectionId);
}
public async Task LongPollingTransportCanBeCanceled()
{
using (StartVerifiableLog())
{
var cts = new CancellationTokenSource();
var httpHandler = new TestHttpMessageHandler(autoNegotiate: false);
httpHandler.OnNegotiate((request, cancellationToken) =>
{
// Cancel token so that the first request poll will throw
cts.Cancel();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationContent()));
});
var lp = new LongPollingTransport(new HttpClient(httpHandler));
await WithConnectionAsync(
CreateConnection(httpHandler, transport : lp, transportType : HttpTransportType.LongPolling),
async (connection) =>
{
var ex = await Assert.ThrowsAsync <AggregateException>(async() => await connection.StartAsync(cts.Token).DefaultTimeout());
});
}
}
public async Task AsyncClientStreamingCall_DeadlineBeforeWrite_ResponseThrowsDeadlineExceededStatus()
{
// Arrange
var tcs = new TaskCompletionSource<object?>(TaskCreationOptions.RunContinuationsAsynchronously);
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
await tcs.Task.DefaultTimeout();
return ResponseUtils.CreateResponse(HttpStatusCode.OK);
});
var systemClock = new TestSystemClock(DateTime.UtcNow);
var invoker = HttpClientCallInvokerFactory.Create(httpClient, systemClock: systemClock);
// Act
var call = invoker.AsyncClientStreamingCall<HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(deadline: systemClock.UtcNow.AddMilliseconds(10)));
// Ensure the deadline has passed
systemClock.UtcNow = systemClock.UtcNow.AddMilliseconds(200);
await Task.Delay(200);
// Assert
var ex = await ExceptionAssert.ThrowsAsync<RpcException>(() => call.RequestStream.WriteAsync(new HelloRequest())).DefaultTimeout();
Assert.AreEqual(StatusCode.DeadlineExceeded, ex.StatusCode);
Assert.AreEqual(StatusCode.DeadlineExceeded, call.GetStatus().StatusCode);
}
public void InterceptMetadata_AddRequestHeader_HeaderInRequest()
{
// Arrange
const string HeaderKey = "x-client-interceptor";
const string HeaderValue = "hello-world";
string?requestHeaderValue = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
if (request.Headers.TryGetValues(HeaderKey, out var values))
{
requestHeaderValue = values.Single();
}
var streamContent = await TestHelpers.CreateResponseContent(new HelloReply {
Message = "PASS"
}).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var callInvoker = invoker.Intercept(metadata =>
{
metadata = metadata ?? new Metadata();
metadata.Add(new Metadata.Entry(HeaderKey, HeaderValue));
return(metadata);
});
var result = callInvoker.BlockingUnaryCall(TestHelpers.ServiceMethod, Host, new CallOptions(), new HelloRequest());
// Assert
Assert.AreEqual("PASS", result.Message);
Assert.AreEqual(HeaderValue, requestHeaderValue);
}
public async Task AsyncUnaryCall_ErrorParsingTrailers_ThrowsError()
{
// Arrange
var testSink = new TestSink();
var loggerFactory = new TestLoggerFactory(testSink, true);
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
var streamContent = await ClientTestHelpers.CreateResponseContent(new HelloReply()).DefaultTimeout();
var response = ResponseUtils.CreateResponse(
HttpStatusCode.OK,
streamContent,
grpcStatusCode: StatusCode.Aborted,
customTrailers: new Dictionary <string, string>
{
["blah-bin"] = "!"
});
response.Headers.Add("custom", "ABC");
return(response);
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient, loggerFactory);
// 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.Aborted, ex.StatusCode);
Assert.AreEqual(null, ex.Status.Detail);
Assert.AreEqual(0, ex.Trailers.Count);
var log = testSink.Writes.Single(w => w.EventId.Name == "ErrorParsingTrailers");
Assert.AreEqual("Error parsing trailers.", log.State.ToString());
Assert.AreEqual("Invalid Base-64 header value.", log.Exception.Message);
}
public async Task AsyncClientStreamingCall_DeadlineDuringSend_ResponseThrowsDeadlineExceededStatus()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
var content = (PushStreamContent)request.Content;
await content.PushComplete.DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK));
});
var testSystemClock = new TestSystemClock(DateTime.UtcNow);
var invoker = HttpClientCallInvokerFactory.Create(httpClient, systemClock: testSystemClock);
// 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);
}
public void GlobalSetup()
{
var ms = new MemoryStream();
MessageHelpers.WriteMessage(ms, new HelloReply());
var requestMessage = ms.ToArray();
var handler = TestHttpMessageHandler.Create(r =>
{
var content = new ByteArrayContent(requestMessage);
content.Headers.ContentType = new MediaTypeHeaderValue("application/grpc");
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, content)));
});
var httpClient = new HttpClient(handler);
var channel = GrpcChannel.ForAddress("http://localhost", new GrpcChannelOptions
{
HttpClient = httpClient
});
_client = new Greeter.GreeterClient(channel);
}
private async Task <HttpResponseMessage> HandleRequest(HttpRequestMessage request)
{
var requestStream = await request.Content !.ReadAsStreamAsync().DefaultTimeout();
var helloRequest = await StreamExtensions.ReadMessageAsync(
requestStream,
new DefaultDeserializationContext(),
NullLogger.Instance,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
"gzip",
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : true,
CancellationToken.None).AsTask().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 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 systemClock = new TestSystemClock(DateTime.UtcNow);
var invoker = HttpClientCallInvokerFactory.Create(httpClient, systemClock: systemClock);
var deadline = systemClock.UtcNow.AddMilliseconds(0.1);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(deadline: deadline));
systemClock.UtcNow = deadline;
// Assert
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.RequestStream.WriteAsync(new HelloRequest())).DefaultTimeout();
Assert.AreEqual(StatusCode.DeadlineExceeded, ex.StatusCode);
Assert.AreEqual(StatusCode.DeadlineExceeded, call.GetStatus().StatusCode);
}
public async Task AsyncServerStreamingCall_MessagesReturnedTogether_MessagesReceived()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, new ByteArrayContent(Array.Empty <byte>()))));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncDuplexStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions());
var responseStream = call.ResponseStream;
// Assert
Assert.IsNull(responseStream.Current);
Assert.IsFalse(await responseStream.MoveNext(CancellationToken.None).DefaultTimeout());
Assert.IsNull(responseStream.Current);
}
public async Task CallCredentialsWithHttp_NoMetadataOnRequest()
{
// Arrange
bool?hasAuthorizationValue = null;
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
hasAuthorizationValue = request.Headers.TryGetValues("authorization", out _);
var reply = new HelloReply {
Message = "Hello world"
};
var streamContent = await ClientTestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
}, new Uri("http://localhost"));
var testSink = new TestSink();
var loggerFactory = new TestLoggerFactory(testSink, true);
var invoker = HttpClientCallInvokerFactory.Create(httpClient, loggerFactory);
// Act
var callCredentials = CallCredentials.FromInterceptor((context, metadata) =>
{
metadata.Add("authorization", "SECRET_TOKEN");
return(Task.CompletedTask);
});
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(credentials: callCredentials), new HelloRequest());
await call.ResponseAsync.DefaultTimeout();
// Assert
Assert.AreEqual(false, hasAuthorizationValue);
var log = testSink.Writes.Single(w => w.EventId.Name == "CallCredentialsNotUsed");
Assert.AreEqual("The configured CallCredentials were not used because the call does not use TLS.", log.State.ToString());
}
public IHttpActionResult CreateFile([FromBody] PythonFileDM file)
{
RC.PythonFileManager.Commit(CommitTypeEnum.ADD, file);
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, file));
}
public IHttpActionResult UpdateFile([FromBody] PythonFileDM file, [FromUri] int id)
{
RC.PythonFileManager.Commit(CommitTypeEnum.UPDATE, file, id: id);
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, file));
}
public IHttpActionResult GetFile([FromUri] int id)
{
var result = RC.PythonFileManager.Pull((item) => item.ID == id);
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, result));
}
public IHttpActionResult GetFiles()
{
var results = RC.PythonFileManager.PullAll();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, results));
}
public async Task AsyncDuplexStreamingCall_MessagesStreamed_MessagesReceived()
{
// Arrange
var streamContent = new SyncPointMemoryStream();
PushStreamContent <HelloRequest, HelloReply>?content = null;
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
content = (PushStreamContent <HelloRequest, HelloReply>)request.Content !;
await content.PushComplete.DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(streamContent)));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// 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 content !.ReadAsStreamAsync().DefaultTimeout();
var requestMessage = await requestContent.ReadMessageAsync(
deserializationContext,
NullLogger.Instance,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
GrpcProtocolConstants.IdentityGrpcEncoding,
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : false,
CancellationToken.None).AsTask().DefaultTimeout();
Assert.AreEqual("1", requestMessage !.Name);
requestMessage = await requestContent.ReadMessageAsync(
deserializationContext,
NullLogger.Instance,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
GrpcProtocolConstants.IdentityGrpcEncoding,
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : false,
CancellationToken.None).AsTask().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
PushStreamContent <HelloRequest, HelloReply>?content = null;
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
content = (PushStreamContent <HelloRequest, HelloReply>)request.Content !;
await content.PushComplete.DefaultTimeout();
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 call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions());
// Assert
Assert.IsNotNull(call);
Assert.IsNotNull(content);
var responseTask = call.ResponseAsync;
Assert.IsFalse(responseTask.IsCompleted, "Response not returned until client stream is complete.");
var streamTask = content !.ReadAsStreamAsync().DefaultTimeout();
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 streamTask.DefaultTimeout();
var requestMessage = await requestContent.ReadMessageAsync(
NullLogger.Instance,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
GrpcProtocolConstants.IdentityGrpcEncoding,
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : false,
CancellationToken.None).AsTask().DefaultTimeout();
Assert.AreEqual("1", requestMessage !.Name);
requestMessage = await requestContent.ReadMessageAsync(
NullLogger.Instance,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
GrpcProtocolConstants.IdentityGrpcEncoding,
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : false,
CancellationToken.None).AsTask().DefaultTimeout();
Assert.AreEqual("2", requestMessage !.Name);
var responseMessage = await responseTask.DefaultTimeout();
Assert.AreEqual("Hello world", responseMessage.Message);
}
public async Task LongPollingTransportSendsAvailableMessagesWhenTheyArrive()
{
var sentRequests = new List <byte[]>();
var tcs = new TaskCompletionSource <HttpResponseMessage>();
var firstPoll = true;
var mockHttpHandler = new Mock <HttpMessageHandler>();
mockHttpHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) =>
{
await Task.Yield();
if (request.Method == HttpMethod.Post)
{
// Build a new request object, but convert the entire payload to string
sentRequests.Add(await request.Content.ReadAsByteArrayAsync());
}
else if (request.Method == HttpMethod.Get)
{
// First poll completes immediately
if (firstPoll)
{
firstPoll = false;
return(ResponseUtils.CreateResponse(HttpStatusCode.OK));
}
cancellationToken.Register(() => tcs.TrySetCanceled(cancellationToken));
// This is the poll task
return(await tcs.Task);
}
else if (request.Method == HttpMethod.Delete)
{
return(ResponseUtils.CreateResponse(HttpStatusCode.Accepted));
}
return(ResponseUtils.CreateResponse(HttpStatusCode.OK));
});
using (var httpClient = new HttpClient(mockHttpHandler.Object))
{
var longPollingTransport = new LongPollingTransport(httpClient);
try
{
// Start the transport
await longPollingTransport.StartAsync(TestUri, TransferFormat.Binary);
longPollingTransport.Output.Write(Encoding.UTF8.GetBytes("Hello"));
longPollingTransport.Output.Write(Encoding.UTF8.GetBytes("World"));
await longPollingTransport.Output.FlushAsync();
longPollingTransport.Output.Complete();
await longPollingTransport.Running.DefaultTimeout();
await longPollingTransport.Input.ReadAllAsync();
Assert.Single(sentRequests);
Assert.Equal(new[] { (byte)'H', (byte)'e', (byte)'l', (byte)'l', (byte)'o', (byte)'W', (byte)'o', (byte)'r', (byte)'l', (byte)'d' }, sentRequests[0]);
}
finally
{
await longPollingTransport.StopAsync();
}
}
}
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 PickAsync_HedgingWithDrop_ThrowsError()
{
// Arrange
string?authority = null;
var testMessageHandler = TestHttpMessageHandler.Create(async request =>
{
authority = request.RequestUri !.Authority;
var reply = new HelloReply {
Message = "Hello world"
};
var streamContent = await ClientTestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var services = new ServiceCollection();
services.AddNUnitLogger();
services.AddSingleton <TestResolver>();
services.AddSingleton <ResolverFactory, TestResolverFactory>();
DropLoadBalancer?loadBalancer = null;
services.AddSingleton <LoadBalancerFactory>(new DropLoadBalancerFactory(c =>
{
loadBalancer = new DropLoadBalancer(c);
return(loadBalancer);
}));
services.AddSingleton <ISubchannelTransportFactory>(new TestSubchannelTransportFactory());
var invoker = HttpClientCallInvokerFactory.Create(testMessageHandler, "test:///localhost", configure: o =>
{
o.Credentials = ChannelCredentials.Insecure;
o.ServiceProvider = services.BuildServiceProvider();
o.ServiceConfig = new ServiceConfig
{
MethodConfigs =
{
new MethodConfig
{
Names = { MethodName.Default },
HedgingPolicy = new HedgingPolicy
{
MaxAttempts = 5,
HedgingDelay = TimeSpan.FromMinutes(10),
NonFatalStatusCodes ={ StatusCode.DataLoss }
}
}
},
LoadBalancingConfigs = { new LoadBalancingConfig("drop") }
};
});
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions().WithWaitForReady(), new HelloRequest());
// Assert
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseAsync).DefaultTimeout();
Assert.AreEqual(StatusCode.DataLoss, ex.StatusCode);
Assert.AreEqual(1, loadBalancer !.PickCount);
}