taf2-curb 0.4.8.0 → 0.4.9.0

data/ext/curb.h

@@ -20,11 +20,11 @@
 #include "curb_macros.h"
 
 // These should be managed from the Rake 'release' task.
-#define CURB_VERSION   "0.4.8.0"
-#define CURB_VER_NUM   480
+#define CURB_VERSION   "0.4.9.0"
+#define CURB_VER_NUM   490
 #define CURB_VER_MAJ   0
 #define CURB_VER_MIN   4
-#define CURB_VER_MIC   8
+#define CURB_VER_MIC   9
 #define CURB_VER_PATCH 0
 
 

data/ext/curb_easy.c

@@ -82,32 +82,6 @@ static size_t read_data_handler(void *ptr,
     return read_bytes;
   }
 
- // PutStream *pstream = (PutStream*)stream;
- // size_t sent_bytes = (size * nmemb);
- // size_t remaining = pstream->len - pstream->offset;
- /*
-
-  // amount remaining is less then the buffer to send  - can send it all
-  if( remaining < sent_bytes ) {
-    memcpy(ptr, pstream->buffer+pstream->offset, remaining);
-    sent_bytes = remaining;
-    pstream->offset += remaining;
-  }
-  else if( remaining > sent_bytes ) { // sent_bytes <= remaining - send what we can fit in the buffer(ptr)
-    memcpy(ptr, pstream->buffer+pstream->offset, sent_bytes);
-    pstream->offset += sent_bytes;
-  }
-  else { // they're equal
-    memcpy(ptr, pstream->buffer+pstream->offset, --sent_bytes);
-    pstream->offset += sent_bytes;
-  }
-  if (sent_bytes == 0) {
-    free(pstream);
-  }
-  */
-
-  //printf("sent_bytes: %ld of %ld\n", sent_bytes, remaining);
-  //return sent_bytes;
 }
 
 static size_t proc_data_handler(char *stream,
@@ -731,6 +705,70 @@ static VALUE ruby_curl_easy_post_body_get(VALUE self) {
   CURB_OBJECT_GETTER(ruby_curl_easy, postdata_buffer);
 }
 
+/*
+ * call-seq:
+ *   easy.put_data = data                             => ""
+ * 
+ * Points this Curl::Easy instance to data to be uploaded via PUT.  This
+ * sets the request to a PUT type request - useful if you want to PUT via
+ * a multi handle.
+ */
+static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
+  ruby_curl_easy *rbce;
+  CURL *curl;
+  
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  VALUE upload = ruby_curl_upload_new(cCurlUpload);
+  ruby_curl_upload_stream_set(upload,data);
+
+  curl = rbce->curl;
+  rbce->upload = upload; /* keep the upload object alive as long as
+                            the easy handle is active or until the upload
+                            is complete or terminated... */
+
+  curl_easy_setopt(curl, CURLOPT_NOBODY,0);
+  curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
+  curl_easy_setopt(curl, CURLOPT_READFUNCTION, (curl_read_callback)read_data_handler);
+  curl_easy_setopt(curl, CURLOPT_READDATA, rbce);
+
+  /* 
+   * we need to set specific headers for the PUT to work... so
+   * convert the internal headers structure to a HASH if one is set
+   */
+  if (rbce->headers != Qnil) {
+    if (rb_type(rbce->headers) == T_ARRAY || rb_type(rbce->headers) == T_STRING) {
+      rb_raise(rb_eRuntimeError, "Must set headers as a HASH to modify the headers in an PUT request");
+    }
+  }
+
+  if (rb_respond_to(data, rb_intern("read"))) {
+    VALUE stat = rb_funcall(data, rb_intern("stat"), 0);
+    if( stat ) {
+      if( rb_hash_aref(rbce->headers, rb_str_new2("Expect")) == Qnil ) {
+        rb_hash_aset(rbce->headers, rb_str_new2("Expect"), rb_str_new2(""));
+      }
+      VALUE size = rb_funcall(stat, rb_intern("size"), 0);
+      curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2INT(size));
+    }
+    else if( rb_hash_aref(rbce->headers, rb_str_new2("Transfer-Encoding")) == Qnil ) {
+      rb_hash_aset(rbce->headers, rb_str_new2("Transfer-Encoding"), rb_str_new2("chunked"));
+    }
+  }
+  else if (rb_respond_to(data, rb_intern("to_s"))) {
+    curl_easy_setopt(curl, CURLOPT_INFILESIZE, RSTRING_LEN(data));
+    if( rb_hash_aref(rbce->headers, rb_str_new2("Expect")) == Qnil ) {
+      rb_hash_aset(rbce->headers, rb_str_new2("Expect"), rb_str_new2(""));
+    }
+  }
+  else {
+    rb_raise(rb_eRuntimeError, "PUT data must respond to read or to_s");
+  }
+  
+  // if we made it this far, all should be well.
+  return data;
+}
+
 /* ================== IMMED ATTRS ==================*/
 
 /*
@@ -1632,7 +1670,11 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
   }
   if (rbce->cacert != Qnil) {
     // XXX: This should really be using the output of 'curl-config --ca'
+#ifdef HAVE_CURL_CONFIG_CA
+    curl_easy_setopt(curl, CURLOPT_CAINFO, CURL_CONFIG_CA);
+#else
     curl_easy_setopt(curl, CURLOPT_CAINFO, "/usr/local/share/curl/curl-ca-bundle.crt");
+#endif
   }
   
   /* Set the user-agent string if specified */
