curb 0.8.5 → 1.3.6

data/tests/tc_curl_easy.rb

@@ -4,6 +4,456 @@ class FooNoToS
 end
 
 class TestCurbCurlEasy < Test::Unit::TestCase
+  def test_global_reset
+    Curl.get($TEST_URL)
+    # in a Timeout block you should reset the thread current handle 
+    Curl.reset
+  end
+
+  def test_nested_easy_methods
+    easy = Curl.get(TestServlet.url) {|http|
+      res = Curl.get(TestServlet.url + '/not_here')
+      assert_equal 404, res.code
+    }
+    assert_equal 200, easy.code
+  end
+
+  def test_perform_with_implicit_multi
+    easy = Curl::Easy.new($TEST_URL)
+
+    assert_nothing_raised { easy.perform }
+    assert_match(/^# DO NOT REMOVE THIS COMMENT/, easy.body_str)
+  end
+
+  def test_curlopt_resolve
+    require 'resolv'
+    uri = URI.parse(TestServlet.url)
+    resolved_ip = Resolv.getaddress(uri.host)   # perform DNS lookup once
+    mapping = "#{uri.host}:#{uri.port}:#{resolved_ip}"
+
+    http = Curl::Easy.new(TestServlet.url)
+    http.setopt(Curl::CURLOPT_RESOLVE, [mapping])
+
+    http.get
+
+    assert_match(/GET/, http.body)
+  end
+
+  def test_resolve_clear_keeps_handle_usable
+    host = "curb.invalid"
+    url = "http://#{host}:#{TestServlet.port}#{TestServlet.path}"
+    mapping = "#{host}:#{TestServlet.port}:127.0.0.1"
+
+    http = Curl::Easy.new(url)
+    http.dns_cache_timeout = 0
+    http.resolve = [mapping]
+    http.get
+    assert_match(/GET/, http.body)
+
+    http.resolve = nil
+    http.url = TestServlet.url
+    http.get
+    assert_match(/GET/, http.body)
+  end
+
+  def test_curlopt_stderr_with_file
+    # does not work with Tempfile directly
+    path = Tempfile.new('curb_test_curlopt_stderr').path
+    File.open(path, 'w') do |file|
+      easy = Curl::Easy.new(TestServlet.url)
+      easy.verbose = true
+      easy.setopt(Curl::CURLOPT_STDERR, file)
+      easy.perform
+    end
+    output = File.read(path)
+
+    assert_match(/HTTP\/1\.1\ 200\ OK(?:\ )?/, output)
+    assert_match('Host: 127.0.0.1:9129', output)
+  end
+
+  def test_curlopt_stderr_with_io
+    tmp = Tempfile.new('curb_test_curlopt_stderr')
+    path = tmp.path
+    fd = IO.sysopen(path, 'w')
+    io = IO.new(fd, 'w')
+    io.sync = true
+
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.verbose = true
+    easy.setopt(Curl::CURLOPT_STDERR, io)
+    easy.perform
+
+    io.flush
+    io.close
+    output = File.read(path)
+
+    assert_match(/HTTP\/1\.1\ 200\ OK(?:\ )?/, output)
+    assert_match('Host: 127.0.0.1:9129', output)
+  ensure
+    tmp.close! if defined?(tmp) && tmp
+  end
+
+  def test_curlopt_stderr_gc_safe
+    tmp = Tempfile.new('curb_test_curlopt_stderr_gc')
+    path = tmp.path
+    fd = IO.sysopen(path, 'w')
+    io = IO.new(fd, 'w')
+
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.verbose = true
+    easy.setopt(Curl::CURLOPT_STDERR, io)
+
+    # Drop our Ruby reference and force GC; curb should retain it internally
+    io = nil
+    GC.start
+
+    easy.perform
+
+    output = File.read(path)
+    assert_match(/HTTP\/1\.1\ 200\ OK(?:\ )?/, output)
+    assert_match('Host: 127.0.0.1:9129', output)
+  ensure
+    tmp.close! if defined?(tmp) && tmp
+  end
+
+  def test_head_request_no_body_and_no_timeout
+    # Ensure a HEAD request completes and does not attempt to read a body
+    # even when the server advertises a Content-Length.
+    easy = nil
+    assert_nothing_raised do
+      easy = Curl.http(:HEAD, TestServlet.url)
+    end
+    assert_not_nil easy
+    # Header string should contain the HTTP status line.
+    assert_match(/HTTP\/1\.1\s\d+\s/, easy.header_str.to_s)
+    # Body should be empty for HEAD requests (libcurl won't call the write callback).
+    assert_equal "", easy.body_str.to_s
+  end
+
+  def test_head_request_restores_easy_state_after_callback_exception
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.on_complete { raise "head complete blew up" }
+
+    error = assert_raise(Curl::Err::AbortedByCallbackError) { easy.http("HEAD") }
+    assert_equal "head complete blew up", error.message
+
+    easy.on_complete { |_curl| }
+    easy.perform
+
+    assert_equal "GET", easy.body_str
+  end
+
+  def test_patch_request_does_not_leak_custom_method_to_next_perform
+    easy = Curl::Easy.new(TestServlet.url)
+
+    easy.http_patch("a=b")
+    assert_equal "PATCH\na=b", easy.body_str
+
+    easy.perform
+    assert_equal "GET", easy.body_str
+  end
+
+  def test_put_request_does_not_leak_custom_method_to_next_perform
+    easy = Curl::Easy.new(TestServlet.url)
+
+    easy.http_put("payload")
+    assert_equal "PUT\npayload", easy.body_str
+
+    easy.perform
+    assert_equal "GET", easy.body_str
+  end
+
+  def test_failed_put_data_setup_does_not_leave_easy_in_upload_mode
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.headers = ["X-Test: true"]
+
+    assert_raise(RuntimeError) { easy.put_data = "payload" }
+
+    easy.headers = {}
+    easy.perform
+    assert_equal "GET", easy.body_str
+  end
+
+  def test_perform_releases_failed_implicit_multi_without_follow_up_easy_perform
+    Curl::Easy.flush_deferred_multi_closes
+    assert_equal 0, Curl::Easy.deferred_multi_closes.length
+
+    easy, implicit_multi = capture_failed_implicit_multi_cleanup_state
+
+    assert_nil easy.multi
+    assert_equal({}, implicit_multi.requests)
+    assert_equal false, implicit_multi.instance_variable_get(:@deferred_close)
+    assert_equal 0, Curl::Easy.deferred_multi_closes.length
+  ensure
+    easy.multi = nil if defined?(easy) && easy
+    implicit_multi.close if defined?(implicit_multi) && implicit_multi
+    Curl::Easy.flush_deferred_multi_closes
+  end
+
+  def test_deferred_multi_closes_stay_with_their_owner_thread_across_retry
+    Curl::Easy.flush_deferred_multi_closes(all_threads: true)
+    multi = deferred_close_stub_multi(failures: 1)
+
+    Curl::Easy.defer_multi_close(multi, nil)
+
+    Curl::Easy.flush_deferred_multi_closes
+    assert_equal 1, multi.close_attempts
+    assert_equal true, multi.instance_variable_get(:@deferred_close)
+    assert_equal 1, Curl::Easy.deferred_multi_closes.length
+
+    Thread.new { Curl::Easy.flush_deferred_multi_closes }.join
+    assert_equal 1, multi.close_attempts
+    assert_equal true, multi.instance_variable_get(:@deferred_close)
+    assert_equal 1, Curl::Easy.deferred_multi_closes.length
+
+    Curl::Easy.flush_deferred_multi_closes
+    assert_equal 2, multi.close_attempts
+    assert_equal true, multi.closed?
+    assert_equal false, multi.instance_variable_get(:@deferred_close)
+    assert_equal 0, Curl::Easy.deferred_multi_closes.length
+  ensure
+    Curl::Easy.flush_deferred_multi_closes(all_threads: true)
+  end
+
+  def capture_created_multis
+    created_multis = []
+    multi_singleton = class << Curl::Multi; self; end
+
+    multi_singleton.__send__(:alias_method, :__curb_test_original_new, :new)
+    multi_singleton.__send__(:define_method, :new) do |*args, &block|
+      multi = __curb_test_original_new(*args, &block)
+      created_multis << multi
+      multi
+    end
+
+    yield created_multis
+  ensure
+    if defined?(multi_singleton) && multi_singleton.method_defined?(:__curb_test_original_new)
+      multi_singleton.__send__(:remove_method, :new)
+      multi_singleton.__send__(:alias_method, :new, :__curb_test_original_new)
+      multi_singleton.__send__(:remove_method, :__curb_test_original_new)
+    end
+  end
+
+  def capture_failed_implicit_multi_cleanup_state
+    created_multis = nil
+    easy = nil
+
+    capture_created_multis do |captured_multis|
+      created_multis = captured_multis
+      easy = Curl::Easy.new(TestServlet.url)
+      easy.on_complete { raise "complete blew up" }
+
+      error = assert_raise(Curl::Err::AbortedByCallbackError) { easy.perform }
+      assert_equal "complete blew up", error.message
+    end
+
+    assert_equal 1, created_multis.length, "test should observe one implicit multi created by Easy#perform"
+
+    [easy, created_multis.first]
+  end
+
+  def deferred_close_stub_multi(failures:)
+    Object.new.tap do |multi|
+      requests = {}
+      remaining_failures = failures
+      close_attempts = 0
+      closed = false
+
+      multi.define_singleton_method(:requests) { requests }
+      multi.define_singleton_method(:_close) do
+        close_attempts += 1
+        if remaining_failures.positive?
+          remaining_failures -= 1
+          raise "close failed"
+        end
+
+        closed = true
+      end
+      multi.define_singleton_method(:close_attempts) { close_attempts }
+      multi.define_singleton_method(:closed?) { closed }
+    end
+  end
+
+  def test_perform_restores_explicit_multi_after_callback_error
+    multi = Curl::Multi.new
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.multi = multi
+    easy.on_complete { raise "complete blew up" }
+
+    error = assert_raise(Curl::Err::AbortedByCallbackError) { easy.perform }
+    assert_equal "complete blew up", error.message
+    assert_same multi, easy.multi
+    assert_equal({}, multi.requests)
+
+    easy.on_complete { |_curl| }
+    easy.perform
+
+    assert_same multi, easy.multi
+    assert_equal "GET", easy.body_str
+  ensure
+    easy.multi = nil if defined?(easy) && easy && easy.multi.equal?(multi)
+    multi.close if defined?(multi) && multi
+  end
+
+  def test_perform_restores_cached_implicit_multi_after_callback_error
+    Curl::Multi.autoclose = false
+
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.perform
+
+    cached_multi = easy.multi
+    easy.on_complete { raise "complete blew up" }
+
+    error = assert_raise(Curl::Err::AbortedByCallbackError) { easy.perform }
+    assert_equal "complete blew up", error.message
+    assert_same cached_multi, easy.multi
+    assert_equal({}, cached_multi.requests)
+
+    easy.on_complete { |_curl| }
+    easy.perform
+
+    assert_same cached_multi, easy.multi
+    assert_equal "GET", easy.body_str
+  ensure
+    easy.multi = nil if defined?(easy) && easy
+    cached_multi.close if defined?(cached_multi) && cached_multi
+    Curl::Multi.autoclose = false
+  end
+
+  def test_close_clears_explicit_idle_easy_multi_reference
+    easy = Curl::Easy.new($TEST_URL)
+    multi = Curl::Multi.new
+    easy.multi = multi
+
+    assert_same multi, easy.multi
+    assert_equal({}, multi.requests)
+
+    multi.close
+
+    assert_nil easy.multi
+  end
+
+  def test_close_clears_cached_idle_easy_multi_reference
+    Curl::Multi.autoclose = false
+
+    easy = Curl::Easy.new($TEST_URL)
+    easy.perform
+
+    cached_multi = easy.multi
+    assert_not_nil cached_multi
+    assert_equal({}, cached_multi.requests)
+
+    cached_multi.close
+
+    assert_nil easy.multi
+  ensure
+    easy.multi = nil if defined?(easy) && easy
+    Curl::Multi.autoclose = false
+  end
+
+  def test_multi_assignment_rejects_non_multi_objects
+    easy = Curl::Easy.new($TEST_URL)
+
+    error = assert_raise(TypeError) { easy.multi = Object.new }
+
+    assert_match(/Curl::Multi/, error.message)
+    assert_nil easy.multi
+  end
+
+  def test_perform_can_reuse_explicit_multi_when_autoclose_is_enabled
+    Curl::Multi.autoclose = true
+  
+    easy = Curl::Easy.new(TestServlet.url)
+    multi = Curl::Multi.new
+  
+    easy.multi = multi
+    easy.perform
+  
+    assert_nil easy.multi
+    assert_equal({}, multi.requests)
+  
+    easy.multi = multi
+    easy.perform
+  
+    assert_nil easy.multi
+    assert_equal({}, multi.requests)
+    assert_equal "GET", easy.body_str
+  ensure
+    easy.multi = nil if defined?(easy) && easy
+    multi.close if defined?(multi) && multi
+    Curl::Multi.autoclose = false
+  end
+
+  def test_perform_reraises_on_body_exception_for_frozen_easy
+    easy = Curl::Easy.new($TEST_URL)
+    callback_error = Class.new(RuntimeError)
+    easy.on_body { raise callback_error, "body blew up" }
+    easy.freeze
+  
+    error = assert_raise(callback_error) { easy.perform }
+  
+    assert_equal "body blew up", error.message
+  end
+
+  def test_perform_preserves_implicit_multi_when_autoclose_is_disabled
+    Curl::Multi.autoclose = false
+
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.perform
+
+    first_multi = easy.multi
+    assert_not_nil first_multi
+    assert_equal({}, first_multi.requests)
+
+    easy.perform
+
+    assert_same first_multi, easy.multi
+    assert_equal "GET", easy.body_str
+  ensure
+    easy.multi = nil if defined?(easy) && easy
+    first_multi.close if defined?(first_multi) && first_multi
+    Curl::Multi.autoclose = false
+  end
+
+  def test_curlopt_stderr_fails_with_tempdir
+    Tempfile.open('curb_test_curlopt_stderr') do |tempfile|
+      easy = Curl::Easy.new(TestServlet.url)
+
+      assert_raise(TypeError) do
+        easy.setopt(Curl::CURLOPT_STDERR, tempfile)
+      end
+    end
+  end
+
+  def test_curlopt_stderr_fails_with_stringio
+    stringio = StringIO.new
+    easy = Curl::Easy.new(TestServlet.url)
+
+    assert_raise(TypeError) do
+      easy.setopt(Curl::CURLOPT_STDERR, stringio)
+    end
+  end
+
+  def test_curlopt_stderr_fails_with_string
+    string = String.new
+    easy = Curl::Easy.new(TestServlet.url)
+
+    assert_raise(TypeError) do
+      easy.setopt(Curl::CURLOPT_STDERR, string)
+    end
+  end
+
+  def test_exception
+    begin
+      Curl.get('NOT_FOUND_URL')
+    rescue
+      assert true
+    rescue Exception
+      assert false, "We should raise StandardError"
+    end
+  end
+
   def test_threads
     t = []
     5.times do
@@ -12,33 +462,29 @@ class TestCurbCurlEasy < Test::Unit::TestCase
           c = Curl.get($TEST_URL)
           assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body_str)
           assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body)
