Add interceptor with GetStatus tests (#1502)

Author: JamesNK

test/Grpc.Net.Client.Tests/InterceptorTests.cs

@@ -143,6 +143,115 @@ public async Task Intercept_WrapClientStream_ClientStreamWrapperExecuted()
             Assert.IsNotNull(call.GetTrailers());
         }
 
+        [TestCase(StatusCode.OK)]
+        [TestCase(StatusCode.Internal)]
+        public async Task Intercept_OnCompleted_StatusReturned(StatusCode statusCode)
+        {
+            await StatusReturnedCore(new OnCompletedInterceptor(), statusCode);
+        }
+
+        [TestCase(StatusCode.OK)]
+        [TestCase(StatusCode.Internal)]
+        public async Task Intercept_Await_StatusReturned(StatusCode statusCode)
+        {
+            await StatusReturnedCore(new AwaitInterceptor(), statusCode);
+        }
+
+        private static async Task StatusReturnedCore(StatusInterceptor interceptor, StatusCode statusCode)
+        {
+            // Arrange
+            var httpClient = ClientTestHelpers.CreateTestClient(async request =>
+            {
+                if (statusCode == StatusCode.OK)
+                {
+                    var streamContent = await ClientTestHelpers.CreateResponseContent(new HelloReply { Message = "PASS" }).DefaultTimeout();
+                    return ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent);
+                }
+                else
+                {
+                    return ResponseUtils.CreateHeadersOnlyResponse(HttpStatusCode.OK, statusCode);
+                }
+            });
+
+            var invoker = HttpClientCallInvokerFactory.Create(httpClient);
+
+            // Act
+            var callInvoker = invoker.Intercept(interceptor);
+
+            var call = callInvoker.AsyncUnaryCall(ClientTestHelpers.ServiceMethod, Host, new CallOptions(), new HelloRequest());
+
+            // Assert
+            if (statusCode == StatusCode.OK)
+            {
+                var result = await call.ResponseAsync.DefaultTimeout();
+                Assert.AreEqual("PASS", result.Message);
+            }
+            else
+            {
+                var ex = await ExceptionAssert.ThrowsAsync<RpcException>(() => call.ResponseAsync).DefaultTimeout();
+                Assert.AreEqual(statusCode, ex.StatusCode);
+            }
+
+            var interceptorStatusCode = await interceptor.GetStatusCodeAsync().DefaultTimeout();
+            Assert.AreEqual(statusCode, interceptorStatusCode);
+        }
+
+        private abstract class StatusInterceptor : Interceptor
+        {
+            protected readonly TaskCompletionSource<StatusCode> StatusTcs = new TaskCompletionSource<StatusCode>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            public Task<StatusCode> GetStatusCodeAsync() => StatusTcs.Task;
+        }
+
+        private class OnCompletedInterceptor : StatusInterceptor
+        {
+            public override AsyncUnaryCall<TResponse> AsyncUnaryCall<TRequest, TResponse>(TRequest request, ClientInterceptorContext<TRequest, TResponse> context, AsyncUnaryCallContinuation<TRequest, TResponse> continuation)
+            {
+                var result = continuation(request, context);
+                result.GetAwaiter().OnCompleted(() =>
+                {
+                    try
+                    {
+                        StatusTcs.SetResult(result.GetStatus().StatusCode);
+                    }
+                    catch (Exception ex)
+                    {
+                        StatusTcs.SetException(ex);
+                    }
+                });
+                return result;
+            }
+        }
+
+        private class AwaitInterceptor : StatusInterceptor
+        {
+            public override AsyncUnaryCall<TResponse> AsyncUnaryCall<TRequest, TResponse>(TRequest request, ClientInterceptorContext<TRequest, TResponse> context, AsyncUnaryCallContinuation<TRequest, TResponse> continuation)
+            {
+                var call = continuation(request, context);
+
+                return new AsyncUnaryCall<TResponse>(HandleResponse(call), call.ResponseHeadersAsync, call.GetStatus, call.GetTrailers, call.Dispose);
+
+                async Task<TResponse> HandleResponse(AsyncUnaryCall<TResponse> call)
+                {
+                    try
+                    {
+                        return await call.ResponseAsync;
+                    }
+                    finally
+                    {
+                        try
+                        {
+                            StatusTcs.SetResult(call.GetStatus().StatusCode);
+                        }
+                        catch (Exception ex)
+                        {
+                            StatusTcs.SetException(ex);
+                        }
+                    }
+                }
+            }
+        }
+
         private class ClientStreamingCountingInterceptor : Interceptor
         {
             public override AsyncClientStreamingCall<TRequest, TResponse> AsyncClientStreamingCall<TRequest, TResponse>(ClientInterceptorContext<TRequest, TResponse> context, AsyncClientStreamingCallContinuation<TRequest, TResponse> continuation)