curb 1.0.9 → 1.2.0

data/tests/tc_curl_easy.rb

@@ -18,6 +18,20 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal 200, easy.code
   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_curlopt_stderr_with_file
     # does not work with Tempfile directly
     path = Tempfile.new('curb_test_curlopt_stderr').path
@@ -34,20 +48,62 @@ class TestCurbCurlEasy < Test::Unit::TestCase
   end
 
   def test_curlopt_stderr_with_io
-    path = Tempfile.new('curb_test_curlopt_stderr').path
+    tmp = Tempfile.new('curb_test_curlopt_stderr')
+    path = tmp.path
     fd = IO.sysopen(path, 'w')
-    io = IO.for_fd(fd)
+    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
 
-    assert_match(output, 'HTTP/1.1 200 OK')
-    assert_match(output, 'Host: 127.0.0.1:9129')
+  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_curlopt_stderr_fails_with_tempdir
@@ -231,6 +287,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
@@ -805,8 +862,8 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     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.markdown'))),
-      Curl::PostField.file('bar', File.expand_path(File.join(File.dirname(__FILE__),'..','README.markdown')))
+      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)
@@ -815,8 +872,8 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     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.markdown'))),
-      Curl::PostField.file('bar', File.expand_path(File.join(File.dirname(__FILE__),'..','README.markdown')))
+      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)
@@ -866,7 +923,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     [: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.markdown')))
+      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)
@@ -1027,7 +1084,11 @@ 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 = Curl::Easy.new(TestServlet.url)
     curl.username = "foo"
     curl.password = "bar"
@@ -1048,7 +1109,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
   end
 
   def test_post_streaming
-    readme = File.expand_path(File.join(File.dirname(__FILE__),'..','README.markdown'))
+    readme = File.expand_path(File.join(File.dirname(__FILE__),'..','README.md'))
     
     pf = Curl::PostField.file("filename", readme)
 
@@ -1058,11 +1119,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.tr("\r", ''), 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
@@ -1082,6 +1142,18 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     easy.http_get
   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"

data/tests/tc_curl_multi.rb

@@ -10,6 +10,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
   # for https://github.com/taf2/curb/issues/277
   # must connect to an external
   def test_connection_keepalive
+    omit('Not supported on Windows runners') if WINDOWS
     # this test fails with libcurl 7.22.0. I didn't investigate, but it may be related
     # to CURLOPT_MAXCONNECTS bug fixed in 7.30.0:
     # https://github.com/curl/curl/commit/e87e76e2dc108efb1cae87df496416f49c55fca0
@@ -171,6 +172,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
   end
 
   def test_multi_easy_get_with_error
+    omit('Path/line parsing differs on Windows') if WINDOWS
     begin
       did_raise = false
       n = 3
@@ -552,6 +554,25 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     end
   end
 
+  def test_multi_easy_http_with_max_host_connections
+    urls = [
+      { :url => TestServlet.url + '?q=1', :method => :get },
+      { :url => TestServlet.url + '?q=2', :method => :get },
+      { :url => TestServlet.url + '?q=3', :method => :get }
+    ]
+    Curl::Multi.http(urls, {:pipeline => true, :max_host_connections => 1}) do|easy, code, method|
+      assert_equal 200, code
+      case method
+      when :post
+        assert_match(/POST/, easy.body)
+      when :get
+        assert_match(/GET/, easy.body)
+      when :put
+        assert_match(/PUT/, easy.body)
+      end
+    end
+  end
+
   def test_multi_recieves_500
     m = Curl::Multi.new
     e = Curl::Easy.new("http://127.0.0.1:9129/methods")

data/tests/tc_fiber_scheduler.rb