-          assert_equal "", c.header_str
-          assert_equal "", c.head
         end
       end
     end
 
-    t.each {|t| t.join }
+    t.each {|x| x.join }
   end
 
   def test_class_perform_01   
     assert_instance_of Curl::Easy, c = Curl::Easy.perform($TEST_URL)
     assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body_str)
     assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body)
-    assert_equal "", c.header_str
   end    
 
   def test_class_perform_02
-    data = ""
+    data = String.new
     assert_instance_of Curl::Easy, c = Curl::Easy.perform($TEST_URL) { |curl| curl.on_body { |d| data << d; d.length } }    
 
     assert_nil c.body_str
-    assert_equal "", c.header_str
     assert_match(/^# DO NOT REMOVE THIS COMMENT/, data)
   end    
 
   def test_class_perform_03
-    assert_raise(Curl::Err::CouldntReadError) { c = Curl::Easy.perform($TEST_URL + "nonexistent") }
+    assert_raise(Curl::Err::CouldntReadError) { Curl::Easy.perform($TEST_URL + "nonexistent") }
   end    
   
   def test_new_01
@@ -128,11 +574,10 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     c = Curl::Easy.new($TEST_URL)    
     assert_equal true, c.http_get
     assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body_str)
-    assert_equal "", c.header_str
   end    
 
   def test_get_02