@@ -1667,6 +1709,8 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce, VALUE *body_buffer, VALUE *hea
  */
 VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, VALUE bodybuf, VALUE headerbuf, struct curl_slist *headers ) {
 
+  CURL *curl = rbce->curl;
+  
   // Free everything up
   if (headers) {
     curl_slist_free_all(headers);
@@ -1701,6 +1745,15 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, VALUE bodybuf, V
   } else {
     rbce->header_data = Qnil;
   }
+  
+  // clean up a PUT request's curl options.
+  if (rbce->upload != Qnil) {
+    rbce->upload = Qnil; // set the upload object to Qnil to let the GC clean up
+    curl_easy_setopt(curl, CURLOPT_UPLOAD, 0);
+    curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);
+    curl_easy_setopt(curl, CURLOPT_READDATA, NULL);
+    curl_easy_setopt(curl, CURLOPT_INFILESIZE, 0);
+  }
 
   return Qnil;
 }
@@ -1878,7 +1931,10 @@ static VALUE ruby_curl_easy_perform_head(VALUE self) {
 
   curl_easy_setopt(curl, CURLOPT_NOBODY, 1);
 
-  return handle_perform(self,rbce);
+  VALUE ret = handle_perform(self,rbce);
+
+  curl_easy_setopt(curl, CURLOPT_NOBODY, 0);
+  return ret;
 }
 
 /*
@@ -1914,61 +1970,14 @@ static VALUE ruby_curl_easy_set_head_option(VALUE self, VALUE onoff) {
 static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
   ruby_curl_easy *rbce;
   CURL *curl;
-
+  
   Data_Get_Struct(self, ruby_curl_easy, rbce);
-
-  VALUE upload = ruby_curl_upload_new(cCurlUpload);
-  ruby_curl_upload_stream_set(upload,data);
-
   curl = rbce->curl;
-  rbce->upload = upload; /* keep the upload object alive as long as
-                            the easy handle is active or until the upload
-                            is complete or terminated... */
-
-  curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
-  curl_easy_setopt(curl, CURLOPT_READFUNCTION, (curl_read_callback)read_data_handler);
-  curl_easy_setopt(curl, CURLOPT_READDATA, rbce);
-
-  /* 
-   * we need to set specific headers for the PUT to work... so
-   * convert the internal headers structure to a HASH if one is set
-   */
-  if (rbce->headers != Qnil) {
-    if (rb_type(rbce->headers) == T_ARRAY || rb_type(rbce->headers) == T_STRING) {
-      rb_raise(rb_eRuntimeError, "Must set headers as a HASH to modify the headers in an http_put request");
-    }
-  }
-
-  if (rb_respond_to(data, rb_intern("read"))) {
-    VALUE stat = rb_funcall(data, rb_intern("stat"), 0);
-    if( stat ) {
-      if( rb_hash_aref(rbce->headers, rb_str_new2("Expect")) == Qnil ) {
-        rb_hash_aset(rbce->headers, rb_str_new2("Expect"), rb_str_new2(""));
-      }
-      VALUE size = rb_funcall(stat, rb_intern("size"), 0);
-      curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2INT(size));
-    }
-    else if( rb_hash_aref(rbce->headers, rb_str_new2("Transfer-Encoding")) == Qnil ) {
-      rb_hash_aset(rbce->headers, rb_str_new2("Transfer-Encoding"), rb_str_new2("chunked"));
-    }
-  }
-  else if (rb_respond_to(data, rb_intern("to_s"))) {
-    curl_easy_setopt(curl, CURLOPT_INFILESIZE, RSTRING_LEN(data));
-    if( rb_hash_aref(rbce->headers, rb_str_new2("Expect")) == Qnil ) {
-      rb_hash_aset(rbce->headers, rb_str_new2("Expect"), rb_str_new2(""));
-    }
-  }
-  else {
-    rb_raise(rb_eRuntimeError, "PUT data must respond to read or to_s");
-  }
-
+  
+  ruby_curl_easy_put_data_set(self, data);
+  
   VALUE ret = handle_perform(self, rbce);
