Fix flaky Netty request-timeout metrics tests (#5381)

## Problem

The test `properly update metrics when a request times out` (in
`NettyFutureRequestTimeoutTests`, and its sync counterpart in
`NettySyncRequestTimeoutTests`) is flaky on CI, failing intermittently
with `1 was not equal to 0` at the `activeRequests.get() shouldBe 0`
assertion. It failed on three dependency-update PRs in the week of
2026-07-06 alone (runs for #5379, #5376 and #5373).

The root cause is a race in the test, not in production code: the
metrics are only decremented when the endpoint's logic completes, which
for the Future-based server happens ~1 second *after* the 503 timeout
response is received (the `Future` running the logic is not
interruptible). The test used a fixed `Thread.sleep(1100)`, leaving only
a ~100 ms margin before asserting — not enough on a loaded CI machine.
The sync test had an even tighter fixed `Thread.sleep(100)`.

## Fix

Replace the fixed sleeps with `eventually { ... }` and a widened
patience config (15 s timeout / 150 ms interval) — the same idiom
already used for the same reason in `ServerMetricsTest`. This asserts
eventual consistency instead of racing the asynchronous metrics update.
No production code is changed.

## Verification

Ran locally:
- `sbt "nettyServer/testOnly
sttp.tapir.server.netty.NettyFutureServerTest -- -z \"properly update
metrics\""` — passed
- `sbt "nettyServerSync3/testOnly
sttp.tapir.server.netty.sync.NettySyncServerTest -- -z \"properly update
metrics\""` — passed

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: adamw

server/netty-server/src/test/scala/sttp/tapir/server/netty/NettyFutureRequestTimeoutTests.scala

@@ -14,13 +14,21 @@ import cats.effect.kernel.Resource
 import scala.concurrent.ExecutionContext
 import sttp.client4._
 import sttp.capabilities.fs2.Fs2Streams
+import org.scalatest.concurrent.Eventually
+import org.scalatest.concurrent.Eventually.eventually
 import org.scalatest.matchers.should.Matchers._
 import cats.effect.unsafe.implicits.global
 import sttp.model.StatusCode
 
 class NettyFutureRequestTimeoutTests(eventLoopGroup: EventLoopGroup, backend: WebSocketStreamBackend[IO, Fs2Streams[IO]])(implicit
     ec: ExecutionContext
 ) {
+  // increase the patience for `eventually` for slow CI tests
+  implicit val patienceConfig: Eventually.PatienceConfig = Eventually.PatienceConfig(
+    timeout = org.scalatest.time.Span(15, org.scalatest.time.Seconds),
+    interval = org.scalatest.time.Span(150, org.scalatest.time.Millis)
+  )
+
   def tests(): List[Test] = List(
     Test("properly update metrics when a request times out") {
       val e = endpoint.post
@@ -68,10 +76,12 @@ class NettyFutureRequestTimeoutTests(eventLoopGroup: EventLoopGroup, backend: We
           basicRequest.post(uri"http://localhost:$port").body("test").send(backend).map { response =>
             response.body should matchPattern { case Left(_) => }
             response.code shouldBe StatusCode.ServiceUnavailable
-            // the metrics will only be updated when the endpoint's logic completes, which is 1 second after receiving the timeout response
-            Thread.sleep(1100)
-            activeRequests.get() shouldBe 0
-            totalRequests.get() shouldBe 1
+            // the metrics will only be updated when the endpoint's logic completes, which is ~1 second
+            // after receiving the timeout response (and possibly later on a loaded CI machine)
+            eventually {
+              activeRequests.get() shouldBe 0
+              totalRequests.get() shouldBe 1
+            }
           }
         }
         .unsafeToFuture()

server/netty-server/sync/src/test/scala/sttp/tapir/server/netty/sync/NettySyncRequestTimeoutTests.scala

@@ -3,6 +3,8 @@ package sttp.tapir.server.netty
 import cats.effect.IO
 import cats.effect.unsafe.implicits.global
 import io.netty.channel.EventLoopGroup
+import org.scalatest.concurrent.Eventually
+import org.scalatest.concurrent.Eventually.eventually
 import org.scalatest.matchers.should.Matchers.*
 import ox.*
 import sttp.capabilities.fs2.Fs2Streams
@@ -23,6 +25,12 @@ import org.slf4j.LoggerFactory
 class NettySyncRequestTimeoutTests(eventLoopGroup: EventLoopGroup, backend: WebSocketStreamBackend[IO, Fs2Streams[IO]]):
   val logger = LoggerFactory.getLogger(getClass.getName)
 
+  // increase the patience for `eventually` for slow CI tests
+  implicit val patienceConfig: Eventually.PatienceConfig = Eventually.PatienceConfig(
+    timeout = org.scalatest.time.Span(15, org.scalatest.time.Seconds),
+    interval = org.scalatest.time.Span(150, org.scalatest.time.Millis)
+  )
+
   def tests(): List[Test] = List(
     Test("properly update metrics when a request times out") {
       val e = endpoint.post
@@ -77,10 +85,12 @@ class NettySyncRequestTimeoutTests(eventLoopGroup: EventLoopGroup, backend: WebS
             .map: response =>
               response.body should matchPattern { case Left(_) => }
               response.code shouldBe StatusCode.ServiceUnavailable
-              // unlike in NettyFutureRequestTimeoutTest, here interruption works properly, and the metrics should be updated quickly
-              Thread.sleep(100)
-              activeRequests.get() shouldBe 0
-              totalRequests.get() shouldBe 1
+              // unlike in NettyFutureRequestTimeoutTest, here interruption works properly, and the metrics should be updated
+              // quickly; however, on a loaded CI machine this might still take some time
+              eventually {
+                activeRequests.get() shouldBe 0
+                totalRequests.get() shouldBe 1
+              }
             .unsafeRunSync()
     }
   )