em-http-request 0.2.9 → 0.3.0

data/spec/request_spec.rb

@@ -1,19 +1,19 @@
-require 'spec/helper'
-require 'spec/stallion'
-require 'spec/stub_server'
+require 'helper'
+require 'stallion'
+require 'stub_server'
 
 describe EventMachine::HttpRequest do
 
-  def failed
+  def failed(http=nil)
     EventMachine.stop
-    fail
+    http ? fail(http.error) : fail
   end
 
   it "should fail GET on DNS timeout" do
     EventMachine.run {
       EventMachine.heartbeat_interval = 0.1
       http = EventMachine::HttpRequest.new('http://127.1.1.1/').get :timeout => 1
-      http.callback { failed }
+      http.callback { failed(http) }
       http.errback {
         http.response_header.status.should == 0
         EventMachine.stop
@@ -25,20 +25,31 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       EventMachine.heartbeat_interval = 0.1
       http = EventMachine::HttpRequest.new('http://somethinglocal/').get :timeout => 1
-      http.callback { failed }
+      http.callback { failed(http) }
       http.errback {
         http.response_header.status.should == 0
         http.error.should match(/unable to resolve server address/)
+        http.uri.to_s.should match('http://somethinglocal:80/')
         EventMachine.stop
       }
     }
   end
 
-  it "should fail GET on missing path" do
+  it "should raise error on invalid URL" do
     EventMachine.run {
       lambda {
-        EventMachine::HttpRequest.new('http://www.google.com').get
-      }.should raise_error(ArgumentError)
+        EventMachine::HttpRequest.new('random?text').get
+      }.should raise_error
+
+      EM.stop
+    }
+  end
+
+  it "should succeed GET on missing path" do
+    EventMachine.run {
+      lambda {
+        EventMachine::HttpRequest.new('http://127.0.0.1:8080').get
+      }.should_not raise_error(ArgumentError)
 
       EventMachine.stop
     }
@@ -48,7 +59,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should match(/Hello/)
@@ -57,12 +68,90 @@ describe EventMachine::HttpRequest do
     }
   end
 
+  context "host override" do
+
+    it "should accept optional host" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://google.com:8080/').get :host => '127.0.0.1'
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          http.response.should match(/Hello/)
+          EventMachine.stop
+        }
+      }
+    end
+
+    it "should reset host on redirect" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/redirect').get :redirects => 1, :host => '127.0.0.1'
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          http.response_header["CONTENT_ENCODING"].should == "gzip"
+          http.response.should == "compressed"
+          http.last_effective_url.to_s.should == 'http://127.0.0.1:8080/gzip'
+          http.redirects.should == 1
+
+          EM.stop
+        }
+      }
+    end
+
+    it "should redirect with missing content-length" do
+      EventMachine.run {
+        @s = StubServer.new("HTTP/1.0 301 MOVED PERMANENTLY\r\nlocation: http://127.0.0.1:8080/redirect\r\n\r\n")
+
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8081/').get :redirects => 2
+        http.errback { failed(http) }
+
+        http.callback {
+          http.response_header.status.should == 200
+          http.response_header["CONTENT_ENCODING"].should == "gzip"
+          http.response.should == "compressed"
+          http.last_effective_url.to_s.should == 'http://127.0.0.1:8080/gzip'
+          http.redirects.should == 2
+
+          @s.stop
+          EM.stop
+        }
+      }
+    end
+
+    it "should follow redirects on HEAD method" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/redirect/head').head :redirects => 1
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          http.last_effective_url.to_s.should == 'http://127.0.0.1:8080/'
+          EM.stop
+        }
+      }
+    end
+
+    it "should follow redirects on HEAD method (external)" do
+
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://www.google.com/').head :redirects => 1
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          EM.stop
+        }
+      }
+    end
+
+  end
+
   it "should perform successfull GET with a URI passed as argument" do
     EventMachine.run {
       uri = URI.parse('http://127.0.0.1:8080/')
       http = EventMachine::HttpRequest.new(uri).get
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should match(/Hello/)
@@ -76,7 +165,7 @@ describe EventMachine::HttpRequest do
       uri = URI.parse('http://127.0.0.1:8080/')
       http = EventMachine::HttpRequest.new(uri).head
 
-      http.errback { p http; failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should == ""
@@ -91,7 +180,7 @@ describe EventMachine::HttpRequest do
       uri = URI.parse('http://127.0.0.1:8080/')
       http = EventMachine::HttpRequest.new(uri).delete
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should == ""
@@ -104,7 +193,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/fail').get
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 404
         EventMachine.stop
@@ -116,7 +205,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :query => {:q => 'test'}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should match(/test/)
@@ -129,7 +218,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :query => "q=test"
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should match(/test/)
@@ -142,7 +231,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_query').get :query => {:hash => ['value1', 'value2']}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should match(/hash\[\]=value1&hash\[\]=value2/)
@@ -156,7 +245,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').put :body => "data"
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should match(/data/)
@@ -169,7 +258,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').post :body => "data"
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should match(/data/)
@@ -178,11 +267,24 @@ describe EventMachine::HttpRequest do
     }
   end
 
+  it "should escape body on POST" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').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 successfull POST with Ruby Hash/Array as params" do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').post :body => {"key1" => 1, "key2" => [2,3]}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
 
