em-http-request 0.3.0 → 1.0.0.beta.1

data/lib/em-http/http_connection.rb

@@ -0,0 +1,125 @@
+module EventMachine
+
+  module HTTPMethods
+    def get    options = {}, &blk;  setup_request(:get,   options, &blk); end
+    def head   options = {}, &blk;  setup_request(:head,  options, &blk); end
+    def delete options = {}, &blk;  setup_request(:delete,options, &blk); end
+    def put    options = {}, &blk;  setup_request(:put,   options, &blk); end
+    def post   options = {}, &blk;  setup_request(:post,  options, &blk); end
+  end
+
+  class FailedConnection
+    include HTTPMethods
+    include Deferrable
+
+    attr_accessor :error, :opts
+
+    def initialize(req)
+      @opts = req
+    end
+
+    def setup_request(method, options)
+      c = HttpClient.new(self, HttpOptions.new(@opts.uri, options, method), options)
+      c.close(@error)
+      c
+    end
+  end
+
+  class HttpConnection < Connection
+    include HTTPMethods
+    include Deferrable
+    include Socksify
+
+    attr_accessor :error, :opts
+
+    def setup_request(method, options = {})
+      c = HttpClient.new(self, HttpOptions.new(@opts.uri, options, method), options)
+      callback { c.connection_completed }
+
+      middleware.each do |m|
+        c.callback &m.method(:response) if m.respond_to?(:response)
+      end
+
+      @clients.push c
+      c
+    end
+
+    def middleware
+      [HttpRequest.middleware, @middleware].flatten
+    end
+
+    def post_init
+      @clients = []
+      @pending = []
+
+      @middleware = []
+
+      @p = Http::Parser.new
+      @p.on_headers_complete = proc do |h|
+        @clients.first.parse_response_header(h, @p.http_version, @p.status_code)
+      end
+
+      @p.on_body = proc do |b|
+        @clients.first.on_body_data(b)
+      end
+
+      @p.on_message_complete = proc do
+        if not @clients.first.continue?
+          c = @clients.shift
+          c.state = :finished
+          c.on_request_complete
+        end
+      end
+    end
+
+    def use(klass)
+      @middleware << klass
+    end
+
+    def receive_data(data)
+      @p << data
+    end
+
+    def connection_completed
+      if @opts.proxy && @opts.proxy[:type] == :socks5
+        socksify(@opts.uri.host, @opts.uri.port, *@opts.proxy[:authorization]) { start }
+      else
+        start
+      end
+    end
+
+    def start
+      ssl = @opts.options[:tls] || @opts.options[:ssl] || {}
+      start_tls(ssl) if @opts.uri.scheme == "https" or @opts.uri.port == 443
+
+      succeed
+    end
+
+    def redirect(client, location)
+      client.req.set_uri(location)
+      @pending.push client
+    rescue Exception => e
+      client.on_error(e.message)
+    end
+
+    def unbind
+      @clients.map {|c| c.unbind }
+
+      if r = @pending.shift
+        @clients.push r
+
+        r.reset!
+        @p.reset!
+
+        begin
+          set_deferred_status :unknown
+          reconnect(r.req.host, r.req.port)
+          callback { r.connection_completed }
+        rescue EventMachine::ConnectionError => e
+          @clients.pop.close(e.message)
+        end
+      end
+
+    end
+  end
+end

data/lib/em-http/http_encoding.rb

@@ -3,14 +3,24 @@ module EventMachine
     HTTP_REQUEST_HEADER="%s %s HTTP/1.1\r\n"
     FIELD_ENCODING = "%s: %s\r\n"
 
-    # Escapes a URI.
     def escape(s)
-      EscapeUtils.escape_url(s.to_s)
+      if defined?(EscapeUtils)
+        EscapeUtils.escape_url(s.to_s)
+      else
+        s.to_s.gsub(/([^a-zA-Z0-9_.-]+)/n) {
+          '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
+        }
+      end
     end
 
-    # Unescapes a URI escaped string.
     def unescape(s)
-      EscapeUtils.unescape_url(s.to_s)
+      if defined?(EscapeUtils)
+        EscapeUtils.unescape_url(s.to_s)
+      else
+        s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n) {
+          [$1.delete('%')].pack('H*')
+        }
+      end
     end
 
     if ''.respond_to?(:bytesize)
@@ -28,14 +38,11 @@ module EventMachine
       head.inject({}) { |h, (k, v)| h[k.to_s.downcase] = v; h }
     end
 
-    # HTTP is kind of retarded that you have to specify a Host header, but if
-    # you include port 80 then further redirects will tack on the :80 which is
-    # annoying.
     def encode_host
