curb 1.2.2 → 1.3.0

data/tests/tc_curl_native_coverage.rb

@@ -0,0 +1,130 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class TestCurbCurlErrorMappings < Test::Unit::TestCase
+  def assert_easy_error_mapping(code, expected_class)
+    actual_class, message = Curl::Easy.error(code)
+
+    assert_equal expected_class, actual_class
+    assert_kind_of String, message
+    assert_not_empty message
+  end
+
+  def test_easy_error_known_mappings
+    assert_easy_error_mapping(0, Curl::Err::CurlOK)
+    assert_easy_error_mapping(1, Curl::Err::UnsupportedProtocolError)
+    assert_easy_error_mapping(2, Curl::Err::FailedInitError)
+    assert_easy_error_mapping(3, Curl::Err::MalformedURLError)
+    assert_easy_error_mapping(5, Curl::Err::ProxyResolutionError)
+    assert_easy_error_mapping(6, Curl::Err::HostResolutionError)
+    assert_easy_error_mapping(7, Curl::Err::ConnectionFailedError)
+    assert_easy_error_mapping(23, Curl::Err::WriteError)
+    assert_easy_error_mapping(26, Curl::Err::ReadError)
+    assert_easy_error_mapping(28, Curl::Err::TimeoutError)
+    assert_easy_error_mapping(42, Curl::Err::AbortedByCallbackError)
+    assert_easy_error_mapping(47, Curl::Err::TooManyRedirectsError)
+    assert_easy_error_mapping(52, Curl::Err::GotNothingError)
+    assert_easy_error_mapping(55, Curl::Err::SendError)
+    assert_easy_error_mapping(56, Curl::Err::RecvError)
+    assert_easy_error_mapping(57, Curl::Err::ShareInUseError)
+    assert_easy_error_mapping(58, Curl::Err::SSLCertificateError)
+    assert_easy_error_mapping(59, Curl::Err::SSLCypherError)
+    assert_easy_error_mapping(61, Curl::Err::BadContentEncodingError)
+    assert_easy_error_mapping(63, Curl::Err::FileSizeExceededError)
+    assert_easy_error_mapping(64, Curl::Err::FTPSSLFailed)
+
+    ssl_peer_or_ca_error =
+      if Gem::Version.new(Curl::CURL_VERSION) >= Gem::Version.new('7.62.0')
+        Curl::Err::SSLPeerCertificateError
+      else
+        Curl::Err::SSLCACertificateError
+      end
+
+    assert_easy_error_mapping(60, ssl_peer_or_ca_error)
+  end
+
+  def test_easy_error_returns_error_info_for_known_numeric_range
+    0.upto(92) do |code|
+      error_class, message = Curl::Easy.error(code)
+
+      assert_kind_of Class, error_class
+      assert error_class <= Curl::Err::CurlError
+      assert_kind_of String, message
+      assert_not_empty message
+    end
+  end
+
+  def test_easy_error_uses_generic_mapping_for_unknown_codes
+    error_class, message = Curl::Easy.error(9_999)
+
+    assert_equal Curl::Err::CurlError, error_class
+    assert_equal 'Unknown error result from libcurl', message
+  end
+end
+
+class TestCurbCurlNativeCoverage < Test::Unit::TestCase
+  include TestServerMethods
+
+  def setup
+    server_setup
+  end
+
+  def test_clone_preserves_native_lists_after_original_handle_closes
+    easy = Curl::Easy.new("http://curb.invalid:#{TestServlet.port}#{TestServlet.path}")
+    easy.headers['X-Test'] = '1'
+    easy.proxy_headers['X-Proxy'] = '2'
+    easy.ftp_commands = ['PWD']
+    easy.resolve = ["curb.invalid:#{TestServlet.port}:127.0.0.1"]
+
+    clone = easy.clone
+    easy.close
+
+    clone.http_get
+
+    assert_equal 'GET', clone.body_str
+    assert_equal '1', clone.headers['X-Test']
+    assert_equal '2', clone.proxy_headers['X-Proxy']
+    assert_equal ['PWD'], clone.ftp_commands
+    assert_equal ["curb.invalid:#{TestServlet.port}:127.0.0.1"], clone.resolve
+  ensure
+    clone.close if defined?(clone) && clone
+    easy.close if defined?(easy) && easy
+  end
+
+  def test_native_accessors_round_trip
+    easy = Curl::Easy.new(TestServlet.url)
+
+    assert_equal '127.0.0.1', easy.interface = '127.0.0.1'
+    assert_equal 'user:pass', easy.userpwd = 'user:pass'
+    assert_equal 'proxy:pass', easy.proxypwd = 'proxy:pass'
+    assert_equal 'tests/cert.pem', easy.cert_key = 'tests/cert.pem'
+    assert_equal 'gzip', easy.encoding = 'gzip'
+
+    if easy.respond_to?(:max_send_speed_large=)
+      assert_equal 123, easy.max_send_speed_large = 123
+      assert_equal 123, easy.max_send_speed_large
+    end
+
+    if easy.respond_to?(:max_recv_speed_large=)
+      assert_equal 456, easy.max_recv_speed_large = 456
+      assert_equal 456, easy.max_recv_speed_large
+    end
+
+    assert_equal '127.0.0.1', easy.interface
+    assert_equal 'user:pass', easy.userpwd
+    assert_equal 'proxy:pass', easy.proxypwd
+    assert_equal 'tests/cert.pem', easy.cert_key
+    assert_equal 'gzip', easy.encoding
+  ensure
+    easy.close if defined?(easy) && easy
+  end
+
+  def test_upload_round_trips_stream_and_offset
+    upload = Curl::Upload.new
+    stream = StringIO.new('payload')
+
+    assert_same stream, upload.stream = stream
+    assert_same stream, upload.stream
+    assert_equal 7, upload.offset = 7
+    assert_equal 7, upload.offset
+  end
+end

