em-http-request 0.2.7 → 0.2.9

data/lib/em-http/mock.rb

@@ -7,8 +7,12 @@ module EventMachine
 
       def setup(response, uri)
         @uri = uri
-        receive_data(response)
-        succeed(self) 
+        if response == :fail
+          fail(self)
+        else
+          receive_data(response)
+          succeed(self)
+        end
       end
       
       def unbind
@@ -20,11 +24,15 @@ module EventMachine
     @@registry_count = nil
     
     def self.reset_counts!
-      @@registry_count = Hash.new{|h,k| h[k] = Hash.new(0)}
+      @@registry_count = Hash.new do |registry,query| 
+        registry[query] = Hash.new{|h,k| h[k] = Hash.new(0)}
+      end
     end
     
     def self.reset_registry!
-      @@registry = Hash.new{|h,k| h[k] = {}}
+      @@registry = Hash.new do |registry,query| 
+        registry[query] = Hash.new{|h,k| h[k] = {}}
+      end
     end
     
     reset_counts!
@@ -40,34 +48,49 @@ module EventMachine
       @@pass_through_requests
     end
     
-    def self.register(uri, method, data)
+    def self.register(uri, method, headers, data)
       method = method.to_s.upcase
-      @@registry[uri][method] = data
+      headers = headers.to_s
+      @@registry[uri][method][headers] = data
     end
     
-    def self.register_file(uri, method, file)
-      register(uri, method, File.read(file))
+    def self.register_file(uri, method, headers, file)
+      register(uri, method, headers, File.read(file))
     end
     
-    def self.count(uri, method)
+    def self.count(uri, method, headers)
       method = method.to_s.upcase
-      @@registry_count[uri][method]
+      headers = headers.to_s
+      @@registry_count[uri][method][headers] rescue 0
+    end
+    
+    def self.registered?(query, method, headers)
+      @@registry[query] and @@registry[query][method] and @@registry[query][method][headers]
+    end
+    
+    def self.registered_content(query, method, headers)
+      @@registry[query][method][headers]
+    end
+    
+    def self.increment_access(query, method, headers)
+      @@registry_count[query][method][headers] += 1
     end
     
     alias_method :real_send_request, :send_request
     
     protected
     def send_request(&blk)
-      query = "#{@uri.scheme}://#{@uri.host}:#{@uri.port}#{encode_query(@uri.path, @options[:query], @uri.query)}"
-      if s = @@registry[query] and fake = s[@method]
-        @@registry_count[query][@method] += 1
+      query = "#{@req.uri.scheme}://#{@req.uri.host}:#{@req.uri.port}#{encode_query(@req.uri.path, @req.options[:query], @req.uri.query)}"
+      headers = @req.options[:head].to_s
+      if self.class.registered?(query, @req.method, headers)
+        self.class.increment_access(query, @req.method, headers)
         client = FakeHttpClient.new(nil)
-        client.setup(fake, @uri)
+        client.setup(self.class.registered_content(query, @req.method, headers), @req.uri)
         client
       elsif @@pass_through_requests
         real_send_request
       else
-        raise "this request #{query} for method #{@method} isn't registered, and pass_through_requests is current set to false"
+        raise "this request #{query} for method #{@req.method} with the headers #{@req.options[:head].inspect} isn't registered, and pass_through_requests is current set to false"
       end
     end
   end

data/lib/em-http/request.rb

@@ -1,103 +1,79 @@
-require 'base64'
-require 'addressable/uri'
-
-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
-    
-    attr_reader :options, :method
-
-    def initialize(host)
-      @uri = host.kind_of?(Addressable::URI) ? host : Addressable::URI::parse(host)
-    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 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
-
-    protected
-
-    def setup_request(method, options, &blk)
-      raise ArgumentError, "invalid request path" unless /^\// === @uri.path
-      @options = options
-      
-      if proxy = options[:proxy]
-        @host_to_connect = proxy[:host]
-        @port_to_connect = proxy[:port]
-      else
-        @host_to_connect = @uri.host
-        @port_to_connect = @uri.port
-      end                                      
-      
-      # default connect & inactivity timeouts        
-      @options[:timeout] = 10 if not @options[:timeout]  
-
-      # Make sure the ports are set as Addressable::URI doesn't
-      # set the port if it isn't there
-      if @uri.scheme == "https"
-        @uri.port ||= 443
-        @port_to_connect ||= 443
-      else
-        @uri.port ||= 80
-        @port_to_connect ||= 80
-      end
-      
-      @method = method.to_s.upcase
-      send_request(&blk)
-    end
-    
-    def send_request(&blk)
-      begin
-       EventMachine.connect(@host_to_connect, @port_to_connect, EventMachine::HttpClient) { |c|
-          c.uri = @uri
-          c.method = @method
-          c.options = @options
-          c.comm_inactivity_timeout = @options[:timeout]
-          c.pending_connect_timeout = @options[:timeout]
-          blk.call(c) unless blk.nil?
-        }
-      rescue EventMachine::ConnectionError => e
-        conn = EventMachine::HttpClient.new("")
-        conn.on_error(e.message, true)
-        conn
-      end
-    end
-  end
+require 'base64'
+require 'addressable/uri'
+
+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
+
+    attr_reader :options, :method
+
+    def initialize(host)
+      @uri = host.kind_of?(Addressable::URI) ? host : Addressable::URI::parse(host)
+    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 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
+
+    protected
+
+    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
+      end
+    end
+  end
 end

