curb 1.3.7 → 1.4.1

data/tests/tc_curl_network_policy.rb

@@ -12,6 +12,110 @@ class TestCurbCurlNetworkPolicy < Test::Unit::TestCase
     super
   end
 
+  def test_safe_bang_defaults_to_public_network_policy
+    assert_equal :public, Curl::SafetyConfig.new.network_policy
+    require_public_network_policy!
+    Curl.safe!
+
+    assert_raise(Curl::Err::UnsafeDestinationError) { Curl.get(TestServlet.url) }
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.network_policy = :none
+    assert_raise(Curl::Err::UnsafeDestinationError) { easy.perform }
+    assert_equal :public, easy.network_policy
+  end
+
+  def test_safe_bang_default_blocks_private_and_metadata_destinations
+    require_public_network_policy!
+    Curl.safe!
+    ['10.0.0.1', '172.16.0.1', '192.168.0.1', '169.254.169.254', '[::1]'].each do |host|
+      assert_raise(Curl::Err::UnsafeDestinationError, host) do
+        Curl.get("http://#{host}/") do |easy|
+          easy.network_policy = :none
+          easy.connect_timeout_ms = 100
+          easy.timeout_ms = 200
+        end
+      end
+    end
+  end
+
+  def test_safe_bang_default_applies_to_previously_added_multi_handles
+    require_public_network_policy!
+    easy = Curl::Easy.new(TestServlet.url)
+    multi = Curl::Multi.new
+    multi.add(easy)
+    Curl.safe!
+    multi.perform
+
+    assert_equal :public, easy.network_policy
+    assert_match(/127\.0\.0\.1/, easy.unsafe_destination_error)
+  ensure
+    multi.close if multi
+  end
+
+  def test_safe_helpers_block_loopback_without_global_policy
+    require_public_network_policy!
+    [:get, :post, :put, :delete, :patch, :head, :options].each do |verb|
+      assert_raise(Curl::Err::UnsafeDestinationError, verb.to_s) do
+        Curl.public_send("safe_#{verb}", TestServlet.url) do |easy|
+          easy.network_policy = :none
+        end
+      end
+    end
+  end
+
+  def test_safe_http_reapplies_public_policy_before_perform
+    require_public_network_policy!
+    easy = Curl::Easy.new(TestServlet.url)
+    assert_same easy, easy.safe_http!
+    assert_equal :public, easy.network_policy
+    easy.network_policy = :none
+
+    assert_raise(Curl::Err::UnsafeDestinationError) { easy.perform }
+  end
+
+  def test_safe_http_cannot_be_weakened_by_global_policy
+    require_public_network_policy!
+    Curl.safe! { |config| config.network_policy = :none }
+
+    assert_raise(Curl::Err::UnsafeDestinationError) { Curl.safe_get(TestServlet.url) }
+  end
+
+  def test_safe_helpers_block_private_and_metadata_destinations
+    require_public_network_policy!
+    ['10.0.0.1', '172.16.0.1', '192.168.0.1', '169.254.169.254', '[::1]'].each do |host|
+      assert_raise(Curl::Err::UnsafeDestinationError, host) do
+        Curl.safe_get("http://#{host}/") do |easy|
+          easy.connect_timeout_ms = 100
+          easy.timeout_ms = 200
+        end
+      end
+    end
+  end
+
+  def test_safe_http_rejects_resolve_override_without_global_policy
+    require_public_network_policy!
+    assert_raise(Curl::Err::UnsafeDestinationError) do
+      Curl.safe_get('http://example.invalid/') do |easy|
+        easy.resolve = ['example.invalid:80:127.0.0.1']
+      end
+    end
+  end
+
+  def test_safe_http_applies_to_multi
+    require_public_network_policy!
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.safe_http!
+    easy.network_policy = :none
+    multi = Curl::Multi.new
+    multi.add(easy)
+    multi.perform
+
+    assert_equal :public, easy.network_policy
+    assert_match(/127\.0\.0\.1/, easy.unsafe_destination_error)
+  ensure
+    multi.close if multi
+  end
+
   def test_network_policy_defaults_to_none
     easy = Curl::Easy.new
 