data/tests/tc_curl_postfield.rb

@@ -142,3 +142,164 @@ class TestCurbCurlPostfield < Test::Unit::TestCase
     #assert_raise(Curl::Err::InvalidPostFieldError) { pf.to_s }
   end
 end
+
+class TestCurbCurlPostfieldNativeCoverage < Test::Unit::TestCase
+  def test_attribute_writers_round_trip
+    pf = Curl::PostField.content('foo', 'bar')
+
+    assert_equal 'renamed', pf.name = 'renamed'
+    assert_equal 'payload', pf.content = 'payload'
+    assert_equal 'text/plain', pf.content_type = 'text/plain'
+    assert_equal 'local.txt', pf.local_file = 'local.txt'
+    assert_equal 'remote.txt', pf.remote_file = 'remote.txt'
+
+    assert_equal 'renamed', pf.name
+    assert_equal 'payload', pf.content
+    assert_equal 'text/plain', pf.content_type
+    assert_equal 'local.txt', pf.local_file
+    assert_equal 'remote.txt', pf.remote_file
+  end
+
+  def test_to_s_accepts_non_string_name_via_to_s
+    name_like = Object.new
+    def name_like.to_s
+      'fancy name'
+    end
+
+    pf = Curl::PostField.content(name_like, 'value')
+    assert_equal 'fancy%20name=value', pf.to_s
+  end
+
+  def test_to_s_uses_remote_file_when_local_file_is_missing
+    pf = Curl::PostField.file('upload', 'local.txt', 'remote.txt')
+    pf.local_file = nil
+
+    assert_equal 'upload=remote.txt', pf.to_s
+  end
+
+  def test_to_s_rejects_name_without_to_s
+    name_like = Class.new do
+      undef to_s
+    end.new
+
+    pf = Curl::PostField.content(name_like, 'value')
+
+    error = assert_raise(Curl::Err::InvalidPostFieldError) { pf.to_s }
+    assert_match(/Cannot convert unnamed field to string/, error.message)
+  end
+
+  def test_to_s_rejects_content_without_to_s
+    content_like = Class.new do
+      undef to_s
+    end.new
+
+    pf = Curl::PostField.content('name', content_like)
+
+    error = assert_raise(RuntimeError) { pf.to_s }
+    assert_match(/does not respond_to to_s/, error.message)
+  end
+
+  def test_multipart_rejects_unnamed_field
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.multipart_form_post = true
+    pf = Curl::PostField.content('name', 'value')
+    pf.name = nil
+
+    error = assert_raise(Curl::Err::InvalidPostFieldError) { curl.http_post(pf) }
+    assert_match(/Cannot post unnamed field/, error.message)
+  end
+
+  def test_multipart_rejects_content_field_without_data
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.multipart_form_post = true
+    pf = Curl::PostField.content('name', 'value')
+    pf.content = nil
+
+    error = assert_raise(Curl::Err::InvalidPostFieldError) { curl.http_post(pf) }
+    assert_match(/Cannot post content field with no data/, error.message)
+  end
+
+  def test_multipart_rejects_file_field_without_filename
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.multipart_form_post = true
+    pf = Curl::PostField.file('upload', 'remote.txt') { 'payload' }
+    pf.local_file = 'dummy.txt'
+    pf.remote_file = nil
+
+    error = assert_raise(Curl::Err::InvalidPostFieldError) { curl.http_post(pf) }
+    assert_match(/Cannot post file upload field with no filename/, error.message)
+  end
+end
+
+class TestCurbCurlPostfieldMultipartCoverage < Test::Unit::TestCase
+  include TestServerMethods
+
+  def setup
+    server_setup
+  end
+
+  def test_multipart_content_variants_include_dynamic_and_typed_fields
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.multipart_form_post = true
+
+    proc_without_type = Curl::PostField.content('proc_without_type') { 'alpha' }
+    proc_with_type = Curl::PostField.content('proc_with_type', 'text/plain') { 'beta' }
+    direct_with_type = Curl::PostField.content('direct_with_type', 'gamma', 'text/plain')
+
+    curl.http_post([proc_without_type, proc_with_type, direct_with_type])
+    body = curl.body_str
+
+    assert_match(/name="proc_without_type"/, body)
+    assert_match(/alpha/, body)
+    assert_match(/name="proc_with_type"/, body)
+    assert_match(/beta/, body)
+    assert_match(/name="direct_with_type"/, body)
+    assert_match(/gamma/, body)
+    assert_match(/Content-Type: text\/plain/, body)
+  end
+
+  def test_multipart_file_variants_include_buffered_and_local_uploads
+    readme = File.expand_path(File.join(File.dirname(__FILE__), '..', 'README.md'))
+
+    proc_without_type = Curl::PostField.file('proc_without_type', 'proc_without_type.txt') { 'alpha' }
+    proc_with_type = Curl::PostField.file('proc_with_type', 'proc_with_type.txt') { 'beta' }
+    proc_with_type.content_type = 'text/plain'
+
+    direct_without_type = Curl::PostField.file('direct_without_type', 'ignored.txt', 'direct_without_type.txt')
+    direct_without_type.content = 'gamma'
+    direct_without_type.local_file = nil
+
+    direct_with_type = Curl::PostField.file('direct_with_type', 'ignored.txt', 'direct_with_type.txt')
+    direct_with_type.content = 'delta'
+    direct_with_type.local_file = nil
+    direct_with_type.content_type = 'text/plain'
+
+    local_with_type = Curl::PostField.file('local_with_type', readme)
+    local_with_type.content_type = 'text/plain'
+
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.multipart_form_post = true
+    curl.http_post([proc_without_type, proc_with_type, direct_without_type, direct_with_type, local_with_type])
+    body = curl.body_str
+
+    assert_match(/name="proc_without_type"/, body)
+    assert_match(/filename="proc_without_type.txt"/, body)
+    assert_match(/alpha/, body)
+
+    assert_match(/name="proc_with_type"/, body)
+    assert_match(/filename="proc_with_type.txt"/, body)
+    assert_match(/beta/, body)
+
+    assert_match(/name="direct_without_type"/, body)
+    assert_match(/filename="direct_without_type.txt"/, body)
+    assert_match(/gamma/, body)
+
+    assert_match(/name="direct_with_type"/, body)
+    assert_match(/filename="direct_with_type.txt"/, body)
+    assert_match(/delta/, body)
+
+    assert_match(/name="local_with_type"/, body)
+    assert_match(/Curb - Libcurl bindings for Ruby/, body)
+    assert_match(/Content-Type: text\/plain/, body)
+  end
+end

