curb 0.6.5.0 → 0.8.4

data/tests/tc_curl_easy.rb

@@ -1,6 +1,24 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+class FooNoToS 
+  undef to_s
+end
 
 class TestCurbCurlEasy < Test::Unit::TestCase
+  def test_threads
+    t = []
+    5.times do
+      t << Thread.new do
+        5.times do
+          c = Curl.get($TEST_URL)
+          assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body_str)
+          assert_equal "", c.header_str
+        end
+      end
+    end
+
+    t.each {|t| t.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)
@@ -57,8 +75,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal nil, c.on_body
   end
 
-  class Foo < Curl::Easy
-  end
+  class Foo < Curl::Easy ; end
   def test_new_05
     # can use Curl::Easy as a base class
     c = Foo.new
@@ -222,7 +239,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
 
     assert_equal $TEST_URL, c.url
     assert_equal "http://some.proxy", c.proxy_url
-    
+ 
     c.proxy_url = nil
     assert_equal $TEST_URL, c.url
     assert_nil c.proxy_url
@@ -352,6 +369,30 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal 30, c.dns_cache_timeout
   end
   
+  def test_low_speed_limit_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.low_speed_limit
+    
+    c.low_speed_limit = 3
+    assert_equal 3, c.low_speed_limit
+    
+    c.low_speed_limit = nil
+    assert_nil c.low_speed_limit
+  end
+  
+  def test_low_speed_time_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.low_speed_time
+    
+    c.low_speed_time = 3
+    assert_equal 3, c.low_speed_time
+    
+    c.low_speed_time = nil
+    assert_nil c.low_speed_time
+  end
+  
   def test_on_body
     blk = lambda { |i| i.length }
     
@@ -361,6 +402,25 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal blk, c.on_body   # sets handler nil, returns old handler
     assert_equal nil, c.on_body
   end
+
+  def test_inspect_with_no_url
+    c = Curl::Easy.new
+    assert_equal '#<Curl::Easy>', c.inspect
+  end
+  
+  def test_inspect_with_short_url
+    c = Curl::Easy.new('http://www.google.com/')
+    assert_equal "#<Curl::Easy http://www.google.com/>", c.inspect
+  end
+  
+  def test_inspect_truncates_to_64_chars
+    base_url      = 'http://www.google.com/'
+    truncated_url = base_url + 'x' * (64 - '#<Curl::Easy >'.size - base_url.size)
+    long_url      = truncated_url + 'yyyy'
+    c = Curl::Easy.new(long_url)
+    assert_equal 64, c.inspect.size
+    assert_equal "#<Curl::Easy #{truncated_url}>", c.inspect
+  end
   
   def test_on_header
     blk = lambda { |i| i.length }
@@ -416,7 +476,8 @@ class TestCurbCurlEasy < Test::Unit::TestCase
   def test_ssl_verify_host
     c = Curl::Easy.new    
     assert c.ssl_verify_host?
-    assert !c.ssl_verify_host = false
+    c.ssl_verify_host = 0
+    c.ssl_verify_host = false
     assert !c.ssl_verify_host?
   end
   
@@ -455,6 +516,24 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert c.multipart_form_post?
   end
 
+  def test_ignore_content_length
+    c = Curl::Easy.new
+    assert !c.ignore_content_length?
+    assert c.ignore_content_length = true
+    assert c.ignore_content_length?
+  end
+
+  def test_resolve_mode
+    c = Curl::Easy.new
+    assert_equal :auto, c.resolve_mode
+    c.resolve_mode = :ipv4
+    assert_equal :ipv4, c.resolve_mode 
+    c.resolve_mode = :ipv6
+    assert_equal :ipv6, c.resolve_mode 
+
+    assert_raises(ArgumentError) { c.resolve_mode = :bad }
+  end
+
   def test_enable_cookies
     c = Curl::Easy.new
     assert !c.enable_cookies?
@@ -497,13 +576,34 @@ class TestCurbCurlEasy < Test::Unit::TestCase
   end
 
   def test_on_success_with_on_failure
-    curl = Curl::Easy.new("#{$TEST_URL.gsub(/file:\/\//,'')}/not_here")
+    curl = Curl::Easy.new(TestServlet.url + '/error')
     on_failure_called = false
     curl.on_success {|c| } # make sure we get the failure call even though this handler is defined
     curl.on_failure {|c,code| on_failure_called = true }
     curl.perform
+    assert_equal 500, curl.response_code
     assert on_failure_called, "Failure handler not called" 
   end
