curb 0.7.15 → 1.0.0

data/tests/tc_curl_multi.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require 'set'
 
 class TestCurbCurlMulti < Test::Unit::TestCase
   def teardown
@@ -6,6 +7,110 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     ObjectSpace.garbage_collect
   end
 
+  # for https://github.com/taf2/curb/issues/277
+  # must connect to an external
+  def test_connection_keepalive
+    # 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
+    omit("Skip, libcurl too old (< 7.22.0)") if Curl::CURL_VERSION.split('.')[1].to_i <= 22
+
+    @server.shutdown if @server
+    @test_thread.kill if @test_thread
+    @server = nil
+    File.unlink(locked_file)
+    Curl::Multi.autoclose = true
+    assert Curl::Multi.autoclose
+# XXX: thought maybe we can clean house here to have the full suite pass in osx... but for now running this test in isolate does pass
+#      additionally, if ss allows this to pass on linux without requesting google i think this is a good trade off... leaving some of the thoughts below
+#      in hopes that coming back to this later will find it and remember how to fix it
+#    types = Set.new
+#    close_types = Set.new([TCPServer,TCPSocket,Socket,Curl::Multi, Curl::Easy,WEBrick::Log])
+#    ObjectSpace.each_object {|o|
+#      if o.respond_to?(:close)
+#        types << o.class
+#      end
+#      if close_types.include?(o.class)
+#        o.close
+#      end
+#    }
+    #puts "unique types: #{types.to_a.join("\n")}"
+    GC.start # cleanup FDs left over from other tests
+    server_setup
+    GC.start # cleanup FDs left over from other tests
+
+    if `which ss`.strip.size == 0
+      # osx need lsof still :(
+      open_fds = lambda do
+        out = `/usr/sbin/lsof -p #{Process.pid} | egrep "TCP|UDP"`# | egrep ':#{TestServlet.port} ' | egrep ESTABLISHED`# | wc -l`.strip.to_i
+        #puts out.lines.join("\n")
+        out.lines.size
+      end
+    else
+      ss = `which ss`.strip
+      open_fds = lambda do
+        `#{ss} -n4 state established dport = :#{TestServlet.port} | wc -l`.strip.to_i
+      end
+    end
+    Curl::Multi.autoclose = false
+    before_open = open_fds.call
+    #puts "before_open: #{before_open.inspect}"
+    assert !Curl::Multi.autoclose
+    multi = Curl::Multi.new
+    multi.max_connects = 1 # limit to 1 connection within the multi handle
+
+    did_complete = false
+    5.times do |n|
+      easy = Curl::Easy.new(TestServlet.url) do |curl|
+        curl.timeout = 5 # ensure we don't hang for ever connecting to an external host
+        curl.on_complete {
+          did_complete = true
+        }
+      end
+      multi.add(easy)
+    end
+
+    multi.perform
+    assert did_complete
+    after_open = open_fds.call
+    #puts "after_open: #{after_open} before_open: #{before_open.inspect}"
+    assert_equal 1, (after_open - before_open), "with max connections set to 1 at this point the connection to google should still be open"
+    multi.close
+
+    after_open = open_fds.call
+    #puts "after_open: #{after_open} before_open: #{before_open.inspect}"
+    assert_equal 0, (after_open - before_open), "after closing the multi handle all connections should be closed"
+
+    Curl::Multi.autoclose = true
+    multi = Curl::Multi.new
+    did_complete = false
+    5.times do |n|
+      easy = Curl::Easy.new(TestServlet.url) do |curl|
+        curl.timeout = 5 # ensure we don't hang for ever connecting to an external host
+        curl.on_complete {
+          did_complete = true
+        }
+      end
+      multi.add(easy)
+    end
+
+    multi.perform
+    assert did_complete
+    after_open = open_fds.call
+    #puts "after_open: #{after_open} before_open: #{before_open.inspect}"
+    assert_equal 0, (after_open - before_open), "auto close the connections"
+  ensure
+    Curl::Multi.autoclose = false # restore default
+  end
+
+  def test_connection_autoclose
+    assert !Curl::Multi.autoclose
+    Curl::Multi.autoclose = true
+    assert Curl::Multi.autoclose
+  ensure
+    Curl::Multi.autoclose = false # restore default
+  end
+
   def test_new_multi_01
     d1 = ""
     c1 = Curl::Easy.new($TEST_URL) do |curl|