@@ -95,6 +199,7 @@ class TestCurbCurlNetworkPolicy < Test::Unit::TestCase
 
     with_host_redirect_server(allowed_host, allowed_host) do |port, hits|
       Curl.safe! do |config|
+        config.network_policy = :none # Isolate host filtering from peer filtering.
         config.allowed_hosts = [allowed_host]
       end
 
@@ -119,6 +224,7 @@ class TestCurbCurlNetworkPolicy < Test::Unit::TestCase
 
     with_host_redirect_server(allowed_host, blocked_host) do |port, hits|
       Curl.safe! do |config|
+        config.network_policy = :none # Isolate host filtering from peer filtering.
         config.allowed_hosts = [allowed_host]
       end
 
@@ -142,6 +248,7 @@ class TestCurbCurlNetworkPolicy < Test::Unit::TestCase
 
   def test_safe_bang_allowed_cidrs_requires_public_network_policy
     Curl.safe! do |config|
+      config.network_policy = :none # Isolate the host/CIDR policy from peer filtering.
       config.allowed_cidrs = ['1.1.1.0/24']
     end
 
@@ -1080,7 +1187,7 @@ class TestCurbCurlNetworkPolicy < Test::Unit::TestCase
       multi = Curl::Multi.new
 
       multi.add(easy)
-      Curl.safe!
+      Curl.safe! { |config| config.network_policy = :none }
       multi.perform
 
       assert_equal [['1']], request_headers

data/tests/tc_curl_postfield.rb

@@ -253,6 +253,143 @@ class TestCurbCurlPostfieldMultipartCoverage < Test::Unit::TestCase
     server_setup
   end
 
+  [:http_post, :http_patch, :http_put].each do |method|
+    [:close, :reset, :initialize, :perform, :http_post, :post_body=].each do |operation|
+      [:proc, :coercion].each do |source|
+        define_method("test_#{method}_guards_#{operation}_from_#{source}") do
+          curl = Curl::Easy.new(TestServlet.url)
+          curl.multipart_form_post = true
+          action = lambda do |*_|
+            if operation == :post_body=
+              curl.post_body = 'replacement'
+            elsif operation == :http_post
+              curl.http_post(Curl::PostField.content('nested', 'payload'))
+            else
+              curl.__send__(operation)
+            end
+            'payload'
+          end
+          field = if source == :proc
+            Curl::PostField.content('trigger', &action)
+          else
+            value = Object.new
+            value.define_singleton_method(:to_str, &action)
+            Curl::PostField.content('trigger', value)
+          end
+
+          error = assert_raise(RuntimeError) do
+            curl.__send__(method, Curl::PostField.content('first', 'allocated'), field)
+          end
+          assert_match(/active curl handle/, error.message)
+
+          # Both partial forms and guards must unwind before reuse.
+          curl.multipart_form_post = false
+          curl.perform
+          assert_equal 'GET', curl.body_str
+          assert_nothing_raised { curl.reset }
+          assert_nothing_raised { curl.close }
+        end
+      end
+    end
+  end
+
+  [:content, :file].each do |kind|
+    [false, true].each do |dynamic|
+      define_method("test_multipart_snapshots_#{kind}_#{dynamic ? 'proc' : 'direct'}") do
+        name = +'original_name'
+        payload = +"original\0payload"
+        field = multipart_field(kind, dynamic, nil, payload)
+        field.name = name
+        later = Curl::PostField.content('later') do
+          Thread.new do
+            name.replace('changed_name' * 1000)
+            payload.replace('changed_payload' * 1000)
+            field.content = nil
+            field.name = nil
+            GC.start
+            GC.verify_compaction_references(double_heap: true, toward: :empty) if GC.respond_to?(:verify_compaction_references)
+          end.join
+          'later_value'
+        end
+        curl = Curl::Easy.new(TestServlet.url)
+        curl.multipart_form_post = true
+        curl.http_post(field, later)
+
+        assert_include curl.body_str, 'name="original_name"'
+        assert_include curl.body_str, "original\0payload"
+        assert_include curl.body_str, 'filename="remote.txt"' if kind == :file
+        assert_not_include curl.body_str, 'changed_payload'
+      end
+    end
+  end
+
+  def test_multipart_snapshots_before_later_coercions_in_same_field
+    name = +'original_name'
+    payload = +'original_payload'
+    content_type = Object.new
+    content_type.define_singleton_method(:to_str) do
+      name.replace('changed_name' * 1000)
+      payload.replace('changed_payload' * 1000)
+      'text/plain'
+    end
+    field = Curl::PostField.content(name, payload, content_type)
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.multipart_form_post = true
+    curl.http_post(field)
+
+    assert_include curl.body_str, 'name="original_name"'
+    assert_include curl.body_str, 'original_payload'
+  end
+
+  # Exercise each pointer/length pair with and without a content type.
+  [:content, :file].each do |kind|
+    [false, true].each do |dynamic|
+      [nil, 'text/plain'].each do |content_type|
+        variant = "#{kind}_#{dynamic ? 'proc' : 'direct'}_#{content_type ? 'typed' : 'untyped'}"
+
+        define_method("test_multipart_coerces_#{variant}") do
+          payload = "before\0after"
+          string_like = Object.new
+          string_like.define_singleton_method(:to_str) { payload }
+          field = multipart_field(kind, dynamic, content_type, string_like)
+          curl = Curl::Easy.new(TestServlet.url)
+          curl.multipart_form_post = true
+
+          curl.http_post(field)
+
+          assert_include curl.body_str, payload
+          assert_equal payload, field.content unless dynamic
+        end
+
+        define_method("test_multipart_rejects_non_string_#{variant}") do
+          field = multipart_field(kind, dynamic, content_type, 5)
+          curl = Curl::Easy.new(TestServlet.url)
+          curl.multipart_form_post = true
+
+          assert_raise(TypeError) { curl.http_post(field) }
+        end
+      end
+    end
+  end
+
+  def multipart_field(kind, dynamic, content_type, value)
+    field = if dynamic
+      if kind == :file
+        Curl::PostField.file('upload', 'remote.txt') { value }
+      else
+        Curl::PostField.content('value') { value }
+      end
+    elsif kind == :file
+      upload = Curl::PostField.file('upload', 'remote.txt')
+      upload.content = value
+      upload
+    else
+      Curl::PostField.content('value', value)
+    end
+    field.content_type = content_type
+    field
+  end
+
   def test_multipart_content_variants_include_dynamic_and_typed_fields
     curl = Curl::Easy.new(TestServlet.url)
     curl.multipart_form_post = true