-  /* cleanup  */
-  curl_easy_setopt(curl, CURLOPT_UPLOAD, 0);
-  curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);
-  curl_easy_setopt(curl, CURLOPT_READDATA, NULL);
-  curl_easy_setopt(curl, CURLOPT_INFILESIZE, 0);
-
+  
   return ret;
 }
 
@@ -2531,6 +2540,21 @@ static VALUE ruby_curl_easy_ftp_entry_path_get(VALUE self) {
 #endif
 }
 
+/*
+ * call-seq:
+ *   easy.inspect                                => "#<Curl::Easy http://google.com/>"
+ */
+static VALUE ruby_curl_easy_inspect(VALUE self) {
+  char buf[64];
+  ruby_curl_easy *rbce;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+  // "#<Net::HTTP http://www.google.com/:80 open=false>"
+  snprintf(buf,sizeof(buf),"#<Curl::Easy %s", RSTRING_PTR(rbce->url));
+  size_t r = strlen(buf);
+  buf[r-1] = '>';
+  return rb_str_new(buf,r);
+}
+
 
 /* ================== ESCAPING FUNCS ==============*/
 
@@ -2676,6 +2700,7 @@ static VALUE ruby_curl_easy_class_perform_head(int argc, VALUE *argv, VALUE klas
   }
 
   ruby_curl_easy_perform_head(c);
+
   return c;
 }
 
@@ -2764,6 +2789,7 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "useragent", ruby_curl_easy_useragent_get, 0);
   rb_define_method(cCurlEasy, "post_body=", ruby_curl_easy_post_body_set, 1);
   rb_define_method(cCurlEasy, "post_body", ruby_curl_easy_post_body_get, 0);
+  rb_define_method(cCurlEasy, "put_data=", ruby_curl_easy_put_data_set, 1);
 
   rb_define_method(cCurlEasy, "local_port=", ruby_curl_easy_local_port_set, 1);
   rb_define_method(cCurlEasy, "local_port", ruby_curl_easy_local_port_get, 0);
@@ -2855,6 +2881,7 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "os_errno", ruby_curl_easy_os_errno_get, 0);
   rb_define_method(cCurlEasy, "num_connects", ruby_curl_easy_num_connects_get, 0);
   rb_define_method(cCurlEasy, "ftp_entry_path", ruby_curl_easy_ftp_entry_path_get, 0);
+  rb_define_method(cCurlEasy, "inspect", ruby_curl_easy_inspect, 0);
 
   /* Curl utils */
   rb_define_method(cCurlEasy, "escape", ruby_curl_easy_escape, 1);