@@ -109,8 +214,12 @@ class TestCurbCurlMulti < Test::Unit::TestCase
 
     assert(m.idle?, 'A new Curl::Multi handle should be idle')
 
+    assert_nil e.multi
+
     m.add(e)
 
+    assert_not_nil e.multi
+
     assert((not m.idle?), 'A Curl::Multi handle with a request should not be idle')
 
     m.perform
@@ -121,7 +230,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
   def test_requests
     m = Curl::Multi.new
 
-    assert_equal([], m.requests, 'A new Curl::Multi handle should have no requests')
+    assert_equal(0, m.requests.length, 'A new Curl::Multi handle should have no requests')
 
     10.times do
       m.add(Curl::Easy.new($TEST_URL))
@@ -131,7 +240,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
 
     m.perform
 
-    assert_equal([], m.requests, 'A new Curl::Multi handle should have no requests after a perform')
+    assert_equal(0, m.requests.length, 'A new Curl::Multi handle should have no requests after a perform')
   end
 
   def test_cancel
@@ -144,7 +253,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
 
     m.cancel!
 
-    assert_equal([], m.requests, 'A new Curl::Multi handle should have no requests after being canceled')
+    assert_equal(0, m.requests.size, 'A new Curl::Multi handle should have no requests after being canceled')
   end
 
   def test_with_success
@@ -188,7 +297,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     c1.on_success do|c|
       success_called1 = true
       #puts "success 1 called: #{c.body_str.inspect}"
-      #assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body_str)
+      assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body_str)
     end
 
     c1.on_failure do|c,rc|
@@ -327,7 +436,6 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     Curl::Multi.download(urls,{},{},downloads) do|curl,download_path|
       assert_equal 200, curl.response_code
       assert File.exist?(download_path)
-      store = file_info[File.basename(download_path)]
       assert_equal file_info[File.basename(download_path)][:size], File.size(download_path), "incomplete download: #{download_path}"
     end
   ensure
@@ -342,7 +450,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     ]
     Curl::Multi.post(urls, {:follow_location => true, :multipart_form_post => true}, {:pipeline => true}) do|easy|
       str = easy.body_str
-      assert_match /POST/, str
+      assert_match(/POST/, str)
       fields = {}
       str.gsub(/POST\n/,'').split('&').map{|sv| k, v = sv.split('='); fields[k] = v }
       expected = urls.find{|s| s[:url] == easy.last_effective_url }
@@ -357,8 +465,8 @@ class TestCurbCurlMulti < Test::Unit::TestCase
            { :url => TestServlet.url, :method => :put, :put_data => "message",
              :headers => {'Content-Type' => 'application/json' } }]
     Curl::Multi.put(urls, {}, {:pipeline => true}) do|easy|
-      assert_match /PUT/, easy.body_str
-      assert_match /message/, easy.body_str
+      assert_match(/PUT/, easy.body_str)
+      assert_match(/message/, easy.body_str)
     end
   end
 
@@ -375,17 +483,36 @@ class TestCurbCurlMulti < Test::Unit::TestCase
       assert_equal nil, code
       case method
       when :post
-        assert_match /POST/, easy.body_str
+        assert_match(/POST/, easy.body_str)
       when :get
-        assert_match /GET/, easy.body_str
+        assert_match(/GET/, easy.body_str)
       when :put
-        assert_match /PUT/, easy.body_str
+        assert_match(/PUT/, easy.body_str)
       end
       #puts "#{easy.body_str.inspect}, #{method.inspect}, #{code.inspect}"
     end
   end
 
-  def test_mutli_recieves_500
+  def test_multi_easy_http_with_max_connects
+        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_connects => 1}) do|easy, code, method|
+      assert_equal nil, code
+      case method
+      when :post
+        assert_match(/POST/, easy.body_str)
+      when :get
+        assert_match(/GET/, easy.body_str)
+      when :put
+        assert_match(/PUT/, easy.body_str)
+      end
+    end
+  end
+
+  def test_multi_recieves_500
     m = Curl::Multi.new
     e = Curl::Easy.new("http://127.0.0.1:9129/methods")
     failure = false
@@ -410,7 +537,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     c = Curl::Easy.new("http://127.9.9.9:999110")
     m.remove(c)
   rescue => e
-    assert_equal 'Invalid easy handle', e.message
+    assert_equal 'CURLError: Invalid easy handle', e.message
     assert_equal 0, m.requests.size
   end
 
@@ -447,7 +574,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     m.add(c)
     m.add(c)
   rescue => e
