Remove reliance of tests on Cats Effect, to enable Scala Native release for sttp client module (#4617)

Most tests operate within or via Future anyways, so we remove the level
of indirection and express as much as possible in terms of Future,
removing the need for CE dependency in a lot of places, but especially
on Native. I got `sttpClient4Native4/test` to pass locally, which is all
I care about really.

Note that CE release on Native 0.5 is imminent, but if it's delayed,
this might be _an_ option to get native builds of sttp modules out (and
may be others?).

Getting a native tapir-sttp-client module is my only goal here, so I
don't care if it's achieved by any other means – you can consider this
PR if you think it has merit on its own.

not a Draft as I want to get a CI run out of it.

---------

Co-authored-by: Adam Warski <[email protected]>

Author: keynmol

build.sbt

@@ -389,6 +389,23 @@ val clientTestServerSettings = Seq(
   })
 )
 
+lazy val superMatrixSettings = Seq((Compile / unmanagedSourceDirectories) ++= {
+  val allCombos = List("js", "jvm", "native").combinations(2).toList
+  val dis =
+    virtualAxes.value.collectFirst { case p: VirtualAxis.PlatformAxis =>
+      p.directorySuffix
+    }.get
+
+  allCombos
+    .filter(_.contains(dis))
+    .map { suff =>
+      val suffixes = "scala" + suff.mkString("-", "-", "")
+
+      (Compile / sourceDirectory).value / suffixes
+    }
+})
+
+
 lazy val clientTestServer = (projectMatrix in file("client/testserver"))
   .settings(commonSettings)
   .settings(
@@ -504,15 +521,23 @@ lazy val tests: ProjectMatrix = (projectMatrix in file("tests"))
       "io.circe" %%% "circe-generic" % Versions.circe,
       "com.softwaremill.common" %%% "tagging" % "2.3.5",
       scalaTest.value,
-      "org.typelevel" %%% "cats-effect" % Versions.catsEffect,
       logback
     )
   )
-  .jvmPlatform(scalaVersions = scala2And3Versions, settings = commonJvmSettings)
+  .jvmPlatform(
+    scalaVersions = scala2And3Versions,
+    settings = commonJvmSettings ++ Seq(
+      libraryDependencies += "org.typelevel" %%% "cats-effect" % Versions.catsEffect
+    )
+  )
   .jsPlatform(
     scalaVersions = scala2And3Versions,
     settings = commonJsSettings
   )
+  .nativePlatform(
+    scalaVersions = Seq(scala3),
+    settings = commonNativeSettings
+  )
   .dependsOn(core, files, circeJson, cats)
 
 lazy val perfServerJavaOptions = List(
@@ -1936,7 +1961,9 @@ lazy val clientTests: ProjectMatrix = (projectMatrix in file("client/tests"))
   )
   .jvmPlatform(scalaVersions = scala2And3Versions, settings = commonJvmSettings)
   .jsPlatform(scalaVersions = scala2And3Versions, settings = commonJsSettings)
+  .nativePlatform(scalaVersions = Seq(scala3), settings = commonNativeSettings)
   .dependsOn(tests)
+  .settings(superMatrixSettings)
 
 lazy val clientCore: ProjectMatrix = (projectMatrix in file("client/core"))
   .settings(commonSettings)
@@ -2059,6 +2086,15 @@ lazy val sttpClient4: ProjectMatrix = (projectMatrix in file("client/sttp-client
       )
     )
   )
+  .nativePlatform(
+    scalaVersions = Seq(scala3),
+    settings = commonNativeSettings ++ Seq(
+      libraryDependencies ++= Seq(
+        "io.github.cquiroz" %%% "scala-java-time" % Versions.nativeScalaJavaTime,
+        "io.github.cquiroz" %%% "scala-java-time-tzdb" % Versions.nativeScalaJavaTime % Test
+      )
+    )
+  )
   .dependsOn(clientCore, clientTests % Test)
 
 lazy val playClient: ProjectMatrix = (projectMatrix in file("client/play-client"))

client/http4s-client/src/test/scala/sttp/tapir/client/http4s/Http4ClientStreamingTests.scala

@@ -5,8 +5,10 @@ import cats.effect.IO
 import fs2.text
 import sttp.capabilities.fs2.Fs2Streams
 import sttp.tapir.client.tests.ClientStreamingTests