@@ -196,7 +298,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_content_length').post :body => {"key1" => "data1"}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
 
@@ -210,7 +312,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :head => {'if-none-match' => 'evar!'}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 304
         EventMachine.stop
@@ -222,9 +324,9 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
 
       # digg.com uses chunked encoding
-      http = EventMachine::HttpRequest.new('http://digg.com/').get
+      http = EventMachine::HttpRequest.new('http://digg.com/news').get
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         EventMachine.stop
@@ -237,7 +339,7 @@ describe EventMachine::HttpRequest do
 
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :head => {'authorization' => ['user', 'pass']}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         EventMachine.stop
@@ -250,7 +352,7 @@ describe EventMachine::HttpRequest do
       oauth_header = 'OAuth oauth_nonce="oqwgSYFUD87MHmJJDv7bQqOF2EPnVus7Wkqj5duNByU", b=c, d=e'
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/oauth_auth').get :head => {'authorization' => oauth_header}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should == oauth_header
@@ -259,14 +361,43 @@ describe EventMachine::HttpRequest do
     }
   end
 
-  it "should work with keep-alive servers" do
-    EventMachine.run {
+  context "keepalive" do
+    it "should default to non-keepalive" do
+      EventMachine.run {
+        headers = {'If-Modified-Since' => 'Thu, 05 Aug 2010 22:54:44 GMT'}
+        http = EventMachine::HttpRequest.new('http://www.google.com/images/logos/ps_logo2.png').get :head => headers
 
-      http = EventMachine::HttpRequest.new('http://mexicodiario.com/touch.public.json.php').get
+        http.errback { fail }
+        start = Time.now.to_i
+        http.callback {
+          (start - Time.now.to_i).should be_within(1).of(0)
+          EventMachine.stop
+        }
+      }
+    end
+
+    it "should work with keep-alive servers" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://mexicodiario.com/touch.public.json.php').get :keepalive => true
 
-      http.errback { failed }
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          EventMachine.stop
+        }
+      }
+    end
+  end
+
+  it "should return ETag and Last-Modified headers" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/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
       }
     }
@@ -277,7 +408,7 @@ describe EventMachine::HttpRequest do
 
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/deflate').get :head => {"accept-encoding" => "deflate"}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response_header["CONTENT_ENCODING"].should == "deflate"
@@ -293,7 +424,7 @@ describe EventMachine::HttpRequest do
 
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/gzip').get :head => {"accept-encoding" => "gzip, compressed"}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response_header["CONTENT_ENCODING"].should == "gzip"
@@ -314,51 +445,98 @@ describe EventMachine::HttpRequest do
         (Time.now.to_i - t).should <= 5
         EventMachine.stop
       }