data/tests/tc_fiber_scheduler.rb

@@ -12,6 +12,51 @@ end
 # by running multiple requests concurrently in a single thread using the Async gem.
 class TestCurbFiberScheduler < Test::Unit::TestCase
   include BugTestServerSetupTeardown
+  include TestServerMethods
+
+  class RecordingScheduler
+    attr_reader :io_wait_events
+
+    def initialize
+      @io_wait_events = []
+    end
+
+    def fiber(&block)
+      Fiber.new(blocking: false, &block)
+    end
+
+    def io_wait(io, events, timeout = nil)
+      @io_wait_events << events
+      raise TypeError, "expected Integer events, got #{events.class}" unless events.is_a?(Integer)
+
+      readers = (events & IO::READABLE) != 0 ? [io] : nil
+      writers = (events & IO::WRITABLE) != 0 ? [io] : nil
+      readable, writable = IO.select(readers, writers, nil, timeout)
+
+      ready = 0
+      ready |= IO::READABLE if readable && !readable.empty?
+      ready |= IO::WRITABLE if writable && !writable.empty?
+      ready.zero? ? false : ready
+    end
+
+    def kernel_sleep(duration = nil)
+      sleep(duration || 0)
+    end
+
+    def block(_blocker, timeout = nil)
+      sleep(timeout || 0)
+      false
+    end
+
+    def unblock(*)
+    end
+
+    def close
+    end
+
+    def fiber_interrupt(*)
+    end
+  end
 
   ITERS = 4
   MIN_S = 0.25
