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 MoveNext_MultipleCallsWithoutAwait_ThrowError()
{
// Arrange
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
var stream = new SyncPointMemoryStream();
var content = new StreamContent(stream);
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, content)));
});
var httpClientCallInvoker = new HttpClientCallInvoker(httpClient, null);
var call = new GrpcCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, new CallOptions(), httpClientCallInvoker);
call.StartServerStreaming(httpClient, new HelloRequest());
// Act
var moveNextTask1 = call.ClientStreamReader !.MoveNext(CancellationToken.None);
var moveNextTask2 = call.ClientStreamReader.MoveNext(CancellationToken.None);
// Assert
Assert.IsFalse(moveNextTask1.IsCompleted);
var ex = await ExceptionAssert.ThrowsAsync <InvalidOperationException>(() => moveNextTask2).DefaultTimeout();
Assert.AreEqual("Cannot read next message because the previous read is in progress.", ex.Message);
}
public async Task AsyncUnaryCall_NoHeaders_RequestMessageHasNoHeaders()
{
// 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);
var headers = new Metadata();
// Act
var rs = await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(headers : headers), new HelloRequest());
// Assert
Assert.AreEqual("Hello world", rs.Message);
Assert.IsNotNull(httpRequestMessage);
// User-Agent is always sent
Assert.AreEqual(0, httpRequestMessage.Headers.Count(h => !string.Equals(h.Key, HeaderNames.UserAgent, StringComparison.OrdinalIgnoreCase)));
}
public async Task AsyncUnaryCall_SuccessAndReadValuesAfterDeadline_ValuesReturned()
{
// 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 = new HttpClientCallInvoker(httpClient);
invoker.Clock = new TestSystemClock(new DateTime(2019, 11, 29, 1, 1, 1, DateTimeKind.Utc));
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(deadline: invoker.Clock.UtcNow.AddSeconds(0.5)), new HelloRequest());
// Assert
var result = await call;
Assert.IsNotNull(result);
// Wait for deadline to trigger
await Task.Delay(1000);
Assert.IsNotNull(await call.ResponseHeadersAsync);
Assert.IsNotNull(call.GetTrailers());
Assert.AreEqual(StatusCode.OK, call.GetStatus().StatusCode);
}
public void AsyncUnaryCall_PercentEncodedMessage_MessageDecoded()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(async request =>
{
var streamContent = await TestHelpers.CreateResponseContent(new HelloReply()).DefaultTimeout();
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent, grpcStatusCode: StatusCode.Aborted);
response.TrailingHeaders.Add(GrpcProtocolConstants.MessageTrailer, "%C2%A3");
return(response);
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest());
// Assert
var ex = Assert.ThrowsAsync <RpcException>(async() => await call.ResponseAsync.DefaultTimeout());
Assert.AreEqual(StatusCode.Aborted, ex.StatusCode);
var status = call.GetStatus();
Assert.AreEqual(StatusCode.Aborted, status.StatusCode);
Assert.AreEqual("£", status.Detail);
}
public async Task AsyncServerStreamingCall_NoContent_NoMessagesReturned()
{
// Arrange
HttpRequestMessage httpRequestMessage = null;
var httpClient = TestHelpers.CreateTestClient(request =>
{
httpRequestMessage = request;
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, new ByteArrayContent(Array.Empty <byte>()))));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncServerStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, 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 AsyncServerStreamingCall_UnfinishedReader_ThrowsError()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(async request =>
{
var streamContent = await TestHelpers.CreateResponseContent(
new HelloReply
{
Message = "Hello world 1"
},
new HelloReply
{
Message = "Hello world 2"
}).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncServerStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest());
var responseStream = call.ResponseStream;
Assert.IsTrue(await responseStream.MoveNext(CancellationToken.None).DefaultTimeout());
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 AsyncServerStreamingCall_FinishedReader_ReturnsTrailers()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(async request =>
{
var streamContent = await TestHelpers.CreateResponseContent(
new HelloReply
{
Message = "Hello world 1"
},
new HelloReply
{
Message = "Hello world 2"
}).DefaultTimeout();
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent);
response.TrailingHeaders.Add("custom-header", "value");
return(response);
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncServerStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest());
var responseStream = call.ResponseStream;
Assert.IsTrue(await responseStream.MoveNext(CancellationToken.None).DefaultTimeout());
Assert.IsTrue(await responseStream.MoveNext(CancellationToken.None).DefaultTimeout());
Assert.IsFalse(await responseStream.MoveNext(CancellationToken.None).DefaultTimeout());
var trailers = call.GetTrailers();
// Assert
Assert.AreEqual("value", trailers.Single(t => t.Key == "custom-header").Value);
}
public async Task AsyncUnaryCall_DisposeAfterHeadersAndBeforeMessage_ThrowsError()
{
// Arrange
var stream = new SyncPointMemoryStream();
var httpClient = TestHelpers.CreateTestClient(request =>
{
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(stream));
response.Headers.Add("custom", "value!");
return(Task.FromResult(response));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest {
Name = "World"
});
var responseHeaders = await call.ResponseHeadersAsync.DefaultTimeout();
call.Dispose();
// Assert
Assert.ThrowsAsync <ObjectDisposedException>(async() => await call.ResponseAsync.DefaultTimeout());
var header = responseHeaders.Single(h => h.Key == "custom");
Assert.AreEqual("value!", header.Value);
}
public async Task MoveNext_TokenCanceledDuringCall_ThrowError()
{
// Arrange
var cts = new CancellationTokenSource();
var httpClient = ClientTestHelpers.CreateTestClient(request =>
{
var stream = new SyncPointMemoryStream();
var content = new StreamContent(stream);
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, content)));
});
var httpClientCallInvoker = new HttpClientCallInvoker(httpClient, null);
var call = new GrpcCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, new CallOptions(), httpClientCallInvoker);
call.StartServerStreaming(httpClient, new HelloRequest());
// Act
var moveNextTask1 = call.ClientStreamReader !.MoveNext(cts.Token);
// Assert
Assert.IsFalse(moveNextTask1.IsCompleted);
cts.Cancel();
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => moveNextTask1).DefaultTimeout();
Assert.AreEqual(StatusCode.Cancelled, ex.StatusCode);
}
public async Task AsyncUnaryCall_AwaitMultipleTimes_SameMessageReturned()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(async 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.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest {
Name = "World"
});
var response1 = await call;
var response2 = await call;
var response3 = await call.ResponseAsync.DefaultTimeout();
var response4 = await call.ResponseAsync.DefaultTimeout();
// Assert
Assert.AreEqual("Hello world", response1.Message);
Assert.AreEqual(response1, response2);
Assert.AreEqual(response1, response3);
Assert.AreEqual(response1, response4);
}
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 async Task AsyncUnaryCall_SendHeaders_RequestMessageContainsHeaders()
{
// 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);
var headers = new Metadata();
headers.Add("custom", "ascii");
headers.Add("custom-bin", Encoding.UTF8.GetBytes("Hello world"));
// Act
var rs = await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(headers : headers), new HelloRequest());
// Assert
Assert.AreEqual("Hello world", rs.Message);
Assert.IsNotNull(httpRequestMessage);
Assert.AreEqual("ascii", httpRequestMessage.Headers.GetValues("custom").Single());
Assert.AreEqual("Hello world", Encoding.UTF8.GetString(Convert.FromBase64String(httpRequestMessage.Headers.GetValues("custom-bin").Single())));
}
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 async Task AsyncUnaryCall_SendDeadlineHeaderAndDeadlineValue_DeadlineValueIsUsed()
{
// 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);
invoker.Clock = new TestSystemClock(new DateTime(2019, 11, 29, 1, 1, 1, DateTimeKind.Utc));
var headers = new Metadata();
headers.Add("grpc-timeout", "1D");
// Act
var rs = await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(headers : headers, deadline : invoker.Clock.UtcNow.AddSeconds(1)), new HelloRequest());
// Assert
Assert.AreEqual("Hello world", rs.Message);
Assert.IsNotNull(httpRequestMessage);
Assert.AreEqual("1S", httpRequestMessage.Headers.GetValues(GrpcProtocolConstants.TimeoutHeader).Single());
}
public async Task AsyncUnaryCall_Success_RequestContentSent()
{
// Arrange
HttpContent content = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
content = request.Content;
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 rs = await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest { Name = "World" });
// Assert
Assert.AreEqual("Hello world", rs.Message);
Assert.IsNotNull(content);
var requestContent = await content.ReadAsStreamAsync().DefaultTimeout();
var requestMessage = await requestContent.ReadSingleMessageAsync(TestHelpers.ServiceMethod.RequestMarshaller.Deserializer, CancellationToken.None).DefaultTimeout();
Assert.AreEqual("World", requestMessage.Name);
}
public TClient CreateClient(HttpClient httpClient, string name)
{
if (httpClient == null)
{
throw new ArgumentNullException(nameof(httpClient));
}
var httpClientCallInvoker = new HttpClientCallInvoker(httpClient, _loggerFactory);
var options = _optionsMonitor.Get(name);
for (var i = 0; i < options.CallInvokerActions.Count; i++)
{
options.CallInvokerActions[i](httpClientCallInvoker);
}
CallInvoker resolvedCallInvoker = httpClientCallInvoker;
// Interceptors wrap each other and execute in reverse order
for (var i = options.Interceptors.Count - 1; i >= 0; i--)
{
resolvedCallInvoker = resolvedCallInvoker.Intercept(options.Interceptors[i]);
}
return((TClient)_cache.Activator(_services, new object[] { resolvedCallInvoker }));
}
public void AsyncServerStreamingCall_DisposeBeforeHeadersReceived_ReturnsError()
{
// Arrange
var tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
var httpClient = TestHelpers.CreateTestClient(async(request, ct) =>
{
await tcs.Task.DefaultTimeout();
ct.ThrowIfCancellationRequested();
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.AsyncServerStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest());
call.Dispose();
tcs.TrySetResult(true);
// Assert
Assert.ThrowsAsync <ObjectDisposedException>(() => call.ResponseHeadersAsync);
}
public async Task AsyncServerStreamingCall_MessagesStreamed_MessagesReceived()
{
// Arrange
var streamContent = new SyncPointMemoryStream();
var httpClient = TestHelpers.CreateTestClient(request =>
{
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(streamContent))));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncServerStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest());
var responseStream = call.ResponseStream;
// Assert
Assert.IsNull(responseStream.Current);
var moveNextTask1 = responseStream.MoveNext(CancellationToken.None);
Assert.IsFalse(moveNextTask1.IsCompleted);
await streamContent.AddDataAndWait(await TestHelpers.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 TestHelpers.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 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);
}
private static HttpClientCallInvoker CreateTimedoutCallInvoker()
{
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);
return(invoker);
}
public void AsyncUnaryCall_NonOkStatusTrailer_ThrowRpcError()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(request =>
{
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, new ByteArrayContent(Array.Empty <byte>()), StatusCode.Unimplemented);
return(Task.FromResult(response));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var ex = Assert.ThrowsAsync <RpcException>(async() => await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest()));
// Assert
Assert.AreEqual(StatusCode.Unimplemented, ex.StatusCode);
}
public void AsyncUnaryCall_ErrorSendingRequest_ThrowsError()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(request =>
{
return(Task.FromException <HttpResponseMessage>(new Exception("An error!")));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest());
var ex = Assert.CatchAsync <Exception>(() => call.ResponseAsync);
// Assert
Assert.AreEqual("An error!", 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_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 ClientStreamReader_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.AsyncServerStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest());
// Assert
var ex = Assert.ThrowsAsync <InvalidOperationException>(async() => await call.ResponseStream.MoveNext(CancellationToken.None).DefaultTimeout());
Assert.AreEqual("Bad gRPC response. Expected HTTP status code 200. Got status code: 404", ex.Message);
}
public TClient CreateClient(HttpClient httpClient, string name)
{
if (httpClient == null)
{
throw new ArgumentNullException(nameof(httpClient));
}
var httpClientCallInvoker = new HttpClientCallInvoker(httpClient, _loggerFactory);
var options = _optionsMonitor.Get(name);
for (var i = 0; i < options.CallInvokerActions.Count; i++)
{
options.CallInvokerActions[i](httpClientCallInvoker);
}
return((TClient)_cache.Activator(_services, new object[] { httpClientCallInvoker.Intercept(options.Interceptors.ToArray()) }));
}
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 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 = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncServerStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, 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);
}