-    assert_equal Curl::Err::MultiBadEasyHandle, e.class
+    assert Curl::Err::MultiBadEasyHandle == e.class || Curl::Err::MultiAddedAlready == e.class
   end
 
   def test_multi_default_timeout
@@ -462,5 +589,4 @@ class TestCurbCurlMulti < Test::Unit::TestCase
   def setup
     server_setup
   end
-
 end

data/tests/tc_curl_postfield.rb

@@ -2,63 +2,63 @@ require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
 class TestCurbCurlPostfield < Test::Unit::TestCase
   def test_private_new
-    assert_raise(NoMethodError) { Curl::PostField.new }  
+    assert_raise(NoMethodError) { Curl::PostField.new }
   end
-  
+
   def test_new_content_01
     pf = Curl::PostField.content('foo', 'bar')
-    
+
     assert_equal 'foo', pf.name
     assert_equal 'bar', pf.content
     assert_nil pf.content_type
     assert_nil pf.local_file
-    assert_nil pf.remote_file    
+    assert_nil pf.remote_file
     assert_nil pf.set_content_proc
   end
-    
+
   def test_new_content_02
     pf = Curl::PostField.content('foo', 'bar', 'text/html')
-    
+
     assert_equal 'foo', pf.name
     assert_equal 'bar', pf.content
     assert_equal 'text/html', pf.content_type
     assert_nil pf.local_file
     assert_nil pf.remote_file
-    assert_nil pf.set_content_proc    
-  end    
-  
+    assert_nil pf.set_content_proc
+  end
+
   def test_new_content_03
     l = lambda { |field| "never gets run" }
     pf = Curl::PostField.content('foo', &l)
-    
+
     assert_equal 'foo', pf.name
     assert_nil pf.content
     assert_nil pf.content_type
     assert_nil pf.local_file
     assert_nil pf.remote_file
-    
+
     # N.B. This doesn't just get the proc, but also removes it.
     assert_equal l, pf.set_content_proc
-  end    
+  end
 
   def test_new_content_04
     l = lambda { |field| "never gets run" }
     pf = Curl::PostField.content('foo', 'text/html', &l)
-    
+
     assert_equal 'foo', pf.name
     assert_nil pf.content
     assert_equal 'text/html', pf.content_type
     assert_nil pf.local_file
     assert_nil pf.remote_file
-    
+
     # N.B. This doesn't just get the proc, but also removes it.
     assert_equal l, pf.set_content_proc
-  end    
+  end
 
 
   def test_new_file_01
     pf = Curl::PostField.file('foo', 'localname')
-    
+
     assert_equal 'foo', pf.name
     assert_equal 'localname', pf.local_file
     assert_equal 'localname', pf.remote_file
@@ -67,44 +67,44 @@ class TestCurbCurlPostfield < Test::Unit::TestCase
     assert_nil pf.content
     assert_nil pf.set_content_proc
   end
-    
+
   def test_new_file_02
     pf = Curl::PostField.file('foo', 'localname', 'remotename')
-    
+
     assert_equal 'foo', pf.name
     assert_equal 'localname', pf.local_file
     assert_equal 'remotename', pf.remote_file
     assert_nil pf.content_type
     assert_nil pf.content
     assert_nil pf.set_content_proc
-  end    
-  
+  end
+
   def test_new_file_03
     l = lambda { |field| "never gets run" }
     pf = Curl::PostField.file('foo', 'remotename', &l)
-    
+
     assert_equal 'foo', pf.name
     assert_equal 'remotename', pf.remote_file
     assert_nil pf.local_file
     assert_nil pf.content_type
     assert_nil pf.content
-    
+
     # N.B. This doesn't just get the proc, but also removes it.
     assert_equal l, pf.set_content_proc
-  end    
+  end
 
   def test_new_file_04
     assert_raise(ArgumentError) do
       # no local name, no block
       Curl::PostField.file('foo')
     end
-    
+
     assert_raise(ArgumentError) do
       # no remote name with block
       Curl::PostField.file('foo') { |field| "never runs" }
     end
   end
-  
+
   def test_new_file_05
     # local gets ignored when supplying a block, but remote
     # is still set up properly.
@@ -118,15 +118,15 @@ class TestCurbCurlPostfield < Test::Unit::TestCase
     assert_nil pf.content
 
     assert_equal l, pf.set_content_proc
-  end    
-  
+  end
+
   def test_to_s_01