@@ -0,0 +1,190 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+begin
+  require 'async'
+rescue LoadError
+  HAS_ASYNC = false
+else
+  HAS_ASYNC = true
+end
+
+# This test verifies that Curl::Easy#perform cooperates with Ruby's Fiber scheduler
+# by running multiple requests concurrently in a single thread using the Async gem.
+class TestCurbFiberScheduler < Test::Unit::TestCase
+  include BugTestServerSetupTeardown
+
+  ITERS = 4
+  MIN_S = 0.25
+  # Each request sleeps 0.25s; two concurrent requests should be ~0.25–0.5s.
+  # Allow some jitter in CI environments.
+  THRESHOLD = ((MIN_S*(ITERS/2.0)) + (MIN_S/2.0)) # add more jitter for slower CI environments
+  SERIAL_TIME_WOULD_BE_ABOUT = MIN_S * ITERS
+
+  def setup
+    @port = 9993
+
+    @response_proc = lambda do |res|
+      res['Content-Type'] = 'text/plain'
+      sleep MIN_S
+      res.body = '200'
+    end
+    super
+  end
+
+  def test_multi_is_scheduler_friendly
+    if skip_no_async
+      return
+    end
+
+    url = "http://127.0.0.1:#{@port}/test"
+
+    started = Time.now
+    results = []
+
+
+    async_run do
+      m = Curl::Multi.new
+      ITERS.times.each do
+        c = Curl::Easy.new(url)
+        c.on_complete { results << c.code }
+        m.add(c)
+      end
+      m.perform
+    end
+
+    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_equal ITERS, results.size
+    assert_equal ITERS.times.map {200}, results
+  end
+
+  def test_easy_perform_is_scheduler_friendly
+    if skip_no_async
+      return
+    end
+
+    url = "http://127.0.0.1:#{@port}/test"
+
+    started = Time.now
+    results = []
+
+    async_run do |top|
+      tasks = ITERS.times.map do
+        top.async do
+          #t = Time.now.to_i
+          #puts "starting fiber [#{results.size}] -> #{t}"
+          c = Curl.get(url)
+          #puts "received result: #{results.size} -> #{Time.now.to_f - t.to_f}"
+          results << c.code
+
+        end
+      end
+      tasks.each(&:wait)
+    end
+
+    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_equal ITERS, results.size
+    assert_equal ITERS.times.map {200}, results
+  end
+
+  def test_multi_perform_yields_block_under_scheduler
+    if skip_no_async
+      return
+    end
+
+    url = "http://127.0.0.1:#{@port}/test"
+    yielded = 0
+    results = []
+
+    async_run do
+      m = Curl::Multi.new
+      ITERS.times do
+        c = Curl::Easy.new(url)
+        c.on_complete { results << c.code }
+        m.add(c)
+      end
+      m.perform do
+        yielded += 1
+      end
+    end
+
+    assert_operator yielded, :>=, 1, 'perform did not yield block while waiting under scheduler'
+    assert_equal ITERS, results.size
+    assert_equal ITERS.times.map {200}, results
+  end
+
+  def test_multi_single_request_scheduler_path
+    if skip_no_async
+      return
+    end
+
+    url = "http://127.0.0.1:#{@port}/test"
+    result = nil
+
+    async_run do
+      m = Curl::Multi.new
+      c = Curl::Easy.new(url)
+      c.on_complete { result = c.code }
+      m.add(c)
+      m.perform
+    end
+
+    assert_equal 200, result
+  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
+      c1 = Curl::Easy.new(url)
+      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
+    end
+
+    assert_equal [200, 200], results
+  end
+
+  private
+  def skip_no_async
+    if WINDOWS
+      warn 'Skipping fiber scheduler tests on Windows'
+      return true
+    end
+    unless HAS_ASYNC
+      warn 'Skipping fiber scheduler test (Async gem not available)'
+      return true
+    end
+    false
+  end
+
+  def async_run(&block)
+    # Prefer newer Async.run to avoid deprecated scheduler.async path.
+    if defined?(Async) && Async.respond_to?(:run)
+      Async.run(&block)
+    else
+      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
+end