-    data = ""
+    data = String.new
     c = Curl::Easy.new($TEST_URL) do |curl|
       curl.on_body { |d| data << d; d.length }
     end
@@ -140,7 +585,6 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal true, c.http_get    
     
     assert_nil c.body_str
-    assert_equal "", c.header_str
     assert_match(/^# DO NOT REMOVE THIS COMMENT/, data)
   end    
 
@@ -153,6 +597,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
 
 
   def test_last_effective_url_01
+    omit('Windows file URL semantics differ') if WINDOWS
     c = Curl::Easy.new($TEST_URL)
     
     assert_equal $TEST_URL, c.url
@@ -323,19 +768,71 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     c.max_redirects = nil
     assert_nil c.max_redirects
   end
-  
+
+  def test_timeout_with_floats
+    c = Curl::Easy.new($TEST_URL)
+
+    c.timeout = 1.5
+    assert_equal 1500, c.timeout_ms
+    assert_equal 1.5, c.timeout
+  end
+
+  def test_timeout_with_negative
+    c = Curl::Easy.new($TEST_URL)
+
+    c.timeout = -1.5
+    assert_equal 0, c.timeout
+    assert_equal 0, c.timeout_ms
+
+    c.timeout = -4.8
+    assert_equal 0, c.timeout
+    assert_equal 0, c.timeout_ms
+  end
+
   def test_timeout_01
     c = Curl::Easy.new($TEST_URL)
-    
-    assert_nil c.timeout
-    
+
+    assert_equal 0, c.timeout
+
     c.timeout = 3
     assert_equal 3, c.timeout
-    
-    c.timeout = nil
-    assert_nil c.timeout
+
+    c.timeout = 0
+    assert_equal 0, c.timeout
   end
-  
+
+  def test_timeout_ms_01
+    c = Curl::Easy.new($TEST_URL)
+
+    assert_equal 0, c.timeout_ms
+
+    c.timeout_ms = 100
+    assert_equal 100, c.timeout_ms
+
+    c.timeout_ms = nil
+    assert_equal 0, c.timeout_ms
+  end
+
+  def test_timeout_ms_with_floats
+    c = Curl::Easy.new($TEST_URL)
+
+    c.timeout_ms = 55.5
+    assert_equal 55, c.timeout_ms
+    assert_equal 0.055, c.timeout
+  end
+
+  def test_timeout_ms_with_negative
+    c = Curl::Easy.new($TEST_URL)
+
+    c.timeout_ms = -1.5
+    assert_equal 0, c.timeout
+    assert_equal 0, c.timeout_ms
+
+    c.timeout_ms = -4.8
+    assert_equal 0, c.timeout
+    assert_equal 0, c.timeout_ms
+  end
+
   def test_connect_timeout_01
     c = Curl::Easy.new($TEST_URL)
     
@@ -347,7 +844,19 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     c.connect_timeout = nil
     assert_nil c.connect_timeout
   end
-  
+
+  def test_connect_timeout_ms_01
+    c = Curl::Easy.new($TEST_URL)
+
+    assert_nil c.connect_timeout_ms
+
+    c.connect_timeout_ms = 100
+    assert_equal 100, c.connect_timeout_ms
+
+    c.connect_timeout_ms = nil
+    assert_nil c.connect_timeout_ms
+  end
+
   def test_ftp_response_timeout_01
     c = Curl::Easy.new($TEST_URL)
     
@@ -537,6 +1046,27 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_raises(ArgumentError) { c.resolve_mode = :bad }
   end
 
+  def test_http_version_accessors
+    c = Curl::Easy.new
+    assert_equal Curl::HTTP_NONE, c.http_version
+
+    c.http_version = Curl::HTTP_1_1
+    assert_equal Curl::HTTP_1_1, c.http_version
+
+    if Curl.const_defined?(:HTTP_2TLS)
+      c.http_version = Curl::HTTP_2TLS
+      assert_equal Curl::HTTP_2TLS, c.http_version
+    end
+
+    if Curl.const_defined?(:HTTP_2_PRIOR_KNOWLEDGE)
+      c.http_version = Curl::HTTP_2_PRIOR_KNOWLEDGE
+      assert_equal Curl::HTTP_2_PRIOR_KNOWLEDGE, c.http_version
+    end
+
+    c.http_version = nil
+    assert_equal Curl::HTTP_NONE, c.http_version
+  end
+
   def test_enable_cookies
     c = Curl::Easy.new
     assert !c.enable_cookies?
@@ -565,14 +1095,23 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal "some.file", c.cookiejar        
   end
 
+  def test_cookielist
+    c = Curl::Easy.new TestServlet.url
+    c.enable_cookies = true
+    c.post_body = URI.encode_www_form('c' => 'somename=somevalue')
+    assert_nil c.cookielist
+    c.perform
+    assert_match(/somevalue/, c.cookielist.join(''))
+  end
+
   def test_on_success
     curl = Curl::Easy.new($TEST_URL)    
     on_success_called = false
     curl.on_success {|c|
       on_success_called = true
-      assert_not_nil c.body_str
-      assert_equal "", c.header_str
-      assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body_str)
+      assert_not_nil c.body
+      assert_match(/Content-Length: /, c.head)
+      assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body)
     }
     curl.perform
     assert on_success_called, "Success handler not called" 