-      http.callback { failed }
+      http.callback { failed(http) }
     }
   end
 
-  it "should report last_effective_url" do
-    EventMachine.run {
-      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get
-      http.errback { failed }
-      http.callback {
-        http.response_header.status.should == 200
-        http.last_effective_url.to_s.should == 'http://127.0.0.1:8080/'
+  context "redirect" do
+    it "should report last_effective_url" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          http.last_effective_url.to_s.should == 'http://127.0.0.1:8080/'
 
-        EM.stop
+          EM.stop
+        }
       }
-    }
-  end
+    end
 
-  it "should follow location redirects" do
-    EventMachine.run {
-      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/redirect').get :redirects => 1
-      http.errback { failed }
-      http.callback {
-        http.response_header.status.should == 200
-        http.response_header["CONTENT_ENCODING"].should == "gzip"
-        http.response.should == "compressed"
-        http.last_effective_url.to_s.should == 'http://127.0.0.1:8080/gzip'
-        http.redirects.should == 1
+    it "should follow location redirects" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/redirect').get :redirects => 1
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          http.response_header["CONTENT_ENCODING"].should == "gzip"
+          http.response.should == "compressed"
+          http.last_effective_url.to_s.should == 'http://127.0.0.1:8080/gzip'
+          http.redirects.should == 1
 
-        EM.stop
+          EM.stop
+        }
       }
-    }
-  end
+    end
 
-  it "should default to 0 redirects" do
-    EventMachine.run {
-      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/redirect').get
-      http.errback { failed }
-      http.callback {
-        http.response_header.status.should == 301
-        http.last_effective_url.to_s.should == 'http://127.0.0.1:8080/gzip'
-        http.redirects.should == 0
+    it "should default to 0 redirects" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/redirect').get
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 301
+          http.last_effective_url.to_s.should == 'http://127.0.0.1:8080/gzip'
+          http.redirects.should == 0
 
-        EM.stop
+          EM.stop
+        }
       }
-    }
+    end
+
+    it "should not invoke redirect logic on failed(http) connections" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8081/').get :timeout => 0.1, :redirects => 5
+        http.callback { failed(http) }
+        http.errback {
+          http.redirects.should == 0
+          EM.stop
+        }
+      }
+    end
+
+    it "should normalize redirect urls" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/redirect/bad').get :redirects => 1
+        http.errback { failed(http) }
+        http.callback {
+          http.last_effective_url.to_s.should match('http://127.0.0.1:8080/')
+          http.response.should match('Hello, World!')
+          EM.stop
+        }
+      }
+    end
+
+    it "should fail gracefully on a missing host in absolute Location header" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/redirect/nohost').get :redirects => 1
+        http.callback { failed(http) }
+        http.errback {
+          http.error.should == 'Location header format error'
+          EM.stop
+        }
+      }
+    end
+
+    it "should fail gracefully on an invalid host in Location header" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/redirect/badhost').get :redirects => 1
+        http.callback { failed(http) }
+        http.errback {
+          http.error.should == 'unable to resolve server address'
+          EM.stop
+        }
+      }
+    end
   end
 
   it "should optionally pass the response body progressively" do