data/ext/curb_multi.c

@@ -296,55 +296,57 @@ static VALUE ruby_curl_multi_cancel(VALUE self) {
   return self;
 }
 
-static void rb_curl_multi_read_info(VALUE self, CURLM *multi_handle) {
-  int msgs_left, result;
-  CURLMsg *msg;
-  CURLcode ecode;
-  CURL *easy_handle;
+static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int result) {
+
+  long response_code = -1;
   ruby_curl_easy *rbce = NULL;
 
-  /* check for finished easy handles and remove from the multi handle */
-  while ((msg = curl_multi_info_read(multi_handle, &msgs_left))) {
+  CURLcode ecode = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, (char**)&rbce);
 
-    if (msg->msg != CURLMSG_DONE) {
-      continue;
-    }
+  if (ecode != 0) {
+    raise_curl_easy_error_exception(ecode);
+  }
 
-    easy_handle = msg->easy_handle;
-    result = msg->data.result;
-    if (easy_handle) {
-      ecode = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, (char**)&rbce);
-      if (ecode != 0) {
-        raise_curl_easy_error_exception(ecode);
-      }
-      rbce->last_result = result; // save the last easy result code
-      ruby_curl_multi_remove( self, rbce->self );
+  rbce->last_result = result; /* save the last easy result code */
 
-      if (rbce->complete_proc != Qnil) {
-        rb_funcall( rbce->complete_proc, idCall, 1, rbce->self );
-      }
+  ruby_curl_multi_remove( self, rbce->self );
 
-      long response_code = -1;
-      curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
+  if (rbce->complete_proc != Qnil) {
+    rb_funcall( rbce->complete_proc, idCall, 1, rbce->self );
+  }
 
-      if (result != 0) {
-        if (rbce->failure_proc != Qnil) {
-          rb_funcall( rbce->failure_proc, idCall, 2, rbce->self, rb_curl_easy_error(result) );
-        }
-      }
-      else if (rbce->success_proc != Qnil &&
-              ((response_code >= 200 && response_code < 300) || response_code == 0)) {
-        /* NOTE: we allow response_code == 0, in the case the file is being read from disk */
-        rb_funcall( rbce->success_proc, idCall, 1, rbce->self );
-      }
-      else if (rbce->failure_proc != Qnil &&
-              (response_code >= 300 && response_code <= 999)) {
-        rb_funcall( rbce->failure_proc, idCall, 2, rbce->self, rb_curl_easy_error(result) );
-      }
-      rbce->self = Qnil;
+  curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
+
+  if (result != 0) {
+    if (rbce->failure_proc != Qnil) {
+      rb_funcall( rbce->failure_proc, idCall, 2, rbce->self, rb_curl_easy_error(result) );
     }
-    else {
-      //printf( "missing easy handle\n" );
+  }
+  else if (rbce->success_proc != Qnil &&
+          ((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 */
+    rb_funcall( rbce->success_proc, idCall, 1, rbce->self );
+  }
+  else if (rbce->failure_proc != Qnil &&
+          (response_code >= 300 && response_code <= 999)) {
+    rb_funcall( rbce->failure_proc, idCall, 2, rbce->self, rb_curl_easy_error(result) );
+  }
+  rbce->self = Qnil;
+}
+
+static void rb_curl_multi_read_info(VALUE self, CURLM *multi_handle) {
+  int msgs_left, result;
+  CURLMsg *msg;
+  CURL *easy_handle;
+
+  /* check for finished easy handles and remove from the multi handle */
+  while ((msg = curl_multi_info_read(multi_handle, &msgs_left))) {
+    if (msg->msg == CURLMSG_DONE) {
+      easy_handle = msg->easy_handle;
+      result = msg->data.result;
+      if (easy_handle) {
+        rb_curl_mutli_handle_complete(self, easy_handle, result);
+      }
     }
   }
 }
@@ -385,7 +387,7 @@ VALUE ruby_curl_multi_perform(VALUE self) {
   int maxfd, rc;
   fd_set fdread, fdwrite, fdexcep;
 
-  long timeout;
+  long timeout_milliseconds;
   struct timeval tv = {0, 0};
 
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
@@ -406,37 +408,46 @@ VALUE ruby_curl_multi_perform(VALUE self) {
 
 #ifdef HAVE_CURL_MULTI_TIMEOUT
     /* get the curl suggested time out */
-    mcode = curl_multi_timeout(rbcm->handle, &timeout);
+    mcode = curl_multi_timeout(rbcm->handle, &timeout_milliseconds);
     if (mcode != CURLM_OK) {
       raise_curl_multi_error_exception(mcode);
     }
 #else
     /* libcurl doesn't have a timeout method defined... make a wild guess */
-    timeout = 1; /* wait a second */
+    timeout_milliseconds = -1;
 #endif
+    //printf("libcurl says wait: %ld ms or %ld s\n", timeout_milliseconds, timeout_milliseconds/1000);
 
-    if (timeout == 0) { /* no delay */
+    if (timeout_milliseconds == 0) { /* no delay */
       rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
       continue;
     }
-    else if (timeout == -1) {
-      timeout = 1; /* wait a second */
+    else if(timeout_milliseconds < 0) {
+      timeout_milliseconds = 500; /* wait half a second, libcurl doesn't know how long to wait */
     }
-
-    if (rb_block_given_p()) {
-      rb_yield(self);
+#ifdef __APPLE_CC__
+    if(timeout_milliseconds > 1000) {
+      timeout_milliseconds = 1000; /* apple libcurl sometimes reports huge timeouts... let's cap it */
     }
+#endif
 
-    tv.tv_sec = timeout / 1000;
-    tv.tv_usec = (timeout * 1000) % 1000000;
+    tv.tv_sec = timeout_milliseconds / 1000; // convert milliseconds to seconds
+    tv.tv_usec = (timeout_milliseconds % 1000) * 1000; // get the remainder of milliseconds and convert to micro seconds
 
     rc = rb_thread_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
-    if (rc < 0) {
+    switch(rc) {
+    case -1:
       rb_raise(rb_eRuntimeError, "select(): %s", strerror(errno));
+      break;
+    case 0:
+      if (rb_block_given_p()) {
+        rb_yield(self);
+      }
+    default: 
+      rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
+      break;
     }
 
-    rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
-
   }
 
   return Qtrue;

data/ext/curb_postfield.c

@@ -143,7 +143,7 @@ void append_to_form(VALUE self,
   }
   
   if (result != 0) {
-    char *reason;
+    const char *reason = NULL;
     
     switch (result) {
       case CURL_FORMADD_MEMORY:

data/ext/extconf.rb

@@ -5,6 +5,9 @@ dir_config('curl')
 if find_executable('curl-config')
   $CFLAGS << " #{`curl-config --cflags`.strip}"
   $LIBS << " #{`curl-config --libs`.strip}"
+  ca_bundle_path=`curl-config --ca`.strip
+  $defs.push( %{-D HAVE_CURL_CONFIG_CA} )
+  $defs.push( %{-D CURL_CONFIG_CA='#{ca_bundle_path.inspect}'} )
 elsif !have_library('curl') or !have_header('curl/curl.h')
   fail <<-EOM
   Can't find libcurl or curl/curl.h

data/tests/bug_curb_easy_blocks_ruby_threads.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'helper')
+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

data/tests/bug_instance_post_differs_from_class_post.rb

@@ -23,7 +23,7 @@
 #   instance httppost. This bug is intermittent, but results in an
 #   exception from the first post when it occurs.
 #   
-require File.join(File.dirname(__FILE__), 'helper')
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
 class BugTestInstancePostDiffersFromClassPost < Test::Unit::TestCase
   def test_bug

data/tests/bug_multi_segfault.rb

@@ -3,8 +3,8 @@
 # irb: multi = Curl::Multi.new
 # irb: exit
 # <main>:47140: [BUG] Bus Error
-$:.unshift File.join(File.dirname(__FILE__),'..','ext')
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__),'..','ext'))
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__),'..','lib'))
 require 'curb'
 multi = Curl::Multi.new
 exit

data/tests/helper.rb

@@ -72,7 +72,15 @@ class TestServlet < WEBrick::HTTPServlet::AbstractServlet
   end
 
   def do_POST(req,res)
-    respond_with("POST\n#{req.body}",req,res)
+    if req.body
+      params = {}
+      req.body.split('&').map{|s| k,v=s.split('='); params[k] = v }
+    end
+    if params and params['s'] == '500'
+      res.status = 500
+    else
+      respond_with("POST\n#{req.body}",req,res)
+    end
   end
 
   def do_PUT(req,res)

data/tests/require_last_or_segfault_script.rb

@@ -21,8 +21,8 @@
 #  Aborted
 #  ------------------------------------------------------------------
 #
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'ext'))
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'ext')))
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
 require 'curb'
 require 'uri'
  