-      if @uri.port == 80 || @uri.port == 443
-        return @uri.host
+      if @req.uri.port == 80 || @req.uri.port == 443
+        return @req.uri.host
       else
-        @uri.host + ":#{@uri.port}"
+        @req.uri.host + ":#{@req.uri.port}"
       end
     end
 
@@ -44,7 +51,7 @@ module EventMachine
 
       # Non CONNECT proxies require that you provide the full request
       # uri in request header, as opposed to a relative path.
-      query = uri.join(query) if proxy && proxy[:type] != :socks && !proxy[:use_connect]
+      query = uri.join(query) if proxy && proxy[:type] != :socks
 
       HTTP_REQUEST_HEADER % [method.to_s.upcase, query]
     end
@@ -105,7 +112,7 @@ module EventMachine
     #     String - custom auth string (OAuth, etc)
     def encode_auth(k,v)
       if v.is_a? Array
-        FIELD_ENCODING % [k, ["Basic", Base64.encode64(v.join(":")).chomp].join(" ")]
+        FIELD_ENCODING % [k, ["Basic", Base64.encode64(v.join(":")).split.join].join(" ")]
       else
         encode_field(k,v)
       end

data/lib/em-http/http_header.rb

@@ -41,7 +41,7 @@ module EventMachine
       /chunked/i === self[HttpClient::TRANSFER_ENCODING]
     end
 
-    def keep_alive?
+    def keepalive?
       /keep-alive/i === self[HttpClient::KEEP_ALIVE]
     end
 
@@ -53,19 +53,4 @@ module EventMachine
       self[HttpClient::LOCATION]
     end
   end
-
-  class HttpChunkHeader < Hash
-    # When parsing chunked encodings this is set
-    attr_accessor :http_chunk_size
-
-    def initialize
-      super
-      @http_chunk_size = '0'
-    end
-
-    # Size of the chunk as an integer
-    def chunk_size
-      @http_chunk_size.to_i(base=16)
-    end
-  end
-end
+end

data/lib/em-http/http_options.rb

@@ -1,35 +1,53 @@
 class HttpOptions
   attr_reader :uri, :method, :host, :port, :options
 
-  def initialize(method, uri, options)
-    uri.path = '/' if uri.path.empty?
-
+  def initialize(uri, options, method = :none)
     @options = options
     @method = method.to_s.upcase
-    @uri = uri
 
-    if proxy = options[:proxy]
-      @host = proxy[:host]
-      @port = proxy[:port]
-    else
-      # optional host for cases where you may have
-      # pre-resolved the host, or you need an override
-      @host = options.delete(:host) || uri.host
-      @port = uri.port
-    end
+    set_uri(uri)
 
-    @options[:timeout]    ||= 10    # default connect & inactivity timeouts
-    @options[:redirects]  ||= 0     # default number of redirects to follow
     @options[:keepalive]  ||= false # default to single request per connection
+    @options[:redirects]  ||= 0     # default number of redirects to follow
+    @options[:followed]   ||= 0     # keep track of number of followed requests
+
+    @options[:connect_timeout] ||= 5        # default connection setup timeout
+    @options[:inactivity_timeout] ||= 10    # default connection inactivity (post-setup) timeout
+  end
+
+  def proxy
+    @options[:proxy]
+  end
+
+  def follow_redirect?
+    @options[:followed] < @options[:redirects]
+  end
+
+  def set_uri(uri)
+    uri = uri.kind_of?(Addressable::URI) ? uri : Addressable::URI::parse(uri.to_s)
+
+    uri.path = '/' if uri.path.empty?
+    if path = @options.delete(:path)
+      uri.path = path
+    end
+
+    @uri = uri
 
     # Make sure the ports are set as Addressable::URI doesn't
     # set the port if it isn't there
-    if uri.scheme == "https"
+    if @uri.scheme == "https"
       @uri.port ||= 443
-      @port     ||= 443
     else
       @uri.port ||= 80
-      @port     ||= 80
     end
+
+    if proxy = @options[:proxy]
+      @host = proxy[:host]
+      @port = proxy[:port]
+    else
+      @host = @uri.host
+      @port = @uri.port
+    end
+
   end
-end
+end

data/lib/em-http/request.rb

@@ -1,77 +1,44 @@
 module EventMachine
-
-  # EventMachine based HTTP request class with support for streaming consumption
-  # of the response. Response is parsed with a Ragel-generated whitelist parser
-  # which supports chunked HTTP encoding.
-  #
-  # == Example
-  #
-  #  EventMachine.run {
-  #    http = EventMachine::HttpRequest.new('http://127.0.0.1/').get :query => {'keyname' => 'value'}
-  #
-  #    http.callback {
-  #     p http.response_header.status
-  #     p http.response_header
-  #     p http.response
-  #
-  #  EventMachine.stop
-  #    }
-  #  }
-  #
-
   class HttpRequest
