Sample http4s REST client/server with client macro derivation

modules/http/src/main/scala/higherkindness/mu/http/implicits.scala

@@ -19,6 +19,7 @@ package higherkindness.mu.http
 import cats.ApplicativeError
 import cats.effect._
 import cats.implicits._
+import cats.syntax.either._
 import fs2.{RaiseThrowable, Stream}
 import io.grpc.Status.Code._
 import org.typelevel.jawn.ParseException
@@ -34,6 +35,29 @@ import scala.util.control.NoStackTrace
 
 object implicits {
 
+  implicit val unexpectedErrorEncoder: Encoder[UnexpectedError] = new Encoder[UnexpectedError] {
+    final def apply(a: UnexpectedError): Json = Json.obj(
+      ("className", Json.fromString(a.className)),
+      ("msg", a.msg.fold(Json.Null)(s => Json.fromString(s)))
+    )
+  }
+
+  implicit val unexpectedErrorDecoder: Decoder[UnexpectedError] = new Decoder[UnexpectedError] {
+    final def apply(c: HCursor): Decoder.Result[UnexpectedError] =
+      for {
+        className <- c.downField("className").as[String]
+        msg       <- c.downField("msg").as[Option[String]]
+      } yield UnexpectedError(className, msg)
+  }
+
+  implicit def EitherDecoder[A, B](implicit a: Decoder[A], b: Decoder[B]): Decoder[Either[A, B]] =
+    a.map(Left.apply) or b.map(Right.apply)
+
+  implicit def EitherEncoder[A, B](implicit ea: Encoder[A], eb: Encoder[B]): Encoder[Either[A, B]] =
+    new Encoder[Either[A, B]] {
+      final def apply(a: Either[A, B]): Json = a.fold(_.asJson, _.asJson)
+    }
+
   implicit class MessageOps[F[_]](private val message: Message[F]) extends AnyVal {
 
     def jsonBodyAsStream[A](
@@ -55,47 +79,18 @@ object implicits {
 
   implicit class ResponseOps[F[_]](private val response: Response[F]) {
 
-    implicit def EitherDecoder[A, B](
-        implicit a: Decoder[A],
-        b: Decoder[B]): Decoder[Either[A, B]] = {
-      val l: Decoder[Either[A, B]] = a.map(Left.apply)
-      val r: Decoder[Either[A, B]] = b.map(Right.apply)
-      l or r
-    }
-
-    implicit private val throwableDecoder: Decoder[Throwable] =
-      Decoder.decodeTuple2[String, String].map {
-        case (cls, msg) =>
-          Class
-            .forName(cls)
-            .getConstructor(classOf[String])
-            .newInstance(msg)
-            .asInstanceOf[Throwable]
-      }
-
     def asStream[A](
         implicit decoder: Decoder[A],
         F: ApplicativeError[F, Throwable],
         R: RaiseThrowable[F]): Stream[F, A] =
       if (response.status.code != Ok.code) Stream.raiseError(ResponseError(response.status))
-      else response.jsonBodyAsStream[Either[Throwable, A]].rethrow
+      else response.jsonBodyAsStream[Either[UnexpectedError, A]].rethrow
   }
 
   implicit class Fs2StreamOps[F[_], A](private val stream: Stream[F, A]) {
 
-    implicit def EitherEncoder[A, B](implicit ea: Encoder[A], eb: Encoder[B]): Encoder[Either[A, B]] =
-      new Encoder[Either[A, B]] {
-        final def apply(a: Either[A, B]): Json = a match {
-          case Left(a)  => a.asJson
-          case Right(b) => b.asJson
-        }
-      }
-
-    implicit val throwableEncoder: Encoder[Throwable] = new Encoder[Throwable] {
-      def apply(ex: Throwable): Json = (ex.getClass.getName, ex.getMessage).asJson
-    }
-
-    def asJsonEither(implicit encoder: Encoder[A]): Stream[F, Json] = stream.attempt.map(_.asJson)
+    def asJsonEither(implicit encoder: Encoder[A]): Stream[F, Json] =
+      stream.attempt.map(_.bimap(_.toUnexpected, identity).asJson)
   }
 
   implicit class FResponseOps[F[_]: Sync](private val response: F[Response[F]])
@@ -121,8 +116,18 @@ object implicits {
   def handleResponseError[F[_]: Sync](errorResponse: Response[F]): F[Throwable] =
     errorResponse.bodyAsText.compile.foldMonoid.map(body =>
       ResponseError(errorResponse.status, Some(body).filter(_.nonEmpty)))
+
+  implicit class ThrowableOps(self: Throwable) {
+    def toUnexpected: UnexpectedError =
+      UnexpectedError(self.getClass.getName, Option(self.getMessage))
+  }
+
 }
 
+final case class UnexpectedError(className: String, msg: Option[String])
+    extends RuntimeException(className + msg.fold("")(": " + _))
+    with NoStackTrace
+
 final case class ResponseError(status: Status, msg: Option[String] = None)
     extends RuntimeException(status + msg.fold("")(": " + _))
     with NoStackTrace

modules/http/src/test/scala/higherkindness/mu/rpc/http/GreeterDerivedRestTests.scala

@@ -19,22 +19,18 @@ package higherkindness.mu.rpc.http
 import cats.effect.{IO, _}
 import fs2.Stream
 import fs2.interop.reactivestreams._
-import higherkindness.mu.http.{HttpServer, ResponseError, RouteMap}
+import higherkindness.mu.http.{HttpServer, ResponseError, RouteMap, UnexpectedError}
 import higherkindness.mu.rpc.common.RpcBaseTestSuite
 import monix.reactive.Observable
 import io.circe.generic.auto._
 import org.http4s._
 import org.http4s.client.blaze.BlazeClientBuilder
 import org.http4s.server.blaze._
 import org.scalatest._
-import org.scalatestplus.scalacheck.ScalaCheckDrivenPropertyChecks
 
 import scala.concurrent.duration._
 
-class GreeterDerivedRestTests
-    extends RpcBaseTestSuite
-    with ScalaCheckDrivenPropertyChecks
-    with BeforeAndAfter {
+class GreeterDerivedRestTests extends RpcBaseTestSuite with BeforeAndAfter {
 
   val host            = "localhost"
   val port            = 8080
@@ -153,17 +149,17 @@ class GreeterDerivedRestTests
       val request = HelloRequest("")
       val responses =
         BlazeClientBuilder[IO](ec).stream.flatMap(fs2Client.sayHelloAll(request)(_))
-      the[IllegalArgumentException] thrownBy responses.compile.toList
-        .unsafeRunSync() should have message "empty greeting"
+      the[UnexpectedError] thrownBy responses.compile.toList
+        .unsafeRunSync() should have message "java.lang.IllegalArgumentException: empty greeting"
     }
 
     "handle errors with Observable streaming response" in {
       val request = HelloRequest("")
       val responses = BlazeClientBuilder[IO](ec).stream
         .flatMap(monixClient.sayHelloAll(request)(_).toReactivePublisher.toStream[IO])
-      the[IllegalArgumentException] thrownBy responses.compile.toList
+      the[UnexpectedError] thrownBy responses.compile.toList
         .unsafeRunTimed(10.seconds)
-        .getOrElse(sys.error("Stuck!")) should have message "empty greeting"
+        .getOrElse(sys.error("Stuck!")) should have message "java.lang.IllegalArgumentException: empty greeting"
     }
 
     "serve a POST request with bidirectional fs2 streaming" in {
@@ -199,17 +195,6 @@ class GreeterDerivedRestTests
         .getOrElse(sys.error("Stuck!")) shouldBe Nil
     }
 
-    "serve ScalaCheck-generated POST requests with bidirectional Observable streaming" in {
-      forAll { strings: List[String] =>
-        val requests = Observable.fromIterable(strings.map(HelloRequest))
-        val responses = BlazeClientBuilder[IO](ec).stream
-          .flatMap(monixClient.sayHellosAll(requests)(_).toReactivePublisher.toStream[IO])
-        responses.compile.toList
-          .unsafeRunTimed(10.seconds)
-          .getOrElse(sys.error("Stuck!")) shouldBe strings.map(HelloResponse)
-      }
-    }
-
   }
 
 }

modules/http/src/test/scala/higherkindness/mu/rpc/http/GreeterRestTests.scala

@@ -19,7 +19,7 @@ package higherkindness.mu.rpc.http
 import cats.effect.{IO, _}
 import fs2.Stream
 import fs2.interop.reactivestreams._
-import higherkindness.mu.http.ResponseError
+import higherkindness.mu.http.{ResponseError, UnexpectedError}
 import higherkindness.mu.rpc.common.RpcBaseTestSuite
 import higherkindness.mu.http.implicits._
 import io.circe.Json
@@ -34,14 +34,10 @@ import org.http4s.server.blaze._
 import org.scalatest._
 import org.http4s.implicits._
 import org.http4s.server.Router
-import org.scalatestplus.scalacheck.ScalaCheckDrivenPropertyChecks
 
 import scala.concurrent.duration._
 
-class GreeterRestTests
-    extends RpcBaseTestSuite
-    with ScalaCheckDrivenPropertyChecks
-    with BeforeAndAfter {
+class GreeterRestTests extends RpcBaseTestSuite with BeforeAndAfter {
 
   val Hostname = "localhost"
   val Port     = 8080
@@ -72,7 +68,7 @@ class GreeterRestTests
         s"/$Fs2ServicePrefix"   -> fs2Service,
         s"/$MonixServicePrefix" -> monixService).orNotFound)
 
-  var serverTask: Fiber[IO, Nothing] = _ // sorry
+  var serverTask: Fiber[IO, Nothing] = _
   before(serverTask = server.resource.use(_ => IO.never).start.unsafeRunSync())
   after(serverTask.cancel)
 
@@ -208,17 +204,17 @@ class GreeterRestTests
       val request = HelloRequest("")
       val responses =
         BlazeClientBuilder[IO](ec).stream.flatMap(fs2ServiceClient.sayHelloAll(request)(_))
-      the[IllegalArgumentException] thrownBy responses.compile.toList
-        .unsafeRunSync() should have message "empty greeting"
+      the[UnexpectedError] thrownBy responses.compile.toList
+        .unsafeRunSync() should have message "java.lang.IllegalArgumentException: empty greeting"
     }
 
     "handle errors with Observable streaming response" in {
       val request = HelloRequest("")
       val responses = BlazeClientBuilder[IO](ec).stream
         .flatMap(monixServiceClient.sayHelloAll(request)(_).toReactivePublisher.toStream[IO])
-      the[IllegalArgumentException] thrownBy responses.compile.toList
+      the[UnexpectedError] thrownBy responses.compile.toList
         .unsafeRunTimed(10.seconds)
-        .getOrElse(sys.error("Stuck!")) should have message "empty greeting"
+        .getOrElse(sys.error("Stuck!")) should have message "java.lang.IllegalArgumentException: empty greeting"
     }
 
     "serve a POST request with bidirectional fs2 streaming" in {
@@ -254,15 +250,5 @@ class GreeterRestTests
         .getOrElse(sys.error("Stuck!")) shouldBe Nil
     }
 
-    "serve ScalaCheck-generated POST requests with bidirectional Observable streaming" in {
-      forAll { strings: List[String] =>
-        val requests = Observable.fromIterable(strings.map(HelloRequest))
-        val responses = BlazeClientBuilder[IO](ec).stream
-          .flatMap(monixServiceClient.sayHellosAll(requests)(_).toReactivePublisher.toStream[IO])
-        responses.compile.toList
-          .unsafeRunTimed(10.seconds)
-          .getOrElse(sys.error("Stuck!")) shouldBe strings.map(HelloResponse)
-      }
-    }
   }
 }

project/ProjectPlugin.scala

@@ -137,7 +137,6 @@ object ProjectPlugin extends AutoPlugin {
         %%("monix", V.monix),
         %%("http4s-blaze-client", V.http4s) % Test,
         %%("circe-generic") % Test,
-        %%("scalacheck") % Test,
         "ch.qos.logback" % "logback-classic" % V.logback % Test
       )
     )