Add tests to check serialization and deserialization

json/circe/src/test/scala/sttp/client4/circe/BackendStubCirceTests.scala

@@ -8,6 +8,7 @@ import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 
 class BackendStubCirceTests extends AnyFlatSpec with Matchers with ScalaFutures {
+
   it should "deserialize to json using a string stub" in {
     val backend = SyncBackendStub.whenAnyRequest.thenRespond("""{"name": "John"}""")
     val r = basicRequest.get(uri"http://example.org").response(asJson[Person]).send(backend)

json/circe/src/test/scala/sttp/client4/circe/CirceTests.scala

@@ -5,14 +5,10 @@ import org.scalatest._
 import sttp.client4.internal._
 import sttp.client4._
 import sttp.model._
-
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 
 class CirceTests extends AnyFlatSpec with Matchers with EitherValues {
-  // Needed for the implicit to work in Scala3. Normally this is imported explicitly, only in tests we are in the same package
-  import sttp.client4.circe.circeBodySerializer
-  import EitherDecoders._
 
   "The circe module" should "encode arbitrary bodies given an encoder" in {
     val body = Outer(Inner(42, true, "horses"), "cats")
@@ -105,6 +101,19 @@ class CirceTests extends AnyFlatSpec with Matchers with EitherValues {
     ct shouldBe Some("horses/cats")
   }
 
+  it should "serialize from JsonObject using implicit circeBodySerializer" in {
+    import io.circe.syntax.EncoderOps
+    import io.circe.JsonObject
+    import sttp.model.Uri
+
+    val jObject: JsonObject = JsonObject(("location", "hometown".asJson), ("bio", "Scala programmer".asJson))
+    val result = basicRequest.get(Uri("http://example.org")).body(jObject).body.show
+
+    val expectedResult = "string: {\"location\":\"hometown\",\"bio\":\"Scala programmer\"}"
+
+    result should be(expectedResult)
+  }
+
   case class Inner(a: Int, b: Boolean, c: String)
 
   object Inner {

json/json4s/src/test/scala/sttp/client4/BackendStubJson4sTests.scala

@@ -0,0 +1,26 @@
+package sttp.client4
+
+import org.scalatest.concurrent.ScalaFutures
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+import sttp.client4.testing.SyncBackendStub
+import sttp.model.Uri
+import org.json4s.{native, DefaultFormats}
+
+case class Person(name: String)
+
+class BackendStubJson4sTests extends AnyFlatSpec with Matchers with ScalaFutures {
+
+  implicit val serialization = native.Serialization
+  implicit val formats = DefaultFormats
+
+  import json4s._
+
+  it should "deserialize to json using a string stub" in {
+    val backend = SyncBackendStub.whenAnyRequest.thenRespond("""{"name": "John"}""")
+    val r = basicRequest.get(Uri("http://example.org")).response(asJson[Person]).send(backend)
+
+    r.is200 should be(true)
+    r.body should be(Right(Person("John")))
+  }
+}

json/json4s/src/test/scala/sttp/client4/Json4sTests.scala

@@ -1,7 +1,8 @@
 package sttp.client4
 
+import org.json4s.JsonAST.JString
 import org.json4s.ParserUtil.ParseException
-import org.json4s.{native, DefaultFormats, MappingException}
+import org.json4s.{DefaultFormats, JField, JObject, MappingException, native}
 import org.scalatest._
 import sttp.client4.internal._
 import sttp.model._
@@ -80,6 +81,15 @@ class Json4sTests extends AnyFlatSpec with Matchers with EitherValues {
     ct shouldBe Some(MediaType.ApplicationJson.copy(charset = Some(Utf8)).toString)
   }
 
+  it should "serialize from JObject using implicit json4sBodySerializer" in {
+    val jObject: JObject = JObject(JField("location", JString("hometown")), JField("bio", JString("Scala programmer")))
+    val result = basicRequest.get(Uri("http://example.org")).body(jObject).body.show
+
+    val expectedResult = "string: {\"location\":\"hometown\",\"bio\":\"Scala programmer\"}"
+
+    result should be(expectedResult)
+  }
+
   def extractBody[T](request: PartialRequest[T]): String =
     request.body match {
       case StringBody(body, "utf-8", MediaType.ApplicationJson) =>

json/jsoniter/src/test/scala/sttp/client4/jsoniter/BackendStubJsoniterTests.scala

@@ -0,0 +1,28 @@
+package sttp.client4.jsoniter
+
+import org.scalatest.concurrent.ScalaFutures
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+import sttp.client4.testing.SyncBackendStub
+import sttp.model.Uri
+import com.github.plokhotnyuk.jsoniter_scala.core.JsonValueCodec
+import com.github.plokhotnyuk.jsoniter_scala.macros.JsonCodecMaker
+
+case class Person(name: String)
+
+object Person {
+  implicit val personJsonValueCodec: JsonValueCodec[Person] = JsonCodecMaker.make
+}
+
+class BackendStubJsoniterTests extends AnyFlatSpec with Matchers with ScalaFutures {
+
+  import sttp.client4.basicRequest
+
+  it should "deserialize to json using a string stub" in {
+    val backend = SyncBackendStub.whenAnyRequest.thenRespond("""{"name": "John"}""")
+    val r = basicRequest.get(Uri("http://example.org")).response(asJson[Person]).send(backend)
+
+    r.is200 should be(true)
+    r.body should be(Right(Person("John")))
+  }
+}

json/jsoniter/src/test/scala/sttp/client4/jsoniter/JsoniterJsonTests.scala

@@ -81,6 +81,15 @@ class JsoniterJsonTests extends AnyFlatSpec with Matchers with EitherValues {
     ct shouldBe Some("horses/cats")
   }
 
+  it should "serialize from case class Person using implicit jsoniterBodySerializer" in {
+    val person = Person("John")
+    val result = basicRequest.get(Uri("http://example.org")).body(person).body.show
+
+    val expectedResult = "string: {\"name\":\"John\"}"
+
+    result should be(expectedResult)
+  }
+
   def extractBody[T](request: PartialRequest[T]): String =
     request.body match {
       case StringBody(body, "utf-8", MediaType.ApplicationJson) =>

json/play-json/src/test/scala/sttp/client4/BackendStubPlayJsonTests.scala

@@ -0,0 +1,27 @@
+package sttp.client4
+
+import org.scalatest.concurrent.ScalaFutures
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+import sttp.client4.testing.SyncBackendStub
+import sttp.model.Uri
+import play.api.libs.json.Json
+import play.api.libs.json.OFormat
+import playJson._
+
+case class Person(name: String)
+
+object Person {
+  implicit val personFormat: OFormat[Person] = Json.format[Person]
+}
+
+class BackendStubPlayJsonTests extends AnyFlatSpec with Matchers with ScalaFutures {
+
+  it should "deserialize to json using a string stub" in {
+    val backend = SyncBackendStub.whenAnyRequest.thenRespond("""{"name": "John"}""")
+    val r = basicRequest.get(Uri("http://example.org")).response(asJson[Person]).send(backend)
+
+    r.is200 should be(true)
+    r.body should be(Right(Person("John")))
+  }
+}

json/play-json/src/test/scala/sttp/client4/PlayJsonTests.scala

@@ -100,6 +100,17 @@ class PlayJsonTests extends AnyFlatSpec with Matchers with EitherValues {
     ct shouldBe Some("horses/cats")
   }
 
+  it should "serialize from JsObject using implicit playJsonBodySerializer" in {
+    val fields: Seq[(String, JsValue)] =
+      Seq[(String, JsValue)](("location", JsString("hometown")), ("bio", JsString("Scala programmer")))
+    val json: JsObject = JsObject(fields)
+    val result = basicRequest.get(Uri("http://example.org")).body(json).body.show
+
+    val expectedResult = "string: {\"location\":\"hometown\",\"bio\":\"Scala programmer\"}"
+
+    result should be(expectedResult)
+  }
+
   case class Inner(a: Int, b: Boolean, c: String)
 
   object Inner {

json/spray-json/src/test/scala/sttp/client4/BackendStubSprayJsonTests.scala

@@ -0,0 +1,27 @@
+package sttp.client4
+
+import org.scalatest.concurrent.ScalaFutures
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+import sttp.client4.testing.SyncBackendStub
+import sttp.model.Uri
+import spray.json.DefaultJsonProtocol.{jsonFormat1, StringJsonFormat}
+import spray.json.RootJsonFormat
+import sprayJson._
+
+case class Person(name: String)
+
+object Person {
+  implicit val personRootJsonFormat: RootJsonFormat[Person] = jsonFormat1(Person.apply)
+}
+
+class BackendStubSprayJsonTests extends AnyFlatSpec with Matchers with ScalaFutures {
+
+  it should "deserialize to json using a string stub" in {
+    val backend = SyncBackendStub.whenAnyRequest.thenRespond("""{"name": "John"}""")
+    val r = basicRequest.get(Uri("http://example.org")).response(asJson[Person]).send(backend)
+
+    r.is200 should be(true)
+    r.body should be(Right(Person("John")))
+  }
+}

json/spray-json/src/test/scala/sttp/client4/SprayJsonTests.scala

@@ -77,6 +77,18 @@ class SprayJsonTests extends AnyFlatSpec with Matchers with EitherValues {
     ct shouldBe Some(MediaType.ApplicationJson.copy(charset = Some(Utf8)).toString)
   }
 
+  it should "serialize from JsObject using implicit sprayBodySerializer" in {
+    val json: JsObject = JsObject(
+      "location" -> "hometown".toJson,
+      "bio" -> "Scala programmer".toJson
+    )
+    val result = basicRequest.get(Uri("http://example.org")).body(json).body.show
+
+    val expectedResult = "string: {\"bio\":\"Scala programmer\",\"location\":\"hometown\"}"
+
+    result should be(expectedResult)
+  }
+
   def extractBody[T](request: PartialRequest[T]): String =
     request.body match {
       case StringBody(body, "utf-8", MediaType.ApplicationJson) =>

json/upickle/src/test/scala/sttp/client4/upicklejson/BackendStubUpickleTests.scala

@@ -21,5 +21,4 @@ class BackendStubUpickleTests extends AnyFlatSpec with Matchers with ScalaFuture
     r.is200 should be(true)
     r.body should be(Right(Person("John")))
   }
-
 }

json/upickle/src/test/scala/sttp/client4/upicklejson/UpickleTests.scala

@@ -5,9 +5,9 @@ import org.scalatest._
 import sttp.client4.internal._
 import sttp.client4._
 import sttp.model._
-
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
+import ujson.Obj
 
 class UpickleTests extends AnyFlatSpec with Matchers with EitherValues {
   "The upickle module" should "encode arbitrary bodies given an encoder" in {
@@ -88,6 +88,18 @@ class UpickleTests extends AnyFlatSpec with Matchers with EitherValues {
     ct shouldBe Some("horses/cats")
   }
 
+  it should "serialize ujson.Obj using implicit upickleBodySerializer" in {
+    val json: Obj = ujson.Obj(
+      "location" -> "hometown",
+      "bio" -> "Scala programmer"
+    )
+    val result = basicRequest.get(Uri("http://example.org")).body(json).body.show
+
+    val expectedResult = "string: {\"location\":\"hometown\",\"bio\":\"Scala programmer\"}"
+
+    result should be(expectedResult)
+  }
+
   case class Inner(a: Int, b: Boolean, c: String)
 
   object Inner {

json/zio-json/src/test/scala/sttp/client4/ziojson/BackendStubZioJsonTests.scala

@@ -0,0 +1,27 @@
+package sttp.client4.ziojson
+
+import org.scalatest.concurrent.ScalaFutures
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+import sttp.client4.basicRequest
+import sttp.client4.testing.SyncBackendStub
+import sttp.model.Uri
+import zio.json.{DeriveJsonDecoder, DeriveJsonEncoder, JsonDecoder, JsonEncoder}
+
+case class Person(name: String)
+
+object Person {
+  implicit val encoder: JsonEncoder[Person] = DeriveJsonEncoder.gen[Person]
+  implicit val codec: JsonDecoder[Person] = DeriveJsonDecoder.gen[Person]
+}
+
+class BackendStubJson4sTests extends AnyFlatSpec with Matchers with ScalaFutures {
+
+  it should "deserialize to json using a string stub" in {
+    val backend = SyncBackendStub.whenAnyRequest.thenRespond("""{"name": "John"}""")
+    val r = basicRequest.get(Uri("http://example.org")).response(asJson[Person]).send(backend)
+
+    r.is200 should be(true)
+    r.body should be(Right(Person("John")))
+  }
+}

json/zio-json/src/test/scala/sttp/client4/ziojson/ZioJsonTests.scala

@@ -6,8 +6,9 @@ import org.scalatest.matchers.should.Matchers
 import zio.json._
 import sttp.client4._
 import sttp.client4.internal.Utf8
-
 import sttp.model._
+import zio.Chunk
+import zio.json.ast.Json
 
 class ZioJsonTests extends AnyFlatSpec with Matchers with EitherValues {
 
@@ -90,6 +91,16 @@ class ZioJsonTests extends AnyFlatSpec with Matchers with EitherValues {
     ct shouldBe Some("horses/cats")
   }
 
+  it should "serialize from Json.Obj using implicit zioJsonBodySerializer" in {
+    val fields: Chunk[(String, Json)] = Chunk(("location", Json.Str("hometown")), ("bio", Json.Str("Scala programmer")))
+    val jObject: Json.Obj = Json.Obj(fields)
+    val result = basicRequest.get(Uri("http://example.org")).body(jObject).body.show
+
+    val expectedResult = "string: {\"location\":\"hometown\",\"bio\":\"Scala programmer\"}"
+
+    result should be(expectedResult)
+  }
+
   def extractBody[T](request: PartialRequest[T]): String =
     request.body match {
       case StringBody(body, "utf-8", MediaType.ApplicationJson) =>

json/zio1-json/src/test/scala/sttp/client4/ziojson/BackendStubZioJsonTests.scala

@@ -0,0 +1,27 @@
+package sttp.client4.ziojson
+
+import org.scalatest.concurrent.ScalaFutures
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+import sttp.client4.testing.SyncBackendStub
+import sttp.model.Uri
+import sttp.client4.basicRequest
+import zio.json.{DeriveJsonDecoder, DeriveJsonEncoder, JsonDecoder, JsonEncoder}
+
+case class Person(name: String)
+
+object Person {
+  implicit val encoder: JsonEncoder[Person] = DeriveJsonEncoder.gen[Person]
+  implicit val codec: JsonDecoder[Person] = DeriveJsonDecoder.gen[Person]
+}
+
+class BackendStubJson4sTests extends AnyFlatSpec with Matchers with ScalaFutures {
+
+  it should "deserialize to json using a string stub" in {
+    val backend = SyncBackendStub.whenAnyRequest.thenRespond("""{"name": "John"}""")
+    val r = basicRequest.get(Uri("http://example.org")).response(asJson[Person]).send(backend)
+
+    r.is200 should be(true)
+    r.body should be(Right(Person("John")))
+  }
+}

json/zio1-json/src/test/scala/sttp/client4/ziojson/ZioJsonTests.scala

@@ -6,8 +6,9 @@ import org.scalatest.matchers.should.Matchers
 import zio.json._
 import sttp.client4._
 import sttp.client4.internal.Utf8
-
 import sttp.model._
+import zio.Chunk
+import zio.json.ast.Json
 
 class ZioJsonTests extends AnyFlatSpec with Matchers with EitherValues {
 
@@ -90,6 +91,16 @@ class ZioJsonTests extends AnyFlatSpec with Matchers with EitherValues {
     ct shouldBe Some("horses/cats")
   }
 
+  it should "serialize from Json.Obj using implicit zioJsonBodySerializer" in {
+    val fields: Chunk[(String, Json)] = Chunk(("location", Json.Str("hometown")), ("bio", Json.Str("Scala programmer")))
+    val jObject: Json.Obj = Json.Obj(fields)
+    val result = basicRequest.get(Uri("http://example.org")).body(jObject).body.show
+
+    val expectedResult = "string: {\"location\":\"hometown\",\"bio\":\"Scala programmer\"}"
+
+    result should be(expectedResult)
+  }
+
   def extractBody[T](request: PartialRequest[T]): String =
     request.body match {
       case StringBody(body, "utf-8", MediaType.ApplicationJson) =>