em-http-request 0.2.10 → 0.2.14

data/spec/request_spec.rb

@@ -29,16 +29,27 @@ describe EventMachine::HttpRequest do
       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
     }
@@ -57,6 +68,64 @@ 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.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.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 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.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.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/')
@@ -178,6 +247,19 @@ 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.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]}
@@ -222,7 +304,7 @@ 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.callback {
@@ -272,6 +354,20 @@ describe EventMachine::HttpRequest do
     }
   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.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 {
 
@@ -318,58 +414,94 @@ describe EventMachine::HttpRequest do
     }
   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.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.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.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
+    end
 
-  it "should not invoke redirect logic on failed connections" do
-    EventMachine.run {
-      http = EventMachine::HttpRequest.new('http://127.0.0.1:8081/').get :timeout => 0.1, :redirects => 5
-      http.callback { failed }
-      http.errback {
-        http.redirects.should == 0
-        EM.stop
+    it "should not invoke redirect logic on failed connections" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8081/').get :timeout => 0.1, :redirects => 5
+        http.callback { failed }
+        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.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.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.errback {
+          http.error.should == 'unable to resolve server address'
+          EM.stop
+        }
+      }
+    end
   end
 
   it "should optionally pass the response body progressively" do
@@ -389,6 +521,49 @@ 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.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.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 = ''
@@ -582,8 +757,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
@@ -593,35 +768,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.errback { p http.inspect; failed }
+          http.callback {
+            http.response_header.status.should == 200
+            http.response.should match('test')
+            EventMachine.stop
+          }
+        }
+      end
 
-        http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :proxy => {:host => '127.0.0.1', :port => 8082}
+      it "should send absolute URIs to the proxy server" do
+        EventMachine.run {
 
-        http.errback { p http.inspect; failed }
-        http.callback {
-          http.response_header.status.should == 200
-          http.response.should == 'Hello, World!'
-          EventMachine.stop
+          http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/?q=test').get :proxy => {
+            :host => '127.0.0.1', :port => 8083
+          }
+
+          http.errback { p http.inspect; failed }
+          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 { p http.inspect; failed }
+          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 { p http.inspect; failed }
+          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.callback {
+            http.response_header.status.should == 200
+            http.response.should match(/data/)
+            EventMachine.stop
+          }
+        }
+      end
     end
   end
 

data/spec/spec.opts

@@ -0,0 +1,7 @@
+--colour
+--format
+specdoc
+--loadby
+mtime
+--reverse
+--backtrace

data/spec/stallion.rb

@@ -78,12 +78,14 @@ Stallion.saddle :spec do |stable|
       stable.response.write 'test'
 
     elsif stable.request.path_info == '/echo_query'
+      stable.response["ETag"] = "abcdefg"
+      stable.response["Last-Modified"] = "Fri, 13 Aug 2010 17:31:21 GMT"
       stable.response.write stable.request.query_string
 
     elsif stable.request.path_info == '/echo_content_length'
       stable.response.write stable.request.content_length
 
-    elsif stable.request.head?
+    elsif stable.request.head? && stable.request.path_info == '/'
       stable.response.status = 200
 
     elsif stable.request.delete?
@@ -113,6 +115,23 @@ Stallion.saddle :spec do |stable|
     elsif stable.request.path_info == '/redirect'
       stable.response.status = 301
       stable.response["Location"] = "/gzip"
+      stable.response.write 'redirect'
+
+    elsif stable.request.path_info == '/redirect/bad'
+      stable.response.status = 301
+      stable.response["Location"] = "http://127.0.0.1:8080"
+
+    elsif stable.request.path_info == '/redirect/head'
+      stable.response.status = 301
+      stable.response["Location"] = "/"
+
+    elsif stable.request.path_info == '/redirect/nohost'
+      stable.response.status = 301
+      stable.response["Location"] = "http:/"
+
+    elsif stable.request.path_info == '/redirect/badhost'
+      stable.response.status = 301
+      stable.response["Location"] = "http://$$$@$!%&^"
 
     elsif stable.request.path_info == '/gzip'
       io = StringIO.new
@@ -164,7 +183,7 @@ Thread.new do
 end
 
 #
-# HTTP Proxy server
+# Tunneling HTTP Proxy server
 #
 Thread.new do
   server = TCPServer.new('127.0.0.1', 8082)
@@ -220,4 +239,46 @@ Thread.new do
   end
 end
 
-sleep(1)
+#
+# CONNECT-less HTTP Proxy server
+#
+Thread.new do
+  server = TCPServer.new('127.0.0.1', 8083)
+  loop do
+    session = server.accept
+    request = ""
+    while (data = session.gets) != "\r\n"
+      request << data
+    end
+    parts = request.split("\r\n")
+    method, destination, http_version = parts.first.split(' ')
+    if destination =~ /^http:/
+      uri = Addressable::URI.parse(destination)
+      absolute_path = uri.path + (uri.query ? "?#{uri.query}" : "")
+      client = TCPSocket.open(uri.host, uri.port || 80)
+      client.write "#{method} #{absolute_path} #{http_version}\r\n"
+      parts[1..-1].each do |part|
+        client.write "#{part}\r\n"
+      end
+
+      client.write "\r\n"
+      client.flush
+      client.close_write
+
+      # Take the initial line from the upstream response
+      session.write client.gets
+
+      # What (absolute) uri was requested?  Send it back in a header
+      session.write "X-The-Requested-URI: #{destination}\r\n"
+
+      while data = client.gets
+        session.write data
+      end
+      session.flush
+      client.close
+    end
+    session.close
+  end
+end
+
+sleep(1)

data/spec/stub_server.rb

@@ -1,22 +1,22 @@
-class StubServer
-  module Server
-    def receive_data(data)
-      send_data @response
-      close_connection_after_writing
-    end
-
-    def response=(response)
-      @response = response
-    end
-  end
-
-  def initialize(response, port=8081)
-    @sig = EventMachine::start_server("127.0.0.1", port, Server) { |s|
-      s.response = response
-    }
-  end
-
-  def stop
-    EventMachine.stop_server @sig
-  end
-end
+class StubServer
+  module Server
+    def receive_data(data)
+      send_data @response
+      close_connection_after_writing
+    end
+
+    def response=(response)
+      @response = response
+    end
+  end
+
+  def initialize(response, port=8081)
+    @sig = EventMachine::start_server("127.0.0.1", port, Server) { |s|
+      s.response = response
+    }
+  end
+
+  def stop
+    EventMachine.stop_server @sig
+  end
+end