data/tests/test_basic.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class TestBasic < Test::Unit::TestCase
+  include TestServerMethods
+  
+  def setup
+    server_setup
+  end
+  
+  def test_basic_request
+    puts "\n=== Testing basic request ==="
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.perform
+    puts "Response code: #{easy.response_code}"
+    puts "Body (first 100 chars): #{easy.body_str[0..100]}"
+    assert_equal 200, easy.response_code
+  end
+  
+  def test_slow_request
+    puts "\n=== Testing slow request ==="
+    url = TestServlet.url_to("/slow?seconds=0.1")
+    puts "URL: #{url}"
+    easy = Curl::Easy.new(url)
+    easy.perform
+    puts "Response code: #{easy.response_code}"
+    puts "Body: #{easy.body_str}"
+    assert_equal 200, easy.response_code
+  end
+end

data/tests/test_fiber_debug.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require 'async'
+
+class TestFiberDebug < Test::Unit::TestCase
+  include TestServerMethods
+  
+  def setup
+    server_setup
+  end
+  
+  def test_simple_fiber_request
+    puts "\n=== Starting simple fiber request test ==="
+    
+    run_async do |task|
+      puts "Inside Async block"
+      puts "Fiber scheduler available: #{Curl::Multi.fiber_scheduler_available?}"
+      
+      multi = Curl::Multi.new
+      easy = Curl::Easy.new(TestServlet.url)
+      easy.on_complete { |curl| puts "Request completed: #{curl.response_code}" }
+      
+      multi.add(easy)
+      puts "Added easy handle to multi"
+      
+      # Perform without block first
+      puts "Calling perform..."
+      multi.perform
+      puts "Perform completed"
+    end
+    
+    puts "Test completed"
+  end
+  
+  def test_fiber_with_block
+    puts "\n=== Starting fiber with block test ==="
+    
+    run_async do |task|
+      puts "Inside Async block"
+      
+      multi = Curl::Multi.new
+      easy = Curl::Easy.new(TestServlet.url_to("/slow?seconds=0.1"))
+      easy.on_complete { |curl| puts "Request completed: #{curl.response_code}" }
+      
+      multi.add(easy)
+      
+      block_calls = 0
+      multi.perform do
+        block_calls += 1
+        puts "Block called: #{block_calls}"
+        if block_calls < 5  # Limit iterations to prevent infinite loop
+          Async::Task.yield
+        end
+      end
+      
+      puts "Perform completed, block called #{block_calls} times"
+    end
+    
+    puts "Test completed"
+  end
+
+  private
+  def run_async(&block)
+    if defined?(Async) && Async.respond_to?(:run)
+      Async.run(&block)
+    else
+      Async(&block)
+    end
+  end
+end

data/tests/test_fiber_simple.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require 'async'
+
+class TestFiberSimple < Test::Unit::TestCase
+  include TestServerMethods
+  
+  def setup
+    server_setup
+  end
+  
+  def test_simple_concurrent
+    puts "\n=== Testing simple concurrent requests ==="
+    
+    results = []
+    
+    if Async.respond_to?(:run)
+      Async.run do |task|
+        puts "Fiber scheduler available: #{Curl::Multi.fiber_scheduler_available?}"
+        
+        multi = Curl::Multi.new
+        
+        # Add 3 requests
+        3.times do |i|
+          easy = Curl::Easy.new(TestServlet.url_to("/slow?seconds=0.2&id=#{i}"))
+          easy.on_complete { |curl| 
+            results << { id: i, code: curl.response_code }
+            puts "Request #{i} completed"
+          }
+          multi.add(easy)
+        end
+        
+        puts "Starting perform..."
+        start_time = Time.now
+        multi.perform  # No block
+        elapsed = Time.now - start_time
+        puts "Perform completed in #{elapsed.round(2)}s"
+      end
+    else
+      Async do |task|
+      puts "Fiber scheduler available: #{Curl::Multi.fiber_scheduler_available?}"
+      
+      multi = Curl::Multi.new
+      
+      # Add 3 requests
+      3.times do |i|
+        easy = Curl::Easy.new(TestServlet.url_to("/slow?seconds=0.2&id=#{i}"))
+        easy.on_complete { |curl| 
+          results << { id: i, code: curl.response_code }
+          puts "Request #{i} completed"
+        }
+        multi.add(easy)
+      end
+      
+      puts "Starting perform..."
+      start_time = Time.now
+      multi.perform  # No block
+      elapsed = Time.now - start_time
+      puts "Perform completed in #{elapsed.round(2)}s"
+      end
+    end
+    
+    assert_equal 3, results.size
+    results.each { |r| assert_equal 200, r[:code] }
+  end
+end