+    @middleware = []
 
-    attr_reader :options, :method
-
-    def initialize(host)
-      @uri = host.kind_of?(Addressable::URI) ? host : Addressable::URI::parse(host.to_s)
-    end
-
-    # Send an HTTP request and consume the response. Supported options:
-    #
-    #   head: {Key: Value}
-    #     Specify an HTTP header, e.g. {'Connection': 'close'}
-    #
-    #   query: {Key: Value}
-    #     Specify query string parameters (auto-escaped)
-    #
-    #   body: String
-    #     Specify the request body (you must encode it for now)
-    #
-    #   on_response: Proc
-    #     Called for each response body chunk (you may assume HTTP 200
-    #     OK then)
-    #
+    def self.new(uri, options={})
+      begin
+        req = HttpOptions.new(uri, options)
 
-    def get    options = {}, &blk;  setup_request(:get,   options, &blk);   end
-    def head   options = {}, &blk;  setup_request(:head,  options, &blk);   end
-    def delete options = {}, &blk;  setup_request(:delete,options, &blk);   end
-    def put    options = {}, &blk;  setup_request(:put,   options, &blk);   end
-    def post   options = {}, &blk;  setup_request(:post,  options, &blk);   end
+        EventMachine.connect(req.host, req.port, HttpConnection) do |c|
+          c.opts = req
 
-    protected
+          c.pending_connect_timeout = req.options[:connect_timeout]
+          c.comm_inactivity_timeout = req.options[:inactivity_timeout]
+        end
 
-    def setup_request(method, options, &blk)
-      @req = HttpOptions.new(method, @uri, options)
-      send_request(&blk)
-    end
-
-    def send_request(&blk)
-      begin
-        EventMachine.connect(@req.host, @req.port, EventMachine::HttpClient) { |c|
-          c.uri = @req.uri
-          c.method = @req.method
-          c.options = @req.options
-          c.comm_inactivity_timeout = @req.options[:timeout]
-          c.pending_connect_timeout = @req.options[:timeout]
-          blk.call(c) unless blk.nil?
-        }
       rescue EventMachine::ConnectionError => e
-        conn = EventMachine::HttpClient.new("")
-        conn.on_error(e.message, true)
-        conn.uri = @req.uri
+        #
+        # Currently, this can only fire on initial connection setup
+        # since #connect is a synchronous method. Hence, rescue the
+        # exception, and return a failed deferred which will immediately
+        # fail any client request.
+        #
+        # Once there is async-DNS, then we'll iterate over the outstanding
+        # client requests and fail them in order.
+        #
+        # Net outcome: failed connection will invoke the same ConnectionError
+        # message on the connection deferred, and on the client deferred.
+        #
+        conn = EventMachine::FailedConnection.new(req)
+        conn.error = e.message
+        conn.fail
         conn
       end
     end
+
+    def self.use(klass)
+      @middleware << klass
+    end
+
+    def self.middleware
+      @middleware
+    end
   end
-end
+end

data/lib/em-http/version.rb

@@ -1,5 +1,5 @@
 module EventMachine
   class HttpRequest
-    VERSION = "0.3.0"
+    VERSION = "1.0.0.beta.1"
   end
-end
+end

data/spec/client_spec.rb

