public async Task AsyncClientStreamingCall_Success_HttpRequestMessagePopulated()
{
// Arrange
HttpRequestMessage httpRequestMessage = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await TestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions());
await call.RequestStream.CompleteAsync().DefaultTimeout();
var response = await call;
// Assert
Assert.AreEqual("Hello world", response.Message);
Assert.IsNotNull(httpRequestMessage);
Assert.AreEqual(new Version(2, 0), httpRequestMessage.Version);
Assert.AreEqual(HttpMethod.Post, httpRequestMessage.Method);
Assert.AreEqual(new Uri("https://localhost/ServiceName/MethodName"), httpRequestMessage.RequestUri);
Assert.AreEqual(new MediaTypeHeaderValue("application/grpc"), httpRequestMessage.Content.Headers.ContentType);
}
public void AsyncClientStreamingCall_DeadlineDuringSend_ResponseThrowsDeadlineExceededStatus()
{
// Arrange
PushStreamContent content = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
content = (PushStreamContent)request.Content;
await content.PushComplete.DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, 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 void ClientStreamWriter_CompleteWhilePendingWrite_ErrorThrown()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(request =>
{
var streamContent = new StreamContent(new SyncPointMemoryStream());
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent)));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions());
// Assert
var writeTask1 = call.RequestStream.WriteAsync(new HelloRequest {
Name = "1"
});
Assert.IsFalse(writeTask1.IsCompleted);
var completeTask = call.RequestStream.CompleteAsync();
var ex = Assert.ThrowsAsync <InvalidOperationException>(() => completeTask.DefaultTimeout());
Assert.AreEqual("Cannot complete client stream writer because the previous write is in progress.", ex.Message);
}
public async Task AsyncClientStreamingCall_Success_RequestContentSent()
{
// Arrange
PushStreamContent content = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
content = (PushStreamContent)request.Content;
await content.PushComplete.DefaultTimeout();
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await TestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, 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();
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.ReadStreamedMessageAsync(TestHelpers.ServiceMethod.RequestMarshaller.Deserializer, CancellationToken.None).DefaultTimeout();
Assert.AreEqual("1", requestMessage.Name);
requestMessage = await requestContent.ReadStreamedMessageAsync(TestHelpers.ServiceMethod.RequestMarshaller.Deserializer, CancellationToken.None).DefaultTimeout();
Assert.AreEqual("2", requestMessage.Name);
var responseMessage = await responseTask.DefaultTimeout();
Assert.AreEqual("Hello world", responseMessage.Message);
}
public void AsyncClientStreamingCall_NotFoundStatus_ThrowsError()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(request =>
{
var response = ResponseUtils.CreateResponse(HttpStatusCode.NotFound);
return(Task.FromResult(response));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions());
var ex = Assert.Throws <InvalidOperationException>(() => call.GetTrailers());
// Assert
Assert.AreEqual("Bad gRPC response. Expected HTTP status code 200. Got status code: 404", ex.Message);
}
public void ClientStreamWriter_WriteAfterResponseHasFinished_ErrorThrown()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(request =>
{
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK)));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions());
// Assert
var ex = Assert.ThrowsAsync <RpcException>(async() => await call.RequestStream.WriteAsync(new HelloRequest()).DefaultTimeout());
Assert.AreEqual(StatusCode.Cancelled, ex.Status.StatusCode);
}
public void AsyncClientStreamingCall_DeadlineBeforeWrite_ResponseThrowsDeadlineExceededStatus()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(request =>
{
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK)));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(deadline: DateTime.UtcNow));
// Assert
var ex = Assert.ThrowsAsync <RpcException>(async() => await call.RequestStream.WriteAsync(new HelloRequest()).DefaultTimeout());
Assert.AreEqual(StatusCode.DeadlineExceeded, ex.Status.StatusCode);
}
public void AsyncClientStreamingCall_InvalidContentType_ThrowsError()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(request =>
{
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK);
response.Content.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
return(Task.FromResult(response));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions());
var ex = Assert.Throws <InvalidOperationException>(() => call.GetTrailers());
// Assert
Assert.AreEqual("Bad gRPC response. Invalid content-type value: text/plain", ex.Message);
}
public void AsyncClientStreamingCall_UncompleteWriter_ThrowsError()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(request =>
{
var stream = new SyncPointMemoryStream();
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(stream), grpcStatusCode: null);
return(Task.FromResult(response));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions());
var ex = Assert.Throws <InvalidOperationException>(() => call.GetTrailers());
// Assert
Assert.AreEqual("Can't get the call trailers because the call is not complete.", ex.Message);
}
public void AsyncClientStreamingCall_UnfinishedCall_ThrowsError()
{
// Arrange
var tcs = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously);
var httpClient = TestHelpers.CreateTestClient(async request =>
{
await tcs.Task.DefaultTimeout();
return(null);
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions());
var ex = Assert.Throws <InvalidOperationException>(() => call.GetTrailers());
// Assert
Assert.AreEqual("Can't get the call trailers because the call is not complete.", ex.Message);
}
public async Task AsyncClientStreamingCall_CompleteWriter_ReturnsTrailers()
{
// Arrange
var trailingHeadersWrittenTcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
var httpClient = TestHelpers.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 TestHelpers.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 = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, 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 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 = new HttpClientCallInvoker(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_Success_ResponseHeadersPopulated()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(async request =>
{
var streamContent = await TestHelpers.CreateResponseContent(new HelloReply()).DefaultTimeout();
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent);
response.Headers.Add("custom", "ABC");
return(response);
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions());
var responseHeaders = await call.ResponseHeadersAsync.DefaultTimeout();
// Assert
var header = responseHeaders.Single(h => h.Key == "custom");
Assert.AreEqual("ABC", header.Value);
}