@@ -50,6 +95,8 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
         m.add(c)
       end
       m.perform
+    ensure
+      m.close if m
     end
 
     duration = Time.now - started
@@ -109,6 +156,8 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
       m.perform do
         yielded += 1
       end
+    ensure
+      m.close if m
     end
 
     assert_operator yielded, :>=, 1, 'perform did not yield block while waiting under scheduler'
@@ -130,20 +179,49 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
       c.on_complete { result = c.code }
       m.add(c)
       m.perform
+    ensure
+      m.close if m
     end
 
     assert_equal 200, result
   end
 
+  def test_multi_single_request_socket_perform_passes_integer_events_to_io_wait
+    omit('Skipping custom scheduler test on Windows') if WINDOWS
+    omit('Fiber scheduler API unavailable on this Ruby') unless fiber_scheduler_supported?
+
+    url = "http://127.0.0.1:#{@port}/test"
+    scheduler = RecordingScheduler.new
+    result = nil
+
+    with_scheduler(scheduler) do
+      m = Curl::Multi.new
+      c = Curl::Easy.new(url)
+      c.on_complete { result = c.code }
+      m.add(c)
+      unless m.respond_to?(:_socket_perform, true)
+        omit('socket-action perform path is not available in this build')
+      end
+      m.send(:_socket_perform)
+    ensure
+      m.close if m
+    end
+
+    assert_equal 200, result
+    assert_operator scheduler.io_wait_events.length, :>=, 1
+    assert scheduler.io_wait_events.all? { |events| events.is_a?(Integer) }
+    assert scheduler.io_wait_events.any? { |events| (events & (IO::READABLE | IO::WRITABLE)) != 0 }
+  end
+
   def test_multi_reuse_after_scheduler_perform
     unless HAS_ASYNC
       warn 'Skipping fiber scheduler test (Async gem not available)'
       return
     end
-
+  
     url = "http://127.0.0.1:#{@port}/test"
     results = []
-
+  
     async_run do
       m = Curl::Multi.new
       # First round
@@ -151,15 +229,224 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
       c1.on_complete { results << c1.code }
       m.add(c1)
       m.perform
-
+  
       # Second round on same multi
       c2 = Curl::Easy.new(url)
       c2.on_complete { results << c2.code }
       m.add(c2)
       m.perform
+    ensure
+      m.close if m
     end
+  
+    assert_equal [200, 200], results
+  end
 
+  def test_easy_perform_reuses_scheduler_multi_when_autoclose_is_enabled
+    if skip_no_async
+      return
+    end
+  
+    url = "http://127.0.0.1:#{@port}/test"
+    results = []
+    previous_autoclose = Curl::Multi.autoclose
+    Curl::Multi.autoclose = true
+  
+    async_run do
+      2.times do
+        easy = Curl::Easy.new(url)
+        easy.perform
+        results << easy.code
+      end
+    end
+  
     assert_equal [200, 200], results