+
+  def test_on_success_with_on_missing
+    curl = Curl::Easy.new(TestServlet.url + '/not_here')
+    on_missing_called = false
+    curl.on_success {|c| } # make sure we get the missing call even though this handler is defined
+    curl.on_missing {|c,code| on_missing_called = true }
+    curl.perform
+    assert_equal 404, curl.response_code
+    assert on_missing_called, "Missing handler not called" 
+  end
+
+  def test_on_success_with_on_redirect
+    curl = Curl::Easy.new(TestServlet.url + '/redirect')
+    on_redirect_called = false
+    curl.on_success {|c| } # make sure we get the redirect call even though this handler is defined
+    curl.on_redirect {|c,code| on_redirect_called = true }
+    curl.perform
+    assert_equal 302, curl.response_code
+    assert on_redirect_called, "Redirect handler not called" 
+  end
   
   def test_get_remote
     curl = Curl::Easy.new(TestServlet.url)
@@ -513,22 +613,42 @@ class TestCurbCurlEasy < Test::Unit::TestCase
   
   def test_post_remote
     curl = Curl::Easy.new(TestServlet.url)
-    curl.http_post
-    assert_equal "POST\n", curl.body_str
+    curl.http_post([Curl::PostField.content('document_id', 5)])
+    assert_equal "POST\ndocument_id=5", curl.unescape(curl.body_str)
   end
 
   def test_post_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|
-      count = 0
-      curl = Curl::Easy.send("http_#{method}", TestServlet.url) do|c|
-        count += 1
-        assert_equal Curl::Easy, c.class
+    [:post, :get, :head, :delete].each do |method|
+      retries = 0
+      begin
+        count = 0
+        curl = Curl::Easy.send("http_#{method}", TestServlet.url) do|c|
+          count += 1
+          assert_equal Curl::Easy, c.class
+        end
+        assert_equal 1, count, "For request method: #{method.to_s.upcase}"
+      rescue Curl::Err::HostResolutionError => e # travis-ci.org fails to resolve... try again?
+        retries+=1
+        retry if retries < 3
+        raise e
       end
-      assert_equal 1, count, "For request method: #{method.to_s.upcase}"
     end
   end