@@ -614,20 +1153,27 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal 'GET', curl.body_str
   end
   
-  def test_post_remote
+  def test_remote
     curl = Curl::Easy.new(TestServlet.url)
     curl.http_post([Curl::PostField.content('document_id', 5)])
     assert_equal "POST\ndocument_id=5", curl.unescape(curl.body_str)
+
+    curl.http_put([Curl::PostField.content('document_id', 5)])
+    assert_equal "PUT\ndocument_id=5", curl.unescape(curl.body_str)
+
+    curl.http_patch([Curl::PostField.content('document_id', 5)])
+    assert_equal "PATCH\ndocument_id=5", curl.unescape(curl.body_str)
   end
 
-  def test_post_remote_is_easy_handle
+  def test_remote_is_easy_handle
     # see: http://pastie.org/560852 and
     # http://groups.google.com/group/curb---ruby-libcurl-bindings/browse_thread/thread/216bb2d9b037f347?hl=en
-    [:post, :get, :head, :delete].each do |method|
+    [:post, :patch, :put, :get, :head, :delete].each do |method|
       retries = 0
       begin
         count = 0
-        curl = Curl::Easy.send("http_#{method}", TestServlet.url) do|c|
+        m = "http_#{method}".to_sym
+        Curl::Easy.send(m, TestServlet.url) do|c|
           count += 1
           assert_equal Curl::Easy, c.class
         end
