Added tests, corrected some behaviour

Author: Baccata

build.sc

@@ -70,7 +70,7 @@ class FS2Module(versionKey: String) extends define.Module {
  def crossScalaVersion = crossVersion
  def targetPlatform: Platform = Platform.JVM
  def ivyDeps = T(super.ivyDeps() ++ crossPlatformIvyDeps())
- object test extends Tests
+ object test extends WeaverTests
  }
 
  object js extends ScalaJSModule with RpcCrossScalaModule {
@@ -79,7 +79,7 @@ class FS2Module(versionKey: String) extends define.Module {
  def targetPlatform: Platform = Platform.JS
  def scalaJSVersion = versions.scalaJSVersion
  def ivyDeps = T(super.ivyDeps() ++ crossPlatformIvyDeps())
- object test extends Tests
+ object test extends WeaverTests
  }
 }
 
@@ -99,6 +99,11 @@ trait RpcCrossScalaModule extends CrossPlatformScalaModule {
  trait Tests extends super.Tests with TestModule.Munit {
  def ivyDeps = Agg(ivy"org.scalameta::munit:$munitVersion")
  }
+
+ trait WeaverTests extends Tests {
+ def ivyDeps = Agg(ivy"com.disneystreaming::weaver-cats:0.7.13")
+ def testFramework = "weaver.framework.CatsEffect"
+ }
 }
 
 trait CrossPlatformScalaModule extends ScalaModule with CrossModuleBase {

core/src/jsonrpclib/Channel.scala

@@ -1,32 +1,39 @@
 package jsonrpclib
 
-import jsonrpclib.EndpointTemplate.NotificationTemplate
-import jsonrpclib.EndpointTemplate.RequestResponseTemplate
+import jsonrpclib.StubTemplate.NotificationTemplate
+import jsonrpclib.StubTemplate.RequestResponseTemplate
 
 trait Channel[F[_]] {
  def mountEndpoint(endpoint: Endpoint[F]): F[Unit]
  def unmountEndpoint(method: String): F[Unit]
 
- def notificationStub[In](method: String)(implicit inCodec: Codec[In]): In => F[Unit]
- def requestResponseStub[In, Err, Out](
- method: String
- )(implicit inCodec: Codec[In], errCodec: ErrorCodec[Err], outCodec: Codec[Out]): In => F[Either[Err, Out]]
-
- def clientStub[In, Err, Out](template: EndpointTemplate[In, Err, Out]): In => F[Either[Err, Out]]
+ def notificationStub[In: Codec](method: String): In => F[Unit]
+ def simpleStub[In: Codec, Out: Codec](method: String): In => F[Out]
+ def stub[In: Codec, Err: ErrorCodec, Out: Codec](method: String): In => F[Either[Err, Out]]
+ def stub[In, Err, Out](template: StubTemplate[In, Err, Out]): In => F[Either[Err, Out]]
 }
 
 object Channel {
 
  protected[jsonrpclib] abstract class MonadicChannel[F[_]](implicit F: Monadic[F]) extends Channel[F] {
 
- final def clientStub[In, Err, Out](template: EndpointTemplate[In, Err, Out]): In => F[Either[Err, Out]] =
+ final def stub[In, Err, Out](template: StubTemplate[In, Err, Out]): In => F[Either[Err, Out]] =
  template match {
  case NotificationTemplate(method, inCodec) =>
  val stub = notificationStub(method)(inCodec)
  (in: In) => F.doFlatMap(stub(in))(unit => F.doPure(Right(unit)))
  case RequestResponseTemplate(method, inCodec, errCodec, outCodec) =>
- requestResponseStub(method)(inCodec, errCodec, outCodec)
+ stub(method)(inCodec, errCodec, outCodec)
  }
+
+ final def simpleStub[In: Codec, Out: Codec](method: String): In => F[Out] = {
+ val s = stub[In, ErrorPayload, Out](method)
+ (in: In) =>
+ F.doFlatMap(s(in)) {
+ case Left(e) => F.doRaiseError(e)
+ case Right(a) => F.doPure(a)
+ }
+ }
  }
 
 }

core/src/jsonrpclib/EndpointTemplate.scala

@@ -4,7 +4,7 @@ import com.github.plokhotnyuk.jsoniter_scala.core.JsonValueCodec
 import com.github.plokhotnyuk.jsoniter_scala.macros.JsonCodecMaker
 
 private[jsonrpclib] case class ErrorPayload(code: Int, message: String, data: Option[Payload]) extends Throwable {
- override def getMessage(): String = message
+ override def getMessage(): String = s"JsonRPC Error $code: $message"
 }
 
 private[jsonrpclib] object ErrorPayload {

core/src/jsonrpclib/ErrorPayload.scala

@@ -7,6 +7,7 @@ trait Monadic[F[_]] {
  def doFlatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
  def doPure[A](a: A): F[A]
  def doAttempt[A](fa: F[A]): F[Either[Throwable, A]]
+ def doRaiseError[A](e: Throwable): F[A]
 }
 
 object Monadic {
@@ -16,5 +17,7 @@ object Monadic {
  def doPure[A](a: A): Future[A] = Future.successful(a)
 
  def doAttempt[A](fa: Future[A]): Future[Either[Throwable, A]] = fa.map(Right(_)).recover(Left(_))
+
+ def doRaiseError[A](e: Throwable): Future[A] = Future.failed(e)
  }
 }

core/src/jsonrpclib/Monadic.scala

@@ -7,7 +7,7 @@ sealed abstract class ProtocolError(val code: Int, message: String) extends Thro
 object ProtocolError {
  final case class ParseError(message: String) extends ProtocolError(-32700, message)
  final case class InvalidRequest(message: String) extends ProtocolError(-32600, message)
- final case class MethodNotFound(message: String) extends ProtocolError(-32601, message)
+ final case class MethodNotFound(method: String) extends ProtocolError(-32601, s"Method $method not found")
  final case class InvalidParams(message: String) extends ProtocolError(-32602, message)
  final case class InternalError(message: String) extends ProtocolError(-32603, message)
  final case class ServerError(override val code: Int, message: String) extends ProtocolError(code, message)

core/src/jsonrpclib/ProtocolError.scala

@@ -0,0 +1,23 @@
+package jsonrpclib
+
+sealed trait StubTemplate[In, Err, Out]
+object StubTemplate {
+ def notification[In](method: String)(implicit inCodec: Codec[In]): StubTemplate[In, Nothing, Unit] =
+ NotificationTemplate[In](method, inCodec)
+
+ def simple[In, Out](
+ method: String
+ )(implicit inCodec: Codec[In], outCodec: Codec[Out]): StubTemplate[In, ErrorPayload, Out] =
+ RequestResponseTemplate[In, ErrorPayload, Out](method, inCodec, ErrorCodec.errorPayloadCodec, outCodec)
+
+ final case class NotificationTemplate[In](
+ method: String,
+ inCodec: Codec[In]
+ ) extends StubTemplate[In, Nothing, Unit]
+ final case class RequestResponseTemplate[In, Err, Out](
+ method: String,
+ inCodec: Codec[In],
+ errCodec: ErrorCodec[Err],
+ outCodec: Codec[Out]
+ ) extends StubTemplate[In, Err, Out]
+}

core/src/jsonrpclib/StubTemplate.scala

@@ -1,42 +1,14 @@
 package jsonrpclib.internals
 
-import io.circe.Json
 import com.github.plokhotnyuk.jsoniter_scala.core._
 import scala.util.Try
-import io.circe.Codec
-import io.circe.{Decoder, HCursor}
-import io.circe.JsonNumber
-import io.circe.JsonObject
-import io.circe.DecodingFailure
 
-private[jsonrpclib] sealed trait CallId
-private[jsonrpclib] object CallId {
+sealed trait CallId
+object CallId {
  final case class NumberId(long: Long) extends CallId
  final case class StringId(string: String) extends CallId
  case object NullId extends CallId
 
- implicit val callIdCodec: Codec[CallId] = new Codec[CallId] {
- def apply(c: HCursor): Decoder.Result[CallId] = c.value.foldWith(
- new Json.Folder[Decoder.Result[CallId]] {
- val error = Left(DecodingFailure("Expected string, integer or null", c.history))
- def onNull: Decoder.Result[CallId] = Right(NullId)
- def onString(value: String): Decoder.Result[CallId] = Right(StringId(value))
- def onNumber(value: JsonNumber): Decoder.Result[CallId] = value.toLong match {
- case None => error
- case Some(value) => Right(NumberId(value))
- }
- def onBoolean(value: Boolean): Decoder.Result[CallId] = error
- def onArray(value: Vector[Json]): Decoder.Result[CallId] = error
- def onObject(value: JsonObject): Decoder.Result[CallId] = error
- }
- )
- def apply(a: CallId): Json = a match {
- case NumberId(long) => Json.fromLong(long)
- case StringId(string) => Json.fromString(string)
- case NullId => Json.Null
- }
- }
-
  implicit val callIdRW: JsonValueCodec[CallId] = new JsonValueCodec[CallId] {
  def decodeValue(in: JsonReader, default: CallId): CallId =
  Try(in.readLong())

core/src/jsonrpclib/internals/CallId.scala

@@ -5,7 +5,7 @@ import com.github.plokhotnyuk.jsoniter_scala.core.JsonValueCodec
 import com.github.plokhotnyuk.jsoniter_scala.core.JsonReader
 import com.github.plokhotnyuk.jsoniter_scala.core.JsonWriter
 
-private[jsonrpclib] sealed trait Message { def maybeCallId: Option[CallId] }
+sealed trait Message { def maybeCallId: Option[CallId] }
 private[jsonrpclib] sealed trait InputMessage extends Message { def method: String }
 private[jsonrpclib] sealed trait OutputMessage extends Message {
  def callId: CallId; final override def maybeCallId: Option[CallId] = Some(callId)
@@ -31,14 +31,14 @@ private[jsonrpclib] object OutputMessage {
 private[jsonrpclib] object Message {
 
  implicit val messageJsonValueCodecs: JsonValueCodec[Message] = new JsonValueCodec[Message] {
- val rawMessageCodec = implicitly[JsonValueCodec[RawMessage]]
+ val rawMessageCodec = implicitly[JsonValueCodec[internals.RawMessage]]
  def decodeValue(in: JsonReader, default: Message): Message =
  rawMessageCodec.decodeValue(in, null).toMessage match {
  case Left(error) => throw error
  case Right(value) => value
  }
  def encodeValue(x: Message, out: JsonWriter): Unit =
- rawMessageCodec.encodeValue(RawMessage.from(x), out)
+ rawMessageCodec.encodeValue(internals.RawMessage.from(x), out)
  def nullValue: Message = null
  }
 }

core/src/jsonrpclib/internals/Message.scala

@@ -10,8 +10,8 @@ import scala.concurrent.Promise
 import java.util.concurrent.atomic.AtomicLong
 import jsonrpclib.Endpoint.NotificationEndpoint
 import jsonrpclib.Endpoint.RequestResponseEndpoint
-import jsonrpclib.EndpointTemplate.NotificationTemplate
-import jsonrpclib.EndpointTemplate.RequestResponseTemplate
+import jsonrpclib.StubTemplate.NotificationTemplate
+import jsonrpclib.StubTemplate.RequestResponseTemplate
 import jsonrpclib.internals.OutputMessage.ErrorMessage
 import jsonrpclib.internals.OutputMessage.ResponseMessage
 import scala.util.Try
@@ -20,6 +20,7 @@ private[jsonrpclib] abstract class MessageDispatcher[F[_]](implicit F: Monadic[F
 
  import F._
 
+ protected def background[A](fa: F[A]): F[Unit]
  protected def reportError(params: Option[Payload], error: ProtocolError, method: String): F[Unit]
  protected def getEndpoint(method: String): F[Option[Endpoint[F]]]
  protected def sendMessage(message: Message): F[Unit]
@@ -34,7 +35,7 @@ private[jsonrpclib] abstract class MessageDispatcher[F[_]](implicit F: Monadic[F
  sendMessage(message)
  }
 
- def requestResponseStub[In, Err, Out](
+ def stub[In, Err, Out](
  method: String
  )(implicit inCodec: Codec[In], errCodec: ErrorCodec[Err], outCodec: Codec[Out]): In => F[Either[Err, Out]] = {
  (input: In) =>
@@ -43,7 +44,7 @@ private[jsonrpclib] abstract class MessageDispatcher[F[_]](implicit F: Monadic[F
  val message = InputMessage.RequestMessage(method, callId, Some(encoded))
  doFlatMap(createPromise[Either[Err, Out]]()) { case (fulfill, future) =>
  val pc = createPendingCall(method, errCodec, outCodec, fulfill)
- doFlatMap(storePendingCall(callId, pc))(_ => future())
+ doFlatMap(storePendingCall(callId, pc))(_ => doFlatMap(sendMessage(message))(_ => future()))
  }
  }
  }
@@ -52,7 +53,7 @@ private[jsonrpclib] abstract class MessageDispatcher[F[_]](implicit F: Monadic[F
  Codec.decode[Message](Some(payload)).map {
  case im: InputMessage =>
  doFlatMap(getEndpoint(im.method)) {
- case Some(ep) => executeInputMessage(im, ep)
+ case Some(ep) => background(executeInputMessage(im, ep))
  case None =>
  im.maybeCallId match {
  case None =>
@@ -63,7 +64,11 @@ private[jsonrpclib] abstract class MessageDispatcher[F[_]](implicit F: Monadic[F
  sendProtocolError(callId, error)
  }
  }
- case im: OutputMessage => doPure(())
+ case om: OutputMessage =>
+ doFlatMap(removePendingCall(om.callId)) {
+ case Some(pendingCall) => pendingCall(om)
+ case None => doPure(()) // TODO do something
+ }
  } match {
  case Left(error) =>
  sendProtocolError(error)
@@ -117,8 +122,8 @@ private[jsonrpclib] abstract class MessageDispatcher[F[_]](implicit F: Monadic[F
  message match {
  case ErrorMessage(_, errorPayload) =>
  errCodec.decode(errorPayload) match {
- case Left(decodeError) => fulfill(scala.util.Failure(decodeError))
- case Right(value)  => fulfill(scala.util.Success(Left(value)))
+ case Left(_) => fulfill(scala.util.Failure(errorPayload))
+ case Right(value) => fulfill(scala.util.Success(Left(value)))
  }
  case ResponseMessage(_, data) =>
  outCodec.decode(Some(data)) match {