data/spec/mock_spec.rb

@@ -8,7 +8,7 @@ describe 'em-http mock' do
   end
   
   it "should serve a fake http request from a file" do
-    EventMachine::MockHttpRequest.register_file('http://www.google.ca:80/', :get, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
+    EventMachine::MockHttpRequest.register_file('http://www.google.ca:80/', :get, {}, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
     EM.run {
       
       http = EventMachine::MockHttpRequest.new('http://www.google.ca/').get
@@ -19,7 +19,7 @@ describe 'em-http mock' do
       }
     }
     
-    EventMachine::MockHttpRequest.count('http://www.google.ca:80/', :get).should == 1
+    EventMachine::MockHttpRequest.count('http://www.google.ca:80/', :get, {}).should == 1
   end
   
   it "should serve a fake http request from a string" do
@@ -46,7 +46,7 @@ window._gjp && _gjp()</script><style>td{line-height:.8em;}.gac_m td{line-height:
 function a(){google.timers.load.t.ol=(new Date).getTime();google.report&&google.timers.load.t.xjs&&google.report(google.timers.load,google.kCSI)}if(window.addEventListener)window.addEventListener("load",a,false);else if(window.attachEvent)window.attachEvent("onload",a);google.timers.load.t.prt=(new Date).getTime();
 })();
     HEREDOC
-    EventMachine::MockHttpRequest.register('http://www.google.ca:80/', :get, data)
+    EventMachine::MockHttpRequest.register('http://www.google.ca:80/', :get, {}, data)
     EventMachine.run {
       
       http = EventMachine::MockHttpRequest.new('http://www.google.ca/').get
@@ -57,7 +57,52 @@ function a(){google.timers.load.t.ol=(new Date).getTime();google.report&&google.
       }
     }
     