@@ -636,24 +1182,40 @@ class TestCurbCurlEasy < Test::Unit::TestCase
         retries+=1
         retry if retries < 3
         raise e
+      rescue ArgumentError => e
+        assert false, "#{m} - #{e.message}"
       end
     end
   end
 
   # see: https://github.com/rvanlieshout/curb/commit/8bcdefddc0162484681ebd1a92d52a642666a445
-  def test_post_multipart_array_remote
+  def test_multipart_array_remote
     curl = Curl::Easy.new(TestServlet.url)
     curl.multipart_form_post = true
     fields = [
-      Curl::PostField.file('foo', File.expand_path(File.join(File.dirname(__FILE__),'..','README'))),
-      Curl::PostField.file('bar', File.expand_path(File.join(File.dirname(__FILE__),'..','README')))
+      Curl::PostField.file('foo', File.expand_path(File.join(File.dirname(__FILE__),'..','README.md'))),
+      Curl::PostField.file('bar', File.expand_path(File.join(File.dirname(__FILE__),'..','README.md')))
     ]
     curl.http_post(fields)
-    assert_match /HTTP POST file upload/, curl.body_str
-    assert_match /Content-Disposition: form-data/, curl.body_str
+    assert_match(/HTTP POST file upload/, curl.body_str)
+    assert_match(/Content-Disposition: form-data/, curl.body_str)
+
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.multipart_form_post = true
+    fields = [
+      Curl::PostField.file('foo', File.expand_path(File.join(File.dirname(__FILE__),'..','README.md'))),
+      Curl::PostField.file('bar', File.expand_path(File.join(File.dirname(__FILE__),'..','README.md')))
+    ]
+    curl.http_put(fields)
+    assert_match(/HTTP POST file upload/, curl.body_str)
+    assert_match(/Content-Disposition: form-data/, curl.body_str)
+
+    curl.http_patch(fields)
+    assert_match(/HTTP POST file upload/, curl.body_str)
+    assert_match(/Content-Disposition: form-data/, curl.body_str)
   end
   
-  def test_post_with_body_remote
+  def test_with_body_remote
     curl = Curl::Easy.new(TestServlet.url)
     curl.post_body = 'foo=bar&encoded%20string=val'
     
@@ -661,23 +1223,151 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     
     assert_equal "POST\nfoo=bar&encoded%20string=val", curl.body_str
     assert_equal 'foo=bar&encoded%20string=val', curl.post_body
+
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.put_data = 'foo=bar&encoded%20string=val'
+    
+    curl.perform
+    
+    assert_equal "PUT\nfoo=bar&encoded%20string=val", curl.body_str
   end
-  
-  def test_form_post_body_remote
+
+  def test_post_body_from_to_s_keeps_string_buffer_alive
+    post_body = Object.new
+    def post_body.to_s
+      'foo=bar&encoded%20string=val'
+    end
+
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.post_body = post_body
+
+    assert_equal 'foo=bar&encoded%20string=val', curl.post_body
+
+    GC.start
+    GC.compact if GC.respond_to?(:compact)
+
+    curl.perform
+    assert_equal "POST\nfoo=bar&encoded%20string=val", curl.body_str
+  end
+
+  def test_post_body_preserves_assigned_snapshot_when_original_string_is_mutated
+    omit('CURLOPT_COPYPOSTFIELDS is not available in this build') unless Curl.const_defined?(:CURLOPT_COPYPOSTFIELDS)
+
+    curl = Curl::Easy.new(TestServlet.url)
+    post_body = String.new('alpha=1')
+    curl.post_body = post_body
+
+    post_body.replace('beta=2')
+
+    assert_equal 'beta=2', post_body
+    assert_equal 'alpha=1', curl.post_body
+
+    curl.perform
+
+    assert_equal "POST\nalpha=1", curl.body_str
+    assert_equal 'alpha=1', curl.post_body
+  end
+
+  def test_setopt_postfields_keeps_string_buffer_alive
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.set(Curl::CURLOPT_POSTFIELDS, 'foo=bar&encoded%20string=val')
+
+    assert_equal 'foo=bar&encoded%20string=val', curl.post_body
+
+    GC.start
+    GC.compact if GC.respond_to?(:compact)
+
+    curl.perform
+    assert_equal "POST\nfoo=bar&encoded%20string=val", curl.body_str
+  end
+
+  def test_setopt_postfields_preserves_assigned_snapshot_when_original_string_is_mutated
+    omit('CURLOPT_COPYPOSTFIELDS is not available in this build') unless Curl.const_defined?(:CURLOPT_COPYPOSTFIELDS)
+
+    curl = Curl::Easy.new(TestServlet.url)
+    post_body = String.new('alpha=1')
+    curl.set(Curl::CURLOPT_POSTFIELDS, post_body)
+
+    post_body.replace('beta=2')
+
+    assert_equal 'beta=2', post_body
+    assert_equal 'alpha=1', curl.post_body
+
+    curl.perform
+
+    assert_equal "POST\nalpha=1", curl.body_str
+    assert_equal 'alpha=1', curl.post_body
+  end
+
+  def test_setopt_postfields_nil_preserves_post_request
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.set(Curl::CURLOPT_POST, true)
+    curl.set(Curl::CURLOPT_POSTFIELDS, nil)
+
+    curl.perform
+
+    assert_nil curl.post_body
+    assert_equal "POST\n", curl.body_str
+  end
+
+  def test_form_body_remote
     curl = Curl::Easy.new(TestServlet.url)
     curl.http_post('foo=bar', 'encoded%20string=val')
     
     assert_equal "POST\nfoo=bar&encoded%20string=val", curl.body_str
     assert_equal 'foo=bar&encoded%20string=val', curl.post_body