+import cats.effect.unsafe.IORuntime
 
 class Http4ClientStreamingTests extends Http4sClientTests[Fs2Streams[IO]] with ClientStreamingTests[Fs2Streams[IO]] {
+  private implicit val ioRT: IORuntime = cats.effect.unsafe.implicits.global
   override val streams: Fs2Streams[IO] = Fs2Streams[IO]
   override def mkStream(s: String): streams.BinaryStream = fs2.Stream(s).through(text.utf8.encode)
   override def rmStream(s: streams.BinaryStream): String = s.through(text.utf8.decode).compile.string.unsafeRunSync()

client/http4s-client/src/test/scala/sttp/tapir/client/http4s/Http4sClientTests.scala

@@ -1,11 +1,13 @@
 package sttp.tapir.client.http4s
 
-import cats.effect.IO
 import org.http4s.blaze.client.BlazeClientBuilder
 import org.http4s.{Request, Response, Uri}
 import sttp.tapir.client.tests.ClientTests
 import sttp.tapir.{DecodeResult, Endpoint}
 import scala.concurrent.ExecutionContext.global
+import scala.concurrent.Future
+import cats.effect._
+import cats.effect.unsafe.IORuntime
 
 abstract class Http4sClientTests[R] extends ClientTests[R] {
   override def send[A, I, E, O](
@@ -14,7 +16,7 @@ abstract class Http4sClientTests[R] extends ClientTests[R] {
       securityArgs: A,
       args: I,
       scheme: String = "http"
-  ): IO[Either[E, O]] = {
+  ): Future[Either[E, O]] = {
     val (request, parseResponse) =
       Http4sClientInterpreter[IO]()
         .toSecureRequestThrowDecodeFailures(e, Some(Uri.unsafeFromString(s"http://localhost:$port")))
@@ -24,7 +26,12 @@ abstract class Http4sClientTests[R] extends ClientTests[R] {
     sendAndParseResponse(request, parseResponse)
   }
 
-  override def safeSend[A, I, E, O](e: Endpoint[A, I, E, O, R], port: Port, securityArgs: A, args: I): IO[DecodeResult[Either[E, O]]] = {
+  override def safeSend[A, I, E, O](
+      e: Endpoint[A, I, E, O, R],
+      port: Port,
+      securityArgs: A,
+      args: I
+  ): Future[DecodeResult[Either[E, O]]] = {
     val (request, parseResponse) =
       Http4sClientInterpreter[IO]()
         .toSecureRequest(e, Some(Uri.unsafeFromString(s"http://localhost:$port")))
@@ -34,8 +41,12 @@ abstract class Http4sClientTests[R] extends ClientTests[R] {
     sendAndParseResponse(request, parseResponse)
   }
 
+  private implicit val ioRT: IORuntime = cats.effect.unsafe.implicits.global
+
   private def sendAndParseResponse[Result](request: Request[IO], parseResponse: Response[IO] => IO[Result]) =
-    BlazeClientBuilder[IO](global).resource.use { client =>
-      client.run(request).use(parseResponse)
-    }
+    BlazeClientBuilder[IO](global).resource
+      .use { client =>
+        client.run(request).use(parseResponse)
+      }
+      .unsafeToFuture()(ioRT)
 }

client/play-client/src/test/scala/sttp/tapir/client/play/PlayClientTests.scala

@@ -22,26 +22,20 @@ abstract class PlayClientTests[R] extends ClientTests[R] {
       securityArgs: A,
       args: I,
       scheme: String = "http"
-  ): IO[Either[E, O]] = {
-    def response: Future[Either[E, O]] = {
+  ): Future[Either[E, O]] = {
       val (req, responseParser) =
         PlayClientInterpreter().toSecureRequestThrowDecodeFailures(e, s"http://localhost:$port").apply(securityArgs).apply(args)
       req.execute().map(responseParser)
-    }
-    IO.fromFuture(IO(response))
   }
 
   override def safeSend[A, I, E, O](
       e: Endpoint[A, I, E, O, R],
       port: Port,
       securityArgs: A,
       args: I
-  ): IO[DecodeResult[Either[E, O]]] = {
-    def response: Future[DecodeResult[Either[E, O]]] = {
+  ): Future[DecodeResult[Either[E, O]]] = {
       val (req, responseParser) = PlayClientInterpreter().toSecureRequest(e, s"http://localhost:$port").apply(securityArgs).apply(args)
       req.execute().map(responseParser)
-    }
-    IO.fromFuture(IO(response))
   }
 
 }

client/play29-client/src/test/scala/sttp/tapir/client/play/PlayClientTests.scala

@@ -22,26 +22,20 @@ abstract class PlayClientTests[R] extends ClientTests[R] {
       securityArgs: A,
       args: I,
       scheme: String = "http"
-  ): IO[Either[E, O]] = {
-    def response: Future[Either[E, O]] = {
-      val (req, responseParser) =
-        PlayClientInterpreter().toSecureRequestThrowDecodeFailures(e, s"http://localhost:$port").apply(securityArgs).apply(args)
-      req.execute().map(responseParser)
-    }
-    IO.fromFuture(IO(response))
+  ): Future[Either[E, O]] = {
+    val (req, responseParser) =
+      PlayClientInterpreter().toSecureRequestThrowDecodeFailures(e, s"http://localhost:$port").apply(securityArgs).apply(args)
+    req.execute().map(responseParser)
   }
 
   override def safeSend[A, I, E, O](
       e: Endpoint[A, I, E, O, R],
       port: Port,
       securityArgs: A,
       args: I
-  ): IO[DecodeResult[Either[E, O]]] = {
-    def response: Future[DecodeResult[Either[E, O]]] = {
-      val (req, responseParser) = PlayClientInterpreter().toSecureRequest(e, s"http://localhost:$port").apply(securityArgs).apply(args)
-      req.execute().map(responseParser)
-    }
-    IO.fromFuture(IO(response))
+  ): Future[DecodeResult[Either[E, O]]] = {
+    val (req, responseParser) = PlayClientInterpreter().toSecureRequest(e, s"http://localhost:$port").apply(securityArgs).apply(args)
+    req.execute().map(responseParser)
   }
 
 }

client/sttp-client/src/test/scalajs/sttp/tapir/client/sttp/SttpClientTests.scala

@@ -1,7 +1,5 @@
 package sttp.tapir.client.sttp
 
-import cats.effect.IO
-
 import scala.concurrent.Future
 import sttp.tapir.{DecodeResult, Endpoint}
 import sttp.tapir.client.tests.ClientTests
@@ -17,33 +15,29 @@ abstract class SttpClientTests[R >: Any] extends ClientTests[R] {
       securityArgs: A,
       args: I,
       scheme: String = "http"
-  ): IO[Either[E, O]] = {
+  ): Future[Either[E, O]] = {
     implicit val wst: WebSocketToPipe[R] = wsToPipe
-    val response: Future[Either[E, O]] =
-      SttpClientInterpreter()
-        .toSecureRequestThrowDecodeFailures(e, Some(uri"$scheme://localhost:$port"))
-        .apply(securityArgs)
-        .apply(args)
-        .send(backend)
-        .map(_.body)
-    IO.fromFuture(IO(response))
+    SttpClientInterpreter()
+      .toSecureRequestThrowDecodeFailures(e, Some(uri"$scheme://localhost:$port"))
+      .apply(securityArgs)
+      .apply(args)
+      .send(backend)
+      .map(_.body)
   }
 
   override def safeSend[A, I, E, O](
       e: Endpoint[A, I, E, O, R],
       port: Port,
       securityArgs: A,
       args: I
-  ): IO[DecodeResult[Either[E, O]]] = {
+  ): Future[DecodeResult[Either[E, O]]] = {
     implicit val wst: WebSocketToPipe[R] = wsToPipe
-    def response: Future[DecodeResult[Either[E, O]]] =
-      SttpClientInterpreter()
-        .toSecureRequest(e, Some(uri"http://localhost:$port"))
-        .apply(securityArgs)
-        .apply(args)
-        .send(backend)
-        .map(_.body)
-    IO.fromFuture(IO(response))
+    SttpClientInterpreter()
+      .toSecureRequest(e, Some(uri"http://localhost:$port"))
+      .apply(securityArgs)
+      .apply(args)
+      .send(backend)
+      .map(_.body)
   }
 
   override protected def afterAll(): Unit = {

client/sttp-client/src/test/scalajs/sttp/tapir/client/sttp/SttpClientWebSocketZioTests.scala

@@ -1,11 +1,11 @@
 package sttp.tapir.client.sttp
 
-import cats.effect.IO
 import sttp.capabilities.WebSockets
 import sttp.capabilities.zio.ZioStreams
 import sttp.tapir.client.sttp.ws.zio._
 import sttp.tapir.client.tests.ClientWebSocketTests
 import zio.stream.{Stream, ZStream}
+import concurrent.Future
 
 class SttpClientWebSocketZioTests extends SttpClientZioTests[WebSockets with ZioStreams] with ClientWebSocketTests[ZioStreams] {
   override val streams: ZioStreams = ZioStreams
@@ -15,13 +15,11 @@ class SttpClientWebSocketZioTests extends SttpClientZioTests[WebSockets with Zio
       p: Stream[Throwable, A] => Stream[Throwable, B],
       receiveCount: Port,
       as: List[A]
-  ): IO[List[B]] = IO.fromFuture(
-    IO.delay {
-      unsafeToFuture(
-        ZStream(as: _*).viaFunction(p).take(receiveCount).runCollect.map(_.toList)
-      ).future
-    }
-  )
+  ): Future[List[B]] = {
+    unsafeToFuture(
+      ZStream(as: _*).viaFunction(p).take(receiveCount).runCollect.map(_.toList)
+    ).future
+  }
 
   webSocketTests()
 }

client/sttp-client/src/test/scalajs/sttp/tapir/client/sttp/SttpClientZioTests.scala

@@ -1,6 +1,5 @@
 package sttp.tapir.client.sttp
 
-import cats.effect.IO
 import sttp.capabilities.WebSockets
 import sttp.capabilities.zio.ZioStreams
 import sttp.client3._
@@ -9,6 +8,7 @@ import sttp.tapir.client.tests.ClientTests
 import sttp.tapir.{DecodeResult, Endpoint}
 import zio.Runtime.default
 import zio.{CancelableFuture, Task, Unsafe}
+import concurrent.Future
 
 abstract class SttpClientZioTests[R >: WebSockets with ZioStreams] extends ClientTests[R] {
   private val runtime: default.UnsafeAPI = zio.Runtime.default.unsafe
@@ -21,34 +21,32 @@ abstract class SttpClientZioTests[R >: WebSockets with ZioStreams] extends Clien
       securityArgs: A,
       args: I,
       scheme: String = "http"
-  ): IO[Either[E, O]] =
-    IO.fromFuture(IO.delay {
-      implicit val wst: WebSocketToPipe[R] = wsToPipe
-      val send = SttpClientInterpreter()
-        .toSecureRequestThrowDecodeFailures(e, Some(uri"$scheme://localhost:$port"))
-        .apply(securityArgs)
-        .apply(args)
-        .send(backend)
-        .map(_.body)
-      unsafeToFuture(send).future
-    })
+  ): Future[Either[E, O]] = {
+    implicit val wst: WebSocketToPipe[R] = wsToPipe
+    val send = SttpClientInterpreter()
+      .toSecureRequestThrowDecodeFailures(e, Some(uri"$scheme://localhost:$port"))
+      .apply(securityArgs)
+      .apply(args)
+      .send(backend)
+      .map(_.body)
+    unsafeToFuture(send).future
+  }
 
   override def safeSend[A, I, E, O](
       e: Endpoint[A, I, E, O, R],
       port: Port,
       securityArgs: A,
       args: I
-  ): IO[DecodeResult[Either[E, O]]] =
-    IO.fromFuture(IO.delay {
-      implicit val wst: WebSocketToPipe[R] = wsToPipe
-      val send = SttpClientInterpreter()
-        .toSecureRequest(e, Some(uri"http://localhost:$port"))
-        .apply(securityArgs)
-        .apply(args)
-        .send(backend)
-        .map(_.body)
-      unsafeToFuture(send).future
-    })
+  ): Future[DecodeResult[Either[E, O]]] = {
+    implicit val wst: WebSocketToPipe[R] = wsToPipe
+    val send = SttpClientInterpreter()
+      .toSecureRequest(e, Some(uri"http://localhost:$port"))
+      .apply(securityArgs)
+      .apply(args)
+      .send(backend)
+      .map(_.body)
+    unsafeToFuture(send).future
+  }
 
   override protected def afterAll(): Unit = {
     unsafeRun(backend.close())