@@ -0,0 +1,575 @@
+require 'helper'
+
+describe EventMachine::HttpRequest do
+
+  def failed(http=nil)
+    EventMachine.stop
+    http ? fail(http.error) : fail
+  end
+
+  it "should perform successful GET" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/').get
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/Hello/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform successful GET with a URI passed as argument" do
+    EventMachine.run {
+      uri = URI.parse('http://127.0.0.1:8090/')
+      http = EventMachine::HttpRequest.new(uri).get
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/Hello/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should succeed GET on missing path" do
+    EventMachine.run {
+      lambda {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090').get
+      http.callback {
+        http.response.should match(/Hello/)
+        EventMachine.stop
+      }
+    }.should_not raise_error(ArgumentError)
+
+    }
+  end
+
+  it "should raise error on invalid URL" do
+    EventMachine.run {
+      lambda {
+      EventMachine::HttpRequest.new('random?text').get
+    }.should raise_error
+
+    EM.stop
+    }
+  end
+
+  it "should perform successful HEAD with a URI passed as argument" do
+    EventMachine.run {
+      uri = URI.parse('http://127.0.0.1:8090/')
+      http = EventMachine::HttpRequest.new(uri).head
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should == ""
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform successful DELETE with a URI passed as argument" do
+    EventMachine.run {
+      uri = URI.parse('http://127.0.0.1:8090/')
+      http = EventMachine::HttpRequest.new(uri).delete
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should == ""
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should return 404 on invalid path" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/fail').get
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 404
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should build query parameters from Hash" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/').get :query => {:q => 'test'}
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/test/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should pass query parameters string" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/').get :query => "q=test"
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/test/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should encode an array of query parameters" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/echo_query').get :query => {:hash =>['value1','value2']}
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/hash\[\]=value1&hash\[\]=value2/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform successful PUT" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/').put :body => "data"
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/data/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform successful POST" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/').post :body => "data"
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/data/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should escape body on POST" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/').post :body => {:stuff => 'string&string'}
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should == "stuff=string%26string"
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform successful POST with Ruby Hash/Array as params" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/').post :body => {"key1" => 1, "key2" => [2,3]}
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+
+        http.response.should match(/key1=1&key2\[0\]=2&key2\[1\]=3/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform successful POST with Ruby Hash/Array as params and with the correct content length" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/echo_content_length').post :body => {"key1" => "data1"}
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+
+        http.response.to_i.should == 10
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform successful GET with custom header" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/').get :head => {'if-none-match' => 'evar!'}
+
+      http.errback { p http; failed(http) }
+      http.callback {
+        http.response_header.status.should == 304
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should perform basic auth" do
+    EventMachine.run {
+
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/').get :head => {'authorization' => ['user', 'pass']}
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should remove all newlines from long basic auth header" do
+    EventMachine.run {
+      auth = {'authorization' => ['aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz']}
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/auth').get :head => auth
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should == "Basic YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhOnp6enp6enp6enp6enp6enp6enp6enp6enp6enp6eg=="
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should send proper OAuth auth header" do
+    EventMachine.run {
+      oauth_header = 'OAuth oauth_nonce="oqwgSYFUD87MHmJJDv7bQqOF2EPnVus7Wkqj5duNByU", b=c, d=e'
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/auth').get :head => {
+        'authorization' => oauth_header
+      }
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should == oauth_header
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should return ETag and Last-Modified headers" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/echo_query').get
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response_header.etag.should match('abcdefg')
+        http.response_header.last_modified.should match('Fri, 13 Aug 2010 17:31:21 GMT')
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should detect deflate encoding" do
+    EventMachine.run {
+
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/deflate').get :head => {"accept-encoding" => "deflate"}
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response_header["CONTENT_ENCODING"].should == "deflate"
+        http.response.should == "compressed"
+
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should detect gzip encoding" do
+    EventMachine.run {
+
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/gzip').get :head => {
+      "accept-encoding" => "gzip, compressed"
+    }
+
+    http.errback { failed(http) }
+    http.callback {
+      http.response_header.status.should == 200
+      http.response_header["CONTENT_ENCODING"].should == "gzip"
+      http.response.should == "compressed"
+
+      EventMachine.stop
+    }
+    }
+  end
+
+  it "should timeout after 0.1 seconds of inactivity" do
+    EventMachine.run {
+      t = Time.now.to_i
+      EventMachine.heartbeat_interval = 0.1
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/timeout', :inactivity_timeout => 0.1).get
+
+      http.errback {
+        (Time.now.to_i - t).should <= 1
+        EventMachine.stop
+      }
+      http.callback { failed(http) }
+    }
+  end
+
+  it "should complete a Location: with a relative path" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/relative-location').get
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header['LOCATION'].should == 'http://127.0.0.1:8090/forwarded'
+        EventMachine.stop
+      }
+    }
+  end
+
+  context "body content-type encoding" do
+    it "should not set content type on string in body" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/echo_content_type').post :body => "data"
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          http.response.should be_empty
+          EventMachine.stop
+        }
+      }
+    end
+
+    it "should set content-type automatically when passed a ruby hash/array for body" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/echo_content_type').post :body => {:a => :b}
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          http.response.should match("application/x-www-form-urlencoded")
+          EventMachine.stop
+        }
+      }
+    end
+
+    it "should not override content-type when passing in ruby hash/array for body" do
+      EventMachine.run {
+        ct = 'text; charset=utf-8'
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/echo_content_type').post({
+          :body => {:a => :b}, :head => {'content-type' => ct}})
+
+          http.errback { failed(http) }
+          http.callback {
+            http.response_header.status.should == 200
+            http.content_charset.should == Encoding.find('utf-8')
+            http.response_header["CONTENT_TYPE"].should == ct
+            EventMachine.stop
+          }
+      }
+    end
+
+    it "should default to external encoding on invalid encoding" do
+      EventMachine.run {
+        ct = 'text/html; charset=utf-8lias'
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/echo_content_type').post({
+          :body => {:a => :b}, :head => {'content-type' => ct}})
+
+          http.errback { failed(http) }
+          http.callback {
+            http.response_header.status.should == 200
+            http.content_charset.should == Encoding.find('utf-8')
+            http.response_header["CONTENT_TYPE"].should == ct
+            EventMachine.stop
+          }
+      }
+    end
+
+    it "should processed escaped content-type" do
+      EventMachine.run {
+        ct = "text/html; charset=\"ISO-8859-4\""
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/echo_content_type').post({
+          :body => {:a => :b}, :head => {'content-type' => ct}})
+
+          http.errback { failed(http) }
+          http.callback {
+            http.response_header.status.should == 200
+            http.content_charset.should == Encoding.find('ISO-8859-4')
+            http.response_header["CONTENT_TYPE"].should == ct
+            EventMachine.stop
+          }
+      }
+    end
+  end
+
+  context "optional header callback" do
+    it "should optionally pass the response headers" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/').get
+
+        http.errback { failed(http) }
+        http.headers { |hash|
+          hash.should be_an_kind_of Hash
+          hash.should include 'CONNECTION'
+          hash.should include 'CONTENT_LENGTH'
+        }
+
+        http.callback {
+          http.response_header.status.should == 200
+          http.response.should match(/Hello/)
+          EventMachine.stop
+        }
+      }
+    end
+
+    it "should allow to terminate current connection from header callback" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/').get
+
+        http.callback { failed(http) }
+        http.headers { |hash|
+          hash.should be_an_kind_of Hash
+          hash.should include 'CONNECTION'
+          hash.should include 'CONTENT_LENGTH'
+
+          http.close('header callback terminated connection')
+        }
+
+        http.errback { |e|
+          http.response_header.status.should == 200
+          http.error.should == 'header callback terminated connection'
+          http.response.should == ''
+          EventMachine.stop
+        }
+      }
+    end
+  end
+
+  it "should optionally pass the response body progressively" do
+    EventMachine.run {
+      body = ''
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/').get
+
+      http.errback { failed(http) }
+      http.stream { |chunk| body += chunk }
+
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should == ''
+        body.should match(/Hello/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should optionally pass the deflate-encoded response body progressively" do
+    EventMachine.run {
+      body = ''
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/deflate').get :head => {
+        "accept-encoding" => "deflate, compressed"
+      }
+
+      http.errback { failed(http) }
+      http.stream { |chunk| body += chunk }
+
+      http.callback {
+        http.response_header.status.should == 200
+        http.response_header["CONTENT_ENCODING"].should == "deflate"
+        http.response.should == ''
+        body.should == "compressed"
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should accept & return cookie header to user" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/set_cookie').get
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response_header.cookie.should == "id=1; expires=Tue, 09-Aug-2011 17:53:39 GMT; path=/;"
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should pass cookie header to server from string" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/echo_cookie').get :head => {'cookie' => 'id=2;'}
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response.should == "id=2;"
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should pass cookie header to server from Hash" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/echo_cookie').get :head => {'cookie' => {'id' => 2}}
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response.should == "id=2;"
+        EventMachine.stop
+      }
+    }
+  end
+
+  context "when talking to a stub HTTP/1.0 server" do
+    it "should get the body without Content-Length" do
+
+      EventMachine.run {
+        @s = StubServer.new("HTTP/1.0 200 OK\r\nConnection: close\r\n\r\nFoo")
+
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8081/').get
+        http.errback { failed(http) }
+        http.callback {
+          http.response.should match(/Foo/)
+          http.response_header['CONTENT_LENGTH'].should_not == 0
+
+          @s.stop
+          EventMachine.stop
+        }
+      }
+    end
+
+    it "should work with \\n instead of \\r\\n" do
+      EventMachine.run {
+        @s = StubServer.new("HTTP/1.0 200 OK\nContent-Type: text/plain\nContent-Length: 3\nConnection: close\n\nFoo")
+
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8081/').get
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          http.response_header['CONTENT_TYPE'].should == 'text/plain'
+          http.response.should match(/Foo/)
+
+          @s.stop
+          EventMachine.stop
+        }
+      }
+    end
+  end
+
+  it "should stream a file off disk" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/').post :file => 'spec/fixtures/google.ca'
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response.should match('google')
+        EventMachine.stop
+      }
+    }
+  end
+
+end