+
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.http_put('foo=bar', 'encoded%20string=val')
+    
+    assert_equal "PUT\nfoo=bar&encoded%20string=val", curl.body_str
+
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.http_patch('foo=bar', 'encoded%20string=val')
+    
+    assert_equal "PATCH\nfoo=bar&encoded%20string=val", curl.body_str
+  end
+
+  def test_multipart_file_remote
+    [:put, :post, :patch].each {|method|
+      curl = Curl::Easy.new(TestServlet.url)
+      curl.multipart_form_post = true
+      pf = Curl::PostField.file('readme', File.expand_path(File.join(File.dirname(__FILE__),'..','README.md')))
+      curl.send("http_#{method}", pf)
+      assert_match(/HTTP POST file upload/, curl.body_str)
+      assert_match(/Content-Disposition: form-data/, curl.body_str)
+    }
+  end
+
+  def test_multipart_form_reuse_clears_previous_form
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.multipart_form_post = true
+    curl.http_post(Curl::PostField.content('document_id', '5'))
+    assert_match(/document_id/, curl.body_str)
+
+    curl.multipart_form_post = false
+    curl.post_body = 'foo=bar'
+    curl.http_post
+
+    assert_equal "POST\nfoo=bar", curl.body_str
   end
 
-  def test_post_multipart_file_remote
+  def test_multipart_patch_build_failure_restores_easy_request_state
     curl = Curl::Easy.new(TestServlet.url)
     curl.multipart_form_post = true
-    pf = Curl::PostField.file('readme', File.expand_path(File.join(File.dirname(__FILE__),'..','README')))
-    curl.http_post(pf)
-    assert_match /HTTP POST file upload/, curl.body_str
-    assert_match /Content-Disposition: form-data/, curl.body_str
+    field = Curl::PostField.content('document_id', '5')
+
+    field.name = nil
+    error = assert_raise(Curl::Err::InvalidPostFieldError) do
+      # The first field allocates native multipart form state before the second field raises.
+      curl.http_patch(Curl::PostField.content('keep', 'allocated'), field)
+    end
+    assert_match(/Cannot post unnamed field/, error.message)
+
+    curl.multipart_form_post = false
+    curl.perform
+
+    assert_equal 'GET', curl.body_str
   end
 
   def test_delete_remote
@@ -699,7 +1389,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     redirect = curl.header_str.match(/Location: (.*)/)
 
     assert_equal '', curl.body_str
-    assert_match '/nonexistent', redirect[1]
+    assert_match('/nonexistent', redirect[1])
   end
 
   def test_head_accessor
@@ -710,7 +1400,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     redirect = curl.header_str.match(/Location: (.*)/)
 
     assert_equal '', curl.body_str
-    assert_match '/nonexistent', redirect[1]
+    assert_match('/nonexistent', redirect[1])
     curl.head = false
     curl.perform
     assert_equal 'GET', curl.body_str
@@ -720,11 +1410,11 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     curl = Curl::Easy.new(TestServlet.url)
     curl.headers['Content-Type'] = 'application/json'
     assert curl.http_put("message")
-    assert_match /^PUT/, curl.body_str
-    assert_match /message$/, curl.body_str
-    assert_match /message$/, curl.body
-    assert_match /application\/json/, curl.header_str
-    assert_match /application\/json/, curl.head
+    assert_match(/^PUT/, curl.body_str)
+    assert_match(/message$/, curl.body_str)
+    assert_match(/message$/, curl.body)
+    assert_match(/application\/json/, curl.header_str)
+    assert_match(/application\/json/, curl.head)
   end 
   
   def test_put_data
@@ -733,8 +1423,46 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     
     curl.perform
     
-    assert_match /^PUT/, curl.body_str
-    assert_match /message$/, curl.body_str
+    assert_match(/^PUT/, curl.body_str)
+    assert_match(/message$/, curl.body_str)
+  end
+
+  def test_put_data_from_to_s_object
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.put_data = :message
+
+    curl.perform
+
+    assert_equal "PUT\nmessage", curl.body_str
+  end
+
+  def test_put_data_read_exception_sets_result_and_releases_callback_state
+    error_class = Class.new(StandardError)
+    reader_class = Class.new do
+      define_method(:read) do |_len|
+        raise error_class, 'upload read failed'
+      end
+
+      def seek(_offset, _whence = SEEK_SET)
+        0
+      end
+
+      def stat
+        Struct.new(:size).new(1)
+      end
+    end
+
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.put_data = reader_class.new
+
+    error = assert_raise(error_class) { curl.perform }
+    assert_equal 'upload read failed', error.message
+    assert_not_equal 0, curl.last_result
+
+    curl.url = TestServlet.url
+    curl.http_get
+
+    assert_equal 'GET', curl.body_str
   end
 
   # https://github.com/taf2/curb/issues/101
