Parse trailers even when an error occurs

It is possible for gRPC error responses to be empty and for servers to
send the error information within trailers without also sending them in
headers. In these cases, Wire will propagate an exception due to no
response body and will not attempt to read trailers, relying only on
headers instead.

This patch allows Wire to attempt to parse the trailers for
non-streaming requests instead of only relying on headers.

Author: ahmedre

wire-grpc-client/src/jvmMain/kotlin/com/squareup/wire/internal/RealGrpcCall.kt

@@ -106,7 +106,7 @@ internal class RealGrpcCall<S : Any, R : Any>(
         val result = try {
           reader.readExactlyOneAndClose()
         } catch (e: IOException) {
-          throw grpcResponseToException(e)!!
+          throw grpcResponseToException(true, e)!!
         }
         val exception = grpcResponseToException()
         if (exception != null) throw exception

wire-grpc-client/src/jvmMain/kotlin/com/squareup/wire/internal/grpc.kt

@@ -118,7 +118,7 @@ internal fun <R : Any> SendChannel<R>.readFromResponseBodyCallback(
               }
               exception = response.grpcResponseToException()
             } catch (e: IOException) {
-              exception = response.grpcResponseToException(e)
+              exception = response.grpcResponseToException(false, e)
             } catch (e: Exception) {
               exception = e
             } finally {
@@ -200,10 +200,10 @@ private fun Response.checkGrpcResponse() {
 }
 
 /** Returns an exception if the gRPC call didn't have a grpc-status of 0. */
-internal fun Response.grpcResponseToException(suppressed: IOException? = null): IOException? {
+internal fun Response.grpcResponseToException(canReadTrailersOnException: Boolean = false, suppressed: IOException? = null): IOException? {
   var trailers = headersOf()
   var transportException = suppressed
-  if (suppressed == null) {
+  if (suppressed == null || canReadTrailersOnException) {
     try {
       trailers = trailers()
     } catch (e: IOException) {

wire-grpc-tests/src/test/java/com/squareup/wire/GrpcClientTest.kt

@@ -55,6 +55,8 @@ import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import okhttp3.Call
+import okhttp3.ExperimentalOkHttpApi
+import okhttp3.Headers
 import okhttp3.Interceptor
 import okhttp3.Interceptor.Chain
 import okhttp3.MediaType.Companion.toMediaType
@@ -1231,6 +1233,38 @@ class GrpcClientTest {
     }
   }
 
+  @Test
+  fun requestFailureInTrailersNotInHeadersWithEmptyResponseBody() {
+    mockService.enqueue(ReceiveCall("/routeguide.RouteGuide/RouteChat"))
+    mockService.enqueueReceivePoint(latitude = 5, longitude = 6)
+    mockService.enqueue(ReceiveComplete)
+    mockService.enqueueSendError(
+      Status.UNAUTHENTICATED.withDescription("not logged in")
+        .asRuntimeException(),
+    )
+    mockService.enqueue(SendCompleted)
+
+    @OptIn(ExperimentalOkHttpApi::class)
+    interceptor = object : Interceptor {
+      override fun intercept(chain: Chain): Response {
+        val response = chain.proceed(chain.request())
+        return response.newBuilder()
+          .headers(Headers.headersOf())
+          .trailers { response.headers }
+          .build()
+      }
+    }
+
+    val grpcCall = routeGuideService.GetFeature()
+    try {
+      grpcCall.executeBlocking(Point(latitude = 5, longitude = 6))
+      fail()
+    } catch (expected: GrpcException) {
+      assertThat(expected.grpcStatus).isEqualTo(GrpcStatus.UNAUTHENTICATED)
+      assertThat(expected.grpcMessage).isEqualTo("not logged in")
+    }
+  }
+
   @Test
   fun requestEarlyFailureWithDescription() {
     mockService.enqueue(ReceiveCall("/routeguide.RouteGuide/GetFeature"))