curb 0.9.8 → 1.0.5

data/ext/curb_multi.c

@@ -43,8 +43,25 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy);
 static void rb_curl_multi_read_info(VALUE self, CURLM *mptr);
 static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_running);
 
-static VALUE callback_exception(VALUE unused) {
-  return Qfalse;
+static VALUE callback_exception(VALUE did_raise, VALUE exception) {
+  // TODO: we could have an option to enable exception reporting
+/*  VALUE ret = rb_funcall(exception, rb_intern("message"), 0);
+  VALUE trace = rb_funcall(exception, rb_intern("backtrace"), 0);
+  if (RB_TYPE_P(trace, T_ARRAY) && RARRAY_LEN(trace) > 0) {
+    printf("we got an exception: %s:%d\n", StringValueCStr(ret), RARRAY_LEN(trace));
+    VALUE sep = rb_str_new_cstr("\n");
+    VALUE trace_lines = rb_ary_join(trace, sep);
+    if (RB_TYPE_P(trace_lines, T_STRING)) {
+      printf("%s\n", StringValueCStr(trace_lines));
+    } else {
+      printf("trace is not a string??\n");
+    }
+  } else {
+    printf("we got an exception: %s\nno stack available\n", StringValueCStr(ret));
+  }
+  */
+  rb_hash_aset(did_raise, rb_easy_hkey("error"), exception);
+  return exception;
 }
 
 void curl_multi_free(ruby_curl_multi *rbcm) {
@@ -64,7 +81,7 @@ static void ruby_curl_multi_init(ruby_curl_multi *rbcm) {
 
 /*
  * call-seq:
- *   Curl::Multi.new                                   => #<Curl::Easy...>
+ *   Curl::Multi.new                                   => #<Curl::Easy...>
  *
  * Create a new Curl::Multi instance
  */
@@ -132,7 +149,7 @@ VALUE ruby_curl_multi_get_autoclose(VALUE klass) {
 
 /*
  * call-seq:
- *   multi.requests                                   => [#&lt;Curl::Easy...&gt;, ...]
+ *   multi.requests                                   => [#<Curl::Easy...>, ...]
  * 
  * Returns an array containing all the active requests on this Curl::Multi object.
  */
@@ -274,7 +291,7 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
   long response_code = -1;
   VALUE easy;
   ruby_curl_easy *rbce = NULL;
-  VALUE callargs, val = Qtrue;
+  VALUE callargs;
 
   CURLcode ecode = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, (char**)&easy);
 
@@ -295,55 +312,62 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
     raise_curl_easy_error_exception(ecode);
   }
 
+  VALUE did_raise = rb_hash_new();
+
   if (!rb_easy_nil("complete_proc")) {
     callargs = rb_ary_new3(2, rb_easy_get("complete_proc"), easy);
     rbce->callback_active = 1;
-    val = rb_rescue(call_status_handler1, callargs, callback_exception, Qnil);
+    rb_rescue(call_status_handler1, callargs, callback_exception, did_raise);
     rbce->callback_active = 0;
-    //rb_funcall( rb_easy_get("complete_proc"), idCall, 1, easy );
+    CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
   }
 
+#ifdef HAVE_CURLINFO_RESPONSE_CODE
   curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
+#else
+  // old libcurl
+  curl_easy_getinfo(rbce->curl, CURLINFO_HTTP_CODE, &response_code);
+#endif
+  long redirect_count;
+  curl_easy_getinfo(rbce->curl, CURLINFO_REDIRECT_COUNT, &redirect_count);
 
   if (result != 0) {
     if (!rb_easy_nil("failure_proc")) {
       callargs = rb_ary_new3(3, rb_easy_get("failure_proc"), easy, rb_curl_easy_error(result));
       rbce->callback_active = 1;
-      val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
+      rb_rescue(call_status_handler2, callargs, callback_exception, did_raise);
       rbce->callback_active = 0;
-      //rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
+      CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
     }
-  }
-  else if (!rb_easy_nil("success_proc") &&
+  } else if (!rb_easy_nil("success_proc") &&
           ((response_code >= 200 && response_code < 300) || response_code == 0)) {
     /* NOTE: we allow response_code == 0, in the case of non http requests e.g. reading from disk */
     callargs = rb_ary_new3(2, rb_easy_get("success_proc"), easy);
     rbce->callback_active = 1;
-    val = rb_rescue(call_status_handler1, callargs, callback_exception, Qnil);
+    rb_rescue(call_status_handler1, callargs, callback_exception, did_raise);
     rbce->callback_active = 0;
-    //rb_funcall( rb_easy_get("success_proc"), idCall, 1, easy );
-  }
-  else if (!rb_easy_nil("redirect_proc") &&
-          (response_code >= 300 && response_code < 400)) {
+    CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
+
+  } else if (!rb_easy_nil("redirect_proc") && ((response_code >= 300 && response_code < 400) || redirect_count > 0) ) {
     rbce->callback_active = 1;
     callargs = rb_ary_new3(3, rb_easy_get("redirect_proc"), easy, rb_curl_easy_error(result));
     rbce->callback_active = 0;
-    val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
-  }
-  else if (!rb_easy_nil("missing_proc") &&
+    rb_rescue(call_status_handler2, callargs, callback_exception, did_raise);
+    CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
+  } else if (!rb_easy_nil("missing_proc") &&
           (response_code >= 400 && response_code < 500)) {
     rbce->callback_active = 1;
     callargs = rb_ary_new3(3, rb_easy_get("missing_proc"), easy, rb_curl_easy_error(result));
     rbce->callback_active = 0;
-    val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
-  }
-  else if (!rb_easy_nil("failure_proc") &&
+    rb_rescue(call_status_handler2, callargs, callback_exception, did_raise);
+    CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
+  } else if (!rb_easy_nil("failure_proc") &&
           (response_code >= 500 && response_code <= 999)) {
     callargs = rb_ary_new3(3, rb_easy_get("failure_proc"), easy, rb_curl_easy_error(result));
     rbce->callback_active = 1;
-    val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
+    rb_rescue(call_status_handler2, callargs, callback_exception, did_raise);
     rbce->callback_active = 0;
-    //rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
+    CURB_CHECK_RB_CALLBACK_RAISE(did_raise);
   }
 
 }
@@ -627,6 +651,8 @@ void init_curb_multi() {
   idCall = rb_intern("call");
   cCurlMulti = rb_define_class_under(mCurl, "Multi", rb_cObject);
 
+  rb_undef_alloc_func(cCurlMulti);
+
   /* Class methods */
   rb_define_singleton_method(cCurlMulti, "new", ruby_curl_multi_new, 0);
   rb_define_singleton_method(cCurlMulti, "default_timeout=", ruby_curl_multi_set_default_timeout, 1);

data/ext/curb_postfield.c

@@ -195,9 +195,9 @@ void curl_postfield_free(ruby_curl_postfield *rbcpf) {
 
 /*
  * call-seq:
- *   Curl::PostField.content(name, content) => #<Curl::PostField...>
- *   Curl::PostField.content(name, content, content_type = nil) => #<Curl::PostField...>
- *   Curl::PostField.content(name, content_type = nil) { |field| ... } => #<Curl::PostField...>
+ *   Curl::PostField.content(name, content) => #<Curl::PostField...>
+ *   Curl::PostField.content(name, content, content_type = nil) => #<Curl::PostField...>
+ *   Curl::PostField.content(name, content_type = nil) { |field| ... } => #<Curl::PostField...>
  * 
  * Create a new Curl::PostField, supplying the field name, content,
  * and, optionally, Content-type (curl will attempt to determine this if
@@ -241,9 +241,9 @@ static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass)
 
 /*
  * call-seq:
- *   Curl::PostField.file(name, local_file_name) => #&lt;Curl::PostField...&gt;
- *   Curl::PostField.file(name, local_file_name, remote_file_name = local_file_name) => #&lt;Curl::PostField...&gt;
- *   Curl::PostField.file(name, remote_file_name) { |field| ... } => #&lt;Curl::PostField...&gt;
+ *   Curl::PostField.file(name, local_file_name) => #<Curl::PostField...>
+ *   Curl::PostField.file(name, local_file_name, remote_file_name = local_file_name) => #<Curl::PostField...>
+ *   Curl::PostField.file(name, remote_file_name) { |field| ... } => #<Curl::PostField...>
  * 
  * Create a new Curl::PostField for a file upload field, supplying the local filename
  * to read from, and optionally the remote filename (defaults to the local name).
@@ -399,7 +399,7 @@ static VALUE ruby_curl_postfield_remote_file_get(VALUE self) {
 
 /*
  * call-seq:
- *   field.set_content_proc { |field| ... }           => &lt;old proc&gt;
+ *   field.set_content_proc { |field| ... }           => <old proc>
  * 
  * Set a content proc for this field. This proc will be called during the
  * perform to supply the content for this field, overriding any setting
@@ -498,6 +498,8 @@ void init_curb_postfield() {
   
   cCurlPostField = rb_define_class_under(mCurl, "PostField", rb_cObject);
 
+  rb_undef_alloc_func(cCurlPostField);
+
   /* Class methods */
   rb_define_singleton_method(cCurlPostField, "content", ruby_curl_postfield_new_content, -1);
   rb_define_singleton_method(cCurlPostField, "file", ruby_curl_postfield_new_file, -1);

data/ext/curb_upload.c

@@ -72,6 +72,7 @@ VALUE ruby_curl_upload_offset_get(VALUE self) {
 /* =================== INIT LIB =====================*/
 void init_curb_upload() {
   cCurlUpload = rb_define_class_under(mCurl, "Upload", rb_cObject);
+  rb_undef_alloc_func(cCurlUpload);
   rb_define_singleton_method(cCurlUpload, "new", ruby_curl_upload_new, 0);
   rb_define_method(cCurlUpload, "stream=", ruby_curl_upload_stream_set, 1);
   rb_define_method(cCurlUpload, "stream", ruby_curl_upload_stream_get, 0);

data/ext/extconf.rb

@@ -18,6 +18,8 @@ elsif !have_library('curl') or !have_header('curl/curl.h')
   fail <<-EOM
   Can't find libcurl or curl/curl.h
 
+  Make sure development libs (ie libcurl4-openssl-dev) are installed on the system.
+
   Try passing --with-curl-dir or --with-curl-lib and --with-curl-include
   options to extconf.
   EOM
@@ -59,6 +61,9 @@ def have_constant(name)
   end
 end
 
+have_constant "curlopt_tcp_keepalive"
+have_constant "curlopt_tcp_keepidle"
+have_constant "curlopt_tcp_keepintvl"
 have_constant "curlinfo_appconnect_time"
 have_constant "curlinfo_redirect_time"
 have_constant "curlinfo_response_code"
@@ -153,6 +158,8 @@ have_func("curl_multi_timeout")
 have_func("curl_multi_fdset")
 have_func("curl_multi_perform")
 
+have_constant "curlopt_haproxyprotocol"
+
 # constants
 have_constant "curlopt_interleavefunction"
 have_constant "curlopt_interleavedata"
@@ -336,6 +343,9 @@ have_constant :CURL_SSLVERSION_TLSv1_0
 have_constant :CURL_SSLVERSION_TLSv1_1
 have_constant :CURL_SSLVERSION_TLSv1_2
 
+# Added in 7.52.0
+have_constant :CURL_SSLVERSION_TLSv1_3
+
 have_constant "curlopt_ssl_verifypeer"
 have_constant "curlopt_cainfo"
 have_constant "curlopt_issuercert"
@@ -395,6 +405,39 @@ have_constant "curlopt_path_as_is"
 # added in 7.43.0
 have_constant "curlopt_pipewait"
 
+have_constant "curlopt_proxy_ssl_verifyhost"
+
+# protocol constants
+have_constant "curlproto_all"
+have_constant "curlproto_dict"
+have_constant "curlproto_file"
+have_constant "curlproto_ftp"
+have_constant "curlproto_ftps"
+have_constant "curlproto_gopher"
+have_constant "curlproto_http"
+have_constant "curlproto_https"
+have_constant "curlproto_imap"
+have_constant "curlproto_imaps"
+have_constant "curlproto_ldap"
+have_constant "curlproto_ldaps"
+have_constant "curlproto_pop3"
+have_constant "curlproto_pop3s"
+have_constant "curlproto_rtmp"
+have_constant "curlproto_rtmpe"
+have_constant "curlproto_rtmps"
+have_constant "curlproto_rtmpt"
+have_constant "curlproto_rtmpte"
+have_constant "curlproto_rtmpts"
+have_constant "curlproto_rtsp"
+have_constant "curlproto_scp"
+have_constant "curlproto_sftp"
+have_constant "curlproto_smb"
+have_constant "curlproto_smbs"
+have_constant "curlproto_smtp"
+have_constant "curlproto_smtps"
+have_constant "curlproto_telnet"
+have_constant "curlproto_tftp"
+
 if try_compile('int main() { return 0; }','-Wall')
   $CFLAGS << ' -Wall'
 end
@@ -422,6 +465,8 @@ test_for("curl_easy_escape", "CURL_EASY_ESCAPE", %{
 
 have_func('rb_thread_blocking_region')
 have_header('ruby/thread.h') && have_func('rb_thread_call_without_gvl', 'ruby/thread.h')
+have_header('ruby/io.h')
+have_func('rb_io_stdio_file')
 
 create_header('curb_config.h')
 create_makefile('curb_core')

data/lib/curb.rb

@@ -1 +1,2 @@
+# frozen_string_literal: true
 require 'curl'

data/lib/curl/easy.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Curl
   class Easy
 
@@ -20,7 +21,7 @@ module Curl
     #
     def status
       # Matches the last HTTP Status - following the HTTP protocol specification 'Status-Line = HTTP-Version SP Status-Code SP (Opt:)Reason-Phrase CRLF'
-      statuses = self.header_str.scan(/HTTP\/\d(\.\d)?\s(\d+\s.*)\r\n/).map{ |match| match[1] }
+      statuses = self.header_str.to_s.scan(/HTTP\/\d(\.\d)?\s(\d+\s.*)\r\n/).map {|match| match[1] }
       statuses.last.strip if statuses.length > 0
     end
 
@@ -68,9 +69,15 @@ module Curl
       ret = self.multi.perform
       self.multi.remove self
 
+      if Curl::Multi.autoclose
+        self.multi.close
+        self.multi = nil
+      end
+
       if self.last_result != 0 && self.on_failure.nil?
-        error = Curl::Easy.error(self.last_result)
-        raise error.first.new(self.head)
+        (err_class, err_summary) = Curl::Easy.error(self.last_result)
+        err_detail = self.last_error
+        raise err_class.new([err_summary, err_detail].compact.join(": "))
       end
 
       ret
@@ -314,7 +321,7 @@ module Curl
 
       #
       # call-seq:
-      #   Curl::Easy.perform(url) { |easy| ... }           => #<Curl::Easy...>
+      #   Curl::Easy.perform(url) { |easy| ... }           => #<Curl::Easy...>
       #
       # Convenience method that creates a new Curl::Easy instance with
       # the specified URL and calls the general +perform+ method, before returning
@@ -332,7 +339,7 @@ module Curl
 
       #
       # call-seq:
-      #   Curl::Easy.http_get(url) { |easy| ... }          => #&lt;Curl::Easy...&gt;
+      #   Curl::Easy.http_get(url) { |easy| ... }          => #<Curl::Easy...>
       #
       # Convenience method that creates a new Curl::Easy instance with
       # the specified URL and calls +http_get+, before returning the new instance.
@@ -349,7 +356,7 @@ module Curl
 
       #
       # call-seq:
-      #   Curl::Easy.http_head(url) { |easy| ... }         => #&lt;Curl::Easy...&gt;
+      #   Curl::Easy.http_head(url) { |easy| ... }         => #<Curl::Easy...>
       #
       # Convenience method that creates a new Curl::Easy instance with
       # the specified URL and calls +http_head+, before returning the new instance.
@@ -403,7 +410,7 @@ module Curl
 
       #
       # call-seq:
-      #   Curl::Easy.http_delete(url) { |easy| ... }       => #&lt;Curl::Easy...&gt;
+      #   Curl::Easy.http_delete(url) { |easy| ... }       => #<Curl::Easy...>
       #
       # Convenience method that creates a new Curl::Easy instance with
       # the specified URL and calls +http_delete+, before returning the new instance.

data/lib/curl/multi.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
 module Curl
   class Multi
+    class DownloadError < RuntimeError
+      attr_accessor :errors
+    end
     class << self
       # call-seq:
       #   Curl::Multi.get(['url1','url2','url3','url4','url5'], :follow_location => true) do|easy|
@@ -143,7 +147,7 @@ module Curl
 
         max_connects.times do
           conf = urls_with_config.pop
-          add_free_handle.call conf, nil
+          add_free_handle.call(conf, nil) if conf
           break if urls_with_config.empty?
         end
 
@@ -152,7 +156,7 @@ module Curl
           if urls_with_config.size > 0 && free_handles.size > 0
             easy = free_handles.pop
             conf = urls_with_config.pop
-            add_free_handle.call conf, easy
+            add_free_handle.call(conf, easy) if conf
           end
         end
 
@@ -240,7 +244,11 @@ module Curl
             errors << e
           end
         }
-        raise errors unless errors.empty?
+        if errors.any?
+          de = Curl::Multi::DownloadError.new
+          de.errors = errors
+          raise de
+        end
       end
     end
 

data/lib/curl.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'curb_core'
 require 'curl/easy'
 require 'curl/multi'
@@ -8,12 +9,20 @@ require 'cgi'
 module Curl
 
   def self.http(verb, url, post_body=nil, put_data=nil, &block)
-    handle = Thread.current[:curb_curl] ||= Curl::Easy.new
-    handle.reset
+    if Thread.current[:curb_curl_yielding]
+      handle = Curl::Easy.new # we can't reuse this
+    else
+      handle = Thread.current[:curb_curl] ||= Curl::Easy.new
+      handle.reset
+    end
     handle.url = url
     handle.post_body = post_body if post_body
     handle.put_data = put_data if put_data
-    yield handle if block_given?
+    if block_given?
+      Thread.current[:curb_curl_yielding] = true
+      yield handle
+      Thread.current[:curb_curl_yielding] = false
+    end
     handle.http(verb)
     handle
   end

data/tests/bug_crash_on_debug.rb

@@ -1,37 +1,23 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
-require 'webrick'
-class ::WEBrick::HTTPServer ; def access_log(config, req, res) ; end ; end
-class ::WEBrick::BasicLog ; def log(level, data) ; end ; end
-
-require 'curl'
-
 class BugCrashOnDebug < Test::Unit::TestCase
+  include BugTestServerSetupTeardown
 
   def test_on_debug
-    server = WEBrick::HTTPServer.new( :Port => 9999 )
-    server.mount_proc("/test") do|req,res|
-      res.body = "hi"
-      res['Content-Type'] = "text/html"
-    end
-    puts 'a'
-    thread = Thread.new(server) do|srv|
-      srv.start
-    end
-    puts 'b'
-    c = Curl::Easy.new('http://127.0.0.1:9999/test')
-    c.on_debug do|x|
-      puts x.inspect
-      raise "error" # this will get swallowed
+    c = Curl::Easy.new("http://127.0.0.1:#{@port}/test")
+    did_raise = false
+    did_call = false
+    begin
+      c.on_success do|x|
+        did_call = true
+        raise "error" # this will get swallowed
+      end
+      c.perform
+    rescue => e
+      did_raise = true
     end
-    c.perform
-    puts 'c'
-  ensure
-    puts 'd'
-    server.shutdown
-    puts 'e'
-    puts thread.exit
-    puts 'f'
+    assert did_raise
+    assert did_call
   end
 
 end

data/tests/bug_crash_on_progress.rb

@@ -1,22 +1,10 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-require 'webrick'
-class ::WEBrick::HTTPServer ; def access_log(config, req, res) ; end ; end
-class ::WEBrick::BasicLog ; def log(level, data) ; end ; end
 
 class BugCrashOnDebug < Test::Unit::TestCase
-  
-  def test_on_progress_raise
-    server = WEBrick::HTTPServer.new( :Port => 9999 )
-    server.mount_proc("/test") do|req,res|
-      res.body = "hi"
-      res['Content-Type'] = "text/html"
-    end
+  include BugTestServerSetupTeardown
 
-    thread = Thread.new(server) do|srv|
-      srv.start
-    end
-
-    c = Curl::Easy.new('http://127.0.0.1:9999/test')
+  def test_on_progress_raise
+    c = Curl::Easy.new("http://127.0.0.1:#{@port}/test")
     c.on_progress do|x|
       raise "error"
     end
@@ -27,21 +15,9 @@ class BugCrashOnDebug < Test::Unit::TestCase
   rescue => e
     assert_equal 'Curl::Err::AbortedByCallbackError', e.class.to_s
     c.close
-  ensure
-    server.shutdown
   end
 
   def test_on_progress_abort
-    server = WEBrick::HTTPServer.new( :Port => 9999 )
-    server.mount_proc("/test") do|req,res|
-      res.body = "hi"
-      res['Content-Type'] = "text/html"
-    end
-
-    thread = Thread.new(server) do|srv|
-      srv.start
-    end
-
     # see: https://github.com/taf2/curb/issues/192,
     # to pass:
     # 
@@ -54,20 +30,20 @@ class BugCrashOnDebug < Test::Unit::TestCase
     # 
     #  notice no return keyword
     #
-    c = Curl::Easy.new('http://127.0.0.1:9999/test')
+    c = Curl::Easy.new("http://127.0.0.1:#{@port}/test")
+    did_progress = false
     c.on_progress do|x|
-      puts "we're in the progress callback"
+      did_progress = true
       return false
     end
     c.perform
+    assert did_progress
 
     assert false, "should not reach this point"
 
   rescue => e
     assert_equal 'Curl::Err::AbortedByCallbackError', e.class.to_s
     c.close
-  ensure
-    server.shutdown
   end
 
 end

data/tests/bug_curb_easy_blocks_ruby_threads.rb

@@ -1,21 +1,19 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-require 'webrick'
-class ::WEBrick::HTTPServer ; def access_log(config, req, res) ; end ; end
-class ::WEBrick::BasicLog ; def log(level, data) ; end ; end
 
 class BugTestInstancePostDiffersFromClassPost < Test::Unit::TestCase
-  def test_bug
-    server = WEBrick::HTTPServer.new( :Port => 9999 )
-    server.mount_proc("/test") do|req,res|
+  include BugTestServerSetupTeardown
+
+  def setup
+    @port = 9999
+    @response_proc = lambda do|res|
       sleep 0.5
       res.body = "hi"
       res['Content-Type'] = "text/html"
     end
+    super
+  end
 
-    thread = Thread.new(server) do|srv|
-      srv.start
-    end
-
+  def test_bug
     threads = []
     timer = Time.now
 
@@ -45,8 +43,5 @@ class BugTestInstancePostDiffersFromClassPost < Test::Unit::TestCase
     puts "requested in #{single_time}"
 
     assert single_time > multi_time
-
-    server.shutdown
-    thread.join
   end
 end

data/tests/bug_curb_easy_post_with_string_no_content_length_header.rb

@@ -22,26 +22,15 @@ end
 Any insight you care to share would be helpful. Thanks.
 =end
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-require 'webrick'
-class ::WEBrick::HTTPServer ; def access_log(config, req, res) ; end ; end
-class ::WEBrick::BasicLog ; def log(level, data) ; end ; end
 
 class BugCurbEasyPostWithStringNoContentLengthHeader < Test::Unit::TestCase
-  def test_bug_workaround
-    server = WEBrick::HTTPServer.new( :Port => 9999 )
-    server.mount_proc("/test") do|req,res|
-      assert_equal '15', req['Content-Length']
-      res.body = "hi"
-      res['Content-Type'] = "text/html"
-    end
+  include BugTestServerSetupTeardown
 
-    thread = Thread.new(server) do|srv|
-      srv.start
-    end
+  def test_bug_workaround
     params = {:cat => "hat", :foo => "bar"}
 
     post_body = params.map{|f,k| "#{Curl::Easy.new.escape(f)}=#{Curl::Easy.new.escape(k)}"}.join('&')
-    c = Curl::Easy.http_post("http://127.0.0.1:9999/test",post_body) do |curl|
+    c = Curl::Easy.http_post("http://127.0.0.1:#{@port}/test",post_body) do |curl|
       curl.headers["User-Agent"] = "Curl/Ruby"
       curl.headers["X-Tender-Auth"] = "A Token"
       curl.headers["Accept"] = "application/vnd.tender-v1+json"
@@ -50,23 +39,12 @@ class BugCurbEasyPostWithStringNoContentLengthHeader < Test::Unit::TestCase
       curl.enable_cookies = true
     end
 
-    server.shutdown
-    thread.join
   end
-  def test_bug
-    server = WEBrick::HTTPServer.new( :Port => 9999 )
-    server.mount_proc("/test") do|req,res|
-      assert_equal '15', req['Content-Length']
-      res.body = "hi"
-      res['Content-Type'] = "text/html"
-    end
 
-    thread = Thread.new(server) do|srv|
-      srv.start
-    end
+  def test_bug
     params = {:cat => "hat", :foo => "bar"}
 
-    c = Curl::Easy.http_post("http://127.0.0.1:9999/test") do |curl|
+    c = Curl::Easy.http_post("http://127.0.0.1:#{@port}/test") do |curl|
       curl.headers["User-Agent"] = "Curl/Ruby"
       curl.headers["X-Tender-Auth"] = "A Token"
       curl.headers["Accept"] = "application/vnd.tender-v1+json"
@@ -76,8 +54,6 @@ class BugCurbEasyPostWithStringNoContentLengthHeader < Test::Unit::TestCase
       curl.follow_location = true
       curl.enable_cookies = true
     end
-
-    server.shutdown
-    thread.join
   end
+
 end