use play-netty instead akka-http

build.sbt

@@ -396,10 +396,7 @@ lazy val `integration-tests` = project
     Test / fork := true,
     concurrentRestrictions += Tags.limitAll(1), // only one integration test at a time
     Test / testOptions := Seq(Tests.Argument(TestFrameworks.JUnit, "-a", "-v")),
-    libraryDependencies ++= akkaHttp.map(_ % Test) ++ testDependencies,
-    libraryDependencies ++= akkaStreams.map(
-      _.cross(CrossVersion.for3Use2_13) // temporary, to make it tests work with Scala 3
-    ),
+    libraryDependencies ++= playNettyServer.map(_ % Test) ++ testDependencies,
   )
   .settings(shadedAhcSettings)
   .settings(shadedOAuthSettings)

integration-tests/src/test/java/play/libs/ws/ahc/AhcCurlRequestLoggerSpec.scala

@@ -4,11 +4,12 @@
 
 package play.libs.ws.ahc
 
-import akka.http.scaladsl.server.Route
 import org.specs2.concurrent.ExecutionEnv
 import org.specs2.concurrent.FutureAwait
 import org.specs2.mutable.Specification
-import play.AkkaServerProvider
+import play.NettyServerProvider
+import play.api.BuiltInComponents
+import play.api.mvc.Results
 import play.libs.ws.DefaultBodyWritables
 import play.libs.ws.DefaultWSCookie
 import play.libs.ws.WSAuthInfo
@@ -19,23 +20,25 @@ import uk.org.lidalia.slf4jtest.TestLoggerFactory
 
 import scala.jdk.CollectionConverters._
 import scala.jdk.FutureConverters._
+import play.api.routing.sird._
 
 class AhcCurlRequestLoggerSpec(implicit val executionEnv: ExecutionEnv)
     extends Specification
-    with AkkaServerProvider
+    with NettyServerProvider
     with StandaloneWSClientSupport
     with FutureAwait
     with DefaultBodyWritables {
 
-  override def routes: Route = {
-    import akka.http.scaladsl.server.Directives._
-    get {
-      complete("<h1>Say hello to akka-http</h1>")
-    } ~
-      post {
-        entity(as[String]) { echo =>
-          complete(echo)
-        }
+  override def routes(components: BuiltInComponents) = {
+    case GET(_) =>
+      components.defaultActionBuilder(
+        Results.Ok("<h1>Say hello to play</h1>")
+      )
+    case POST(_) =>
+      components.defaultActionBuilder { req =>
+        Results.Ok(
+          req.body.asText.getOrElse("")
+        )
       }
   }
 

integration-tests/src/test/scala/play/AkkaServerProvider.scala → integration-tests/src/test/scala/play/NettyServerProvider.scala

@@ -5,49 +5,52 @@
 package play
 
 import akka.actor.ActorSystem
-import akka.http.scaladsl.Http
-import akka.http.scaladsl.server.Route
 import org.specs2.concurrent.ExecutionEnv
 import org.specs2.specification.BeforeAfterAll
 
 import scala.concurrent.duration._
 import scala.concurrent.Await
-import scala.concurrent.Future
 import akka.stream.Materializer
 
-trait AkkaServerProvider extends BeforeAfterAll {
+import play.api.mvc.Handler
+import play.api.mvc.RequestHeader
+import play.core.server.NettyServer
+import play.core.server.ServerConfig
+import play.api.BuiltInComponents
+import play.api.Mode
+
+trait NettyServerProvider extends BeforeAfterAll {
 
   /**
    * @return Routes to be used by the test.
    */
-  def routes: Route
+  def routes(components: BuiltInComponents): PartialFunction[RequestHeader, Handler]
 
   /**
    * The execution context environment.
    */
   def executionEnv: ExecutionEnv
 
-  var testServerPort: Int            = _
+  lazy val testServerPort: Int       = server.httpPort.getOrElse(sys.error("undefined port number"))
   val defaultTimeout: FiniteDuration = 5.seconds
 
   // Create Akka system for thread and streaming management
   implicit val system: ActorSystem        = ActorSystem()
   implicit val materializer: Materializer = Materializer.matFromSystem
 
-  lazy val futureServer: Future[Http.ServerBinding] = {
-    // Using 0 (zero) means that a random free port will be used.
-    // So our tests can run in parallel and won't mess with each other.
-    Http().bindAndHandle(routes, "localhost", 0)
-  }
+  // Using 0 (zero) means that a random free port will be used.
+  // So our tests can run in parallel and won't mess with each other.
+  val server = NettyServer.fromRouterWithComponents(
+    ServerConfig(
+      port = Option(0),
+      mode = Mode.Test
+    )
+  )(components => routes(components))
 
-  override def beforeAll(): Unit = {
-    val portFuture = futureServer.map(_.localAddress.getPort)(executionEnv.executionContext)
-    portFuture.foreach(port => testServerPort = port)(executionEnv.executionContext)
-    Await.ready(portFuture, defaultTimeout)
-  }
+  override def beforeAll(): Unit = {}
 
   override def afterAll(): Unit = {
-    futureServer.foreach(_.unbind())(executionEnv.executionContext)
+    server.stop()
     val terminate = system.terminate()
     Await.ready(terminate, defaultTimeout)
   }

integration-tests/src/test/scala/play/api/libs/ws/ahc/AhcCurlRequestLoggerSpec.scala

@@ -4,37 +4,43 @@
 
 package play.api.libs.ws.ahc
 
-import akka.http.scaladsl.server.Route
 import org.specs2.concurrent.ExecutionEnv
 import org.specs2.concurrent.FutureAwait
 import org.specs2.mutable.Specification
-import play.AkkaServerProvider
+import play.NettyServerProvider
+import play.api.BuiltInComponents
 import play.api.libs.ws.DefaultBodyWritables
 import play.api.libs.ws.DefaultWSCookie
 import play.api.libs.ws.EmptyBody
 import play.api.libs.ws.WSAuthScheme
+import play.api.mvc.Handler
+import play.api.mvc.RequestHeader
+import play.api.mvc.Results
 import uk.org.lidalia.slf4jext.Level
 import uk.org.lidalia.slf4jtest.TestLogger
 import uk.org.lidalia.slf4jtest.TestLoggerFactory
+import play.api.routing.sird._
 
 import scala.jdk.CollectionConverters._
 
 class AhcCurlRequestLoggerSpec(implicit val executionEnv: ExecutionEnv)
     extends Specification
-    with AkkaServerProvider
+    with NettyServerProvider
     with StandaloneWSClientSupport
     with FutureAwait
     with DefaultBodyWritables {
 
-  override def routes: Route = {
-    import akka.http.scaladsl.server.Directives._
-    get {
-      complete("<h1>Say hello to akka-http</h1>")
-    } ~
-      post {
-        entity(as[String]) { echo =>
-          complete(echo)
-        }
+  override def routes(components: BuiltInComponents): PartialFunction[RequestHeader, Handler] = {
+    case GET(_) =>
+      components.defaultActionBuilder(
+        Results
+          .Ok("<h1>Say hello to play</h1>")
+      )
+    case POST(_) =>
+      components.defaultActionBuilder { req =>
+        Results.Ok(
+          req.body.asText.getOrElse("")
+        )
       }
   }