codders-curb 0.8.0

data/tests/bug_instance_post_differs_from_class_post.rb

@@ -0,0 +1,53 @@
+# From Vlad Jebelev:
+#
+# - Second thing - I think you just probably didn't have the time to update 
+# instance methods yet but when I POST with a reusal of a previous curl 
+# instance, it doesnt' work for me, e.g. when I create a curl previously and 
+# then issue:
+#  
+#   c.http_post(login_url, *fields)
+#   
+# instead of:
+#  
+#   c = Curl::Easy.http_post(login_url, *fields) do |curl|
+#     ...  
+#   end
+#    
+# then the result I am getting is quite different.
+#
+# ================
+#
+# Update:
+#
+#   It seems that class httpost is incorrectly passing arguments down to 
+#   instance httppost. This bug is intermittent, but results in an
+#   exception from the first post when it occurs.
+#   
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class BugTestInstancePostDiffersFromClassPost < Test::Unit::TestCase
+  def test_bug
+    5.times do |i|
+      puts "Test ##{i}"
+      do_test
+      sleep 2
+    end
+  end
+
+  def do_test
+    c = Curl::Easy.http_post('https://www.google.com/accounts/ServiceLoginAuth',
+                Curl::PostField.content('ltmpl','m_blanco'))
+    body_c, header_c = c.body_str, c.header_str
+   
+    sleep 2
+
+    c.http_post('https://www.google.com/accounts/ServiceLoginAuth',
+                Curl::PostField.content('ltmpl','m_blanco'))
+    body_i, header_i = c.body_str, c.header_str
+
+    # timestamps will differ, just check first bit. We wont get here if
+    # the bug bites anyway...
+    assert_equal header_c[0..50], header_i[0..50]
+  end
+end
+

data/tests/bug_multi_segfault.rb

@@ -0,0 +1,14 @@
+# From safis  http://github.com/taf2/curb/issues#issue/5
+# irb: require 'curb'
+# irb: multi = Curl::Multi.new
+# irb: exit
+# <main>:47140: [BUG] Bus Error
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__),'..','ext'))
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__),'..','lib'))
+require 'curb'
+
+class BugMultiSegfault < Test::Unit::TestCase
+  def test_bug
+    multi = Curl::Multi.new
+  end
+end

data/tests/bug_postfields_crash.rb

@@ -0,0 +1,26 @@
+# From GICodeWarrior:
+#
+# $ ruby crash_curb.rb 
+# crash_curb.rb:7: [BUG] Segmentation fault
+# ruby 1.8.7 (2009-06-12 patchlevel 174) [x86_64-linux]
+# 
+# Aborted
+# crash_curb.rb:
+# #!/usr/bin/ruby
+# require 'rubygems'
+# require 'curb'
+# 
+# curl = Curl::Easy.new('http://example.com/')
+# curl.multipart_form_post = true
+# curl.http_post(Curl::PostField.file('test', 'test.xml'){'example data'})
+# Ubuntu 9.10
+# curb gem version 0.6.2.1
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class BugPostFieldsCrash < Test::Unit::TestCase
+  def test_crash
+    curl = Curl::Easy.new('http://example.com/')
+    curl.multipart_form_post = true
+    curl.http_post(Curl::PostField.file('test', 'test.xml'){'example data'})
+  end
+end

data/tests/bug_postfields_crash2.rb

@@ -0,0 +1,57 @@
+# Not sure if this is an IRB bug, but thought you guys should know.
+#
+# ** My Ruby version: ruby 1.8.7 (2009-06-12 patchlevel 174) [x86_64-linux]
+# ** Version of Rubygems: 1.3.5
+# ** Version of the Curb gem: 0.6.6.0
+#
+#
+# Transcript of IRB session:
+# ------------------------------------------------------------------------------------------------------------------
+# irb(main):001:0>  a =  {
+# irb(main):002:1*     :type => :pie,
+# irb(main):003:1*     :series => {
+# irb(main):004:2*       :names => [:a,:b],
+# irb(main):005:2*       :values => [70,30],
+# irb(main):006:2*       :colors => [:red,:green]
+# irb(main):007:2>     },
+# irb(main):008:1*     :output_format => :png
+# irb(main):009:1>   }
+# => {:type=>:pie, :output_format=>:png, :series=>{:names=>[:a, :b], :values=>[70, 30], :colors=>[:red, :green]}}
+# irb(main):010:0> post = []
+# => []
+# irb(main):011:0> require 'rubygems'
+# => true
+# irb(main):012:0> require 'curb'
+# => true
+# irb(main):013:0> include Curl
+# => Object
+# irb(main):014:0> a.each_pair do |k,v|
+# irb(main):015:1* post << PostField.content(k,v)
+# irb(main):016:1> end
+# => {:type=>:pie, :output_format=>:png, :series=>{:names=>[:a, :b], :values=>[70, 30], :colors=>[:red, :green]}}
+# irb(main):017:0> post
+# /usr/lib/ruby/1.8/irb.rb:302: [BUG] Segmentation fault
+# ruby 1.8.7 (2009-06-12 patchlevel 174) [x86_64-linux]
+#
+# Aborted
+# ------------------------------------------------------------------------------------------------------------------
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class BugPostFieldsCrash2 < Test::Unit::TestCase
+  def test_crash
+    a =  {
+       :type => :pie,
+       :series => {
+         :names => [:a,:b],
+         :values => [70,30],
+         :colors => [:red,:green]
+       },
+       :output_format => :png
+    }
+    post = []
+    a.each_pair do |k,v|
+      post << Curl::PostField.content(k,v)
+    end
+    post.inspect
+  end
+end