@@ -318,3 +455,42 @@ class TestCurbCurlPostfieldMultipartCoverage < Test::Unit::TestCase
     assert_match(/Content-Type: text\/plain/, body)
   end
 end
+
+class TestCurbCurlPostfieldInvalidToS < Test::Unit::TestCase
+  class BadToS
+    def to_s
+      42
+    end
+  end
+
+  def test_to_s_with_non_string_content_to_s_result_does_not_crash
+    pf = Curl::PostField.content('name', BadToS.new)
+    body = nil
+    assert_nothing_raised { body = pf.to_s }
+    assert_kind_of String, body
+    assert body.start_with?('name=')
+  end
+
+  def test_to_s_with_non_string_name_to_s_result_does_not_crash
+    pf = Curl::PostField.content(BadToS.new, 'value')
+    body = nil
+    assert_nothing_raised { body = pf.to_s }
+    assert_kind_of String, body
+  end
+
+  def test_to_s_with_content_proc_returning_non_string_does_not_crash
+    pf = Curl::PostField.content('name') { BadToS.new }
+    assert_nothing_raised { pf.to_s }
+  end
+
+  def test_to_s_content_proc_raising_error_still_propagates
+    pf = Curl::PostField.content('name') { raise 'boom' }
+    error = assert_raise(RuntimeError) { pf.to_s }
+    assert_equal 'boom', error.message
+  end
+
+  def test_to_s_still_coerces_objects_with_valid_to_s
+    pf = Curl::PostField.content('name', 42)
+    assert_equal 'name=42', pf.to_s
+  end
+end

data/tests/tc_curl_protocols.rb

@@ -104,11 +104,10 @@ class TestCurbCurlProtocols < Test::Unit::TestCase
     end
   end
 
