curb 0.8.4 → 1.3.5

data/tests/tc_curl_native_coverage.rb

@@ -0,0 +1,145 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class TestCurbCurlErrorMappings < Test::Unit::TestCase
+  def assert_easy_error_mapping(code, expected_class)
+    actual_class, message = Curl::Easy.error(code)
+
+    assert_equal expected_class, actual_class
+    assert_kind_of String, message
+    assert_not_empty message
+  end
+
+  def test_easy_error_known_mappings
+    assert_easy_error_mapping(0, Curl::Err::CurlOK)
+    assert_easy_error_mapping(1, Curl::Err::UnsupportedProtocolError)
+    assert_easy_error_mapping(2, Curl::Err::FailedInitError)
+    assert_easy_error_mapping(3, Curl::Err::MalformedURLError)
+    assert_easy_error_mapping(5, Curl::Err::ProxyResolutionError)
+    assert_easy_error_mapping(6, Curl::Err::HostResolutionError)
+    assert_easy_error_mapping(7, Curl::Err::ConnectionFailedError)
+    assert_easy_error_mapping(23, Curl::Err::WriteError)
+    assert_easy_error_mapping(26, Curl::Err::ReadError)
+    assert_easy_error_mapping(28, Curl::Err::TimeoutError)
+    assert_easy_error_mapping(42, Curl::Err::AbortedByCallbackError)
+    assert_easy_error_mapping(47, Curl::Err::TooManyRedirectsError)
+    assert_easy_error_mapping(52, Curl::Err::GotNothingError)
+    assert_easy_error_mapping(55, Curl::Err::SendError)
+    assert_easy_error_mapping(56, Curl::Err::RecvError)
+    assert_easy_error_mapping(57, Curl::Err::ShareInUseError)
+    assert_easy_error_mapping(58, Curl::Err::SSLCertificateError)
+    assert_easy_error_mapping(59, Curl::Err::SSLCypherError)
+    assert_easy_error_mapping(61, Curl::Err::BadContentEncodingError)
+    assert_easy_error_mapping(63, Curl::Err::FileSizeExceededError)
+    assert_easy_error_mapping(64, Curl::Err::FTPSSLFailed)
+
+    ssl_peer_or_ca_error =
+      if Gem::Version.new(Curl::CURL_VERSION) >= Gem::Version.new('7.62.0')
+        Curl::Err::SSLPeerCertificateError
+      else
+        Curl::Err::SSLCACertificateError
+      end
+
+    assert_easy_error_mapping(60, ssl_peer_or_ca_error)
+  end
+
+  def test_easy_error_returns_error_info_for_known_numeric_range
+    0.upto(92) do |code|
+      error_class, message = Curl::Easy.error(code)
+
+      assert_kind_of Class, error_class
+      assert error_class <= Curl::Err::CurlError
+      assert_kind_of String, message
+      assert_not_empty message
+    end
+  end
+
+  def test_easy_error_uses_generic_mapping_for_unknown_codes
+    error_class, message = Curl::Easy.error(9_999)
+
+    assert_equal Curl::Err::CurlError, error_class
+    assert_equal 'Unknown error result from libcurl', message
+  end
+end
+
+class TestCurbCurlNativeCoverage < Test::Unit::TestCase
+  include TestServerMethods
+
+  def setup
+    server_setup
+  end
+
+  def test_clone_preserves_native_lists_after_original_handle_closes
+    easy = Curl::Easy.new("http://curb.invalid:#{TestServlet.port}#{TestServlet.path}")
+    easy.headers['X-Test'] = '1'
+    easy.proxy_headers['X-Proxy'] = '2'
+    easy.ftp_commands = ['PWD']
+    easy.resolve = ["curb.invalid:#{TestServlet.port}:127.0.0.1"]
+
+    clone = easy.clone
+    easy.close
+
+    clone.http_get
+
+    assert_equal 'GET', clone.body_str
+    assert_equal '1', clone.headers['X-Test']
+    assert_equal '2', clone.proxy_headers['X-Proxy']
+    assert_equal ['PWD'], clone.ftp_commands
+    assert_equal ["curb.invalid:#{TestServlet.port}:127.0.0.1"], clone.resolve
+  ensure
+    clone.close if defined?(clone) && clone
+    easy.close if defined?(easy) && easy
+  end
+
+  def test_clone_rebinds_upload_callbacks_to_clone_state
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.put_data = 'clone-data'
+
+    clone = easy.clone
+    easy.put_data = 'other-data'
+
+    clone.perform
+
+    assert_equal "PUT\nclone-data", clone.body_str
+  ensure
+    clone.close if defined?(clone) && clone
+    easy.close if defined?(easy) && easy
+  end
+
+  def test_native_accessors_round_trip
+    easy = Curl::Easy.new(TestServlet.url)
+
+    assert_equal '127.0.0.1', easy.interface = '127.0.0.1'
+    assert_equal 'user:pass', easy.userpwd = 'user:pass'
+    assert_equal 'proxy:pass', easy.proxypwd = 'proxy:pass'
+    assert_equal 'tests/cert.pem', easy.cert_key = 'tests/cert.pem'
+    assert_equal 'gzip', easy.encoding = 'gzip'
+
+    if easy.respond_to?(:max_send_speed_large=)
+      assert_equal 123, easy.max_send_speed_large = 123
+      assert_equal 123, easy.max_send_speed_large
+    end
+
+    if easy.respond_to?(:max_recv_speed_large=)
+      assert_equal 456, easy.max_recv_speed_large = 456
+      assert_equal 456, easy.max_recv_speed_large
+    end
+
+    assert_equal '127.0.0.1', easy.interface
+    assert_equal 'user:pass', easy.userpwd
+    assert_equal 'proxy:pass', easy.proxypwd
+    assert_equal 'tests/cert.pem', easy.cert_key
+    assert_equal 'gzip', easy.encoding
+  ensure
+    easy.close if defined?(easy) && easy
+  end
+
+  def test_upload_round_trips_stream_and_offset
+    upload = Curl::Upload.new
+    stream = StringIO.new('payload')
+
+    assert_same stream, upload.stream = stream
+    assert_same stream, upload.stream
+    assert_equal 7, upload.offset = 7
+    assert_equal 7, upload.offset
+  end
+end

