Issue-1438: Fix upstream service error represented as 400

modules/core/src/smithy4s/http/HttpContractError.scala

@@ -18,8 +18,7 @@ package smithy4s
 package http
 
 import smithy4s.capability.MonadThrowLike
-import smithy4s.codecs.PayloadError
-import smithy4s.codecs.PayloadPath
+import smithy4s.codecs.{PayloadError, PayloadPath}
 import smithy4s.kinds.PolyFunction
 import smithy4s.schema.Schema._
 import smithy4s.schema._

modules/core/src/smithy4s/http/HttpResponse.scala

@@ -228,9 +228,9 @@ object HttpResponse {
     * Creates a response decoder that dispatches  the response
     * to a given decoder, based on some discriminator.
     */
-    private def discriminating[F[_], Body, Discriminator, E](
-        discriminate: HttpResponse[Body] => F[Discriminator],
-        select: Discriminator => Option[Decoder[F, Body, E]],
+    private def discriminating[F[_], Body, E](
+        discriminate: HttpResponse[Body] => F[HttpDiscriminator],
+        select: HttpDiscriminator => Option[Decoder[F, Body, E]],
         toStrict: Body => F[(Body, Blob)]
     )(implicit F: MonadThrowLike[F]): Decoder[F, Body, E] =
       new Decoder[F, Body, E] {
@@ -239,13 +239,31 @@ object HttpResponse {
             val strictResponse = response.copy(body = strictBody)
             F.flatMap(discriminate(strictResponse)) { discriminator =>
               select(discriminator) match {
-                case Some(decoder) => decoder.decode(strictResponse)
+                case Some(decoder) =>
+                  F.handleErrorWith(decoder.decode(strictResponse)) {
+                    case error: HttpContractError =>
+                      F.raiseError(
+                        RawErrorResponse(
+                          response.statusCode,
+                          response.headers,
+                          bodyBlob.toUTF8String,
+                          Some(
+                            FailedDecodeAttempt(
+                              discriminator = discriminator,
+                              contractError = error
+                            )
+                          )
+                        )
+                      )
+                    case otherError => F.raiseError(otherError)
+                  }
                 case None =>
                   F.raiseError(
-                    smithy4s.http.UnknownErrorResponse(
-                      response.statusCode,
-                      response.headers,
-                      bodyBlob.toUTF8String
+                    smithy4s.http.RawErrorResponse(
+                      code = response.statusCode,
+                      headers = response.headers,
+                      body = bodyBlob.toUTF8String,
+                      failedDecodeAttempt = None
                     )
                   )
               }

modules/core/src/smithy4s/http/HttpUnaryServerCodecs.scala

@@ -197,6 +197,7 @@ object HttpUnaryServerCodecs {
           def encodeError(e: E) = F.map(base)(errorW.write(_, e))
           def httpContractErrorEncoder(e: HttpContractError) =
             F.map(base)(httpContractErrorWriters.write(_, e).withStatusCode(400))
+
           def throwableEncoders(throwable: Throwable): F[HttpResponse[Blob]] =
             throwable match {
               case e: HttpContractError => httpContractErrorEncoder(e)

modules/core/src/smithy4s/http/RawErrorResponse.scala

@@ -0,0 +1,43 @@
+/*
+ *  Copyright 2021-2024 Disney Streaming
+ *
+ *  Licensed under the Tomorrow Open Source Technology License, Version 1.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     https://disneystreaming.github.io/TOST-1.0.txt
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package smithy4s.http
+
+case class RawErrorResponse(
+    code: Int,
+    headers: Map[CaseInsensitive, Seq[String]],
+    body: String,
+    failedDecodeAttempt: Option[FailedDecodeAttempt]
+) extends Throwable {
+  override def getMessage(): String = {
+    val baseMessage = s"status $code, headers: $headers, body:\n$body"
+    failedDecodeAttempt match {
+      case Some(attempt) =>
+        baseMessage +
+          s"""
+             |FailedDecodeAttempt:
+             |  discriminator: ${attempt.discriminator}
+             |  contractError: ${attempt.contractError.getMessage}
+               """.stripMargin
+      case None => baseMessage
+    }
+  }
+}
+
+case class FailedDecodeAttempt(
+    discriminator: HttpDiscriminator,
+    contractError: HttpContractError
+)

modules/http4s/test/src/smithy4s/http4s/Http4sPizzaSpec.scala

@@ -19,8 +19,9 @@ package smithy4s.http4s
 import cats.effect.IO
 import cats.effect.Resource
 import org.http4s.Uri
-import org.http4s.client.Client
+import org.http4s.Response
 import org.http4s.implicits._
+import org.http4s.client.Client
 import smithy4s.example.PizzaAdminService
 
 object Http4sPizzaSpec extends smithy4s.tests.PizzaSpec {
@@ -40,4 +41,24 @@ object Http4sPizzaSpec extends smithy4s.tests.PizzaSpec {
 
   }
 
+  def runServerWithClient(
+      pizzaService: PizzaAdminService[IO],
+      clientResponse: Response[IO]
+  ): Resource[IO, Res] = {
+    SimpleRestJsonBuilder
+      .routes(
+        SimpleRestJsonBuilder(PizzaAdminService)
+          .client[IO](Client(_ => Resource.pure(clientResponse)))
+          .make
+          .toTry
+          .get
+      )
+      .resource
+      .map { httpRoutes =>
+        val client = Client.fromHttpApp(httpRoutes.orNotFound)
+        val uri = Uri.unsafeFromString("http://localhost")
+        (client, uri)
+      }
+  }
+
 }

modules/tests/src/smithy4s/tests/PizzaAdminServiceImpl.scala

@@ -17,15 +17,14 @@
 package smithy4s.tests
 
 import cats.effect._
+import cats.effect.std.UUIDGen
 import cats.implicits._
 import smithy4s.Timestamp
 import smithy4s.example._
+import smithy4s.tests.PizzaAdminServiceImpl._
 
 import java.util.UUID
 
-import PizzaAdminServiceImpl._
-import cats.effect.std.UUIDGen
-
 object PizzaAdminServiceImpl {
   case class Item(food: Food, price: Float, addedAt: Timestamp)
   case class State(restaurants: Map[String, Restaurant])

modules/tests/src/smithy4s/tests/PizzaClientSpec.scala

@@ -31,7 +31,10 @@ import smithy4s.example._
 import smithy4s.Timestamp
 import weaver._
 import smithy4s.http.CaseInsensitive
-import smithy4s.http.UnknownErrorResponse
+import smithy4s.http.RawErrorResponse
+import smithy4s.http.FailedDecodeAttempt
+import smithy4s.http.HttpPayloadError
+import smithy4s.http.HttpDiscriminator
 
 abstract class PizzaClientSpec extends IOSuite {
 
@@ -112,27 +115,59 @@ abstract class PizzaClientSpec extends IOSuite {
   )
 
   clientTestForError(
-    "Handle error w/o a discriminator header nor a unique status code",
-    Response(status = Status.ProxyAuthenticationRequired)
-      .withEntity(
-        Json.obj("message" -> Json.fromString("generic client error message"))
+    "Handle error  with a discriminator but can't be decoded",
+    Response[IO](status = Status.NotFound)
+      .withEntity("malformed body")
+      .withHeaders(Header.Raw(CIString("X-Error-Type"), "NotFoundError")),
+    rawErrorResponse(
+      404,
+      Map("X-Error-Type" -> "NotFoundError"),
+      "malformed body",
+      Some(
+        FailedDecodeAttempt(
+          discriminator = HttpDiscriminator.NameOnly("NotFoundError"),
+          contractError = HttpPayloadError(
+            path = smithy4s.codecs.PayloadPath(List()),
+            expected = "object",
+            message =
+              """Expected JSON object, offset: 0x00000000, buf:
+                |+----------+-------------------------------------------------+------------------+
+                ||          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f | 0123456789abcdef |
+                |+----------+-------------------------------------------------+------------------+
+                || 00000000 | 6d 61 6c 66 6f 72 6d 65 64 20 62 6f 64 79       | malformed body   |
+                |+----------+-------------------------------------------------+------------------+""".stripMargin
+          )
+        )
+      )
+    )
+  )
+
+  clientTestForError(
+    "Handle malformed error response with no discriminator",
+    Response(status = Status.InternalServerError)
+      .withEntity("goodbye world"),
+    rawErrorResponse(
+      code = 500,
+      headers = Map(
+        "Content-Length" -> "13",
+        "Content-Type" -> "text/plain; charset=UTF-8"
       ),
-    unknownResponse(
-      407,
-      Map("Content-Length" -> "42", "Content-Type" -> "application/json"),
-      """{"message":"generic client error message"}"""
+      body = "goodbye world",
+      failedDecodeAttempt = None
     )
   )
 
-  private def unknownResponse(
+  private def rawErrorResponse(
       code: Int,
       headers: Map[String, String],
-      body: String
-  ): UnknownErrorResponse =
-    UnknownErrorResponse(
+      body: String,
+      failedDecodeAttempt: Option[FailedDecodeAttempt]
+  ): RawErrorResponse =
+    RawErrorResponse(
       code,
       headers.map { case (k, v) => CaseInsensitive(k) -> List(v) },
-      body
+      body,
+      failedDecodeAttempt
     )
 
   clientTest("Headers are case insensitive") { (client, backend, log) =>