public void MoveNext_TokenCanceledDuringCall_ThrowError() { // Arrange var cts = new CancellationTokenSource(); var httpClient = TestHelpers.CreateTestClient(request => { var stream = new SyncPointMemoryStream(); var content = new StreamContent(stream); return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, content))); }); var call = new GrpcCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, new CallOptions(), SystemClock.Instance, NullLoggerFactory.Instance); call.StartServerStreaming(httpClient, new HelloRequest()); // Act var moveNextTask1 = call.ClientStreamReader !.MoveNext(cts.Token); // Assert Assert.IsFalse(moveNextTask1.IsCompleted); cts.Cancel(); var ex = Assert.ThrowsAsync <RpcException>(async() => await moveNextTask1.DefaultTimeout()); Assert.AreEqual(StatusCode.Cancelled, ex.StatusCode); }
public async Task MoveNext_TokenCanceledBeforeCall_ThrowOperationCanceledExceptionOnCancellation_ThrowError() { // Arrange var cts = new CancellationTokenSource(); cts.Cancel(); var httpClient = ClientTestHelpers.CreateTestClient(request => { var stream = new SyncPointMemoryStream(); var content = new StreamContent(stream); return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, content))); }); var channel = GrpcChannel.ForAddress(httpClient.BaseAddress, new GrpcChannelOptions { HttpClient = httpClient, ThrowOperationCanceledOnCancellation = true }); var call = CreateGrpcCall(channel); call.StartServerStreaming(new HelloRequest()); // Act var moveNextTask = call.ClientStreamReader !.MoveNext(cts.Token); // Assert Assert.IsTrue(moveNextTask.IsCompleted); await ExceptionAssert.ThrowsAsync <OperationCanceledException>(() => moveNextTask).DefaultTimeout(); }
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 channel = GrpcChannel.ForAddress(httpClient.BaseAddress, new GrpcChannelOptions { HttpClient = httpClient }); var call = new GrpcCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, new CallOptions(), channel); call.StartServerStreaming(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 CompleteThenIncompleteMessage_ErrorResponse() { // Arrange var ms = new MemoryStream(); MessageHelpers.WriteMessage(ms, new CounterRequest { Count = 1 }); var requestStream = new SyncPointMemoryStream(); var httpRequest = new HttpRequestMessage(HttpMethod.Post, "Count.Counter/AccumulateCount"); httpRequest.Content = new StreamContent(requestStream); // Act var responseTask = Fixture.Client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead); // Assert Assert.IsFalse(responseTask.IsCompleted, "Server should wait for client to finish streaming"); // Complete message await requestStream.AddDataAndWait(ms.ToArray()).DefaultTimeout(); // Incomplete message and finish await requestStream.AddDataAndWait(ms.ToArray().AsSpan().Slice(0, (int)ms.Length - 1).ToArray()).DefaultTimeout(); await requestStream.AddDataAndWait(Array.Empty <byte>()).DefaultTimeout(); await responseTask.DefaultTimeout(); Assert.AreEqual(StatusCode.Internal.ToTrailerString(), Fixture.TrailersContainer.Trailers[GrpcProtocolConstants.StatusTrailer].ToString()); Assert.AreEqual("Incomplete message.", Fixture.TrailersContainer.Trailers[GrpcProtocolConstants.MessageTrailer].ToString()); }
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 channel = GrpcChannel.ForAddress(httpClient.BaseAddress, new GrpcChannelOptions { HttpClient = httpClient }); var call = new GrpcCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, new CallOptions(), channel); call.StartServerStreaming(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("Can't read the next message because the previous read is still in progress.", ex.Message); }
public async Task AsyncUnaryCall_DisposeAfterHeadersAndBeforeMessage_ThrowsError() { // Arrange var stream = new SyncPointMemoryStream(); var httpClient = ClientTestHelpers.CreateTestClient(request => { var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(stream)); response.Headers.Add("custom", "value!"); return(Task.FromResult(response)); }); var invoker = HttpClientCallInvokerFactory.Create(httpClient); // Act var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(), new HelloRequest { Name = "World" }); var responseHeaders = await call.ResponseHeadersAsync.DefaultTimeout(); call.Dispose(); // Assert var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseAsync).DefaultTimeout(); Assert.AreEqual(StatusCode.Cancelled, ex.StatusCode); Assert.AreEqual(StatusCode.Cancelled, call.GetStatus().StatusCode); var header = responseHeaders.Single(h => h.Key == "custom"); Assert.AreEqual("value!", header.Value); }
public async Task AdditionalDataAfterStreamedMessage_ErrorResponse() { // Arrange var requestMessage = new HelloRequest { Name = "World" }; var ms = new MemoryStream(); MessageHelpers.WriteMessage(ms, requestMessage); var requestStream = new SyncPointMemoryStream(); var httpRequest = new HttpRequestMessage(HttpMethod.Post, "Greet.Greeter/SayHello"); httpRequest.Content = new StreamContent(requestStream); // Act var responseTask = Fixture.Client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead); // Assert Assert.IsFalse(responseTask.IsCompleted, "Server should wait for client to finish streaming"); await requestStream.AddDataAndWait(ms.ToArray()).DefaultTimeout(); await requestStream.AddDataAndWait(ms.ToArray()).DefaultTimeout(); await responseTask.DefaultTimeout(); Assert.AreEqual(StatusCode.Internal.ToTrailerString(), Fixture.TrailersContainer.Trailers[GrpcProtocolConstants.StatusTrailer].Single()); Assert.AreEqual("Additional data after the message received.", Fixture.TrailersContainer.Trailers[GrpcProtocolConstants.MessageTrailer].Single()); }
public async Task MultipleMessagesThenClose_SuccessResponse() { // Arrange var ms = new MemoryStream(); MessageHelpers.WriteMessage(ms, new CounterRequest { Count = 1 }); var requestStream = new SyncPointMemoryStream(); var httpRequest = new HttpRequestMessage(HttpMethod.Post, "Count.Counter/AccumulateCount"); httpRequest.Content = new GrpcStreamContent(requestStream); // Act var responseTask = Fixture.Client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead); // Assert Assert.IsFalse(responseTask.IsCompleted, "Server should wait for client to finish streaming"); await requestStream.AddDataAndWait(ms.ToArray()).DefaultTimeout(); await requestStream.AddDataAndWait(ms.ToArray()).DefaultTimeout(); await requestStream.AddDataAndWait(Array.Empty <byte>()).DefaultTimeout(); var response = await responseTask.DefaultTimeout(); var reply = await response.GetSuccessfulGrpcMessageAsync <CounterReply>(); Assert.AreEqual(2, reply.Count); response.AssertTrailerStatus(); }
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 testSink = new TestSink(e => e.LogLevel >= LogLevel.Error); var testLoggerFactory = new TestLoggerFactory(testSink, enabled: true); var channel = CreateChannel(httpClient, loggerFactory: testLoggerFactory); var call = CreateGrpcCall(channel); call.StartServerStreaming(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("Can't read the next message because the previous read is still in progress.", ex.Message); Assert.AreEqual(1, testSink.Writes.Count); var write = testSink.Writes.ElementAt(0); Assert.AreEqual("ReadMessageError", write.EventId.Name); Assert.AreEqual(ex, write.Exception); }
public async Task MoveNext_TokenCanceledBeforeCall_ThrowOperationCanceledExceptionOnCancellation_ThrowError() { // Arrange var cts = new CancellationTokenSource(); cts.Cancel(); var httpClient = ClientTestHelpers.CreateTestClient(request => { var stream = new SyncPointMemoryStream(); var content = new StreamContent(stream); return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, content))); }); var testSink = new TestSink(e => e.LogLevel >= LogLevel.Error); var testLoggerFactory = new TestLoggerFactory(testSink, enabled: true); var channel = CreateChannel(httpClient, loggerFactory: testLoggerFactory, throwOperationCanceledOnCancellation: true); var call = CreateGrpcCall(channel); call.StartServerStreaming(new HelloRequest()); // Act var moveNextTask = call.ClientStreamReader !.MoveNext(cts.Token); // Assert Assert.IsTrue(moveNextTask.IsCompleted); await ExceptionAssert.ThrowsAsync <OperationCanceledException>(() => moveNextTask).DefaultTimeout(); Assert.AreEqual(0, testSink.Writes.Count); }
public async Task StreamedMessage_SuccessResponseAfterMessageReceived() { // Arrange var requestMessage = new HelloRequest { Name = "World" }; var ms = new MemoryStream(); MessageHelpers.WriteMessage(ms, requestMessage); var requestStream = new SyncPointMemoryStream(); var httpRequest = new HttpRequestMessage(HttpMethod.Post, "Greet.Greeter/SayHello"); httpRequest.Content = new GrpcStreamContent(requestStream); // Act var responseTask = Fixture.Client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead); // Assert Assert.IsFalse(responseTask.IsCompleted, "Server should wait for client to finish streaming"); await requestStream.AddDataAndWait(ms.ToArray()).DefaultTimeout(); await requestStream.AddDataAndWait(Array.Empty <byte>()).DefaultTimeout(); var response = await responseTask.DefaultTimeout(); var responseMessage = await response.GetSuccessfulGrpcMessageAsync <HelloReply>(); Assert.AreEqual("Hello World", responseMessage.Message); }
public void MoveNext_MultipleCallsWithoutAwait_ThrowError() { // Arrange var httpClient = TestHelpers.CreateTestClient(request => { var stream = new SyncPointMemoryStream(); var content = new StreamContent(stream); return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, content))); }); var call = new GrpcCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, new CallOptions(), SystemClock.Instance, NullLoggerFactory.Instance); 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 = Assert.ThrowsAsync <InvalidOperationException>(async() => await moveNextTask2.DefaultTimeout()); Assert.AreEqual("Cannot read next message because the previous read is in progress.", ex.Message); }
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 = HttpClientCallInvokerFactory.Create(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 MessageSentInMultipleChunks_SuccessResponse() { // Arrange SetExpectedErrorsFilter(writeContext => { return(writeContext.LoggerName == typeof(GreeterService).FullName && writeContext.EventId.Name == "RpcConnectionError" && writeContext.State.ToString() == "Error status code 'Internal' raised."); }); var requestMessage = new HelloRequest { Name = "World" }; var ms = new MemoryStream(); MessageHelpers.WriteMessage(ms, requestMessage); var requestStream = new SyncPointMemoryStream(); var httpRequest = new HttpRequestMessage(HttpMethod.Post, "Greet.Greeter/SayHello"); httpRequest.Content = new GrpcStreamContent(requestStream); // Act var responseTask = Fixture.Client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead); // Assert Assert.IsFalse(responseTask.IsCompleted, "Server should wait for client to finish streaming"); // Send message one byte at a time then finish foreach (var b in ms.ToArray()) { await requestStream.AddDataAndWait(new[] { b }).DefaultTimeout(); } await requestStream.AddDataAndWait(Array.Empty <byte>()).DefaultTimeout(); var response = await responseTask.DefaultTimeout(); Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); var responseMessage = MessageHelpers.AssertReadMessage <HelloReply>(await response.Content.ReadAsByteArrayAsync().DefaultTimeout()); Assert.AreEqual("Hello World", responseMessage.Message); Assert.AreEqual(StatusCode.OK.ToTrailerString(), Fixture.TrailersContainer.Trailers[GrpcProtocolConstants.StatusTrailer].Single()); }
public async Task AsyncServerStreamingCall_FailureAfterReadingResponseMessage_Failure() { // Arrange var streamContent = new SyncPointMemoryStream(); var callCount = 0; var httpClient = ClientTestHelpers.CreateTestClient(request => { callCount++; return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(streamContent)))); }); var serviceConfig = ServiceConfigHelpers.CreateRetryServiceConfig(); var invoker = HttpClientCallInvokerFactory.Create(httpClient, serviceConfig: serviceConfig); // Act var call = invoker.AsyncServerStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, 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 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.AddExceptionAndWait(new Exception("Exception!")).DefaultTimeout(); var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => moveNextTask2).DefaultTimeout(); Assert.AreEqual(StatusCode.Internal, ex.StatusCode); Assert.AreEqual(StatusCode.Internal, call.GetStatus().StatusCode); Assert.AreEqual("Error reading next message. Exception: Exception!", call.GetStatus().Detail); }
public async Task AsyncServerStreamingCall_MessagesStreamedThenCancellation_ErrorStatus() { // Arrange var streamContent = new SyncPointMemoryStream(); var httpClient = ClientTestHelpers.CreateTestClient(request => { return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(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); 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 cts = new CancellationTokenSource(); var moveNextTask2 = responseStream.MoveNext(cts.Token); Assert.IsFalse(moveNextTask2.IsCompleted); cts.Cancel(); var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => moveNextTask2).DefaultTimeout(); Assert.AreEqual(StatusCode.Cancelled, ex.StatusCode); Assert.AreEqual(StatusCode.Cancelled, call.GetStatus().StatusCode); Assert.AreEqual("Call canceled by the client.", call.GetStatus().Detail); }
public async Task MultipleMessagesThenClose_SuccessResponse() { // Arrange var ms = new MemoryStream(); MessageHelpers.WriteMessage(ms, new CounterRequest { Count = 1 }); var requestStream = new SyncPointMemoryStream(); var httpRequest = new HttpRequestMessage(HttpMethod.Post, "Count.Counter/AccumulateCount"); httpRequest.Content = new StreamContent(requestStream); // Act var responseTask = Fixture.Client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead); // Assert Assert.IsFalse(responseTask.IsCompleted, "Server should wait for client to finish streaming"); await requestStream.AddDataAndWait(ms.ToArray()).DefaultTimeout(); await requestStream.AddDataAndWait(ms.ToArray()).DefaultTimeout(); await requestStream.AddDataAndWait(Array.Empty <byte>()).DefaultTimeout(); var response = await responseTask.DefaultTimeout(); Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); Assert.AreEqual("identity", response.Headers.GetValues("grpc-encoding").Single()); Assert.AreEqual("application/grpc", response.Content.Headers.ContentType.MediaType); var responseStream = await response.Content.ReadAsStreamAsync().DefaultTimeout(); var replyTask = MessageHelpers.AssertReadMessageAsync <CounterReply>(responseStream); Assert.IsTrue(replyTask.IsCompleted); var reply = await replyTask.DefaultTimeout(); Assert.AreEqual(2, reply.Count); Assert.AreEqual(StatusCode.OK.ToTrailerString(), Fixture.TrailersContainer.Trailers[GrpcProtocolConstants.StatusTrailer].Single()); }
public async Task CompleteThenIncompleteMessage_ErrorResponse() { // Arrange SetExpectedErrorsFilter(writeContext => { return(writeContext.LoggerName == typeof(CounterService).FullName && writeContext.EventId.Name == "RpcConnectionError" && writeContext.State.ToString() == "Error status code 'Internal' raised." && GetRpcExceptionDetail(writeContext.Exception) == "Incomplete message."); }); var ms = new MemoryStream(); MessageHelpers.WriteMessage(ms, new CounterRequest { Count = 1 }); var requestStream = new SyncPointMemoryStream(); var httpRequest = new HttpRequestMessage(HttpMethod.Post, "Count.Counter/AccumulateCount"); httpRequest.Content = new GrpcStreamContent(requestStream); // Act var responseTask = Fixture.Client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead); // Assert Assert.IsFalse(responseTask.IsCompleted, "Server should wait for client to finish streaming"); // Complete message await requestStream.AddDataAndWait(ms.ToArray()).DefaultTimeout(); // Incomplete message and finish await requestStream.AddDataAndWait(ms.ToArray().AsSpan().Slice(0, (int)ms.Length - 1).ToArray()).DefaultTimeout(); await requestStream.AddDataAndWait(Array.Empty <byte>()).DefaultTimeout(); var response = await responseTask.DefaultTimeout(); // Read to end of response so headers are available await response.Content.CopyToAsync(new MemoryStream()); response.AssertTrailerStatus(StatusCode.Internal, "Incomplete 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, 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); }
public void AsyncClientStreamingCall_DeadlineBeforeWrite_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.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_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 is not complete.", ex.Message); }
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 AdditionalDataAfterStreamedMessage_ErrorResponse() { // Arrange SetExpectedErrorsFilter(writeContext => { return(writeContext.LoggerName == typeof(GreeterService).FullName && writeContext.EventId.Name == "RpcConnectionError" && writeContext.State.ToString() == "Error status code 'Internal' raised."); }); var requestMessage = new HelloRequest { Name = "World" }; var ms = new MemoryStream(); MessageHelpers.WriteMessage(ms, requestMessage); var requestStream = new SyncPointMemoryStream(); var httpRequest = new HttpRequestMessage(HttpMethod.Post, "Greet.Greeter/SayHello"); httpRequest.Content = new GrpcStreamContent(requestStream); // Act var responseTask = Fixture.Client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead); // Assert Assert.IsFalse(responseTask.IsCompleted, "Server should wait for client to finish streaming"); await requestStream.AddDataAndWait(ms.ToArray()).DefaultTimeout(); await requestStream.AddDataAndWait(ms.ToArray()).DefaultTimeout(); var response = await responseTask.DefaultTimeout(); // Read to end of response so headers are available await response.Content.CopyToAsync(new MemoryStream()); response.AssertTrailerStatus(StatusCode.Internal, "Additional data after the message received."); }
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 ClientStreamWriter_WriteWhileComplete_ErrorThrown() { // Arrange var streamContent = new SyncPointMemoryStream(); var httpClient = ClientTestHelpers.CreateTestClient(request => { return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(streamContent)))); }); var serviceConfig = ServiceConfigHelpers.CreateRetryServiceConfig(); var invoker = HttpClientCallInvokerFactory.Create(httpClient, serviceConfig: serviceConfig); // Act var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.GetServiceMethod(MethodType.ClientStreaming), string.Empty, new CallOptions()); await call.RequestStream.CompleteAsync().DefaultTimeout(); var resultTask = call.ResponseAsync; // Assert var writeException1 = await ExceptionAssert.ThrowsAsync <InvalidOperationException>(() => call.RequestStream.WriteAsync(new HelloRequest { Name = "1" })).DefaultTimeout(); Assert.AreEqual("Request stream has already been completed.", writeException1.Message); await streamContent.AddDataAndWait(await ClientTestHelpers.GetResponseDataAsync(new HelloReply { Message = "Hello world 1" }).DefaultTimeout()).DefaultTimeout(); await streamContent.AddDataAndWait(new byte[0]); var result = await resultTask.DefaultTimeout(); Assert.AreEqual("Hello world 1", result.Message); var writeException2 = await ExceptionAssert.ThrowsAsync <InvalidOperationException>(() => call.RequestStream.WriteAsync(new HelloRequest { Name = "2" })).DefaultTimeout(); Assert.AreEqual("Request stream has already been completed.", writeException2.Message); }
public async Task MessageSentInMultipleChunks_SuccessResponse() { // Arrange var requestMessage = new HelloRequest { Name = "World" }; var ms = new MemoryStream(); MessageHelpers.WriteMessage(ms, requestMessage); var requestStream = new SyncPointMemoryStream(); var httpRequest = new HttpRequestMessage(HttpMethod.Post, "Greet.Greeter/SayHello"); httpRequest.Content = new StreamContent(requestStream); // Act var responseTask = Fixture.Client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead); // Assert Assert.IsFalse(responseTask.IsCompleted, "Server should wait for client to finish streaming"); // Send message one byte at a time then finish foreach (var b in ms.ToArray()) { await requestStream.AddDataAndWait(new[] { b }).DefaultTimeout(); } await requestStream.AddDataAndWait(Array.Empty <byte>()).DefaultTimeout(); var response = await responseTask.DefaultTimeout(); Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); var responseMessage = MessageHelpers.AssertReadMessage <HelloReply>(await response.Content.ReadAsByteArrayAsync().DefaultTimeout()); Assert.AreEqual("Hello World", responseMessage.Message); }
public async Task CompleteThenIncompleteMessage_ErrorResponse() { // Arrange var ms = new MemoryStream(); MessageHelpers.WriteMessage(ms, new CounterRequest { Count = 1 }); var requestStream = new SyncPointMemoryStream(); var httpRequest = new HttpRequestMessage(HttpMethod.Post, "Count.Counter/AccumulateCount"); httpRequest.Content = new StreamContent(requestStream); // Act var responseTask = Fixture.Client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead); // Assert Assert.IsFalse(responseTask.IsCompleted, "Server should wait for client to finish streaming"); // Complete message await requestStream.AddDataAndWait(ms.ToArray()).DefaultTimeout(); // Incomplete message and finish await requestStream.AddDataAndWait(ms.ToArray().AsSpan().Slice(0, (int)ms.Length - 1).ToArray()).DefaultTimeout(); await requestStream.AddDataAndWait(Array.Empty <byte>()).DefaultTimeout(); // TODO - this should return a response with a gRPC status object var ex = Assert.ThrowsAsync <InvalidDataException>(async() => { await responseTask.DefaultTimeout(); }); Assert.AreEqual("Incomplete message.", ex.Message); }
public async Task StreamedMessage_SuccessResponseAfterMessageReceived() { // Arrange var requestMessage = new HelloRequest { Name = "World" }; var ms = new MemoryStream(); MessageHelpers.WriteMessage(ms, requestMessage); var requestStream = new SyncPointMemoryStream(); var httpRequest = new HttpRequestMessage(HttpMethod.Post, "Greet.Greeter/SayHello"); httpRequest.Content = new StreamContent(requestStream); // Act var responseTask = Fixture.Client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead); // Assert Assert.IsFalse(responseTask.IsCompleted, "Server should wait for client to finish streaming"); await requestStream.AddDataAndWait(ms.ToArray()).DefaultTimeout(); await requestStream.AddDataAndWait(Array.Empty <byte>()).DefaultTimeout(); var response = await responseTask.DefaultTimeout(); Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); Assert.AreEqual("identity", response.Headers.GetValues("grpc-encoding").Single()); Assert.AreEqual("application/grpc", response.Content.Headers.ContentType.MediaType); var responseMessage = MessageHelpers.AssertReadMessage <HelloReply>(await response.Content.ReadAsByteArrayAsync().DefaultTimeout()); Assert.AreEqual("Hello World", responseMessage.Message); }
public async Task AdditionalDataAfterStreamedMessage_ErrorResponse() { // Arrange var requestMessage = new HelloRequest { Name = "World" }; var ms = new MemoryStream(); MessageHelpers.WriteMessage(ms, requestMessage); var requestStream = new SyncPointMemoryStream(); var httpRequest = new HttpRequestMessage(HttpMethod.Post, "Greet.Greeter/SayHello"); httpRequest.Content = new StreamContent(requestStream); // Act var responseTask = Fixture.Client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead); // Assert Assert.IsFalse(responseTask.IsCompleted, "Server should wait for client to finish streaming"); await requestStream.AddDataAndWait(ms.ToArray()).DefaultTimeout(); await requestStream.AddDataAndWait(ms.ToArray()).DefaultTimeout(); // TODO - this should return a response with a gRPC status object var ex = Assert.ThrowsAsync <InvalidDataException>(async() => { await responseTask.DefaultTimeout(); }); Assert.AreEqual("Additional data after the message received.", ex.Message); }
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()); }