+
+  # see: https://github.com/rvanlieshout/curb/commit/8bcdefddc0162484681ebd1a92d52a642666a445
+  def test_post_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.http_post(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
     curl = Curl::Easy.new(TestServlet.url)
@@ -548,12 +668,27 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal 'foo=bar&encoded%20string=val', curl.post_body
   end
 
+  def test_post_multipart_file_remote
+    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
+  end
+
   def test_delete_remote
     curl = Curl::Easy.new(TestServlet.url)
     curl.http_delete
     assert_equal 'DELETE', curl.body_str
   end
 
+  def test_arbitrary_http_verb
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.http('PURGE')
+    assert_equal 'PURGE', curl.body_str
+  end
+
   def test_head_remote
     curl = Curl::Easy.new(TestServlet.url)
     curl.http_head
@@ -597,9 +732,27 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_match /message$/, curl.body_str
   end
 
+  # https://github.com/taf2/curb/issues/101
+  def test_put_data_null_bytes
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.put_data = "a\0b"
+ 
+    curl.perform
+    
+    assert_match /^PUT/, curl.body_str
+    assert_match "a\0b", curl.body_str
+  end
+
+  def test_put_nil_data_no_crash
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.put_data = nil
+    
+    curl.perform
+  end
+
   def test_put_remote_file
     curl = Curl::Easy.new(TestServlet.url)
-    File.open(__FILE__,'r') do|f|
+    File.open(__FILE__,'rb') do|f|
       assert curl.http_put(f)
     end
     assert_equal "PUT\n#{File.read(__FILE__)}", curl.body_str
@@ -621,24 +774,28 @@ class TestCurbCurlEasy < Test::Unit::TestCase
   def test_cert
     curl = Curl::Easy.new(TestServlet.url)
     curl.cert= File.join(File.dirname(__FILE__),"cert.pem")
-    assert /cert.pem$/,curl.cert
+    assert_match /cert.pem$/,curl.cert
   end
 
   def test_cert_with_password
     curl = Curl::Easy.new(TestServlet.url)
-    curl.cert= File.join(File.dirname(__FILE__),"cert.pem:password")
-    assert /cert.pem$/,curl.cert
+    path = File.join(File.dirname(__FILE__),"cert.pem")
+    curl.certpassword = 'password'
+    curl.cert = path
+    assert_match /cert.pem$/,curl.cert
   end
 
   def test_cert_type
     curl = Curl::Easy.new(TestServlet.url)
     curl.certtype= "DER"
-    assert "DER", curl.certtype
+    assert_equal "DER", curl.certtype
   end
 
   def test_default_certtype
     curl = Curl::Easy.new(TestServlet.url)
-    assert "PEM", curl.certtype
+    assert_nil curl.certtype
+    curl.certtype = "PEM"
+    assert_equal "PEM", curl.certtype
   end
 
   # Generate a CA cert with instructions at
@@ -646,13 +803,13 @@ 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 /cacert.pem$/, curl.cacert
+    assert_match /cacert.pem$/, curl.cacert
   end
 
   def test_user_agent
     curl = Curl::Easy.new(TestServlet.url)
     curl.useragent= "Curb-Easy/Ruby"
-    assert /ScrubDog$/,curl.useragent
+    assert_equal "Curb-Easy/Ruby",curl.useragent
   end
 
   def test_username_password
@@ -669,7 +826,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     #curl.verbose = true
     curl.perform
     assert_equal 'Basic Zm9vOmJhcg==', $auth_header
-
+    $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...
 
@@ -684,6 +841,182 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal 'NTLM TlRMTVNTUAABAAAABoIIAAAAAAAAAAAAAAAAAAAAAAA=', $auth_header
   end
 
+  def test_primary_ip
+    curl = Curl::Easy.new(TestServlet.url)
+    if curl.respond_to?(:primary_ip)
+      curl.perform
+      assert_equal '127.0.0.1', curl.primary_ip
+    end
+  end
+
+  def test_post_streaming
+    readme = File.expand_path(File.join(File.dirname(__FILE__),'..','README'))
+    
+    pf = Curl::PostField.file("filename", readme)
+
+    easy = Curl::Easy.new
+
+    easy.url = TestServlet.url
+    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))
+  end
+
+
+  def test_easy_close
+    easy = Curl::Easy.new
+    easy.close
+    easy.url = TestServlet.url
+    easy.http_get
+  end
+
+  def test_easy_reset
+    easy = Curl::Easy.new
+    easy.url = TestServlet.url + "?query=foo"
+    easy.http_get
+    settings = easy.reset
+    assert settings.key?(:url)
+    assert settings.key?(:body_data)
+    assert settings.key?(:header_data)
+    easy.url = TestServlet.url
+    easy.http_get
+  end
+
+  def test_easy_use_http_versions
+    easy = Curl::Easy.new
+    easy.url = TestServlet.url + "?query=foo"
+    #puts "http none: #{Curl::HTTP_NONE.inspect}"
+    #puts "http1.0: #{Curl::HTTP_1_0.inspect}"
+    #puts "http1.1: #{Curl::HTTP_1_1.inspect}"
+    easy.version = Curl::HTTP_1_1
+    #easy.verbose = true
+    easy.http_get
+  end
+
+  def test_easy_http_verbs
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.http_delete
+    assert_equal 'DELETE', curl.body_str
+    curl.http_get
+    assert_equal 'GET', curl.body_str
+    curl.http_post
+    assert_equal "POST\n", curl.body_str
+    curl.http('PURGE')
+    assert_equal 'PURGE', curl.body_str
+    curl.http_put('hello')
+    assert_equal "PUT\nhello", curl.body_str
+    curl.http('COPY')
+    assert_equal 'COPY', curl.body_str
+  end
+
+  def test_easy_http_verbs_must_respond_to_str
+    # issue http://github.com/taf2/curb/issues#issue/45
+    assert_nothing_raised do
+      c = Curl::Easy.new ; c.url = 'http://example.com' ; c.http(:get)
+    end
+
+    assert_raise RuntimeError do
+      c = Curl::Easy.new ; c.url = 'http://example.com' ; c.http(FooNoToS.new)
+    end
+
+  end
+
+  # http://github.com/taf2/curb/issues/#issue/33
+  def test_easy_http_verbs_with_errors
+    curl = Curl::Easy.new("http://127.0.0.1:9012/") # test will fail if http server on port 9012
+    assert_raise Curl::Err::ConnectionFailedError do
+      curl.http_delete
+    end
+    curl.url = TestServlet.url
+    curl.http_get
+    assert_equal 'GET', curl.body_str
+  end
+
+  def test_easy_can_put_with_content_length
+    curl = Curl::Easy.new(TestServlet.url)
+    rd, wr = IO.pipe
+    buf = (("hello")* (1000 / 5))
+
+    producer = Thread.new do
+      5.times do
+        wr << buf
+        sleep 0.1 # act as a slow producer
+      end
+    end
+
+    consumer = Thread.new do
+
+      #curl.verbose = true
+      curl.headers['Content-Length'] = buf.size * 5
+      curl.headers['User-Agent']     = "Something else"
+      curl.headers['Content-Type']   = "text/javascript"
+      curl.headers['Date']           = Time.now.httpdate
+      curl.headers['Host']           = 's3.amazonaws.com'
+      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
+      curl.header_str
+      curl.body_str
+    end
+
+    producer.join
+    wr.close
+    consumer.join
+
+  end
+
+  def test_get_set_multi_on_easy
+    easy = Curl::Easy.new
+    assert_nil easy.multi
+    multi = Curl::Multi.new
+    easy.multi = multi
+    assert_not_nil easy.multi
+    assert_equal multi, easy.multi
+  end
+
+  def test_raise_on_progress
+    c = Curl::Easy.new($TEST_URL)
+    c.on_progress {|w,x,y,z| raise "error" }
+    c.perform
+  rescue => e
+    assert_equal 'Curl::Err::AbortedByCallbackError', e.class.to_s
+    c.close
+  end
+
+  def test_raise_on_success
+    c = Curl::Easy.new($TEST_URL)
+    c.on_success {|x| raise "error" }
+    c.perform
+  rescue => e
+    assert_equal 'Curl::Err::AbortedByCallbackError', e.class.to_s
+    c.close
+  end
+
+  def test_raise_on_debug
+    c = Curl::Easy.new($TEST_URL)
+    c.on_debug { raise "error" }
+    c.perform
+    assert true, "raise in on debug has no effect"
+  end
+
+  def test_status_codes
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.perform
+    assert_equal '200 OK', curl.status
+  end
+
+  def test_close_in_on_callbacks
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.on_body {|d| curl.close; d.size }
+    assert_raises RuntimeError do
+      curl.perform
+    end
+  end
+
   include TestServerMethods 
 
   def setup

