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());
}