+  ensure
+    Curl::Multi.autoclose = previous_autoclose if defined?(previous_autoclose)
+    cleanup_scheduler_state
+  end
+
+  def test_easy_perform_reraises_on_body_exception_under_scheduler
+    if skip_no_async
+      return
+    end
+  
+    url = "http://127.0.0.1:#{@port}/test"
+  
+    async_run do |top|
+      task = top.async do
+        c = Curl::Easy.new(url)
+        c.on_body { raise "body blew up" }
+        c.on_complete { sleep 0 }
+        c.perform
+      end
+  
+      error = assert_raise(RuntimeError) do
+        task.wait
+      end
+  
+      assert_equal "body blew up", error.message
+    end
+  end
+
+  def test_easy_perform_reraises_on_header_exception_under_scheduler
+    if skip_no_async
+      return
+    end
+
+    url = "http://127.0.0.1:#{@port}/test"
+
+    async_run do |top|
+      task = top.async do
+        c = Curl::Easy.new(url)
+        c.on_header { raise "header blew up" }
+        c.on_complete { sleep 0 }
+        c.perform
+      end
+
+      error = assert_raise(RuntimeError) do
+        task.wait
+      end
+
+      assert_equal "header blew up", error.message
+    end
+  end
+
+  def test_easy_perform_does_not_reraise_sibling_on_complete_exception_under_scheduler
+    if skip_no_async
+      return
+    end
+
+    with_ephemeral_http_server do |port, hits|
+      results = {}
+
+      async_run do |top|
+        successful = top.async do
+          easy = Curl::Easy.new("http://127.0.0.1:#{port}/fast")
+          easy.perform
+          results[:successful] = easy.response_code
+        rescue => e
+          results[:successful] = e
+        end
+
+        failing = top.async do
+          easy = Curl::Easy.new("http://127.0.0.1:#{port}/slow")
+          easy.on_complete { raise "boom" }
+          easy.perform
+          results[:failing] = :returned
+        rescue => e
+          results[:failing] = e
+        end
+
+        successful.wait
+        failing.wait
+      end
+
+      assert_equal 200, results[:successful], "successful scheduler peer should return normally"
+      assert_kind_of Curl::Err::AbortedByCallbackError, results[:failing]
+      assert_equal "boom", results[:failing].message
+      assert_equal 1, hits[:fast]
+      assert_equal 1, hits[:slow]
+    end
+  end
+
+  def test_easy_perform_does_not_reraise_fast_on_complete_exception_into_slow_successful_peer_under_scheduler
+    if skip_no_async
+      return
+    end
+
+    with_ephemeral_http_server do |port, hits|
+      results = {}
+
+      async_run do |top|
+        failing = top.async do
+          easy = Curl::Easy.new("http://127.0.0.1:#{port}/fast")
+          easy.on_complete { raise "boom" }
+          easy.perform
+          results[:failing] = :returned
+        rescue => e
+          results[:failing] = e
+        end
+
+        successful = top.async do
+          easy = Curl::Easy.new("http://127.0.0.1:#{port}/slow")
+          easy.perform
+          results[:successful] = easy.response_code
+        rescue => e
+          results[:successful] = e
+        end
+
+        failing.wait
+        successful.wait
+      end
+
+      assert_equal 200, results[:successful], "slow successful scheduler peer should not inherit a fast sibling callback error"
+      assert_kind_of Curl::Err::AbortedByCallbackError, results[:failing]
+      assert_equal "boom", results[:failing].message
+      assert_equal 1, hits[:fast]
+      assert_equal 1, hits[:slow]
+    end
+  end
+
+  def test_easy_perform_keeps_scheduler_timers_running_while_draining_deferred_on_complete_exception
+    if skip_no_async
+      return
+    end
+
+    with_ephemeral_http_server do |port, hits|
+      marks = {}
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      async_run do |top|
+        timer = top.async do
+          sleep 0.05
+          marks[:timer] = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+        end
+
+        failing = top.async do
+          easy = Curl::Easy.new("http://127.0.0.1:#{port}/fast")
+          easy.on_complete { raise "boom" }
+          easy.perform
+          marks[:failing] = :returned
+        rescue => e
+          marks[:failing] = e
+        end
+
+        successful = top.async do
+          easy = Curl::Easy.new("http://127.0.0.1:#{port}/slow")
+          easy.perform
+          marks[:slow_done] = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+        end
+
+        timer.wait
+        failing.wait
+        successful.wait
+      end
+
+      assert_kind_of Curl::Err::AbortedByCallbackError, marks[:failing]
+      assert_operator marks[:timer], :<, marks[:slow_done] - 0.02,
+                      "scheduler timer should fire before the slow sibling finishes draining"
+      assert_equal 1, hits[:fast]
+      assert_equal 1, hits[:slow]
+    end
+  end
+
+  def test_drain_scheduler_pending_does_not_drop_work_rejected_during_deferred_abort
+    state = Curl.scheduler_state
+    easy = Curl::Easy.new("http://127.0.0.1:#{@port}/test")
+    waiter = {completed: false, done: false, error: nil}
+
+    state[:waiters][easy.object_id] = waiter
+    state[:pending] << easy
+    state[:multi].instance_variable_set(:@__curb_deferred_exception, RuntimeError.new("boom"))
+
+    Curl.drain_scheduler_pending(state)
+
+    assert(state[:pending].include?(easy) || waiter[:error],
+           "scheduler enqueue rejected during deferred abort should remain pending or fail its waiter instead of disappearing")
+    assert_equal 0, state[:multi].requests.length
+  ensure
+    cleanup_scheduler_state
   end
 
   private