-    EventMachine::MockHttpRequest.count('http://www.google.ca:80/', :get).should == 1
+    EventMachine::MockHttpRequest.count('http://www.google.ca:80/', :get, {}).should == 1
+  end
+
+  it "should serve a fake failing http request" do
+    EventMachine::MockHttpRequest.register('http://www.google.ca:80/', :get, {}, :fail)
+    error = false
+
+    EventMachine.run {
+      http = EventMachine::MockHttpRequest.new('http://www.google.ca/').get
+      http.errback {
+        error = true
+        EventMachine.stop
+      }
+    }
+
+    error.should be_true
+    EventMachine::MockHttpRequest.count('http://www.google.ca:80/', :get, {}).should == 1
+  end
+  
+  it "should distinguish the cache by the given headers" do
+    EventMachine::MockHttpRequest.register_file('http://www.google.ca:80/', :get,  {:user_agent => 'BERT'}, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
+    EventMachine::MockHttpRequest.register_file('http://www.google.ca:80/', :get, {}, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
+    EM.run {
+      
+      http = EventMachine::MockHttpRequest.new('http://www.google.ca/').get
+      http.errback { fail }
+      http.callback {
+        http.response.should == File.read(File.join(File.dirname(__FILE__), 'fixtures', 'google.ca')).split("\n\n", 2).last
+        EventMachine.stop
+      }
+    }
+    
+    EventMachine::MockHttpRequest.count('http://www.google.ca:80/', :get, {}).should == 1
+    EventMachine::MockHttpRequest.count('http://www.google.ca:80/', :get, {:user_agent => 'BERT'}).should == 0
+    
+    EM.run {
+      
+      http = EventMachine::MockHttpRequest.new('http://www.google.ca/').get({:head => {:user_agent => 'BERT'}})
+      http.errback { fail }
+      http.callback {
+        http.response.should == File.read(File.join(File.dirname(__FILE__), 'fixtures', 'google.ca')).split("\n\n", 2).last
+        EventMachine.stop
+      }
+    }
+    
+    EventMachine::MockHttpRequest.count('http://www.google.ca:80/', :get, {:user_agent => 'BERT'}).should == 1
   end
 
   it "should raise an exception if pass-thru is disabled" do

data/spec/multi_spec.rb

@@ -28,8 +28,8 @@ describe EventMachine::MultiRequest do
   end
 
   it "should handle multiple mock requests" do
-    EventMachine::MockHttpRequest.register_file('http://127.0.0.1:8080/', :get, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
-    EventMachine::MockHttpRequest.register_file('http://0.0.0.0:8083/', :get, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
+    EventMachine::MockHttpRequest.register_file('http://127.0.0.1:8080/', :get, {}, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
+    EventMachine::MockHttpRequest.register_file('http://0.0.0.0:8083/', :get, {}, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
 
     EventMachine.run {
       

data/spec/request_spec.rb

@@ -11,6 +11,7 @@ describe EventMachine::HttpRequest do
 
   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.errback {
@@ -22,11 +23,12 @@ describe EventMachine::HttpRequest do
 
   it "should fail GET on invalid host" do
     EventMachine.run {
+      EventMachine.heartbeat_interval = 0.1
       http = EventMachine::HttpRequest.new('http://somethinglocal/').get :timeout => 1
       http.callback { failed }
       http.errback {
         http.response_header.status.should == 0
-        http.errors.should match(/unable to resolve server address/)
+        http.error.should match(/unable to resolve server address/)
         EventMachine.stop
       }
     }
@@ -74,7 +76,7 @@ describe EventMachine::HttpRequest do
       uri = URI.parse('http://127.0.0.1:8080/')
       http = EventMachine::HttpRequest.new(uri).head
 
-      http.errback { failed }
+      http.errback { p http; failed }
       http.callback {
         http.response_header.status.should == 200
         http.response.should == ""
@@ -302,19 +304,63 @@ describe EventMachine::HttpRequest do
     }
   end
 
-  it "should timeout after 10 seconds" do
+  it "should timeout after 1 second" do
     EventMachine.run {
       t = Time.now.to_i
+      EventMachine.heartbeat_interval = 0.1
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/timeout').get :timeout => 1
 
       http.errback {
-        (Time.now.to_i - t).should >= 2
+        (Time.now.to_i - t).should <= 5
         EventMachine.stop
       }
       http.callback { failed }
     }
   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/'
+
+        EM.stop
+      }
+    }
+  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
+
+        EM.stop
+      }
+    }
+  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
+
+        EM.stop
+      }
+    }
+  end
+
   it "should optionally pass the response body progressively" do
     EventMachine.run {
       body = ''
@@ -486,8 +532,20 @@ describe EventMachine::HttpRequest do
         EventMachine.stop
       }
     }
-  end   
-  
+  end
+
+  it "should stream a file off disk" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').post :file => 'spec/fixtures/google.ca'
+
+      http.errback { failed }
+      http.callback {
+        http.response.should match('google')
+        EventMachine.stop
+      }
+    }
+  end
+
   it 'should let you pass a block to be called once the client is created' do
     client = nil
     EventMachine.run {
@@ -501,14 +559,13 @@ describe EventMachine::HttpRequest do
         client.should be_kind_of(EventMachine::HttpClient)
         http.response_header.status.should == 200
         http.response.should match(/callback_run=yes/)
-        client.normalize_uri.should == Addressable::URI.parse('http://127.0.0.1:8080/')
         EventMachine.stop
       }
     }
   end
 
   it "should retrieve multiple cookies" do
-    EventMachine::MockHttpRequest.register_file('http://www.google.ca:80/', :get, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
+    EventMachine::MockHttpRequest.register_file('http://www.google.ca:80/', :get, {}, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
     EventMachine.run {
 
       http = EventMachine::MockHttpRequest.new('http://www.google.ca/').get
@@ -522,7 +579,7 @@ describe EventMachine::HttpRequest do
       }
     }
 
-    EventMachine::MockHttpRequest.count('http://www.google.ca:80/', :get).should == 1
+    EventMachine::MockHttpRequest.count('http://www.google.ca:80/', :get, {}).should == 1
   end
 
   context "connections via proxy" do
@@ -595,7 +652,7 @@ describe EventMachine::HttpRequest do
           # push should only be invoked after handshake is complete
           http.send(MSG)
         }
-        
+
         http.stream { |chunk|
           chunk.should == MSG
           EventMachine.stop