public static AsyncServerStreamingCall <TResponse> AsyncServerStreamingCall <TRequest, TResponse>(CallInvocationDetails <TRequest, TResponse> call, TRequest req, Action customDisposeAction, string id) where TRequest : class where TResponse : class { var asyncCall = new AsyncCall <TRequest, TResponse>(call); asyncCall.StartServerStreamingCall(req); var responseStream = new ClientResponseStream <TRequest, TResponse>(asyncCall); var token = asyncCall.Details.Options.CancellationToken; if (token.CanBeCanceled) { token.Register(() => { customDisposeAction(); }); return(new AsyncServerStreamingCall <TResponse>(responseStream, asyncCall.ResponseHeadersAsync, asyncCall.GetStatus, asyncCall.GetTrailers, asyncCall.Cancel)); } else { return(new AsyncServerStreamingCall <TResponse>(responseStream, asyncCall.ResponseHeadersAsync, asyncCall.GetStatus, asyncCall.GetTrailers, () => { asyncCall.Cancel(); customDisposeAction(); })); } }
public void ServerStreaming_MoreResponses_Success() { asyncCall.StartServerStreamingCall("request1"); var responseStream = new ClientResponseStream <string, string>(asyncCall); fakeCall.ReceivedResponseHeadersCallback.OnReceivedResponseHeaders(true, new Metadata()); Assert.AreEqual(0, asyncCall.ResponseHeadersAsync.Result.Count); var readTask1 = responseStream.MoveNext(); fakeCall.ReceivedMessageCallback.OnReceivedMessage(true, CreateResponsePayload()); Assert.IsTrue(readTask1.Result); Assert.AreEqual("response1", responseStream.Current); var readTask2 = responseStream.MoveNext(); fakeCall.ReceivedMessageCallback.OnReceivedMessage(true, CreateResponsePayload()); Assert.IsTrue(readTask2.Result); Assert.AreEqual("response1", responseStream.Current); var readTask3 = responseStream.MoveNext(); fakeCall.ReceivedStatusOnClientCallback.OnReceivedStatusOnClient(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata())); fakeCall.ReceivedMessageCallback.OnReceivedMessage(true, CreateNullResponse()); AssertStreamingResponseSuccess(asyncCall, fakeCall, readTask3); }
public void DuplexStreaming_WriteFailureThrowsRpcException() { asyncCall.StartDuplexStreamingCall(); var requestStream = new ClientRequestStream <string, string>(asyncCall); var responseStream = new ClientResponseStream <string, string>(asyncCall); fakeCall.ReceivedResponseHeadersCallback.OnReceivedResponseHeaders(true, new Metadata()); Assert.AreEqual(0, asyncCall.ResponseHeadersAsync.Result.Count); var writeTask = requestStream.WriteAsync("request1"); fakeCall.SendCompletionCallback.OnSendCompletion(false); // The write will wait for call to finish to receive the status code. Assert.IsFalse(writeTask.IsCompleted); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageCallback.OnReceivedMessage(true, CreateNullResponse()); fakeCall.ReceivedStatusOnClientCallback.OnReceivedStatusOnClient(true, CreateClientSideStatus(StatusCode.PermissionDenied)); var ex = Assert.ThrowsAsync <RpcException>(async() => await writeTask); Assert.AreEqual(StatusCode.PermissionDenied, ex.Status.StatusCode); AssertStreamingResponseError(asyncCall, fakeCall, readTask, StatusCode.PermissionDenied); }
/// <summary> /// Invokes a server streaming call asynchronously. /// In server streaming scenario, client sends on request and server responds with a stream of responses. /// </summary> /// <returns>A call object providing access to the asynchronous response stream.</returns> /// <param name="call">The call defintion.</param> /// <param name="req">Request message.</param> /// <typeparam name="TRequest">Type of request message.</typeparam> /// <typeparam name="TResponse">The of response messages.</typeparam> public static AsyncServerStreamingCall <TResponse> AsyncServerStreamingCall <TRequest, TResponse>(CallInvocationDetails <TRequest, TResponse> call, TRequest req) where TRequest : class where TResponse : class { var asyncCall = new AsyncCall <TRequest, TResponse>(call); asyncCall.StartServerStreamingCall(req); var responseStream = new ClientResponseStream <TRequest, TResponse>(asyncCall); return(new AsyncServerStreamingCall <TResponse>(responseStream, asyncCall.GetStatus, asyncCall.GetTrailers, asyncCall.Cancel)); }
public void ServerStreaming_NoResponse_ReadFailure() { asyncCall.StartServerStreamingCall("request1"); var responseStream = new ClientResponseStream <string, string>(asyncCall); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageCallback.OnReceivedMessage(false, null); // after a failed read, we rely on C core to deliver appropriate status code. fakeCall.ReceivedStatusOnClientCallback.OnReceivedStatusOnClient(true, CreateClientSideStatus(StatusCode.Internal)); AssertStreamingResponseError(asyncCall, fakeCall, readTask, StatusCode.Internal); }
public void ServerStreaming_RequestSerializationExceptionDoesntLeakResources() { string nullRequest = null; // will throw when serializing Assert.Throws(typeof(ArgumentNullException), () => asyncCall.StartServerStreamingCall(nullRequest)); Assert.AreEqual(0, channel.GetCallReferenceCount()); Assert.IsTrue(fakeCall.IsDisposed); var responseStream = new ClientResponseStream <string, string>(asyncCall); var readTask = responseStream.MoveNext(); }
/// <summary> /// Invokes a duplex streaming call asynchronously. /// In duplex streaming scenario, client sends a stream of requests and server responds with a stream of responses. /// The response stream is completely independent and both side can be sending messages at the same time. /// </summary> /// <returns>A call object providing access to the asynchronous request and response streams.</returns> /// <param name="call">The call definition.</param> /// <typeparam name="TRequest">Type of request messages.</typeparam> /// <typeparam name="TResponse">Type of reponse messages.</typeparam> public static AsyncDuplexStreamingCall <TRequest, TResponse> AsyncDuplexStreamingCall <TRequest, TResponse>(CallInvocationDetails <TRequest, TResponse> call) where TRequest : class where TResponse : class { var asyncCall = new AsyncCall <TRequest, TResponse>(call); asyncCall.StartDuplexStreamingCall(); var requestStream = new ClientRequestStream <TRequest, TResponse>(asyncCall); var responseStream = new ClientResponseStream <TRequest, TResponse>(asyncCall); return(new AsyncDuplexStreamingCall <TRequest, TResponse>(requestStream, responseStream, asyncCall.ResponseHeadersAsync, asyncCall.GetStatus, asyncCall.GetTrailers, asyncCall.Cancel)); }
public void ServerStreaming_NoResponse_Success2() { asyncCall.StartServerStreamingCall("request1"); var responseStream = new ClientResponseStream <string, string>(asyncCall); var readTask = responseStream.MoveNext(); // try alternative order of completions fakeCall.ReceivedStatusOnClientCallback.OnReceivedStatusOnClient(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata())); fakeCall.ReceivedMessageCallback.OnReceivedMessage(true, null); AssertStreamingResponseSuccess(asyncCall, fakeCall, readTask); }
public static AsyncServerStreamingCall <TResponse> AsyncServerStreamingCall <TRequest, TResponse>(Call <TRequest, TResponse> call, TRequest req, CancellationToken token) where TRequest : class where TResponse : class { var asyncCall = new AsyncCall <TRequest, TResponse>(call.RequestMarshaller.Serializer, call.ResponseMarshaller.Deserializer); asyncCall.Initialize(call.Channel, GetCompletionQueue(), call.Name); asyncCall.StartServerStreamingCall(req, call.Headers); RegisterCancellationCallback(asyncCall, token); var responseStream = new ClientResponseStream <TRequest, TResponse>(asyncCall); return(new AsyncServerStreamingCall <TResponse>(responseStream, asyncCall.Cancel)); }
public void ServerStreaming_NoResponse_Success1() { asyncCall.StartServerStreamingCall("request1"); var responseStream = new ClientResponseStream <string, string>(asyncCall); var readTask = responseStream.MoveNext(); fakeCall.ReceivedResponseHeadersCallback.OnReceivedResponseHeaders(true, new Metadata()); Assert.AreEqual(0, asyncCall.ResponseHeadersAsync.Result.Count); fakeCall.ReceivedMessageCallback.OnReceivedMessage(true, null); fakeCall.ReceivedStatusOnClientCallback.OnReceivedStatusOnClient(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata())); AssertStreamingResponseSuccess(asyncCall, fakeCall, readTask); }
public void DuplexStreaming_WriteAfterReceivingStatusFails() { asyncCall.StartDuplexStreamingCall(); var requestStream = new ClientRequestStream <string, string>(asyncCall); var responseStream = new ClientResponseStream <string, string>(asyncCall); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageHandler(true, null); fakeCall.ReceivedStatusOnClientHandler(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata())); AssertStreamingResponseSuccess(asyncCall, fakeCall, readTask); Assert.ThrowsAsync(typeof(InvalidOperationException), async() => await requestStream.WriteAsync("request1")); }
public void DuplexStreaming_CompleteAfterReceivingStatusSuceeds() { asyncCall.StartDuplexStreamingCall(); var requestStream = new ClientRequestStream <string, string>(asyncCall); var responseStream = new ClientResponseStream <string, string>(asyncCall); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageCallback.OnReceivedMessage(true, null); fakeCall.ReceivedStatusOnClientCallback.OnReceivedStatusOnClient(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata())); AssertStreamingResponseSuccess(asyncCall, fakeCall, readTask); Assert.DoesNotThrowAsync(async() => await requestStream.CompleteAsync()); }
public void DuplexStreaming_WriteAfterCancellationRequestThrowsOperationCancelledException() { asyncCall.StartDuplexStreamingCall(); var requestStream = new ClientRequestStream <string, string>(asyncCall); var responseStream = new ClientResponseStream <string, string>(asyncCall); asyncCall.Cancel(); Assert.IsTrue(fakeCall.IsCancelled); Assert.Throws(typeof(OperationCanceledException), () => requestStream.WriteAsync("request1")); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageHandler(true, null); fakeCall.ReceivedStatusOnClientHandler(true, CreateClientSideStatus(StatusCode.Cancelled)); AssertStreamingResponseError(asyncCall, fakeCall, readTask, StatusCode.Cancelled); }
public void DuplexStreaming_WriteAfterReceivingStatusThrowsRpcException() { asyncCall.StartDuplexStreamingCall(); var requestStream = new ClientRequestStream <string, string>(asyncCall); var responseStream = new ClientResponseStream <string, string>(asyncCall); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageHandler(true, null); fakeCall.ReceivedStatusOnClientHandler(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata())); AssertStreamingResponseSuccess(asyncCall, fakeCall, readTask); var ex = Assert.ThrowsAsync <RpcException>(async() => await requestStream.WriteAsync("request1")); Assert.AreEqual(Status.DefaultSuccess, ex.Status); }
public void DuplexStreaming_NoRequestNoResponse_Success() { asyncCall.StartDuplexStreamingCall(); var requestStream = new ClientRequestStream <string, string>(asyncCall); var responseStream = new ClientResponseStream <string, string>(asyncCall); var writeTask1 = requestStream.CompleteAsync(); fakeCall.SendCompletionHandler(true); Assert.DoesNotThrowAsync(async() => await writeTask1); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageHandler(true, null); fakeCall.ReceivedStatusOnClientHandler(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata())); AssertStreamingResponseSuccess(asyncCall, fakeCall, readTask); }
public void DuplexStreaming_WriteAfterCancellationRequestThrowsTaskCanceledException() { asyncCall.StartDuplexStreamingCall(); var requestStream = new ClientRequestStream <string, string>(asyncCall); var responseStream = new ClientResponseStream <string, string>(asyncCall); asyncCall.Cancel(); Assert.IsTrue(fakeCall.IsCancelled); var writeTask = requestStream.WriteAsync("request1"); Assert.ThrowsAsync(typeof(TaskCanceledException), async() => await writeTask); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageCallback.OnReceivedMessage(true, CreateNullResponse()); fakeCall.ReceivedStatusOnClientCallback.OnReceivedStatusOnClient(true, CreateClientSideStatus(StatusCode.Cancelled)); AssertStreamingResponseError(asyncCall, fakeCall, readTask, StatusCode.Cancelled); }
public void DuplexStreaming_WriteFailureThrowsRpcException2() { asyncCall.StartDuplexStreamingCall(); var requestStream = new ClientRequestStream <string, string>(asyncCall); var responseStream = new ClientResponseStream <string, string>(asyncCall); var writeTask = requestStream.WriteAsync("request1"); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageCallback.OnReceivedMessage(true, null); fakeCall.ReceivedStatusOnClientCallback.OnReceivedStatusOnClient(true, CreateClientSideStatus(StatusCode.PermissionDenied)); fakeCall.SendCompletionCallback.OnSendCompletion(false); var ex = Assert.ThrowsAsync <RpcException>(async() => await writeTask); Assert.AreEqual(StatusCode.PermissionDenied, ex.Status.StatusCode); AssertStreamingResponseError(asyncCall, fakeCall, readTask, StatusCode.PermissionDenied); }
public void DuplexStreaming_WriteAfterReceivingStatusThrowsRpcException() { asyncCall.StartDuplexStreamingCall(); var requestStream = new ClientRequestStream <string, string>(asyncCall); var responseStream = new ClientResponseStream <string, string>(asyncCall); fakeCall.ReceivedResponseHeadersCallback.OnReceivedResponseHeaders(true, new Metadata()); Assert.AreEqual(0, asyncCall.ResponseHeadersAsync.Result.Count); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageCallback.OnReceivedMessage(true, CreateNullResponse()); fakeCall.ReceivedStatusOnClientCallback.OnReceivedStatusOnClient(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata())); AssertStreamingResponseSuccess(asyncCall, fakeCall, readTask); var writeTask = requestStream.WriteAsync("request1"); var ex = Assert.ThrowsAsync <RpcException>(async() => await writeTask); Assert.AreEqual(Status.DefaultSuccess, ex.Status); }
public void DuplexStreaming_NoRequestNoResponse_Success2() { asyncCall.StartDuplexStreamingCall(); var requestStream = new ClientRequestStream <string, string>(asyncCall); var responseStream = new ClientResponseStream <string, string>(asyncCall); var writeTask1 = requestStream.CompleteAsync(); fakeCall.SendCompletionCallback.OnSendCompletion(true); Assert.DoesNotThrowAsync(async() => await writeTask1); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageCallback.OnReceivedMessage(true, CreateNullResponse()); fakeCall.ReceivedStatusOnClientCallback.OnReceivedStatusOnClient(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata())); fakeCall.ReceivedResponseHeadersCallback.OnReceivedResponseHeaders(true, new Metadata()); Assert.AreEqual(0, asyncCall.ResponseHeadersAsync.Result.Count); AssertStreamingResponseSuccess(asyncCall, fakeCall, readTask); }
public void DuplexStreaming_ReadStartedBeforeCancellationRequestCanSucceed() { asyncCall.StartDuplexStreamingCall(); var responseStream = new ClientResponseStream <string, string>(asyncCall); var readTask1 = responseStream.MoveNext(); // initiate the read before cancel request asyncCall.Cancel(); Assert.IsTrue(fakeCall.IsCancelled); fakeCall.ReceivedMessageCallback.OnReceivedMessage(true, CreateResponsePayload()); Assert.IsTrue(readTask1.Result); Assert.AreEqual("response1", responseStream.Current); var readTask2 = responseStream.MoveNext(); fakeCall.ReceivedMessageCallback.OnReceivedMessage(true, null); fakeCall.ReceivedStatusOnClientCallback.OnReceivedStatusOnClient(true, CreateClientSideStatus(StatusCode.Cancelled)); AssertStreamingResponseError(asyncCall, fakeCall, readTask2, StatusCode.Cancelled); }
public void DuplexStreaming_ReadAfterCancellationRequestCanSucceed() { asyncCall.StartDuplexStreamingCall(); var responseStream = new ClientResponseStream <string, string>(asyncCall); fakeCall.ReceivedResponseHeadersCallback.OnReceivedResponseHeaders(true, new Metadata()); Assert.AreEqual(0, asyncCall.ResponseHeadersAsync.Result.Count); asyncCall.Cancel(); Assert.IsTrue(fakeCall.IsCancelled); var readTask1 = responseStream.MoveNext(); fakeCall.ReceivedMessageCallback.OnReceivedMessage(true, CreateResponsePayload()); Assert.IsTrue(readTask1.Result); Assert.AreEqual("response1", responseStream.Current); var readTask2 = responseStream.MoveNext(); fakeCall.ReceivedMessageCallback.OnReceivedMessage(true, CreateNullResponse()); fakeCall.ReceivedStatusOnClientCallback.OnReceivedStatusOnClient(true, CreateClientSideStatus(StatusCode.Cancelled)); AssertStreamingResponseError(asyncCall, fakeCall, readTask2, StatusCode.Cancelled); }
public void DuplexStreaming_ReadStartedBeforeCancellationRequestCanSucceed() { asyncCall.StartDuplexStreamingCall(); var responseStream = new ClientResponseStream<string, string>(asyncCall); var readTask1 = responseStream.MoveNext(); // initiate the read before cancel request asyncCall.Cancel(); Assert.IsTrue(fakeCall.IsCancelled); fakeCall.ReceivedMessageHandler(true, CreateResponsePayload()); Assert.IsTrue(readTask1.Result); Assert.AreEqual("response1", responseStream.Current); var readTask2 = responseStream.MoveNext(); fakeCall.ReceivedMessageHandler(true, null); fakeCall.ReceivedStatusOnClientHandler(true, CreateClientSideStatus(StatusCode.Cancelled)); AssertStreamingResponseError(asyncCall, fakeCall, readTask2, StatusCode.Cancelled); }
public void DuplexStreaming_WriteFailureThrowsRpcException2() { asyncCall.StartDuplexStreamingCall(); var requestStream = new ClientRequestStream<string, string>(asyncCall); var responseStream = new ClientResponseStream<string, string>(asyncCall); var writeTask = requestStream.WriteAsync("request1"); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageHandler(true, null); fakeCall.ReceivedStatusOnClientHandler(true, CreateClientSideStatus(StatusCode.PermissionDenied)); fakeCall.SendCompletionHandler(false); var ex = Assert.ThrowsAsync<RpcException>(async () => await writeTask); Assert.AreEqual(StatusCode.PermissionDenied, ex.Status.StatusCode); AssertStreamingResponseError(asyncCall, fakeCall, readTask, StatusCode.PermissionDenied); }
public void DuplexStreaming_NoRequestNoResponse_Success() { asyncCall.StartDuplexStreamingCall(); var requestStream = new ClientRequestStream<string, string>(asyncCall); var responseStream = new ClientResponseStream<string, string>(asyncCall); var writeTask1 = requestStream.CompleteAsync(); fakeCall.SendCompletionHandler(true); Assert.DoesNotThrowAsync(async () => await writeTask1); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageHandler(true, null); fakeCall.ReceivedStatusOnClientHandler(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata())); AssertStreamingResponseSuccess(asyncCall, fakeCall, readTask); }
public void DuplexStreaming_WriteAfterReceivingStatusThrowsRpcException() { asyncCall.StartDuplexStreamingCall(); var requestStream = new ClientRequestStream<string, string>(asyncCall); var responseStream = new ClientResponseStream<string, string>(asyncCall); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageHandler(true, null); fakeCall.ReceivedStatusOnClientHandler(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata())); AssertStreamingResponseSuccess(asyncCall, fakeCall, readTask); var writeTask = requestStream.WriteAsync("request1"); var ex = Assert.ThrowsAsync<RpcException>(async () => await writeTask); Assert.AreEqual(Status.DefaultSuccess, ex.Status); }
public void ServerStreaming_NoResponse_Success2() { asyncCall.StartServerStreamingCall("request1"); var responseStream = new ClientResponseStream<string, string>(asyncCall); var readTask = responseStream.MoveNext(); // try alternative order of completions fakeCall.ReceivedStatusOnClientHandler(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata())); fakeCall.ReceivedMessageHandler(true, null); AssertStreamingResponseSuccess(asyncCall, fakeCall, readTask); }
public void ServerStreaming_NoResponse_Success1() { asyncCall.StartServerStreamingCall("request1"); var responseStream = new ClientResponseStream<string, string>(asyncCall); var readTask = responseStream.MoveNext(); fakeCall.ReceivedResponseHeadersHandler(true, new Metadata()); Assert.AreEqual(0, asyncCall.ResponseHeadersAsync.Result.Count); fakeCall.ReceivedMessageHandler(true, null); fakeCall.ReceivedStatusOnClientHandler(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata())); AssertStreamingResponseSuccess(asyncCall, fakeCall, readTask); }
public void ServerStreaming_NoResponse_ReadFailure() { asyncCall.StartServerStreamingCall("request1"); var responseStream = new ClientResponseStream<string, string>(asyncCall); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageHandler(false, null); // after a failed read, we rely on C core to deliver appropriate status code. fakeCall.ReceivedStatusOnClientHandler(true, CreateClientSideStatus(StatusCode.Internal)); AssertStreamingResponseError(asyncCall, fakeCall, readTask, StatusCode.Internal); }
public void ServerStreaming_MoreResponses_Success() { asyncCall.StartServerStreamingCall("request1"); var responseStream = new ClientResponseStream<string, string>(asyncCall); var readTask1 = responseStream.MoveNext(); fakeCall.ReceivedMessageHandler(true, CreateResponsePayload()); Assert.IsTrue(readTask1.Result); Assert.AreEqual("response1", responseStream.Current); var readTask2 = responseStream.MoveNext(); fakeCall.ReceivedMessageHandler(true, CreateResponsePayload()); Assert.IsTrue(readTask2.Result); Assert.AreEqual("response1", responseStream.Current); var readTask3 = responseStream.MoveNext(); fakeCall.ReceivedStatusOnClientHandler(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata())); fakeCall.ReceivedMessageHandler(true, null); AssertStreamingResponseSuccess(asyncCall, fakeCall, readTask3); }
public void DuplexStreaming_WriteAfterCancellationRequestThrowsTaskCanceledException() { asyncCall.StartDuplexStreamingCall(); var requestStream = new ClientRequestStream<string, string>(asyncCall); var responseStream = new ClientResponseStream<string, string>(asyncCall); asyncCall.Cancel(); Assert.IsTrue(fakeCall.IsCancelled); var writeTask = requestStream.WriteAsync("request1"); Assert.ThrowsAsync(typeof(TaskCanceledException), async () => await writeTask); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageHandler(true, null); fakeCall.ReceivedStatusOnClientHandler(true, CreateClientSideStatus(StatusCode.Cancelled)); AssertStreamingResponseError(asyncCall, fakeCall, readTask, StatusCode.Cancelled); }
public void DuplexStreaming_WriteAfterReceivingStatusFails() { asyncCall.StartDuplexStreamingCall(); var requestStream = new ClientRequestStream<string, string>(asyncCall); var responseStream = new ClientResponseStream<string, string>(asyncCall); var readTask = responseStream.MoveNext(); fakeCall.ReceivedMessageHandler(true, null); fakeCall.ReceivedStatusOnClientHandler(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata())); AssertStreamingResponseSuccess(asyncCall, fakeCall, readTask); Assert.ThrowsAsync(typeof(InvalidOperationException), async () => await requestStream.WriteAsync("request1")); }