data/tests/tc_curl_download.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'helper')
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
 class TestCurbCurlDownload < Test::Unit::TestCase
   include TestServerMethods 

data/tests/tc_curl_easy.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'helper')
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
 class TestCurbCurlEasy < Test::Unit::TestCase
   def test_class_perform_01   
@@ -555,6 +555,16 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_match /^PUT/, curl.body_str
     assert_match /message$/, curl.body_str
     assert_match /application\/json/, curl.header_str
+  end 
+  
+  def test_put_data
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.put_data = 'message'
+    
+    curl.perform
+    
+    assert_match /^PUT/, curl.body_str
+    assert_match /message$/, curl.body_str
   end
 
   def test_put_remote_file

data/tests/tc_curl_multi.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'helper')
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
 class TestCurbCurlMulti < Test::Unit::TestCase
   def teardown
@@ -54,6 +54,8 @@ class TestCurbCurlMulti < Test::Unit::TestCase
 
   end
 
+  # NOTE: if this test runs slowly on Mac OSX, it is probably due to the use of a port install curl+ssl+ares install
+  # on my MacBook, this causes curl_easy_init to take nearly 0.01 seconds / * 100 below is 1 second too many!
   def test_n_requests
     n = 100
     m = Curl::Multi.new
@@ -220,6 +222,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     m = nil
   end
 