@@ -366,7 +544,7 @@ describe EventMachine::HttpRequest do
       body = ''
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.stream { |chunk| body += chunk }
 
       http.callback {
@@ -378,12 +556,55 @@ describe EventMachine::HttpRequest do
     }
   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:8080/').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:8080/').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 deflate-encoded response body progressively" do
     EventMachine.run {
       body = ''
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/deflate').get :head => {"accept-encoding" => "deflate, compressed"}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.stream { |chunk| body += chunk }
 
       http.callback {
@@ -400,7 +621,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('https://mail.google.com:443/mail/').get
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 302
         EventMachine.stop
@@ -412,7 +633,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/set_cookie').get
 
-      http.errback { failed }
+      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=/;"
@@ -425,7 +646,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_cookie').get :head => {'cookie' => 'id=2;'}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response.should == "id=2;"
         EventMachine.stop
@@ -437,7 +658,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_cookie').get :head => {'cookie' => {'id' => 2}}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response.should == "id=2;"
         EventMachine.stop
@@ -451,7 +672,7 @@ describe EventMachine::HttpRequest do
         @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.errback { failed(http) }
         http.callback {
           http.response.should match(/Foo/)
           http.response_header['CONTENT_LENGTH'].should_not == 0
@@ -467,7 +688,7 @@ describe EventMachine::HttpRequest do
         @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.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 200
           http.response_header['CONTENT_TYPE'].should == 'text/plain'
@@ -485,7 +706,7 @@ describe EventMachine::HttpRequest do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_content_type').post :body => "data"
 
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 200
           http.response.should be_empty
@@ -498,7 +719,7 @@ describe EventMachine::HttpRequest do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_content_type').post :body => {:a => :b}
 
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 200
           http.response.should match("application/x-www-form-urlencoded")
@@ -509,24 +730,59 @@ describe EventMachine::HttpRequest do
 
     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:8080/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:8080/echo_content_type').post({
-            :body => {:a => :b}, :head => {'content-type' => 'text'}})
+        :body => {:a => :b}, :head => {'content-type' => ct}})
 
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 200
-          http.response.should match("text")
+          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:8080/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
 
   it "should complete a Location: with a relative path" do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/relative-location').get
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header['LOCATION'].should == 'http://127.0.0.1:8080/forwarded'
         EventMachine.stop
@@ -538,7 +794,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').post :file => 'spec/fixtures/google.ca'
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response.should match('google')
         EventMachine.stop
@@ -554,7 +810,7 @@ describe EventMachine::HttpRequest do
         c.options[:body] = {:callback_run => 'yes'}
         client = c
       }
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         client.should be_kind_of(EventMachine::HttpClient)
         http.response_header.status.should == 200
@@ -571,8 +827,8 @@ describe EventMachine::HttpRequest do
       http = EventMachine::MockHttpRequest.new('http://www.google.ca/').get
       http.errback { fail }
       http.callback {
-        c1 = "PREF=ID=9454187d21c4a6a6:TM=1258403955:LM=1258403955:S=2-mf1n5oV5yAeT9-; expires=Wed, 16-Nov-2011 20:39:15 GMT; path=/; domain=.google.ca"
-        c2 = "NID=28=lvxxVdiBQkCetu_WFaUxLyB7qPlHXS5OdAGYTqge_laVlCKVN8VYYeVBh4bNZiK_Oan2gm8oP9GA-FrZfMPC3ZMHeNq37MG2JH8AIW9LYucU8brOeuggMEbLNNXuiWg4; expires=Tue, 18-May-2010 20:39:15 GMT; path=/; domain=.google.ca; HttpOnly"
+        c1 = "PREF=ID=11955ae9690fd292:TM=1281823106:LM=1281823106:S=wHdloFqGQ_OLSE92; expires=Mon, 13-Aug-2012 21:58:26 GMT; path=/; domain=.google.ca"
+        c2 = "NID=37=USTdOsxOSMbLjphkJ3S5Ueua3Yc23COXuK_pbztcHx7JoyhomwQySrvebCf3_u8eyrBiLWssVzaZcEOiKGEJbNdy8lRhnq_mfrdz693LaMjNPh__ccW4sgn1ZO6nQltE; expires=Sun, 13-Feb-2011 21:58:26 GMT; path=/; domain=.google.ca; HttpOnly"
         http.response_header.cookie.should == [c1, c2]
 
         EventMachine.stop
@@ -582,35 +838,93 @@ describe EventMachine::HttpRequest do
     EventMachine::MockHttpRequest.count('http://www.google.ca:80/', :get, {}).should == 1
   end
 
-  context "connections via proxy" do
+  context "connections via" do
+    context "direct proxy" do
+      it "should default to skip CONNECT" do
+        EventMachine.run {
 
-    it "should work with proxy servers" do
-      EventMachine.run {
+          http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/?q=test').get :proxy => {
+            :host => '127.0.0.1', :port => 8083
+          }
 
-        http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :proxy => {:host => '127.0.0.1', :port => 8082}
+          http.errback { failed(http) }
+          http.callback {
+            http.response_header.status.should == 200
+            http.response.should match('test')
+            EventMachine.stop
+          }
+        }
+      end
 
-        http.errback { p http.inspect; failed }
-        http.callback {
-          http.response_header.status.should == 200
-          http.response.should == 'Hello, World!'
-          EventMachine.stop
+      it "should send absolute URIs to the proxy server" do
+        EventMachine.run {
+
+          http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/?q=test').get :proxy => {
+            :host => '127.0.0.1', :port => 8083
+          }
+
+          http.errback { failed(http) }
+          http.callback {
+            http.response_header.status.should == 200
+            # The test proxy server gives the requested uri back in this header
+            http.response_header['X_THE_REQUESTED_URI'].should == 'http://127.0.0.1:8080/?q=test'
+            http.response_header['X_THE_REQUESTED_URI'].should_not == '/?q=test'
+            http.response.should match('test')
+            EventMachine.stop
+          }
         }
-      }
+      end
+
+      it "should include query parameters specified in the options" do
+        EventMachine.run {
+
+          http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get(
+            :proxy => { :host => '127.0.0.1', :port => 8083 },
+            :query => { 'q' => 'test' }
+          )
+
+          http.errback { failed(http) }
+          http.callback {
+            http.response_header.status.should == 200
+            http.response.should match('test')
+            EventMachine.stop
+          }
+        }
+      end
     end
 