data/tests/tc_curl_postfield.rb

@@ -2,109 +2,110 @@ 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')
-    
+    pf.content_type = 'text/super'
+
     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_equal 'text/super', pf.content_type
     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 +119,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
 
@@ -135,9 +136,185 @@ class TestCurbCurlPostfield < Test::Unit::TestCase
     assert_equal "foo=FOOBAR", pf.to_s
   end
 
+  def test_content_proc_survives_gc
+    pf = postfield_with_only_native_proc_reference
+
+    10.times do
+      GC.start(full_mark: true, immediate_sweep: true)
+      GC.compact if GC.respond_to?(:compact)
+    end
+
+    assert_equal "foo=FOOBAR", pf.to_s
+  end
+
   def test_to_s_04
     pf = Curl::PostField.file('foo.file', 'bar.file')
     assert_nothing_raised { pf.to_s }
     #assert_raise(Curl::Err::InvalidPostFieldError) { pf.to_s }
   end
+
+  def postfield_with_only_native_proc_reference
+    Curl::PostField.content('foo') { |field| field.name.upcase + "BAR" }
+  end
+end
+
+class TestCurbCurlPostfieldNativeCoverage < Test::Unit::TestCase
+  def test_attribute_writers_round_trip
+    pf = Curl::PostField.content('foo', 'bar')
+
+    assert_equal 'renamed', pf.name = 'renamed'
+    assert_equal 'payload', pf.content = 'payload'
+    assert_equal 'text/plain', pf.content_type = 'text/plain'
+    assert_equal 'local.txt', pf.local_file = 'local.txt'
+    assert_equal 'remote.txt', pf.remote_file = 'remote.txt'
+
+    assert_equal 'renamed', pf.name
+    assert_equal 'payload', pf.content
+    assert_equal 'text/plain', pf.content_type
+    assert_equal 'local.txt', pf.local_file
+    assert_equal 'remote.txt', pf.remote_file
+  end
+
+  def test_to_s_accepts_non_string_name_via_to_s
+    name_like = Object.new
+    def name_like.to_s
+      'fancy name'
+    end
+
+    pf = Curl::PostField.content(name_like, 'value')
+    assert_equal 'fancy%20name=value', pf.to_s
+  end
+
+  def test_to_s_uses_remote_file_when_local_file_is_missing
+    pf = Curl::PostField.file('upload', 'local.txt', 'remote.txt')
+    pf.local_file = nil
+
+    assert_equal 'upload=remote.txt', pf.to_s
+  end
+
+  def test_to_s_rejects_name_without_to_s
+    name_like = Class.new do
+      undef to_s
+    end.new
+
+    pf = Curl::PostField.content(name_like, 'value')
+
+    error = assert_raise(Curl::Err::InvalidPostFieldError) { pf.to_s }
+    assert_match(/Cannot convert unnamed field to string/, error.message)
+  end
+
+  def test_to_s_rejects_content_without_to_s
+    content_like = Class.new do
+      undef to_s
+    end.new
+
+    pf = Curl::PostField.content('name', content_like)
+
+    error = assert_raise(RuntimeError) { pf.to_s }
+    assert_match(/does not respond_to to_s/, error.message)
+  end
+
+  def test_multipart_rejects_unnamed_field
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.multipart_form_post = true
+    pf = Curl::PostField.content('name', 'value')
+    pf.name = nil
+
+    error = assert_raise(Curl::Err::InvalidPostFieldError) { curl.http_post(pf) }
+    assert_match(/Cannot post unnamed field/, error.message)
+  end
+
+  def test_multipart_rejects_content_field_without_data
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.multipart_form_post = true
+    pf = Curl::PostField.content('name', 'value')
+    pf.content = nil
+
+    error = assert_raise(Curl::Err::InvalidPostFieldError) { curl.http_post(pf) }
+    assert_match(/Cannot post content field with no data/, error.message)
+  end
+
+  def test_multipart_rejects_file_field_without_filename
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.multipart_form_post = true
+    pf = Curl::PostField.file('upload', 'remote.txt') { 'payload' }
+    pf.local_file = 'dummy.txt'
+    pf.remote_file = nil
+
+    error = assert_raise(Curl::Err::InvalidPostFieldError) { curl.http_post(pf) }
+    assert_match(/Cannot post file upload field with no filename/, error.message)
+  end
+end
+
+class TestCurbCurlPostfieldMultipartCoverage < Test::Unit::TestCase
+  include TestServerMethods
+
+  def setup
+    server_setup
+  end
+
+  def test_multipart_content_variants_include_dynamic_and_typed_fields
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.multipart_form_post = true
+
+    proc_without_type = Curl::PostField.content('proc_without_type') { 'alpha' }
+    proc_with_type = Curl::PostField.content('proc_with_type', 'text/plain') { 'beta' }
+    direct_with_type = Curl::PostField.content('direct_with_type', 'gamma', 'text/plain')
+
+    curl.http_post([proc_without_type, proc_with_type, direct_with_type])
+    body = curl.body_str
+
+    assert_match(/name="proc_without_type"/, body)
+    assert_match(/alpha/, body)
+    assert_match(/name="proc_with_type"/, body)
+    assert_match(/beta/, body)
+    assert_match(/name="direct_with_type"/, body)
+    assert_match(/gamma/, body)
+    assert_match(/Content-Type: text\/plain/, body)
+  end
+
+  def test_multipart_file_variants_include_buffered_and_local_uploads
+    readme = File.expand_path(File.join(File.dirname(__FILE__), '..', 'README.md'))
+
+    proc_without_type = Curl::PostField.file('proc_without_type', 'proc_without_type.txt') { 'alpha' }
+    proc_with_type = Curl::PostField.file('proc_with_type', 'proc_with_type.txt') { 'beta' }
+    proc_with_type.content_type = 'text/plain'
+
+    direct_without_type = Curl::PostField.file('direct_without_type', 'ignored.txt', 'direct_without_type.txt')
+    direct_without_type.content = 'gamma'
+    direct_without_type.local_file = nil
+
+    direct_with_type = Curl::PostField.file('direct_with_type', 'ignored.txt', 'direct_with_type.txt')
+    direct_with_type.content = 'delta'
+    direct_with_type.local_file = nil
+    direct_with_type.content_type = 'text/plain'
+
+    local_with_type = Curl::PostField.file('local_with_type', readme)
+    local_with_type.content_type = 'text/plain'
+
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.multipart_form_post = true
+    curl.http_post([proc_without_type, proc_with_type, direct_without_type, direct_with_type, local_with_type])
+    body = curl.body_str
+
+    assert_match(/name="proc_without_type"/, body)
+    assert_match(/filename="proc_without_type.txt"/, body)
+    assert_match(/alpha/, body)
+
+    assert_match(/name="proc_with_type"/, body)
+    assert_match(/filename="proc_with_type.txt"/, body)
+    assert_match(/beta/, body)
+
+    assert_match(/name="direct_without_type"/, body)
+    assert_match(/filename="direct_without_type.txt"/, body)
+    assert_match(/gamma/, body)
+
+    assert_match(/name="direct_with_type"/, body)
+    assert_match(/filename="direct_with_type.txt"/, body)
+    assert_match(/delta/, body)
+
+    assert_match(/name="local_with_type"/, body)
+    assert_match(/Curb - Libcurl bindings for Ruby/, body)
+    assert_match(/Content-Type: text\/plain/, body)
+  end
 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