-  def test_safe_get_allows_http_protocol
-    easy = Curl.safe_get(TestServlet.url)
-
-    assert_equal 200, easy.response_code
-    assert_match(/GET/, easy.body_str)
+  def test_safe_get_blocks_local_http_destination
+    assert_raise(Curl::Err::UnsafeDestinationError) do
+      Curl.safe_get(TestServlet.url)
+    end
   end
 
   def test_safe_bang_denies_file_protocol_for_easy_perform
@@ -159,8 +158,8 @@ class TestCurbCurlProtocols < Test::Unit::TestCase
     end
   end
 
-  def test_safe_bang_allows_http_protocol
-    Curl.safe!
+  def test_safe_bang_explicit_none_allows_trusted_http_destination
+    Curl.safe! { |config| config.network_policy = :none }
     easy = Curl.get(TestServlet.url)
 
     assert_equal 200, easy.response_code
@@ -184,6 +183,7 @@ class TestCurbCurlProtocols < Test::Unit::TestCase
     with_file_redirect_server do |url|
       easy = Curl::Easy.new(url)
       easy.follow_location = true
+      stub_public_network_policy_for_local_fixture(easy)
       easy.safe_http!
 
       assert_raises Curl::Err::UnsupportedProtocolError do
@@ -198,6 +198,7 @@ class TestCurbCurlProtocols < Test::Unit::TestCase
 
       easy = Curl::Easy.new(url)
       easy.follow_location = true
+      stub_public_network_policy_for_local_fixture(easy)
 
       assert_raises Curl::Err::UnsupportedProtocolError do
         easy.perform
@@ -211,6 +212,7 @@ class TestCurbCurlProtocols < Test::Unit::TestCase
       easy.follow_location = true
       easy.ssl_verify_peer = false
       easy.ssl_verify_host = false
+      stub_public_network_policy_for_local_fixture(easy)
       easy.safe_http!
 
       easy.perform
@@ -226,6 +228,7 @@ class TestCurbCurlProtocols < Test::Unit::TestCase
       easy.follow_location = true
       easy.ssl_verify_peer = false
       easy.ssl_verify_host = false
+      stub_public_network_policy_for_local_fixture(easy)
       easy.safe_http!
 
       easy.perform
@@ -240,6 +243,7 @@ class TestCurbCurlProtocols < Test::Unit::TestCase
       easy = Curl::Easy.new(url)
       easy.follow_location = true
       easy.max_redirects = 2
+      stub_public_network_policy_for_local_fixture(easy)
       easy.safe_http!
 
       assert_raises Curl::Err::TooManyRedirectsError do
@@ -252,6 +256,14 @@ class TestCurbCurlProtocols < Test::Unit::TestCase
 
   private
 
+  # Isolate protocol/redirect behavior using local fixtures. Destination blocking
+  # is exercised without this stub in tc_curl_network_policy.rb.
+  def stub_public_network_policy_for_local_fixture(easy)
+    def easy.network_policy=(policy)
+      raise "unexpected policy: #{policy}" unless policy == :public
+    end
+  end
+
   def with_file_redirect_server
     port_socket = TCPServer.new('127.0.0.1', 0)
     port = port_socket.addr[1]

data/tests/tc_curl_transfer_guard.rb