-    pf = Curl::PostField.content('foo', 'bar')    
+    pf = Curl::PostField.content('foo', 'bar')
     assert_equal "foo=bar", pf.to_s
   end
 
   def test_to_s_02
-    pf = Curl::PostField.content('foo', 'bar ton')    
+    pf = Curl::PostField.content('foo', 'bar ton')
     assert_equal "foo=bar%20ton", pf.to_s
   end
 

data/tests/tc_curl_protocols.rb

@@ -0,0 +1,37 @@
+class TestCurbCurlProtocols < Test::Unit::TestCase
+  include TestServerMethods
+
+  def setup
+    @easy = Curl::Easy.new
+    @easy.set :protocols, Curl::CURLPROTO_HTTP | Curl::CURLPROTO_HTTPS
+    @easy.follow_location = true
+    server_setup
+  end
+
+  def test_protocol_allowed
+    @easy.set :url, "http://127.0.0.1:9129/this_file_does_not_exist.html"
+    @easy.perform
+    assert_equal 404, @easy.response_code
+  end
+
+  def test_protocol_denied
+    @easy.set :url, "gopher://google.com/"
+    assert_raises Curl::Err::UnsupportedProtocolError do
+      @easy.perform
+    end
+  end
+
+  def test_redir_protocol_allowed
+    @easy.set :url, TestServlet.url + "/redirect"
+    @easy.set :redir_protocols, Curl::CURLPROTO_HTTP
+    @easy.perform
+  end
+
+  def test_redir_protocol_denied
+    @easy.set :url, TestServlet.url + "/redirect"
+    @easy.set :redir_protocols, Curl::CURLPROTO_HTTPS
+    assert_raises Curl::Err::UnsupportedProtocolError do
+      @easy.perform
+    end
+  end
+end

data/tests/timeout.rb

@@ -13,15 +13,27 @@ class TestCurbTimeouts < Test::Unit::TestCase
     elapsed = Time.now - start
     assert elapsed > 2
   end
-  
+
   def test_overall_timeout_on_dead_transfer
     curl = Curl::Easy.new(wait_url(2))
     curl.timeout = 1
+    exception = assert_raise(Curl::Err::TimeoutError) do
+      curl.http_get
+    end
+    assert_match(
+      /^Timeout was reached: Operation timed out after/,
+      exception.message
+    )
+  end
+
+  def test_overall_timeout_ms_on_dead_transfer
+    curl = Curl::Easy.new(wait_url(2))
+    curl.timeout_ms = 1000
     assert_raise(Curl::Err::TimeoutError) do
       curl.http_get
     end
   end
-  
+
   def test_clearing_timeout
     curl = Curl::Easy.new(wait_url(2))
     curl.timeout = 1
@@ -36,16 +48,20 @@ class TestCurbTimeouts < Test::Unit::TestCase
     curl = Curl::Easy.new(serve_url(100, 2, 3))
     curl.timeout = 1
     # transfer is aborted despite data being exchanged
-    assert_raise(Curl::Err::TimeoutError) do
+    exception = assert_raise(Curl::Err::TimeoutError) do
       curl.http_get
     end
+    assert_match(
+      /^Timeout was reached: Operation timed out after/,
+      exception.message
+    )
   end
   
   def test_low_speed_time_on_slow_transfer
     curl = Curl::Easy.new(serve_url(100, 1, 3))
     curl.low_speed_time = 2
     # use default low_speed_limit of 1
-    assert true, curl.http_get
+    assert_equal true, curl.http_get
   end
   
   def test_low_speed_time_on_very_slow_transfer
@@ -55,18 +71,26 @@ class TestCurbTimeouts < Test::Unit::TestCase
     # XXX for some reason this test fails if low speed limit is not specified
     curl.low_speed_limit = 1
     # use default low_speed_limit of 1
-    assert_raise(Curl::Err::TimeoutError) do
+    exception = assert_raise(Curl::Err::TimeoutError) do
       curl.http_get
     end
+    assert_match(
+      /^Timeout was reached: Operation too slow/,
+      exception.message
+    )
   end
   
   def test_low_speed_limit_on_slow_transfer
     curl = Curl::Easy.new(serve_url(10, 1, 3))
     curl.low_speed_time = 2
     curl.low_speed_limit = 1000
-    assert_raise(Curl::Err::TimeoutError) do
+    exception = assert_raise(Curl::Err::TimeoutError) do
       curl.http_get
     end
+    assert_match(
+      /^Timeout was reached: Operation too slow/,
+      exception.message
+    )
   end
   
   def test_clearing_low_speed_time