data/tests/test_real_url.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/curb'))
+require 'async'
+
+puts "Testing fiber scheduler with real URLs..."
+
+# Test without fiber scheduler
+puts "\n1. Without fiber scheduler:"
+start = Time.now
+multi = Curl::Multi.new
+
+easies = []
+3.times do |i|
+  easy = Curl::Easy.new("https://httpbin.org/delay/1")
+  easy.on_complete { |curl| puts "Request #{i} completed: #{curl.response_code}" }
+  multi.add(easy)
+  easies << easy
+end
+
+multi.perform
+elapsed = Time.now - start
+puts "Total time: #{elapsed.round(2)}s"
+
+# Test with fiber scheduler
+puts "\n2. With fiber scheduler:"
+if Async.respond_to?(:run)
+  Async.run do
+    puts "Fiber scheduler available: #{Curl::Multi.fiber_scheduler_available?}"
+    
+    start = Time.now
+    multi = Curl::Multi.new
+    
+    easies = []
+    3.times do |i|
+      easy = Curl::Easy.new("https://httpbin.org/delay/1")
+      easy.on_complete { |curl| puts "Request #{i} completed: #{curl.response_code}" }
+      multi.add(easy)
+      easies << easy
+    end
+    
+    multi.perform
+    elapsed = Time.now - start
+    puts "Total time: #{elapsed.round(2)}s"
+  end
+else
+  Async do
+    puts "Fiber scheduler available: #{Curl::Multi.fiber_scheduler_available?}"
+    
+    start = Time.now
+    multi = Curl::Multi.new
+    
+    easies = []
+    3.times do |i|
+      easy = Curl::Easy.new("https://httpbin.org/delay/1")
+      easy.on_complete { |curl| puts "Request #{i} completed: #{curl.response_code}" }
+      multi.add(easy)
+      easies << easy
+    end
+    
+    multi.perform
+    elapsed = Time.now - start
+    puts "Total time: #{elapsed.round(2)}s"
+  end
+end
+
+puts "\nDone!"

data/tests/test_simple_fiber.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/curb'))
+require 'async'
+
+puts "Testing simple fiber scheduler..."
+
+if Async.respond_to?(:run)
+  Async.run do
+    puts "Fiber scheduler available: #{Curl::Multi.fiber_scheduler_available?}"
+    
+    multi = Curl::Multi.new
+    easy = Curl::Easy.new("https://httpbin.org/delay/1")
+    easy.on_complete { |curl| puts "Request completed: #{curl.response_code}" }
+    
+    multi.add(easy)
+    puts "Starting perform..."
+    multi.perform
+    puts "Perform completed"
+  end
+else
+  Async do
+    puts "Fiber scheduler available: #{Curl::Multi.fiber_scheduler_available?}"
+    
+    multi = Curl::Multi.new
+    easy = Curl::Easy.new("https://httpbin.org/delay/1")
+    easy.on_complete { |curl| puts "Request completed: #{curl.response_code}" }
+    
+    multi.add(easy)
+    puts "Starting perform..."
+    multi.perform
+    puts "Perform completed"
+  end
+end
+
+puts "Done!"