@@ -0,0 +1,112 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class TestCurbTransferGuard < Test::Unit::TestCase
+  class InterruptedTransfer < StandardError; end
+
+  [:perform, :_socket_perform].each do |drive|
+    define_method("test_#{drive}_rejects_cross_thread_handle_access") do
+      with_waiting_transfer(drive) do |easy, multi, worker, release|
+        operations = {
+          close: -> { easy.close },
+          reset: -> { easy.reset },
+          initialize: -> { easy.__send__(:initialize) },
+          clone: -> { easy.clone },
+          dup: -> { easy.dup },
+          setopt: -> { easy.setopt(Curl::CURLOPT_CUSTOMREQUEST, 'DELETE') },
+          post_body: -> { easy.post_body = 'replacement' },
+          url: -> { easy.url = 'http://127.0.0.1/' },
+          timeout: -> { easy.timeout = 1 },
+          multi_assignment: -> { easy.multi = nil },
+          multi_remove: -> { multi.remove(easy) },
+          multi_close: -> { multi.close },
+          multi_initialize: -> { multi.__send__(:initialize) },
+          multi_add: -> { multi.add(Curl::Easy.new('http://127.0.0.1/')) },
+          multi_option: -> { multi.max_connects = 1 }
+        }
+        operations.each do |name, operation|
+          error = assert_raise(RuntimeError, name.to_s, &operation)
+          assert_match(/another thread|active Curl::Multi/, error.message, name.to_s)
+        end
+        assert_equal [easy], multi.requests.values
+
+        release << true
+        assert worker.join(5), 'perform did not finish'
+        worker.value
+        assert_equal 'ok', easy.body_str
+        assert_nothing_raised { easy.clone.close }
+        assert_nothing_raised { easy.reset }
+        assert_nothing_raised { easy.close }
+      end
+    end
+
+    define_method("test_#{drive}_releases_guard_after_interruption") do
+      with_waiting_transfer(drive) do |easy, multi, worker, release|
+        worker.raise(InterruptedTransfer, 'stop')
+        assert worker.join(5), 'interrupted perform did not finish'
+        assert_kind_of InterruptedTransfer, worker[:transfer_error]
+        assert_nothing_raised { multi.remove(easy) }
+        assert_nothing_raised { easy.reset }
+        assert_nothing_raised { easy.close }
+        release << true
+      end
+    end
+  end
+
+  def with_waiting_transfer(drive)
+    if drive == :_socket_perform && !Curl::Multi.private_method_defined?(drive)
+      omit('socket-action perform path is not available')
+    end
+    server = TCPServer.new('127.0.0.1', 0)
+    started = Queue.new
+    release = Queue.new
+    server_thread = Thread.new do
+      socket = server.accept
+      begin
+        request = +''
+        request << socket.readpartial(4096) until request.include?("\r\n\r\n")
+        started << true
+        release.pop
+        socket.write("HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok")
+      rescue Errno::EPIPE, Errno::ECONNRESET
+        # The interruption test intentionally closes the connection early.
+      ensure
+        socket.close
+      end
+    end
+    easy = Curl::Easy.new("http://127.0.0.1:#{server.addr[1]}/")
+    multi = Curl::Multi.new
+    # Exercise reuse after autoclose as well as the active-transfer checks.
+    previous_autoclose = Curl::Multi.autoclose
+    begin
+      Curl::Multi.autoclose = true
+      multi.add(Curl::Easy.new($TEST_URL))
+      multi.perform
+    ensure
+      Curl::Multi.autoclose = previous_autoclose
+    end
+    multi.add(easy)
+    worker = Thread.new do
+      Thread.current.report_on_exception = false if Thread.current.respond_to?(:report_on_exception=)
+      begin
+        multi.__send__(drive)
+      rescue InterruptedTransfer => error
+        # Keep join non-raising so the test can inspect the exception explicitly.
+        Thread.current[:transfer_error] = error
+      end
+    end
+    Timeout.timeout(5) { started.pop }
+    yield easy, multi, worker, release
+  ensure
+    release << true if release
+    if worker && worker.alive?
+      worker.kill
+      worker.join(5)
+    end
+    multi.close if multi
+    server.close if server && !server.closed?
+    if server_thread
+      server_thread.join(5)
+      server_thread.kill if server_thread.alive?
+    end
+  end
+end

data/tests/tc_fiber_scheduler.rb

@@ -118,7 +118,7 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
 
     duration = Time.now - started
 
-    assert duration < THRESHOLD, "Requests did not run concurrently under fiber scheduler (#{duration}s) which exceeds the expected threshold of: #{THRESHOLD} serial time would be about: #{SERIAL_TIME_WOULD_BE_ABOUT}"
+    assert_ran_concurrently(duration)
     assert_equal ITERS, results.size
     assert_equal ITERS.times.map {200}, results
   end
@@ -149,7 +149,7 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
 
     duration = Time.now - started
 
-    assert duration < THRESHOLD, "Requests did not run concurrently under fiber scheduler (#{duration}s) which exceeds the expected threshold of: #{THRESHOLD} serial time would be about: #{SERIAL_TIME_WOULD_BE_ABOUT}"
+    assert_ran_concurrently(duration)
     assert_equal ITERS, results.size
     assert_equal ITERS.times.map {200}, results
   end
