curb 0.1.4 → 0.7.15

data/tests/helper.rb

@@ -11,5 +11,173 @@ $:.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)
+    respond_with(:GET,req,res)
+  end
+
+  def do_HEAD(req,res)
+    res['Location'] = "/nonexistent"
+    respond_with(:HEAD, 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,res)
+  end
+
+  def do_PURGE(req,res)
+    respond_with(:PURGE,req,res)
+  end
+
+  def do_COPY(req,res)
+    respond_with(:COPY,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

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

@@ -0,0 +1,75 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class TestCurbCurlDownload < Test::Unit::TestCase
+  include TestServerMethods 
+
+  def setup
+    server_setup
+  end
+  
+  def test_download_url_to_file_via_string
+    dl_url = "http://127.0.0.1:9129/ext/curb_easy.c"
+    dl_path = File.join(Dir::tmpdir, "dl_url_test.file")
+
+    curb = Curl::Easy.download(dl_url, dl_path)
+    assert File.exist?(dl_path)
+    assert_equal File.read(File.join(File.dirname(__FILE__), '..','ext','curb_easy.c')), File.read(dl_path)
+  ensure
+    File.unlink(dl_path) if File.exist?(dl_path)
+  end
+
+  def test_download_url_to_file_via_file_io
+    dl_url = "http://127.0.0.1:9129/ext/curb_easy.c"
+    dl_path = File.join(Dir::tmpdir, "dl_url_test.file")
+    io = File.open(dl_path, 'wb')
+
+    curb = Curl::Easy.download(dl_url, io)
+    assert io.closed?
+    assert File.exist?(dl_path)
+    assert_equal File.read(File.join(File.dirname(__FILE__), '..','ext','curb_easy.c')), File.read(dl_path)
+  ensure
+    File.unlink(dl_path) if File.exist?(dl_path)
+  end
+
+  def test_download_url_to_file_via_io
+    dl_url = "http://127.0.0.1:9129/ext/curb_easy.c"
+    dl_path = File.join(Dir::tmpdir, "dl_url_test.file")
+    reader, writer = IO.pipe
+
+    # Write to local file
+    fork do
+      begin
+        writer.close
+        File.open(dl_path, 'wb') { |file| file << reader.read }
+      ensure
+        reader.close rescue IOError # if the stream has already been closed
+      end
+    end
+
+    # Download remote source
+    begin
+      reader.close
+      curb = Curl::Easy.download(dl_url, writer)
+      Process.wait
+    ensure
+      writer.close rescue IOError # if the stream has already been closed, which occurs in Easy::download
+    end
+
+    assert File.exist?(dl_path)
+    assert_equal File.read(File.join(File.dirname(__FILE__), '..','ext','curb_easy.c')), File.read(dl_path)
+  ensure
+    File.unlink(dl_path) if File.exist?(dl_path)
+  end
+
+  def test_download_bad_url_gives_404
+    dl_url = "http://127.0.0.1:9129/this_file_does_not_exist.html"
+    dl_path = File.join(Dir::tmpdir, "dl_url_test.file")
+
+    curb = Curl::Easy.download(dl_url, dl_path)
+    assert_equal Curl::Easy, curb.class
+    assert_equal 404, curb.response_code
+  ensure
+    File.unlink(dl_path) if File.exist?(dl_path)
+  end
+
+end