@@ -744,8 +1472,8 @@ class TestCurbCurlEasy < Test::Unit::TestCase
  
     curl.perform
     
-    assert_match /^PUT/, curl.body_str
-    assert_match "a\0b", curl.body_str
+    assert_match(/^PUT/, curl.body_str)
+    assert_match("a\0b", curl.body_str)
   end
 
   def test_put_nil_data_no_crash
@@ -760,7 +1488,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     File.open(__FILE__,'rb') do|f|
       assert curl.http_put(f)
     end
-    assert_equal "PUT\n#{File.read(__FILE__)}", curl.body_str
+    assert_equal "PUT\n#{File.read(__FILE__)}", curl.body_str.tr("\r", '')
   end
   
   def test_put_class_method
@@ -770,7 +1498,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
       assert_equal Curl::Easy, c.class
     end
     assert_equal 1, count
-    assert_equal "PUT\n#{File.read(__FILE__)}", curl.body_str
+    assert_equal "PUT\n#{File.read(__FILE__)}", curl.body_str.tr("\r", '')
   end
 
   # Generate a self-signed cert with
@@ -779,7 +1507,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
   def test_cert
     curl = Curl::Easy.new(TestServlet.url)
     curl.cert= File.join(File.dirname(__FILE__),"cert.pem")
-    assert_match /cert.pem$/,curl.cert
+    assert_match(/cert.pem$/,curl.cert)
   end
 
   def test_cert_with_password
@@ -787,7 +1515,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     path = File.join(File.dirname(__FILE__),"cert.pem")
     curl.certpassword = 'password'
     curl.cert = path
-    assert_match /cert.pem$/,curl.cert
+    assert_match(/cert.pem$/,curl.cert)
   end
 
   def test_cert_type
@@ -808,7 +1536,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
   def test_ca_cert
     curl = Curl::Easy.new(TestServlet.url)
     curl.cacert= File.join(File.dirname(__FILE__),"cacert.pem")
-    assert_match /cacert.pem$/, curl.cacert
+    assert_match(/cacert.pem$/, curl.cacert)
   end
 
   def test_user_agent
@@ -834,7 +1562,15 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     $auth_header = nil
     # curl checks the auth type supported by the server, so we have to create a 
     # new easy handle if we're going to change the auth type...
-
+    if WINDOWS
+      # On Windows, libcurl often uses SSPI for NTLM which yields a different
+      # header value and encoding; skip the NTLM-specific assertion.
+      return
+    end
+    # curl 8.20.0 disables NTLM by default and plans to remove it in
+    # September 2026; libcurl silently downgrades to Basic when NTLM is
+    # unavailable, so skip the NTLM-specific assertion in that case.
+    return unless Curl.ntlm?
     curl = Curl::Easy.new(TestServlet.url)
     curl.username = "foo"
     curl.password = "bar"
@@ -855,7 +1591,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
   end
 
   def test_post_streaming
-    readme = File.expand_path(File.join(File.dirname(__FILE__),'..','README'))
+    readme = File.expand_path(File.join(File.dirname(__FILE__),'..','README.md'))
     
     pf = Curl::PostField.file("filename", readme)
 
@@ -865,11 +1601,10 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     easy.multipart_form_post = true
     easy.http_post(pf)
 
-    assert_not_equal(0,easy.body_str.size)
-    assert_equal(easy.body_str,File.read(readme))
+    assert_not_equal(0,easy.body.size)
+    assert_equal(Digest::MD5.hexdigest(easy.body), Digest::MD5.hexdigest(File.binread(readme)))
   end
 
-
   def test_easy_close
     easy = Curl::Easy.new
     easy.close
@@ -877,6 +1612,18 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     easy.http_get
   end
 
+  def test_easy_close_restores_error_buffer
+    easy = Curl::Easy.new('http://127.0.0.1:1')
+    assert_raise(Curl::Err::ConnectionFailedError) { easy.perform }
+    assert_not_nil easy.last_error
+
+    easy.close
+    easy.url = 'http://127.0.0.1:1'
+    assert_raise(Curl::Err::ConnectionFailedError) { easy.perform }
+
+    assert_not_nil easy.last_error
+  end
+
   def test_easy_reset
     easy = Curl::Easy.new
     easy.url = TestServlet.url + "?query=foo"
@@ -889,6 +1636,48 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     easy.http_get
   end
 
+  def test_easy_reset_clears_network_policy_allowlists
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.allowed_hosts = ['127.0.0.1']
+    easy.network_policy = :public
+    easy.allowed_cidrs = ['1.1.1.0/24']
+
+    settings = easy.reset
+
+    assert settings.key?(:allowed_hosts)
+    assert settings.key?(:allowed_cidrs)
+    assert_nil easy.allowed_hosts
+    assert_nil easy.allowed_cidrs
+    assert_equal :none, easy.network_policy
+  rescue NotImplementedError
+    omit('network_policy=:public requires CURLOPT_OPENSOCKETFUNCTION support')
+  end
+
+  def test_frozen_easy_close_and_reset_skip_safety_override_cleanup
+    closed_easy = Curl::Easy.new
+    closed_easy.freeze
+
+    assert_nothing_raised { closed_easy.close }
+
+    reset_easy = Curl::Easy.new
+    reset_easy.safe_http!
+    reset_easy.freeze
+
+    assert_nothing_raised { reset_easy.reset }
+  end
+
+  def test_last_result_initialization
+    # Test for issue #463 - ensure last_result is properly initialized to 0
+    easy = Curl::Easy.new
+    assert_equal 0, easy.last_result, "last_result should be initialized to 0 for new instance"
+    
+    # Test that reset also sets last_result to 0
+    easy.url = TestServlet.url
+    easy.http_get
+    easy.reset
+    assert_equal 0, easy.last_result, "last_result should be reset to 0 after calling reset"
+  end
+
   def test_easy_use_http_versions
     easy = Curl::Easy.new
     easy.url = TestServlet.url + "?query=foo"