@@ -734,6 +734,97 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
     end
   end
 
+  # Records unblock calls in place of a real scheduler.
+  class UnblockRecorder
+    attr_reader :unblocked
+
+    def initialize
+      @unblocked = []
+    end
+
+    def unblock(blocker, _fiber)
+      @unblocked << blocker
+    end
+  end
+
+  # Enumerating every waiter on every drive-loop pass made release cost
+  # O(waiters) per pass; only the queued completions should be visited.
+  class NonEnumerableWaiters < Hash
+    %i[each each_pair each_value each_key].each do |name|
+      define_method(name) { |*| raise 'release_scheduler_waiters must not enumerate all waiters' }
+    end
+  end
+
+  def scheduler_test_waiter(scheduler)
+    {completed: true, done: false, error: nil, fiber: Fiber.new {}, scheduler: scheduler}
+  end
+
+  def test_release_scheduler_waiters_visits_only_queued_completions
+    state = Curl.scheduler_state
+    recorder = UnblockRecorder.new
+    waiters = NonEnumerableWaiters.new
+    1_000.times { |i| waiters[i] = scheduler_test_waiter(recorder).merge(completed: false) }
+    finished = scheduler_test_waiter(recorder)
+    waiters[:finished] = finished
+    state[:waiters] = waiters
+    state[:completed] << [:finished, finished]
+
+    Curl.release_scheduler_waiters(state)
+
+    assert_equal [finished], recorder.unblocked
+    assert finished[:done]
+    assert_empty state[:completed]
+  ensure
+    cleanup_scheduler_state
+  end
+
+  # A waiter whose perform already returned (it raised) is unregistered and its
+  # fiber may be blocked on something else, so a late completion must not
+  # unblock it.
+  def test_release_scheduler_waiters_skips_unregistered_waiter
+    state = Curl.scheduler_state
+    recorder = UnblockRecorder.new
+    stale = scheduler_test_waiter(recorder)
+    state[:completed] << [:stale, stale]
+
+    Curl.release_scheduler_waiters(state)
+
+    assert_empty recorder.unblocked
+    assert_equal false, stale[:done]
+    assert_empty state[:completed]
+  ensure
+    cleanup_scheduler_state
+  end
+
+  # The transfer whose callback raised the deferred exception receives that
+  # error rather than a normal completion; it stays queued so it is completed
+  # normally if the exception source changes.
+  def test_release_scheduler_waiters_holds_back_deferred_exception_source
+    state = Curl.scheduler_state
+    recorder = UnblockRecorder.new
+    source = scheduler_test_waiter(recorder)
+    sibling = scheduler_test_waiter(recorder)
+    state[:waiters][:source] = source
+    state[:waiters][:sibling] = sibling
+    state[:completed] << [:source, source] << [:sibling, sibling]
+    state[:multi].instance_variable_set(:@__curb_deferred_exception_source_id, :source)
+
+    Curl.release_scheduler_waiters(state)
+
+    assert_equal [sibling], recorder.unblocked
+    assert_equal false, source[:done]
+    assert_equal [[:source, source]], state[:completed]
+
+    state[:multi].remove_instance_variable(:@__curb_deferred_exception_source_id)
+    Curl.release_scheduler_waiters(state)
+
+    assert_equal [sibling, source], recorder.unblocked
+    assert source[:done]
+    assert_empty state[:completed]
+  ensure
+    cleanup_scheduler_state
+  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")
@@ -849,6 +940,14 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
     false
   end
 
+  # Wall-clock bounds are not reliable under valgrind, which slows and
+  # serializes threads unpredictably; there the requests and their results are
+  # still checked under memcheck, only the duration bound is skipped.
+  def assert_ran_concurrently(duration)
+    return if curb_under_valgrind?
+    assert duration < THRESHOLD, "Requests did not run concurrently under fiber scheduler (#{duration}s) which exceeds the expected threshold of: #{THRESHOLD} serial time would be about: #{SERIAL_TIME_WOULD_BE_ABOUT}"
+  end
+
   def socket_perform_supported?
     Curl::Multi.private_method_defined?(:_socket_perform)
   end