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 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 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 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 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 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 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 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 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 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 AsyncDuplexStreamingCall_MessagesStreamed_MessagesReceived()
{
// Arrange
var streamContent = new SyncPointMemoryStream();
PushStreamContent <HelloRequest, HelloReply>?content = null;
var httpClient = ClientTestHelpers.CreateTestClient(async request =>
{
content = (PushStreamContent <HelloRequest, HelloReply>)request.Content !;
await content.PushComplete.DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(streamContent)));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncDuplexStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions());
var requestStream = call.RequestStream;
var responseStream = call.ResponseStream;
// Assert
await call.RequestStream.WriteAsync(new HelloRequest { Name = "1" }).DefaultTimeout();
await call.RequestStream.WriteAsync(new HelloRequest { Name = "2" }).DefaultTimeout();
await call.RequestStream.CompleteAsync().DefaultTimeout();
var deserializationContext = new DefaultDeserializationContext();
Assert.IsNotNull(content);
var requestContent = await content !.ReadAsStreamAsync().DefaultTimeout();
var requestMessage = await requestContent.ReadMessageAsync(
deserializationContext,
NullLogger.Instance,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
GrpcProtocolConstants.IdentityGrpcEncoding,
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : false,
CancellationToken.None).AsTask().DefaultTimeout();
Assert.AreEqual("1", requestMessage !.Name);
requestMessage = await requestContent.ReadMessageAsync(
deserializationContext,
NullLogger.Instance,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
GrpcProtocolConstants.IdentityGrpcEncoding,
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : false,
CancellationToken.None).AsTask().DefaultTimeout();
Assert.AreEqual("2", requestMessage !.Name);
Assert.IsNull(responseStream.Current);
var moveNextTask1 = responseStream.MoveNext(CancellationToken.None);
Assert.IsFalse(moveNextTask1.IsCompleted);
await streamContent.AddDataAndWait(await ClientTestHelpers.GetResponseDataAsync(new HelloReply
{
Message = "Hello world 1"
}).DefaultTimeout()).DefaultTimeout();
Assert.IsTrue(await moveNextTask1.DefaultTimeout());
Assert.IsNotNull(responseStream.Current);
Assert.AreEqual("Hello world 1", responseStream.Current.Message);
var moveNextTask2 = responseStream.MoveNext(CancellationToken.None);
Assert.IsFalse(moveNextTask2.IsCompleted);
await streamContent.AddDataAndWait(await ClientTestHelpers.GetResponseDataAsync(new HelloReply
{
Message = "Hello world 2"
}).DefaultTimeout()).DefaultTimeout();
Assert.IsTrue(await moveNextTask2.DefaultTimeout());
Assert.IsNotNull(responseStream.Current);
Assert.AreEqual("Hello world 2", responseStream.Current.Message);
var moveNextTask3 = responseStream.MoveNext(CancellationToken.None);
Assert.IsFalse(moveNextTask3.IsCompleted);
await streamContent.AddDataAndWait(Array.Empty <byte>()).DefaultTimeout();
Assert.IsFalse(await moveNextTask3.DefaultTimeout());
var moveNextTask4 = responseStream.MoveNext(CancellationToken.None);
Assert.IsTrue(moveNextTask4.IsCompleted);
Assert.IsFalse(await moveNextTask3.DefaultTimeout());
}
public async Task BufferHint_SuccessResponses()
{
// Arrange
var ms = new MemoryStream();
MessageHelpers.WriteMessage(ms, new ChatMessage
{
Name = "John",
Message = "Hello Jill"
});
var requestStream = new SyncPointMemoryStream();
var httpRequest = new HttpRequestMessage(HttpMethod.Post, "Chat.Chatter/ChatBufferHint");
httpRequest.Content = new StreamContent(requestStream);
// Act
var responseTask = Fixture.Client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead);
// Assert
Assert.IsFalse(responseTask.IsCompleted, "Server should wait for first message from client");
await requestStream.AddDataAndWait(ms.ToArray());
Assert.IsFalse(responseTask.IsCompleted, "Server is buffering response");
ms = new MemoryStream();
MessageHelpers.WriteMessage(ms, new ChatMessage
{
Name = "Jill",
Message = "Hello John"
});
await requestStream.AddDataAndWait(ms.ToArray());
Assert.IsFalse(responseTask.IsCompleted, "Server is buffering response");
await requestStream.AddDataAndWait(Array.Empty <byte>());
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 pipeReader = new StreamPipeReader(new PipeReaderFixStream(responseStream));
var message1 = await MessageHelpers.AssertReadStreamMessageAsync <ChatMessage>(pipeReader).DefaultTimeout();
Assert.AreEqual("John", message1.Name);
Assert.AreEqual("Hello Jill", message1.Message);
var message2 = await MessageHelpers.AssertReadStreamMessageAsync <ChatMessage>(pipeReader).DefaultTimeout();
Assert.AreEqual("Jill", message2.Name);
Assert.AreEqual("Hello John", message2.Message);
Assert.IsNull(await MessageHelpers.AssertReadStreamMessageAsync <ChatMessage>(pipeReader).DefaultTimeout());
}
public async Task AsyncDuplexStreamingCall_MessagesStreamed_MessagesReceived()
{
// Arrange
var streamContent = new SyncPointMemoryStream();
PushStreamContent content = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
content = (PushStreamContent)request.Content;
await content.PushComplete.DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(streamContent)));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncDuplexStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, 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 requestContent = await content.ReadAsStreamAsync().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);
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());
}