@@ -914,16 +1703,22 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal "PUT\nhello", curl.body_str
     curl.http('COPY')
     assert_equal 'COPY', curl.body_str
+
+    curl.http_patch
+    assert_equal "PATCH\n", curl.body_str
+
+    curl.http_put
+    assert_equal "PUT\n", curl.body_str
   end
 
   def test_easy_http_verbs_must_respond_to_str
-    # issue http://github.com/taf2/curb/issues#issue/45
+    # issue http://github.com/taf2/curb/issues/45
     assert_nothing_raised do
-      c = Curl::Easy.new ; c.url = 'http://example.com' ; c.http(:get)
+      c = Curl::Easy.new ; c.url = TestServlet.url ; c.http(:get)
     end
 
     assert_raise RuntimeError do
-      c = Curl::Easy.new ; c.url = 'http://example.com' ; c.http(FooNoToS.new)
+      c = Curl::Easy.new ; c.url = TestServlet.url ; c.http(FooNoToS.new)
     end
 
   end
@@ -962,8 +1757,8 @@ class TestCurbCurlEasy < Test::Unit::TestCase
       curl.headers['Accept']         = '*/*'
       curl.headers['Authorization']  = 'Foo Bar Biz Baz'
       curl.http_put(rd)
-      assert_match /^PUT/, curl.body_str
-      assert_match /hello$/, curl.body_str
+      assert_match(/^PUT/, curl.body_str)
+      assert_match(/hello$/, curl.body_str)
       curl.header_str
       curl.body_str
     end
@@ -996,7 +1791,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     c = Curl::Easy.new($TEST_URL)
     c.on_success {|x| raise "error" }
     c.perform
-  rescue => e
+  rescue Curl::Err::AbortedByCallbackError => e
     assert_equal 'Curl::Err::AbortedByCallbackError', e.class.to_s
     c.close
   end
@@ -1022,6 +1817,130 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     end
   end
 
+  def test_close_during_http_post_argument_coercion_is_blocked
+    curl = Curl::Easy.new(TestServlet.url)
+    field = Object.new
+    field.define_singleton_method(:to_s) do
+      curl.close
+      "a=b"
+    end
+
+    error = assert_raise(RuntimeError) { curl.http_post(field) }
+    assert_match(/Cannot close an active curl handle/, error.message)
+
+    assert_nothing_raised { curl.close }
+  end
+
+  def test_close_during_url_coercion_is_blocked
+    curl = Curl::Easy.new
+    url = Object.new
+    url.define_singleton_method(:to_str) do
+      curl.close
+      TestServlet.url
+    end
+
+    curl.url = url
+    error = assert_raise(RuntimeError) { curl.perform }
+    assert_match(/Cannot close an active curl handle/, error.message)
+
+    assert_nothing_raised { curl.close }
+  end
+
+  def test_close_in_on_progress_is_blocked
+    curl = Curl::Easy.new(TestServlet.url)
+    did_raise = false
+
+    curl.on_progress do |_dltotal, _dlnow, _ultotal, _ulnow|
+      unless did_raise
+        begin
+          curl.close
+        rescue RuntimeError
+          did_raise = true
+        end
+      end
+      true
+    end
+
+    curl.perform
+    assert did_raise
+  end
+
+  def test_close_in_on_debug_is_blocked
+    curl = Curl::Easy.new(TestServlet.url)
+    did_raise = false
+
+    curl.on_debug do |_type, _data|
+      unless did_raise
+        begin
+          curl.close
+        rescue RuntimeError
+          did_raise = true
+        end
+      end
+    end
+
+    curl.perform
+    assert did_raise
+  end
+
+  def test_close_in_upload_read_is_blocked
+    curl = Curl::Easy.new(TestServlet.url)
+
+    reader_class = Class.new do
+      attr_reader :close_blocked
+
+      def initialize(curl)
+        @curl = curl
+        @done = false
+        @close_blocked = false
+      end
+
+      def read(_len)
+        return nil if @done
+
+        @done = true
+        begin
+          @curl.close
+        rescue RuntimeError
+          @close_blocked = true
+        end
+
+        'hello'
+      end
+
+      def seek(_offset, _whence = SEEK_SET)
+        0
+      end
+
+      def stat
+        Struct.new(:size).new(5)
+      end
+    end
+
+    reader = reader_class.new(curl)
+    curl.http_put(reader)
+
+    assert reader.close_blocked
+    assert_equal "PUT\nhello", curl.body_str
+  end
+
+  def test_set_unsupported_options
+    curl = Curl::Easy.new
+    assert_raises TypeError do
+      curl.set(99999, 1)
+    end
+  end
+
+  def test_poison
+    res_a = Curl.get("#{TestServlet.url}?a_body")
+    first_a_body = Digest::MD5.hexdigest(res_a.body)
+    res_b = Curl.get("#{TestServlet.url}?b_body")
+
+    b_body = Digest::MD5.hexdigest(res_b.body)
+    a_body = Digest::MD5.hexdigest(res_a.body)
+    assert_not_equal a_body, b_body, "we expected #{a_body} to be #{first_a_body}"
+  end
+
   include TestServerMethods 
 
   def setup