data/tests/bug_require_last_or_segfault.rb

@@ -0,0 +1,40 @@
+# From Vlad Jebelev:
+# 
+# - if I have a require statement after "require 'curb'" and there is a 
+# POST with at least 1 field, the script will fail with a segmentation 
+# fault, e.g. the following sequence fails every time for me (Ruby 1.8.5):
+# -----------------------------------------------------------------
+# require 'curb'
+# require 'uri'
+#  
+#  url = 'https://www.google.com/accounts/ServiceLoginAuth'
+#   
+#  c = Curl::Easy.http_post(
+#         'https://www.google.com/accounts/ServiceLoginAuth',
+#               [Curl:: PostField.content('ltmpl','m_blanco')] ) do |curl|
+#  end
+#  ------------------------------------------------------------------
+#  :..dev/util$ ruby seg.rb
+#  seg.rb:6: [BUG] Segmentation fault
+#  ruby 1.8.5 (2006-08-25) [i686-linux]
+#                
+#  Aborted
+#  ------------------------------------------------------------------
+#
+require 'test/unit'
+require 'rbconfig'
+
+$rubycmd = Config::CONFIG['RUBY_INSTALL_NAME'] || 'ruby'
+
+class BugTestRequireLastOrSegfault < Test::Unit::TestCase
+  def test_bug
+    5.times do |i|
+      puts "Test ##{i}"
+
+      # will be empty string if it segfaults...
+      assert_equal 'success', `#$rubycmd #{File.dirname(__FILE__)}/require_last_or_segfault_script.rb`.chomp
+      sleep 5
+    end
+  end
+end
+

data/tests/bugtests.rb

@@ -0,0 +1,9 @@
+$: << $TESTDIR = File.expand_path(File.dirname(__FILE__))
+puts "start"
+begin
+Dir[File.join($TESTDIR, 'bug_*.rb')].each { |lib| require lib }
+rescue Object => e
+  puts e.message
+ensure
+puts "done"
+end

data/tests/helper.rb

