public void ClientStreaming_WriteFailureThrowsRpcException3() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream <string, string>(asyncCall); var writeTask = requestStream.WriteAsync("request1"); fakeCall.SendCompletionCallback.OnSendCompletion(false); // Until the delayed write completion has been triggered, // we still act as if there was an active write. Assert.Throws(typeof(InvalidOperationException), () => requestStream.WriteAsync("request2")); fakeCall.UnaryResponseClientCallback.OnUnaryResponseClient(true, CreateClientSideStatus(StatusCode.Internal), null, new Metadata()); var ex = Assert.ThrowsAsync <RpcException>(async() => await writeTask); Assert.AreEqual(StatusCode.Internal, ex.Status.StatusCode); // Following attempts to write keep delivering the same status var ex2 = Assert.ThrowsAsync <RpcException>(async() => await requestStream.WriteAsync("after call has finished")); Assert.AreEqual(StatusCode.Internal, ex2.Status.StatusCode); AssertUnaryResponseError(asyncCall, fakeCall, resultTask, StatusCode.Internal); }
public void ClientStreaming_MoreRequests_Success() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream <string, string>(asyncCall); var writeTask = requestStream.WriteAsync("request1"); fakeCall.SendCompletionCallback.OnSendCompletion(true); writeTask.Wait(); var writeTask2 = requestStream.WriteAsync("request2"); fakeCall.SendCompletionCallback.OnSendCompletion(true); writeTask2.Wait(); var completeTask = requestStream.CompleteAsync(); fakeCall.SendCompletionCallback.OnSendCompletion(true); completeTask.Wait(); fakeCall.UnaryResponseClientCallback.OnUnaryResponseClient(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata()), CreateResponsePayload(), new Metadata()); AssertUnaryResponseSuccess(asyncCall, fakeCall, resultTask); }
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); }
public void ClientStreaming_WriteAfterReceivingStatusFails() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream <string, string>(asyncCall); fakeCall.UnaryResponseClientHandler(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata()), CreateResponsePayload(), new Metadata()); AssertUnaryResponseSuccess(asyncCall, fakeCall, resultTask); Assert.Throws(typeof(InvalidOperationException), () => requestStream.WriteAsync("request1")); }
public void ClientStreaming_WriteAfterReceivingStatusThrowsRpcException2() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream <string, string>(asyncCall); fakeCall.UnaryResponseClientHandler(true, new ClientSideStatus(new Status(StatusCode.OutOfRange, ""), new Metadata()), CreateResponsePayload(), new Metadata()); AssertUnaryResponseError(asyncCall, fakeCall, resultTask, StatusCode.OutOfRange); var ex = Assert.Throws <RpcException>(() => requestStream.WriteAsync("request1")); Assert.AreEqual(StatusCode.OutOfRange, ex.Status.StatusCode); }
public void ClientStreaming_WriteAfterReceivingStatusThrowsRpcException() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream <string, string>(asyncCall); fakeCall.UnaryResponseClientHandler(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata()), CreateResponsePayload(), new Metadata()); AssertUnaryResponseSuccess(asyncCall, fakeCall, resultTask); var ex = Assert.Throws <RpcException>(() => requestStream.WriteAsync("request1")); Assert.AreEqual(Status.DefaultSuccess, ex.Status); }
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 ClientStreaming_WriteAfterCancellationRequestThrowsOperationCancelledException() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream <string, string>(asyncCall); asyncCall.Cancel(); Assert.IsTrue(fakeCall.IsCancelled); Assert.Throws(typeof(OperationCanceledException), () => requestStream.WriteAsync("request1")); fakeCall.UnaryResponseClientHandler(true, CreateClientSideStatus(StatusCode.Cancelled), CreateResponsePayload(), new Metadata()); AssertUnaryResponseError(asyncCall, fakeCall, resultTask, StatusCode.Cancelled); }
public void ClientStreaming_WriteFailure() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream <string, string>(asyncCall); var writeTask = requestStream.WriteAsync("request1"); fakeCall.SendCompletionHandler(false); Assert.ThrowsAsync(typeof(InvalidOperationException), async() => await writeTask); fakeCall.UnaryResponseClientHandler(true, CreateClientSideStatus(StatusCode.Internal), CreateResponsePayload(), new Metadata()); AssertUnaryResponseError(asyncCall, fakeCall, resultTask, StatusCode.Internal); }
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_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 ClientStreaming_WriteAfterCompleteThrowsInvalidOperationException() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream <string, string>(asyncCall); requestStream.CompleteAsync(); Assert.Throws(typeof(InvalidOperationException), () => requestStream.WriteAsync("request1")); fakeCall.SendCompletionCallback.OnSendCompletion(true); fakeCall.UnaryResponseClientCallback.OnUnaryResponseClient(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata()), CreateResponsePayload(), new Metadata()); AssertUnaryResponseSuccess(asyncCall, fakeCall, resultTask); }
public void ClientStreaming_WriteAfterCancellationRequestThrowsTaskCanceledException() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream <string, string>(asyncCall); asyncCall.Cancel(); Assert.IsTrue(fakeCall.IsCancelled); var writeTask = requestStream.WriteAsync("request1"); Assert.ThrowsAsync(typeof(TaskCanceledException), async() => await writeTask); fakeCall.UnaryResponseClientCallback.OnUnaryResponseClient(true, CreateClientSideStatus(StatusCode.Cancelled), null, new Metadata()); AssertUnaryResponseError(asyncCall, fakeCall, resultTask, StatusCode.Cancelled); }
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 ClientStreaming_WriteFailureThrowsRpcException2() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream <string, string>(asyncCall); var writeTask = requestStream.WriteAsync("request1"); fakeCall.UnaryResponseClientCallback.OnUnaryResponseClient(true, CreateClientSideStatus(StatusCode.Internal), null, new Metadata()); fakeCall.SendCompletionCallback.OnSendCompletion(false); var ex = Assert.ThrowsAsync <RpcException>(async() => await writeTask); Assert.AreEqual(StatusCode.Internal, ex.Status.StatusCode); AssertUnaryResponseError(asyncCall, fakeCall, resultTask, StatusCode.Internal); }
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 ClientStreaming_WriteFailureThrowsRpcException() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream <string, string>(asyncCall); var writeTask = requestStream.WriteAsync("request1"); fakeCall.SendCompletionHandler(false); // The write will wait for call to finish to receive the status code. Assert.IsFalse(writeTask.IsCompleted); fakeCall.UnaryResponseClientHandler(true, CreateClientSideStatus(StatusCode.Internal), null, new Metadata()); var ex = Assert.ThrowsAsync <RpcException>(async() => await writeTask); Assert.AreEqual(StatusCode.Internal, ex.Status.StatusCode); AssertUnaryResponseError(asyncCall, fakeCall, resultTask, StatusCode.Internal); }
public void ClientStreaming_WriteAfterCancellationRequestFails() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream<string, string>(asyncCall); asyncCall.Cancel(); Assert.IsTrue(fakeCall.IsCancelled); Assert.Throws(typeof(OperationCanceledException), () => requestStream.WriteAsync("request1")); fakeCall.UnaryResponseClientHandler(true, CreateClientSideStatus(StatusCode.Cancelled), CreateResponsePayload(), new Metadata()); AssertUnaryResponseError(asyncCall, fakeCall, resultTask, StatusCode.Cancelled); }
public void ClientStreaming_WriteFailureThrowsRpcException2() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream<string, string>(asyncCall); var writeTask = requestStream.WriteAsync("request1"); fakeCall.UnaryResponseClientHandler(true, CreateClientSideStatus(StatusCode.Internal), null, new Metadata()); fakeCall.SendCompletionHandler(false); var ex = Assert.ThrowsAsync<RpcException>(async () => await writeTask); Assert.AreEqual(StatusCode.Internal, ex.Status.StatusCode); AssertUnaryResponseError(asyncCall, fakeCall, resultTask, StatusCode.Internal); }
public void ClientStreaming_WriteFailureThrowsRpcException3() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream<string, string>(asyncCall); var writeTask = requestStream.WriteAsync("request1"); fakeCall.SendCompletionHandler(false); // Until the delayed write completion has been triggered, // we still act as if there was an active write. Assert.Throws(typeof(InvalidOperationException), () => requestStream.WriteAsync("request2")); fakeCall.UnaryResponseClientHandler(true, CreateClientSideStatus(StatusCode.Internal), null, new Metadata()); var ex = Assert.ThrowsAsync<RpcException>(async () => await writeTask); Assert.AreEqual(StatusCode.Internal, ex.Status.StatusCode); // Following attempts to write keep delivering the same status var ex2 = Assert.ThrowsAsync<RpcException>(async () => await requestStream.WriteAsync("after call has finished")); Assert.AreEqual(StatusCode.Internal, ex2.Status.StatusCode); AssertUnaryResponseError(asyncCall, fakeCall, resultTask, StatusCode.Internal); }
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_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 ClientStreaming_WriteCompletionFailure() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream<string, string>(asyncCall); var writeTask = requestStream.WriteAsync("request1"); fakeCall.SendCompletionHandler(false); // TODO: maybe IOException or waiting for RPCException is more appropriate here. Assert.ThrowsAsync(typeof(InvalidOperationException), async () => await writeTask); fakeCall.UnaryResponseClientHandler(true, CreateClientSideStatus(StatusCode.Internal), null, new Metadata()); AssertUnaryResponseError(asyncCall, fakeCall, resultTask, StatusCode.Internal); }
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 ClientStreaming_WriteAfterReceivingStatusThrowsRpcException2() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream<string, string>(asyncCall); fakeCall.UnaryResponseClientHandler(true, new ClientSideStatus(new Status(StatusCode.OutOfRange, ""), new Metadata()), CreateResponsePayload(), new Metadata()); AssertUnaryResponseError(asyncCall, fakeCall, resultTask, StatusCode.OutOfRange); var writeTask = requestStream.WriteAsync("request1"); var ex = Assert.ThrowsAsync<RpcException>(async () => await writeTask); Assert.AreEqual(StatusCode.OutOfRange, ex.Status.StatusCode); }
public void ClientStreaming_WriteAfterCompleteThrowsInvalidOperationException() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream<string, string>(asyncCall); requestStream.CompleteAsync(); Assert.Throws(typeof(InvalidOperationException), () => requestStream.WriteAsync("request1")); fakeCall.SendCompletionHandler(true); fakeCall.UnaryResponseClientHandler(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata()), CreateResponsePayload(), new Metadata()); AssertUnaryResponseSuccess(asyncCall, fakeCall, resultTask); }
public void ClientStreaming_WriteAfterCancellationRequestThrowsTaskCanceledException() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream<string, string>(asyncCall); asyncCall.Cancel(); Assert.IsTrue(fakeCall.IsCancelled); var writeTask = requestStream.WriteAsync("request1"); Assert.ThrowsAsync(typeof(TaskCanceledException), async () => await writeTask); fakeCall.UnaryResponseClientHandler(true, CreateClientSideStatus(StatusCode.Cancelled), null, new Metadata()); AssertUnaryResponseError(asyncCall, fakeCall, resultTask, StatusCode.Cancelled); }
public void ClientStreaming_MoreRequests_Success() { var resultTask = asyncCall.ClientStreamingCallAsync(); var requestStream = new ClientRequestStream<string, string>(asyncCall); var writeTask = requestStream.WriteAsync("request1"); fakeCall.SendCompletionHandler(true); writeTask.Wait(); var writeTask2 = requestStream.WriteAsync("request2"); fakeCall.SendCompletionHandler(true); writeTask2.Wait(); var completeTask = requestStream.CompleteAsync(); fakeCall.SendCompletionHandler(true); completeTask.Wait(); fakeCall.UnaryResponseClientHandler(true, new ClientSideStatus(Status.DefaultSuccess, new Metadata()), CreateResponsePayload(), new Metadata()); AssertUnaryResponseSuccess(asyncCall, fakeCall, resultTask); }
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")); }