data/tests/tc_curl_easy_setopt.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class TestCurbCurlEasySetOpt < Test::Unit::TestCase
+  def setup
+    @easy = Curl::Easy.new
+  end
+
+  def test_opt_verbose
+    @easy.set :verbose, true
+    assert @easy.verbose?
+  end
+
+  def test_opt_header
+    @easy.set :header, true
+  end
+
+  def test_opt_noprogress
+    @easy.set :noprogress, true
+  end
+
+  def test_opt_nosignal
+    @easy.set :nosignal, true
+  end
+
+  def test_opt_url
+    url = "http://google.com/"
+    @easy.set :url, url
+    assert_equal url, @easy.url
+  end
+
+end

data/tests/tc_curl_multi.rb

@@ -70,7 +70,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
 
     m.perform
 
-    assert n, responses.size
+    assert_equal n, responses.size
     n.times do|i|
       assert_match(/^# DO NOT REMOVE THIS COMMENT/, responses[i], "response #{i}")
     end
@@ -93,7 +93,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
       end
       m.perform
 
-      assert n, responses.size
+      assert_equal n, responses.size
       n.times do|i|
         assert_match(/^# DO NOT REMOVE THIS COMMENT/, responses[i], "response #{i}")
       end
@@ -170,7 +170,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
 
     m.perform do
       # idle
-      puts "idling..."
+      #puts "idling..."
     end
 
     assert success_called2
@@ -308,6 +308,32 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     end
   end
 
+  def test_multi_easy_download_01
+    # test collecting response buffers to file e.g. on_body
+    root_uri = 'http://127.0.0.1:9129/ext/'
+    urls = []
+    downloads = []
+    file_info = {}
+    FileUtils.mkdir("tmp/")
+
+    # for each file store the size by file name
+    Dir[File.dirname(__FILE__) + "/../ext/*.c"].each do|path|
+      urls << (root_uri + File.basename(path))
+      downloads << "tmp/" + File.basename(path)
+      file_info[File.basename(path)] = {:size => File.size(path), :path => path}
+    end
+
+    # start downloads
+    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
+    FileUtils.rm_rf("tmp/")
+  end
+
   def test_multi_easy_post_01
     urls = [
       { :url => TestServlet.url + '?q=1', :post_fields => {'field1' => 'value1', 'k' => 'j'}},
@@ -359,7 +385,26 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     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
@@ -384,7 +429,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
 
@@ -424,6 +469,13 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     assert_equal Curl::Err::MultiBadEasyHandle, e.class
   end
 
+  def test_multi_default_timeout
+    assert_equal 100, Curl::Multi.default_timeout
+    Curl::Multi.default_timeout = 12
+    assert_equal 12, Curl::Multi.default_timeout
+    assert_equal 100, (Curl::Multi.default_timeout = 100)
+  end
+
   include TestServerMethods
 
   def setup

data/tests/tc_curl_postfield.rb

@@ -62,6 +62,7 @@ class TestCurbCurlPostfield < Test::Unit::TestCase
     assert_equal 'foo', pf.name
     assert_equal 'localname', pf.local_file
     assert_equal 'localname', pf.remote_file
+    assert_nothing_raised { pf.to_s }
     assert_nil pf.content_type
     assert_nil pf.content
     assert_nil pf.set_content_proc
@@ -136,6 +137,7 @@ class TestCurbCurlPostfield < Test::Unit::TestCase
 
   def test_to_s_04
     pf = Curl::PostField.file('foo.file', 'bar.file')
-    assert_raise(Curl::Err::InvalidPostFieldError) { pf.to_s }
+    assert_nothing_raised { pf.to_s }
+    #assert_raise(Curl::Err::InvalidPostFieldError) { pf.to_s }
   end
 end