@@ -0,0 +1,199 @@
+# DO NOT REMOVE THIS COMMENT - PART OF TESTMODEL.
+# Copyright (c)2006 Ross Bamford. See LICENSE.
+$CURB_TESTING = true
+require 'uri'
+
+$TOPDIR = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+$EXTDIR = File.join($TOPDIR, 'ext')
+$LIBDIR = File.join($TOPDIR, 'lib')
+$:.unshift($LIBDIR)
+$:.unshift($EXTDIR)
+
+require 'curb'
+require 'test/unit'
+require 'fileutils'
+
+$TEST_URL = "file://#{URI.escape(File.expand_path(__FILE__).tr('\\','/').tr(':','|'))}"
+
+require 'thread'
+require 'webrick'
+
+# set this to true to avoid testing with multiple threads
+# or to test with multiple threads set it to false
+# this is important since, some code paths will change depending
+# on the presence of multiple threads
+TEST_SINGLE_THREADED=false
+
+# keep webrick quiet
+class ::WEBrick::HTTPServer
+  def access_log(config, req, res)
+    # nop
+  end
+end
+class ::WEBrick::BasicLog
+  def log(level, data)
+    # nop
+  end
+end
+
+#
+# Simple test server to record number of times a request is sent/recieved of a specific 
+# request type, e.g. GET,POST,PUT,DELETE
+#
+class TestServlet < WEBrick::HTTPServlet::AbstractServlet
+
+  def self.port=(p)
+    @port = p
+  end
+
+  def self.port
+    (@port or 9129)
+  end
+
+  def self.path
+    '/methods'
+  end
+
+  def self.url
+    "http://127.0.0.1:#{port}#{path}"
+  end
+
+  def respond_with(method,req,res)
+    res.body = method.to_s
+    $auth_header = req['Authorization']
+    res['Content-Type'] = "text/plain"
+  end
+
+  def do_GET(req,res)
+    if req.path.match /redirect$/
+      res.status = 302
+      res['Location'] = '/foo'
+    elsif req.path.match /not_here$/
+      res.status = 404
+    elsif req.path.match /error$/
+      res.status = 500
+    end
+    respond_with("GET#{req.query_string}",req,res)
+  end
+
+  def do_HEAD(req,res)
+    res['Location'] = "/nonexistent"
+    respond_with("HEAD#{req.query_string}",req,res)
+  end
+
+  def do_POST(req,res)
+    if req.query['filename'].nil?
+      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
+    else
+      respond_with(req.query['filename'],req,res)
+    end
+  end
+
+  def do_PUT(req,res)
+    res['X-Requested-Content-Type'] = req.content_type
+    respond_with("PUT\n#{req.body}",req,res)
+  end
+
+  def do_DELETE(req,res)
+    respond_with("DELETE#{req.query_string}",req,res)
+  end
+
+  def do_PURGE(req,res)
+    respond_with("PURGE#{req.query_string}",req,res)
+  end
+
+  def do_COPY(req,res)
+    respond_with("COPY#{req.query_string}",req,res)
+  end
+
+  def do_PATCH(req,res)
+    respond_with("PATCH\n#{req.body}",req,res)
+  end
+
+  def do_OPTIONS(req,res)
+    respond_with("OPTIONS#{req.query_string}",req,res)
+  end
+
+end
+
+module TestServerMethods
+  def locked_file
+    File.join(File.dirname(__FILE__),"server_lock-#{@__port}")
+  end
+
+  def server_setup(port=9129,servlet=TestServlet)
+    @__port = port
+    if @server.nil? and !File.exist?(locked_file)
+
+      File.open(locked_file,'w') {|f| f << 'locked' }
+      if TEST_SINGLE_THREADED
+        rd, wr = IO.pipe
+        @__pid = fork do
+          rd.close
+          rd = nil
+
+          # start up a webrick server for testing delete 
+          server = WEBrick::HTTPServer.new :Port => port, :DocumentRoot => File.expand_path(File.dirname(__FILE__))
+
+          server.mount(servlet.path, servlet)
+          server.mount("/ext", WEBrick::HTTPServlet::FileHandler, File.join(File.dirname(__FILE__),'..','ext'))
+
+          trap("INT") { server.shutdown }
+          GC.start
+          wr.flush
+          wr.close
+          server.start
+        end
+        wr.close
+        rd.read
+        rd.close
+      else
+        # start up a webrick server for testing delete 
+        @server = WEBrick::HTTPServer.new :Port => port, :DocumentRoot => File.expand_path(File.dirname(__FILE__))
+
+        @server.mount(servlet.path, servlet)
+        @server.mount("/ext", WEBrick::HTTPServlet::FileHandler, File.join(File.dirname(__FILE__),'..','ext'))
+        queue = Queue.new # synchronize the thread startup to the main thread
+
+        @test_thread = Thread.new { queue << 1; @server.start }
+
+        # wait for the queue
+        value = queue.pop
+        if !value
+          STDERR.puts "Failed to startup test server!"
+          exit(1)
+        end
+
+      end
+
+      exit_code = lambda do
+        begin
+          if File.exist?(locked_file)
+            File.unlink locked_file
+            if TEST_SINGLE_THREADED
+              Process.kill 'INT', @__pid
+            else
+              @server.shutdown unless @server.nil?
+            end
+          end
+          #@server.shutdown unless @server.nil?
+        rescue Object => e
+          puts "Error #{__FILE__}:#{__LINE__}\n#{e.message}"
+        end
+      end
+
+      trap("INT"){exit_code.call}
+      at_exit{exit_code.call}
+
+    end
+  rescue Errno::EADDRINUSE
+  end
+end

data/tests/mem_check.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+#require 'rubygems'
+#require 'rmem'
+
+#
+# Run some tests to measure the memory usage of curb, these tests require fork and ps
+#
+class TestCurbMemory < Test::Unit::TestCase
+
+  def test_easy_memory
+    easy_avg, easy_std = measure_object_memory(Curl::Easy)
+    printf "Easy average: %.2f kilobytes +/- %.2f kilobytes\n", easy_avg.to_f, easy_std.to_f
+
+    multi_avg, multi_std = measure_object_memory(Curl::Multi)
+    printf "Multi average: %.2f kilobytes +/- %.2f kilobytes\n", multi_avg.to_f, multi_std.to_f
+
+    # now that we have the average size of an easy handle lets see how much a multi request consumes with 10 requests
+  end
+
+  def c_avg(report)
+    sum = 0
+    report.each {|r| sum += r.last }
+    (sum.to_f / report.size)
+  end
+
+  def c_std(report,avg)
+    var = 0
+    report.each {|r| var += (r.last-avg)*(r.last-avg) }
+    Math.sqrt(var / (report.size-1))
+  end
+
+  def measure_object_memory(klass)
+    report = []
+    200.times do
+      res = mem_check do
+        obj = klass.new
+      end
+      report << res
+    end
+    avg = c_avg(report)
+    std = c_std(report,avg)
+    [avg,std]
+  end
+
+  def mem_check
+    # see: http://gist.github.com/264060 for inspiration of ps command line
+    rd, wr = IO.pipe
+    memory_usage = `ps -o rss= -p #{Process.pid}`.to_i # in kilobytes
+    fork do
+      before = `ps -o rss= -p #{Process.pid}`.to_i # in kilobytes
+      rd.close
+      yield
+      after = `ps -o rss= -p #{Process.pid}`.to_i # in kilobytes
+      wr.write((after - before))
+      wr.flush
+      wr.close
+    end
+    wr.close
+    total = rd.read.to_i
+    rd.close
+    Process.wait
+    # return the delta and the total
+    [memory_usage, total]
+  end
+end