-    it "should proxy POST data" do
-      EventMachine.run {
+    context "CONNECT proxy" do
+      it "should work with CONNECT proxy servers" do
+        EventMachine.run {
 
-        http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').post({
-            :body => "data", :proxy => {:host => '127.0.0.1', :port => 8082}})
+          http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get({
+                                                                               :proxy => {:host => '127.0.0.1', :port => 8082, :use_connect => true}
+          })
 
-        http.errback { failed }
-        http.callback {
-          http.response_header.status.should == 200
-          http.response.should match(/data/)
-          EventMachine.stop
+          http.errback { failed(http) }
+          http.callback {
+            http.response_header.status.should == 200
+            http.response.should == 'Hello, World!'
+            EventMachine.stop
+          }
         }
-      }
+      end
+
+      it "should proxy POST data" do
+        EventMachine.run {
+
+          http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').post({
+                                                                                :body => "data", :proxy => {:host => '127.0.0.1', :port => 8082, :use_connect => true}
+          })
+
+          http.errback { failed(http) }
+          http.callback {
+            http.response_header.status.should == 200
+            http.response.should match(/data/)
+            EventMachine.stop
+          }
+        }
+      end
     end
   end
 
@@ -626,7 +940,7 @@ describe EventMachine::HttpRequest do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('ws://127.0.0.1:8080/').get :timeout => 0
 
-        http.callback { failed }
+        http.callback { failed(http) }
         http.errback {
           http.response_header.status.should == 200
           EventMachine.stop
@@ -643,7 +957,7 @@ describe EventMachine::HttpRequest do
         end
 
         http = EventMachine::HttpRequest.new('ws://127.0.0.1:8085/').get :timeout => 1
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 101
           http.response_header['CONNECTION'].should match(/Upgrade/)
@@ -674,7 +988,7 @@ describe EventMachine::HttpRequest do
 
         EventMachine.add_timer(0.1) do
           http = EventMachine::HttpRequest.new('ws://127.0.0.1:8085/').get :timeout => 0
-          http.errback { failed }
+          http.errback { failed(http) }
           http.callback { http.response_header.status.should == 101 }
           http.stream {|msg|
             msg.should == messages[recieved.size]