+  # This tests whether, ruby's GC will trash an out of scope easy handle
   class TestForScope
     attr_reader :buf
 
@@ -299,6 +302,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     Dir[File.dirname(__FILE__) + "/../ext/*.c"].each do|path|
       urls << root_uri + File.basename(path)
     end
+    urls = urls[0..(urls.size/2)] # keep it fast, webrick...
     Curl::Multi.get(urls, {:follow_location => true}, {:pipeline => true}) do|curl|
       assert_equal 200, curl.response_code
     end
@@ -321,6 +325,26 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     end
   end
 
+  def test_mutli_recieves_500
+    m = Curl::Multi.new
+    e = Curl::Easy.new("http://127.0.0.1:9129/methods")
+    failure = false
+    e.post_body = "hello=world&s=500"
+    e.on_failure{|c,r| failure = true }
+    e.on_success{|c| failure = false }
+    m.add(e)
+    m.perform
+    assert failure
+    e2 = Curl::Easy.new(TestServlet.url)
+    e2.post_body = "hello=world"
+    e2.on_failure{|c,r| failure = true }
+    m.add(e2)
+    m.perform
+    failure = false
+    assert !failure
+    assert_equal "POST\nhello=world", e2.body_str
+  end
+
   include TestServerMethods 
 
   def setup

data/tests/tc_curl_postfield.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'helper')
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
 class TestCurbCurlPostfield < Test::Unit::TestCase
   def test_private_new

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: taf2-curb
 version: !ruby/object:Gem::Version 
-  version: 0.4.8.0
+  version: 0.4.9.0
 platform: ruby
 authors: 
 - Ross Bamford
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-21 00:00:00 -07:00
+date: 2009-07-26 00:00:00 -07:00
 default_executable: 
 dependencies: []