reset counter in beforeEach, set IdleTimout explicitly,

Author: halotukozak

rest/.jvm/src/test/scala/io/udash/rest/SttpRestCallTest.scala

@@ -3,13 +3,22 @@ package rest
 
 import io.udash.rest.raw.HttpErrorException
 import io.udash.rest.raw.RawRest.HandleRequest
-import sttp.client3.SttpBackend
+import sttp.client3.{HttpClientFutureBackend, SttpBackend}
 
-import scala.concurrent.duration._
+import java.net.http.HttpClient
+import java.time.Duration as JDuration
+import scala.concurrent.duration.*
 import scala.concurrent.{Await, Future}
 
 trait SttpClientRestTest extends ServletBasedRestApiTest {
-  implicit val backend: SttpBackend[Future, Any] = SttpRestClient.defaultBackend()
+  implicit val backend: SttpBackend[Future, Any] = HttpClientFutureBackend.usingClient(
+    //like defaultHttpClient but with connection timeout >> CallTimeout
+    HttpClient
+      .newBuilder()
+      .connectTimeout(JDuration.ofMillis(IdleTimout.toMillis))
+      .followRedirects(HttpClient.Redirect.NEVER)
+      .build()
+  )
 
   def clientHandle: HandleRequest =
     SttpRestClient.asHandleRequest[Future](s"$baseUrl/api")

rest/jetty/src/test/scala/io/udash/rest/jetty/JettyRestCallTest.scala

@@ -8,6 +8,7 @@ import org.eclipse.jetty.client.HttpClient
 final class JettyRestCallTest extends ServletBasedRestApiTest with RestApiTestScenarios {
   val client: HttpClient = new HttpClient() {
     setMaxConnectionsPerDestination(MaxConnections)
+    setIdleTimeout(IdleTimout.toMillis)
   }
 
   def clientHandle: HandleRequest =

rest/src/test/scala/io/udash/rest/RestApiTest.scala

@@ -8,20 +8,27 @@ import io.udash.rest.raw.RawRest.HandleRequest
 import monix.eval.Task
 import monix.execution.Scheduler
 import org.scalactic.source.Position
+import org.scalatest.BeforeAndAfterEach
 import org.scalatest.concurrent.ScalaFutures
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.time.{Millis, Seconds, Span}
 
 import scala.concurrent.duration.FiniteDuration
 
-abstract class RestApiTest extends AnyFunSuite with ScalaFutures {
+abstract class RestApiTest extends AnyFunSuite with ScalaFutures with BeforeAndAfterEach {
+  implicit def scheduler: Scheduler = Scheduler.global
+
   protected final val MaxConnections: Int = 1 // to timeout quickly
   protected final val Connections: Int = 10 // > MaxConnections
   protected final val CallTimeout: FiniteDuration = 300.millis // << idle timeout
+  protected final val IdleTimout: FiniteDuration = CallTimeout * 100
 
-  implicit def scheduler: Scheduler = Scheduler.global
+  protected val impl: RestTestApi.Impl = new RestTestApi.Impl
 
-  private val impl: RestTestApi = RestTestApi.impl()
+  override protected def beforeEach(): Unit = {
+    super.beforeEach()
+    impl.resetCounter()
+  }
 
   final val serverHandle: RawRest.HandleRequest =
     RawRest.asHandleRequest[RestTestApi](impl)
@@ -41,9 +48,6 @@ abstract class RestApiTest extends AnyFunSuite with ScalaFutures {
     case arr: Array[_] => IArraySeq.empty[AnyRef] ++ arr.iterator.map(mkDeep)
     case _ => value
   }
-
-  def getNeverGetCounter(): Int = impl.neverGetCounter.get()
-  def resetNeverGetCounter(): Unit = impl.neverGetCounter.set(0)
 }
 
 trait RestApiTestScenarios extends RestApiTest {
@@ -107,24 +111,22 @@ trait RestApiTestScenarios extends RestApiTest {
   }
 
   test("close connection on monix task timeout") {
-    resetNeverGetCounter()
     Task
       .traverse(List.range(0, Connections))(_ => Task.deferFuture(proxy.neverGet).timeout(CallTimeout).failed)
-      .map(_ => assertResult(expected = Connections)(actual = getNeverGetCounter())) // neverGet should be called Connections times
+      .map(_ => assertResult(expected = Connections)(actual = impl.counterValue())) // neverGet should be called Connections times
       .runToFuture
       .futureValue
   }
 
   test("close connection on monix task cancellation") {
-    resetNeverGetCounter()
     Task
       .traverse(List.range(0, Connections)) { i =>
         val cancelable = Task.deferFuture(proxy.neverGet).runAsync(_ => ())
         Task.sleep(100.millis)
-          .restartUntil(_ => getNeverGetCounter() >= i)
+          .restartUntil(_ => impl.counterValue() >= i)
           .map(_ => cancelable.cancel())
       }
-      .map(_ => assertResult(expected = Connections)(actual = getNeverGetCounter())) // neverGet should be called Connections times
+      .map(_ => assertResult(expected = Connections)(actual = impl.counterValue())) // neverGet should be called Connections times
       .runToFuture
       .futureValue
   }

rest/src/test/scala/io/udash/rest/RestTestApi.scala

@@ -9,7 +9,7 @@ import com.avsystem.commons.serialization.json.JsonStringOutput
 import io.udash.rest.openapi.adjusters.*
 import io.udash.rest.openapi.{Header as OASHeader, *}
 import io.udash.rest.raw.*
-import monix.execution.atomic.Atomic
+import monix.execution.atomic.{Atomic, AtomicInt}
 import monix.execution.{FutureUtils, Scheduler}
 
 import scala.concurrent.Future
@@ -95,7 +95,6 @@ case class ErrorWrapper[T](error: T)
 object ErrorWrapper extends HasPolyGenCodec[ErrorWrapper]
 
 trait RestTestApi {
-  final val neverGetCounter = Atomic(0)
 
   @GET @group("TrivialGroup") def trivialGet: Future[Unit]
   @GET @group("TrivialDescribedGroup") @tagDescription("something") def failingGet: Future[Unit]
@@ -179,13 +178,13 @@ object RestTestApi extends DefaultRestApiCompanion[RestTestApi] {
 
   import Scheduler.Implicits.global
 
-  def impl(): RestTestApi = new RestTestApi {
+  final class Impl extends RestTestApi {
     def trivialGet: Future[Unit] = Future.unit
     def failingGet: Future[Unit] = Future.failed(HttpErrorException.plain(503, "nie"))
     def jsonFailingGet: Future[Unit] = Future.failed(HttpErrorException(503, HttpBody.json(JsonValue(JsonStringOutput.write(ErrorWrapper("nie"))))))
     def moreFailingGet: Future[Unit] = throw HttpErrorException.plain(503, "nie")
     def neverGet: Future[Unit] = {
-      neverGetCounter.transform(_ + 1)
+      counter.increment()
       Future.never
     }
     def wait(millis: Int): Future[String] = FutureUtils.delayedResult(millis.millis)(s"waited $millis ms")
@@ -209,6 +208,11 @@ object RestTestApi extends DefaultRestApiCompanion[RestTestApi] {
     def wrappedBinaryEcho(bytes: Bytes): Future[Bytes] = Future.successful(bytes)
     def wrappedBody(id: RestEntityId): Future[RestEntityId] = Future.successful(id)
     def thirdPartyBody(dur: HasThirdParty): Future[HasThirdParty] = Future.successful(dur)
+
+    /** Counter for neverGet calls */
+    private val counter: AtomicInt = Atomic(0)
+    def counterValue(): Int = counter.get()
+    def resetCounter(): Unit = counter.set(0)
   }
 }