@@ -168,6 +455,10 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
       warn 'Skipping fiber scheduler tests on Windows'
       return true
     end
+    unless fiber_scheduler_supported?
+      warn 'Skipping fiber scheduler tests (Fiber scheduler API unavailable)'
+      return true
+    end
     unless HAS_ASYNC
       warn 'Skipping fiber scheduler test (Async gem not available)'
       return true
@@ -183,8 +474,52 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
       Async(&block)
     end
   end
-end
-if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.1')
-  warn 'Skipping fiber scheduler tests on Ruby < 3.1'
-  return
+
+  def fiber_scheduler_supported?
+    Fiber.respond_to?(:set_scheduler) && Fiber.respond_to?(:schedule)
+  end
+
+  def with_scheduler(scheduler)
+    previous_scheduler = Fiber.scheduler if Fiber.respond_to?(:scheduler)
+    Fiber.set_scheduler(scheduler)
+    fiber = Fiber.schedule { yield }
+    fiber.resume while fiber.alive?
+  ensure
+    Fiber.set_scheduler(previous_scheduler) if Fiber.respond_to?(:set_scheduler)
+  end
+
+  def cleanup_scheduler_state
+    state = Thread.current.thread_variable_get(:curb_scheduler_state)
+    state[:multi].close if state && state[:multi]
+    Thread.current.thread_variable_set(:curb_scheduler_state, nil)
+  end
+
+  def with_ephemeral_http_server
+    port_socket = TCPServer.new('127.0.0.1', 0)
+    port = port_socket.addr[1]
+    port_socket.close
+
+    hits = Hash.new(0)
+    server = WEBrick::HTTPServer.new(:Port => port, :Logger => WEBRICK_TEST_LOG, :AccessLog => [])
+    server.mount_proc('/fast') do |_req, res|
+      hits[:fast] += 1
+      res['Content-Type'] = 'text/plain'
+      res.body = 'fast'
+    end
+    server.mount_proc('/slow') do |_req, res|
+      hits[:slow] += 1
+      res['Content-Type'] = 'text/plain'
+      sleep 0.2
+      res.body = 'slow'
+    end
+
+    server_thread = Thread.new(server) { |srv| srv.start }
+    wait_for_server_ready(port, thread: server_thread)
+
+    yield port, hits
+  ensure
+    server.shutdown if defined?(server) && server
+    server_thread.join(server_startup_timeout) if defined?(server_thread) && server_thread
+    server_thread.kill if defined?(server_thread) && server_thread&.alive?
+  end
 end