thin_http 0.1.0

data/README

@@ -0,0 +1,28 @@
+== ThinHTTP Library
+
+[ThinHTTP]          A light-weight and user friendly HTTP library.
+[MultipartFormData] Facilitates in building multipart/form-data encoded messages.
+[CookieCollection]  Handles the storing, parsing, and managing of HTTP cookies.
+
+== Applications
+
+* Testing environments
+* Embedded in full-blown HTTP clients
+* Automating HTTP transactions
+
+== Usage Examples (see "Examples" sections)
+
+* ThinHTTP
+* MultipartFormData
+* MIME Library (http://mime.rubyforge.org/)
+
+== Contact
+
+Please email inquiries to pachl at ecentryx dot com.
+
+[Home Page] http://thinhttp.rubyforge.org/
+[RubyForge] http://rubyforge.org/projects/thinhttp/
+
+== License
+
+The entire ThinHTTP library is free to use under the terms of the Ruby license.

data/Rakefile

@@ -0,0 +1,82 @@
+require 'rake/contrib/rubyforgepublisher'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'webrick'
+
+WEBRICK_PID_FILE = 'webrick/pid'
+WEBRICK_LOG_FILE = 'webrick/log'
+
+gem_spec = Gem::Specification.new do |s|
+  s.add_dependency 'mime', '>=0.1.0'
+  s.name = 'thin_http'
+  s.version = '0.1.0'
+  s.summary = 'Lightweight and user-friendly HTTP client library'
+  s.test_files = FileList['test/*_test.rb']
+  s.files = FileList['README', 'Rakefile', 'lib/**/*.rb', 'test/**/*']
+  s.author = 'Clint Pachl'
+  s.email = 'pachl@ecentryx.com'
+  s.homepage = 'http://thinhttp.rubyforge.org/'
+  s.rubyforge_project = 'thinhttp'
+  s.has_rdoc = true
+end
+
+
+Rake::GemPackageTask.new(gem_spec) do |pkg|
+  pkg.need_tar_gz = true
+end
+
+Rake::RDocTask.new do |rd|
+    rd.rdoc_files.include('README', 'lib/')
+    rd.rdoc_dir = 'html'  # :publish task looks here
+    rd.main = 'README'
+    rd.options << '--all' << '--inline-source'
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib' << 'test'
+  t.pattern = 'test/*_test.rb'
+  t.warning = true
+end
+
+desc 'Publish docs to RubyForge'
+task :publish => [:rerdoc] do
+  Rake::RubyForgePublisher.new('thinhttp', 'pachl').upload
+end
+
+namespace :webrick do
+
+  desc 'Start WEBrick (run before test task)'
+  task :start do
+  
+    if File.exist?(WEBRICK_PID_FILE)
+      puts "Already running (if not, remove '#{WEBRICK_PID_FILE}')."
+    else
+      webrick_pid = fork do
+        STDERR.reopen(WEBRICK_LOG_FILE, "w")
+      
+        s = WEBrick::HTTPServer.new(
+          :DocumentRoot => Dir::pwd + '/test/scaffold/htdocs',
+          :Port => ENV['WEBRICK_PORT'] || 2000
+        )
+      
+        trap('INT') {s.shutdown}
+        s.logger.info "Root=#{s.config[:DocumentRoot]}"
+        s.start
+      end
+    
+      open(WEBRICK_PID_FILE, 'w') {|f| f << webrick_pid}
+    end
+  
+  end
+  
+  desc 'Stop WEBrick (run after test task)'
+  task :stop do
+    if File.exist?(WEBRICK_PID_FILE)
+      webrick_pid = IO.read(WEBRICK_PID_FILE).to_i
+      Process.kill('INT', webrick_pid)
+      FileUtils.rm(WEBRICK_PID_FILE)
+    end
+  end
+
+end

data/lib/cookie_collection.rb

@@ -0,0 +1,85 @@
+require 'time'
+
+#
+# == Synopsis
+#
+# CookieCollection should be utilized by clients that need HTTP cookie
+# management. This class assists in storing and parsing raw cookies and
+# returning non-expired cookies for the cookie's originating server.
+#
+# *NOTE* This class is largely unimplemented and only stores and returns a
+# single raw cookie header without any processing or domain discretion.
+#
+# == Implementation Notes
+#
+# * RFC 2109, version 1 cookies (http://tools.ietf.org/html/rfc2109)
+# * Uses Netscapes' "Expires" instead of RFC's "Max-Age" attribute. Expires is
+#   an RFC 2822 date. 
+#
+#--
+# TODO Fully implement this class.
+#++
+# 
+class CookieCollection
+
+  #--
+  # XXX do we want to accept CGI::Cookie or raw cookie strings and convert to CGI::Cookie?
+  #++
+  def initialize
+    @cookies = nil
+  end
+
+  #--
+  # Need to parse set-cookie response string and instantiate a CGI::Cookie for
+  # each and store in +@cookies+.
+  #
+  # Example of 2 cookies returned by WEBrick:
+  #
+  # "VAL1=Data1; Version=1; Expires=Sat, 11 Oct 2008 11:17:54 GMT, VAL2=Data2; Max-Age=3600"
+  #++
+  def store cookie
+    @cookies = cookie
+  end
+
+  def clear
+    @cookies = nil
+  end
+
+  #--
+  # Don't return expired cookies.
+  # Commas seperate cookie values.
+  # Only compile cookies that have applicable domain and path.
+  # Cookie data needs to be ordered by path.
+  # 
+  # Cookie header to send in an HTTP request to the originating server.
+  #
+  # Cookie Header Syntax:
+  #   cookie          =    "Cookie:" cookie-version
+  #                        1*((";" | ",") cookie-value)
+  #   cookie-value    =    NAME "=" VALUE [";" path] [";" domain]
+  #   cookie-version  =    "$Version" "=" value
+  #   NAME            =    attr
+  #   VALUE           =    value
+  #   path            =    "$Path" "=" value
+  #   domain          =    "$Domain" "=" value
+  #
+  # Cookie Header Example:
+  #
+  #   $Version=1; Val1="data1"; $Path="/dir"; Val2="data2"; $Path="/"
+  #++
+  def cookie_header_data domain, path
+    @cookies
+    #@cookies.collect do |cookie|
+    #  next  if Time.rfc2822(cookie.expires) < Time.now 
+    #  next  if cookie.domain != domain
+    #  next  if cookie.path !~ /^#{path}/
+
+    #  "Cookie: #{cookie}"  if cookie.domain == domain
+    #end
+  end
+
+  def cookie_header domain, path
+    "Cookie: " + cookie_header_data(domain, path)
+  end
+
+end

data/lib/multipart_form_data.rb

@@ -0,0 +1,109 @@
+require 'pathname'
+require 'mime'
+
+#
+# == Synopsis
+#
+# MultipartFormData facilitates in building multipart/form-data encoded
+# messages that can be POSTed using ThinHTTP. This class is a simple wrapper
+# around the MIME::MultipartMedia::FormData class.
+#
+# == Caveats
+#
+# According to RFC 1867 and 2388, each field of the form is to be sent in the
+# order in which it occurs in the form. However, the Hash containing the form
+# fields inherently does not maintain order. This is probably not a problem.
+#
+# == Examples
+# 
+# === Simple usage of the class
+#
+# The following +params+ Hash:
+#
+#   params = {
+#     'text_field' => 'this is some text',
+#     'image_field' => Pathname.new('/tmp/pic.jpg')
+#   }
+#
+# simulates the following HTML form:
+#
+#   <form>
+#     <input type="text" name="text_field"/>
+#     <input type="file" name="image_field"/>
+#   </form>
+#
+# Creating and using a MultipartFormData instance initialized with +params+:
+#
+#   fd = MultipartFormData.new(params)
+#   fd.content_type   # outputs the content type header including boundary
+#   fd.content        # outputs the content (multipart/form-data encoded entities)
+#
+#
+# === Constructing a multipart/form-data message and POSTing it via ThinHTTP
+#
+#   form_data = MultipartFormData.new(
+#     :dog_owner => 'Mary Jane',
+#     :pic_comment => 'These are my two black lab/pit mix puppies.',
+#     :dog_pic1 => Pathname.new('/tmp/lexi.jpg'),
+#     :dog_pic2 => Pathname.new('/tmp/simone.jpg')
+#   )
+#
+#   th = ThinHTTP.new('petfotoz.com', 80)
+#   th.post('/photo_album.cgi', form_data, form_data.content_type)
+#
+class MultipartFormData
+
+  attr_reader :content_type
+
+  #
+  # Returns new MultipartFormData instance initialized with +params+. +params+
+  # is a Hash of key/value pairs representing HTML input variable names and
+  # values. For HTML file type inputs, use a Pathname object.
+  #
+  def initialize params
+    @form_data = MIME::MultipartMedia::FormData.new
+    @content_type = @form_data.content_type
+    initialize_form_data(params)
+  end
+
+  #
+  # Return the multipart/form-data content.
+  #
+  def to_s
+    @form_data.body
+  end
+  alias :content :to_s
+
+  private
+
+  #
+  # Add the +params+ to the form data.
+  #
+  def initialize_form_data params
+    params.each do |name, value|
+      @form_data.add_entity(media_type(value), name.to_s)
+    end
+  end
+
+  #
+  # Convert +param+, which can be a String or Pathname, to a MediaType.
+  #
+  def media_type param
+    case param
+    when String
+      MIME::TextMedia.new(param)
+    when Pathname
+      path = param.to_s
+
+      # return application/octet-stream if file content is unknown
+      begin
+        MIME::DiscreteMediaFactory.create(path)
+      rescue MIME::UnknownContentError
+        MIME::DiscreteMediaFactory.create(path, 'application/octet-stream')
+      end
+    else
+      raise 'invalid parameter'
+    end
+  end
+
+end

data/lib/thin_http.rb

@@ -0,0 +1,254 @@
+require 'cgi'
+require 'net/http'
+require 'cookie_collection'
+
+#
+# == Synopsis
+#
+# ThinHTTP is a light-weight and user friendly HTTP library.  This class is
+# useful for sending simple GET requests or uploading files via POST.
+#
+# By default, it sends URL encoded data (application/x-www-form-urlencoded).
+# MIME multipart encoded data (multipart/form-data) can be sent by utilizing
+# the MIME library or the MultipartFormData class.
+#
+# == Features
+#
+# * Implements GET and POST requests.
+# * Follows redirects using GET requests and set instance's host, port, and
+#   path attributes using the final destination URI.
+# * Accepts either a params hash or an encoded string for POST and GET
+#   requests.
+# * User-defined headers are sent with each request.
+# * Sends and receives cookies automatically.
+# * HTTP support only (HTTPS will be implemented when needed).
+#
+# == Design Goals
+#
+# * Extremely simple implementation and easy to use interface.
+# * Only implement what is absolutely necessary.
+# * Adhere to the RFCs.
+# * Utilize third party libraries for added functionality when appropriate
+#   (i.e. MIME library for constructing multipart/form-data POSTs).
+# * Build lightly on top of the standard Net::HTTP library.
+# * Useful as a test tool in unit and integration testing (original design
+#   goal).
+#
+# == Examples
+#
+# === GET Request
+#
+#   th = ThinHTTP.new('rubyforge.org', 80)
+#   th.set_header('User-Agent', th.class.to_s)
+#   response = th.get('/')
+#
+#
+# === POST Request (URL encoding)
+#
+#   th = ThinHTTP.new('example.com')
+#   response = th.post('/submit_form', :param1 => 'val1', :param2 => 'val2')
+#
+#
+# === POST Request (multipart/form-data encoding using MIME library)
+#
+#   fd = MIME::MultipartMedia::FormData.new
+#   fd.add_entity(MIME::TextMedia.new('Clint'), 'first_name')
+#   fd.add_entity(MIME::DiscreteMediaFactory.create('/tmp/pic.jpg'), 'portrait')
+#
+#   th = ThinHTTP.new('example.com')
+#   response = th.post('/upload_file', fd.body, fd.content_type)
+#
+#
+# == More Examples
+#
+# * Check the MultipartFormData class examples
+# * Check the ThinHTTPTest class source code
+#
+#--
+# TODO
+# * May want to create a Response object to encapsulate the HTTPResponse
+#   returned from the request methods. See SOAP::Response.
+# * May want to decompose the HTTP headers.
+#++
+#
+class ThinHTTP
+
+  attr_reader :host, :port
+  attr_accessor :path
+  attr_accessor :cookies
+  attr_accessor :request_headers
+  attr_accessor :response_headers
+
+  #
+  # Assign initial connection params for +host+, +port+, and +http_headers+. No
+  # connection is established until an HTTP method is invoked.
+  #
+  def initialize host = 'localhost', port = 2000, http_headers = {}
+    @host = host
+    @port = port
+    @path = ''
+    self.cookies = CookieCollection.new
+    self.request_headers = http_headers
+    self.response_headers = Hash.new
+  end
+
+  #
+  # Change the remote connection host.
+  #
+  def host= host
+    if @host != host
+      @host = host
+      reset_connection
+    end
+    @host
+  end
+
+  #
+  # Change the remote connection port.
+  #
+  def port= port
+    if @port != port
+      @port = port
+      reset_connection
+    end
+    @port
+  end
+
+  #
+  # Set the +name+ header and its +value+ in each request.
+  #
+  def set_header name, value
+    request_headers.store(name, value)
+  end
+
+  #
+  # Delete the +name+ header, thus not setting +name+ in subsequent requests.
+  #
+  def unset_header name
+    request_headers.delete(name)
+  end
+
+  #
+  # Send +params+ to +path+ as a GET request and return the response body.
+  #
+  # +params+ may be a URL encoded String or a Hash.
+  #
+  def get path, params = nil
+    url_path =
+      case params
+      when Hash    ; path + '?' + url_encode(params)
+      when String  ; path + '?' + params
+      when NilClass; path
+      else raise 'cannot process params'
+      end
+
+    send_request Net::HTTP::Get.new(url_path)
+  end
+
+  #
+  # Send +params+ to +path+ as a POST request and return the response body.
+  #
+  # +params+ may be a String or a Hash. If +params+ is a String, it is
+  # considered encoded data and +content_type+ must be set accordingly.
+  # Otherwise, the +params+ Hash is URL encoded.
+  #
+  def post path, params, content_type = 'application/x-www-form-urlencoded'
+    post_request = Net::HTTP::Post.new(path)
+    post_request.content_type = content_type
+    post_request.body = params.is_a?(Hash) ? url_encode(params) : params.to_s
+
+    send_request post_request
+  end
+
+
+  private
+
+  #
+  # Return an existing connection, otherwise create a new one.
+  #
+  def connection
+    @connection ||= Net::HTTP.new(host, port)
+  end
+
+  #
+  # Force a new HTTP connection on next connection attempt.
+  #
+  def reset_connection
+    @connection = nil
+  end
+
+  #
+  # Send +request+ to <tt>self.host:self.port</tt>, following redirection
+  # responses if necessary. Applicable cookies and user-defined headers are
+  # attached to the +request+ before sending.
+  #
+  # NOTE Sends and receives cookies in unverifiable transactions (i.e. 3rd
+  # party cookies).
+  #
+  # http://tools.ietf.org/html/rfc2965#section-3.3.6
+  #
+  def send_request request
+    self.path = request.path
+    request['cookie'] = cookies.cookie_header_data(host, request.path)
+    request_headers.each {|name, value| request[name] = value}
+
+    response = connection.request(request)
+
+    case response
+    when Net::HTTPSuccess
+      save_response_headers response
+      response.body
+    when Net::HTTPRedirection
+      uri = URI.parse(response['location'])
+      self.host = uri.host
+      self.port = uri.port
+      send_request redirection_request(request, uri.path)
+    else
+      response.error!
+    end
+  end
+
+  #
+  # Create a request that is to be utilized in following a redirection to
+  # +path+. The new request will inherit +prev_request+'s state tracking
+  # redirection information if available. A maximum of five sequential
+  # redirections will be followed.
+  #--
+  # TODO Adhere to RFC2616 redirection behavior when implementing new request
+  # methods. See http://tools.ietf.org/html/rfc2616#section-10.3 for details.
+  #++
+  #
+  def redirection_request prev_request, path
+    max_redirects = 5
+
+    class << (request = Net::HTTP::Get.new(path))
+      attr_accessor :num_redirects
+    end
+
+    if prev_request.respond_to? :num_redirects
+      raise 'exceeded redirection limit'  if prev_request.num_redirects >= max_redirects
+      request.num_redirects = prev_request.num_redirects + 1
+    else
+      request.num_redirects = 1
+    end
+    request
+  end
+
+  #
+  # Save +response+'s cookies and headers.
+  #
+  def save_response_headers response
+    cookies.store response['set-cookie']
+    self.response_headers = response.to_hash
+  end
+
+  #
+  # URL encodes +params+ hash.
+  #
+  def url_encode params
+    params.collect do |key,value|
+      CGI::escape(key.to_s) + "=" + CGI::escape(value)
+    end.join('&')
+  end
+
+end

data/test/cookie_collection_test.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+require 'cookie_collection'
+
+#
+# Test the CookieCollection class functionality.
+#
+class CookieCollectionTest < Test::Unit::TestCase
+
+  def test_cookie_initialization
+    cookies = CookieCollection.new
+    assert_kind_of CookieCollection, cookies
+  end
+
+end

data/test/multipart_form_data_test.rb

@@ -0,0 +1,62 @@
+require 'test/unit'
+require 'test_helper'
+require 'multipart_form_data'
+
+
+#
+# Test the MultipartFormData class functionality.
+#
+class MultipartFormDataTest < Test::Unit::TestCase
+
+  include TestHelper
+
+  def setup
+    @generalized_content_type = 'multipart/form-data; boundary=Boundary_00.00'
+  end
+
+  def test_initialization_with_text_and_file_params
+    params = {  # this will fail if params reorders the key/value pairs.
+      # symbol and string keys acceptable
+      :name => 'Betty Crocker',
+      'address' => '1234 Doughboy Lane',
+      'pie_pic' => Pathname.new(sd('/image.jpg'))
+    }
+    fd = MultipartFormData.new(params)
+    expected_content = IO.read(sd('/form_data.msg'))
+
+    assert_equal_content_type @generalized_content_type, fd.content_type
+    assert_equal_mime_message expected_content, fd.content
+    assert_equal fd.to_s, fd.content  # check alias
+  end
+
+  def test_initialization_with_unknown_file
+    params = { 'file_to_upload' => Pathname.new(sd('/unknown.yyy')) }
+    fd = MultipartFormData.new(params)
+    expected_content = IO.read(sd('/form_data_unknown.msg'))
+
+    assert_equal_content_type @generalized_content_type, fd.content_type
+    assert_equal_mime_message expected_content, fd.content
+  end
+
+  def test_initialization_with_valid_parameter_values
+    params = Hash.new
+    valid_params = ['some string', Pathname.new(sd('/image.jpg'))]
+
+    valid_params.each do |valid_param|
+      params['field'] = valid_param
+      assert_nothing_raised {MultipartFormData.new(params)}
+    end
+  end
+
+  def test_initialization_with_invalid_parameter_values
+    params = Hash.new
+    invalid_params = [1, [1,2,3], {:key=>'value'}]
+
+    invalid_params.each do |invalid_param|
+      params['field'] = invalid_param
+      err = assert_raise(RuntimeError) {MultipartFormData.new(params)}
+      assert_equal 'invalid parameter', err.message
+    end
+  end
+
+end

data/test/scaffold/ascii.txt

@@ -0,0 +1 @@
+this is an ASCII file

data/test/scaffold/form_data_unknown.msg

@@ -0,0 +1,8 @@
+--Boundary_10425688400.695421641501527
+Content-ID: <10425676800.215758180614315>
+Content-Disposition: form-data; name="file_to_upload"; filename="unknown.yyy"
+Content-Type: application/octet-stream
+
+this is an unknown file type
+
+--Boundary_10425688400.695421641501527--

data/test/scaffold/htdocs/cgi/echo_get_params.cgi

@@ -0,0 +1,5 @@
+#!/bin/sh
+# Echo URL encoded parameters.
+
+printf "Content-type: text/plain\n\n"
+printf "$QUERY_STRING"

data/test/scaffold/htdocs/cgi/echo_post_params.cgi

@@ -0,0 +1,5 @@
+#!/bin/sh
+# Echo POST parameters.
+
+echo "Content-type: text/plain\n"
+cat /dev/stdin

data/test/scaffold/htdocs/cgi/print_env.cgi

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+echo "Content-type: text/plain\n" 
+printenv

data/test/scaffold/htdocs/cgi/redirect_loop.cgi

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+echo redirect >> /tmp/REDIRECT
+
+cat << EOF
+Status: 307 Temporary Redirect
+Location: $REQUEST_URI
+
+EOF

data/test/scaffold/htdocs/cgi/redirect_to_external.cgi

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+cat << EOF
+Status: 307 Temporary Redirect
+Location: http://ecentryx.com:80/
+
+EOF

data/test/scaffold/htdocs/cgi/redirect_to_print_env.cgi

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+# Flush STDIN in case of POST or PUT request.
+cat /dev/stdin >/dev/null
+
+cat << EOF
+Status: 307 Temporary Redirect
+Location: http://$HTTP_HOST/cgi/print_env.cgi
+
+EOF

data/test/scaffold/htdocs/cgi/set_cookie.cgi

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+cat << EOF
+Status: 200 OK
+Set-Cookie: cookie_key=cookie_value
+
+EOF

data/test/scaffold/htdocs/index.html

@@ -0,0 +1,7 @@
+<html>
+<head><title>index.html</title></head>
+<body>
+	<h1>index.html</h1>
+	<p>ThinHTTP test</p>
+</body>
+</html>

data/test/scaffold/unknown.yyy

@@ -0,0 +1 @@
+this is an unknown file type

data/test/test_helper.rb

@@ -0,0 +1,31 @@
+module TestHelper
+
+  private
+
+  MATCH_BOUNDARY = /Boundary_\d+\.\d+/
+  MATCH_ID_HEADER  = /-ID: <[^>]+>\r\n/
+
+  def assert_equal_mime_message expected, actual
+    assert_equal normalize_message(expected), normalize_message(actual)
+  end
+
+  def assert_equal_content_type expected, actual
+    assert_equal expected.sub(MATCH_BOUNDARY, ''), actual.sub(MATCH_BOUNDARY, '')
+
+  end
+
+  #
+  # Make messages comparable by removing *-ID header values and boundaries.
+  #
+  def normalize_message message
+    message.
+      gsub(MATCH_ID_HEADER, "-ID:\r\n").
+      gsub(MATCH_BOUNDARY, "Boundary_")
+  end
+
+  def sd filename
+    @scaffold_dir ||= File.join(File.dirname(__FILE__), 'scaffold')
+    @scaffold_dir + filename
+  end
+
+end

data/test/thin_http_test.rb

@@ -0,0 +1,163 @@
+require 'test/unit'
+require 'test_helper'
+require 'thin_http'
+require 'multipart_form_data'
+
+
+#
+# Test the ThinHTTP class functionality by interacting with a local WEBrick
+# server.
+#
+class ThinHTTPTest < Test::Unit::TestCase
+
+  include TestHelper
+
+  def setup
+    @th = ThinHTTP.new
+  end
+
+  def test_thin_http_object_defaults
+    assert_equal @th.host, 'localhost'
+    assert_equal @th.port, 2000
+  end
+
+  def test_get_index
+    response = @th.get('/index.html')
+    index_html = IO.read(sd('/htdocs/index.html'))
+    assert_equal index_html, response 
+  end
+
+  def test_get_hash_params
+    params = {:one => 'abc', 'two' => 'xyz'}
+    response  = @th.get('/cgi/echo_get_params.cgi', params)
+    assert_equal_url_params params, response
+  end
+
+  def test_get_string_params
+    params = 'foo=bar&dead=beef'
+    response  = @th.get('/cgi/echo_get_params.cgi', params)
+    assert_equal_url_params params, response
+  end
+
+  def test_post_url_encoded_params
+    params = {:one => 'abc', :two => 'xyz'}
+    response = @th.post('/cgi/echo_post_params.cgi', params)
+    assert_equal_url_params params, response
+  end
+
+  def test_post_mime_encoded_params
+    form_data = MultipartFormData.new(
+      :name => 'John Schmo',
+      :address=>'1516 Nowhere Place'
+    )
+    response = @th.post('/cgi/echo_post_params.cgi', form_data, form_data.content_type)
+    assert_equal form_data.content, response
+  end
+
+  def test_post_mime_encoded_params_and_files
+    form_data = MultipartFormData.new(
+      :comment => 'this is a cool test',
+      :txtfile => Pathname.new(sd('/ascii.txt')),
+      :imgfile => Pathname.new(sd('/image.jpg'))
+    )
+    response = @th.post('/cgi/echo_post_params.cgi', form_data, form_data.content_type)
+    assert_equal form_data.content, response
+  end
+
+  def test_get_redirect_after_get_request
+    assert_equal '', @th.path
+    response = @th.get('/cgi/redirect_to_print_env.cgi')
+    assert_equal '/cgi/print_env.cgi', @th.path
+    assert_equal 'GET', print_env_var('METHOD', response)
+  end
+
+  def test_get_redirect_after_post_request
+    assert_equal '', @th.path
+    response = @th.post('/cgi/redirect_to_print_env.cgi', :post => 'test')
+    assert_equal '/cgi/print_env.cgi', @th.path
+    assert_equal 'GET', print_env_var('METHOD', response)
+  end
+
+  def test_exceed_maximum_redirects
+    err = assert_raise(RuntimeError) {@th.get('/cgi/redirect_loop.cgi')}
+    assert_equal 'exceeded redirection limit', err.message
+  end
+
+  def test_redirect_to_external_domain
+    initial_host = @th.host
+    initial_port = @th.port
+
+    @th.get('/cgi/redirect_to_external.cgi')
+
+    assert_not_equal initial_host, @th.host
+    assert_not_equal initial_port, @th.port
+  end
+
+  # TODO more elaborate cookie tests.
+  def test_set_and_get_cookie
+    @th.get('/cgi/set_cookie.cgi')
+    response = @th.get('/cgi/print_env.cgi')
+    assert_equal 'cookie_key=cookie_value', print_env_var('COOKIE', response)
+  end
+
+  def test_add_and_delete_custom_headers
+    user_agent_name = @th.class.to_s
+    referer_url = 'http://ecentryx.com/index.html'
+
+    @th.set_header('User-Agent', user_agent_name)
+    @th.set_header('Referer', referer_url)
+    response = @th.get('/cgi/print_env.cgi')
+
+    assert_equal user_agent_name, print_env_var('USER_AGENT', response)
+    assert_equal referer_url, print_env_var('REFERER', response)
+
+    @th.unset_header('User-Agent')
+    response = @th.get('/cgi/print_env.cgi')
+
+    assert_nil print_env_var('USER_AGENT', response)
+    assert_equal referer_url, print_env_var('REFERER', response)
+  end
+
+
+  private
+
+  #
+  # Test Helpers
+  #
+
+  #
+  # Easy comparison of URL params, which may be a Hash (i.e. {k1=>v1, k2=v2})
+  # or a String (i.e. "k1=v1&k2=v2").
+  #
+  def assert_equal_url_params expected, actual
+    assert_equal url_params_to_hash(expected), url_params_to_hash(actual)
+  end
+
+  #
+  # Converts +params+ to a Hash that contains only String keys. +params+
+  # represents URL parameters as a key/value Hash or a URL encoded String. 
+  #
+  def url_params_to_hash params
+    if params.is_a? Hash
+      params.inject({}) do |hsh, (key,value)|
+        hsh.store(key.to_s, value)
+        hsh
+      end
+    else
+      params.split('&').inject({}) do |hsh, key_value|
+        key, value = key_value.split('=')
+        hsh.store(key, value)
+        hsh
+      end
+    end
+  end
+
+  #
+  # Return the value of the environment variable +var_name+, otherwise nil.
+  # Works in conjunction with the CGI script print_env.cgi.
+  #
+  def print_env_var var_name, response
+    response.match(/#{var_name}=(.*)$/)[1]  rescue nil
+  end
+
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: thin_http
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Clint Pachl
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-06 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mime
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.0
+    version: 
+description: 
+email: pachl@ecentryx.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- Rakefile
+- lib/thin_http.rb
+- lib/cookie_collection.rb
+- lib/multipart_form_data.rb
+- test/scaffold
+- test/scaffold/image.jpg
+- test/scaffold/ascii.txt
+- test/scaffold/htdocs
+- test/scaffold/htdocs/cgi
+- test/scaffold/htdocs/cgi/echo_get_params.cgi
+- test/scaffold/htdocs/cgi/echo_post_params.cgi
+- test/scaffold/htdocs/cgi/redirect_loop.cgi
+- test/scaffold/htdocs/cgi/redirect_to_external.cgi
+- test/scaffold/htdocs/cgi/print_env.cgi
+- test/scaffold/htdocs/cgi/set_cookie.cgi
+- test/scaffold/htdocs/cgi/redirect_to_print_env.cgi
+- test/scaffold/htdocs/index.html
+- test/scaffold/unknown.yyy
+- test/scaffold/form_data.msg
+- test/scaffold/form_data_unknown.msg
+- test/thin_http_test.rb
+- test/multipart_form_data_test.rb
+- test/cookie_collection_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://thinhttp.rubyforge.org/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: thinhttp
+rubygems_version: 1.3.0
+signing_key: 
+specification_version: 2
+summary: Lightweight and user-friendly HTTP client library
+test_files: 
+- test/thin_http_test.rb
+- test/multipart_form_data_test.rb
+- test/cookie_collection_test.rb