excon 0.17.0 → 0.18.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    excon (0.17.0)
+    excon (0.18.0)
 
 GEM
   remote: http://rubygems.org/
@@ -14,6 +14,7 @@ GEM
     delorean (2.0.0)
       chronic
     eventmachine (1.0.0)
+    eventmachine (1.0.0-java)
     formatador (0.2.3)
     i18n (0.6.0)
     jruby-openssl (0.7.7)

data/README.md

@@ -100,6 +100,14 @@ You can make `Transfer-Encoding: chunked` requests by passing a block that will
 
 Iterating in this way allows you to have more granular control over writes and to write things where you can not calculate the overall length up front.
 
+Pipelining Requests
+------------------
+
+You can make use of HTTP pipelining to improve performance. Insead of the normal request/response cyle, pipelining sends a series of requests and then receives a series of responses. You can take advantage of this using the `requests` method, which takes an array of params where each is a hash like request would receive and returns an array of responses.
+
+    connection = Excon.new('http://geemus.com/')
+    connection.requests([{:method => :get, :method => :get}])
+
 Streaming Responses
 -------------------
 

data/changelog.txt

@@ -1,3 +1,20 @@
+0.18.0 02/21/2013
+=================
+
+more refactoring around middlewares
+add pipelining capabilities
+allow [] style access to response attributes
+
+
+0.17.0 02/01/2013
+=================
+
+add patch method
+allow passing family for addresses to params/proxy
+more consistent empty header passing
+nicer debug output
+internal refactoring toward middleware pattern
+
 0.16.10 11/16/2012
 ==================
 

data/excon.gemspec

@@ -13,8 +13,8 @@ Gem::Specification.new do |s|
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = 'excon'
-  s.version           = '0.17.0'
-  s.date              = '2013-02-01'
+  s.version           = '0.18.0'
+  s.date              = '2013-02-21'
   s.rubyforge_project = 'excon'
 
   ## Make sure your summary is short. The description may be as long
@@ -96,8 +96,10 @@ Gem::Specification.new do |s|
     lib/excon/connection.rb
     lib/excon/constants.rb
     lib/excon/errors.rb
+    lib/excon/middlewares/base.rb
     lib/excon/middlewares/expects.rb
     lib/excon/middlewares/instrumentor.rb
+    lib/excon/middlewares/mock.rb
     lib/excon/response.rb
     lib/excon/socket.rb
     lib/excon/ssl_socket.rb
@@ -109,6 +111,7 @@ Gem::Specification.new do |s|
     tests/header_tests.rb
     tests/idempotent_tests.rb
     tests/middlewares/instrumentation_tests.rb
+    tests/middlewares/mock_tests.rb
     tests/proxy_tests.rb
     tests/query_string_tests.rb
     tests/rackups/basic.rb
@@ -124,9 +127,9 @@ Gem::Specification.new do |s|
     tests/rackups/timeout.ru
     tests/request_headers_tests.rb
     tests/request_method_tests.rb
+    tests/requests_tests.rb
     tests/servers/bad.rb
     tests/servers/eof.rb
-    tests/stub_tests.rb
     tests/test_helper.rb
     tests/thread_safety_tests.rb
     tests/timeout_tests.rb

data/lib/excon.rb

@@ -21,6 +21,11 @@ module Excon
         :headers            => {},
         :idempotent         => false,
         :instrumentor_name  => 'excon',
+        :middlewares        => [
+          Excon::Middleware::Instrumentor,
+          Excon::Middleware::Expects,
+          Excon::Middleware::Mock
+        ],
         :mock               => false,
         :nonblock           => DEFAULT_NONBLOCK,
         :read_timeout       => 60,
@@ -43,8 +48,10 @@ end
 require 'excon/constants'
 require 'excon/connection'
 require 'excon/errors'
+require 'excon/middlewares/base'
 require 'excon/middlewares/expects'
 require 'excon/middlewares/instrumentor'
+require 'excon/middlewares/mock'
 require 'excon/response'
 require 'excon/socket'
 require 'excon/ssl_socket'
@@ -111,7 +118,7 @@ module Excon
         request_params.update(
           :host              => uri.host,
           :path              => uri.path,
-          :port              => uri.port,
+          :port              => uri.port.to_s,
           :query             => uri.query,
           :scheme            => uri.scheme
         )

data/lib/excon/connection.rb

@@ -1,6 +1,10 @@
 module Excon
   class Connection
-
+    VALID_CONNECTION_KEYS = [:body, :headers, :host, :host_port, :path, :port, :query, :scheme, :user, :password,
+                             :instrumentor, :instrumentor_name, :ssl_ca_file, :ssl_verify_peer, :chunk_size,
+                             :nonblock, :retry_limit, :connect_timeout, :read_timeout, :write_timeout, :captures,
+                             :exception, :expects, :mock, :proxy, :method, :idempotent, :request_block, :response_block,
+                             :middlewares, :retries_remaining, :connection, :stack, :response, :pipeline]
     attr_reader :data
 
     def params
@@ -21,6 +25,13 @@ module Excon
       @data[:proxy] = new_proxy
     end
 
+    def assert_valid_keys_for_argument!(argument, valid_keys)
+      invalid_keys = argument.keys - valid_keys
+      return true if invalid_keys.empty?
+      raise ArgumentError, "The following keys are invalid: #{invalid_keys.map(&:inspect).join(', ')}"
+    end
+    private :assert_valid_keys_for_argument!
+
     # Initializes a new Connection instance
     #   @param [String] url The destination URL
     #   @param [Hash<Symbol, >] params One or more optional params
@@ -36,14 +47,16 @@ module Excon
     #     @option params [Class] :instrumentor Responds to #instrument as in ActiveSupport::Notifications
     #     @option params [String] :instrumentor_name Name prefix for #instrument events.  Defaults to 'excon'
     def initialize(url, params = {})
+      assert_valid_keys_for_argument!(params, VALID_CONNECTION_KEYS)
       uri = URI.parse(url)
       @data = Excon.defaults.merge({
         :host       => uri.host,
-        :host_port  => '' << uri.host << ':' << uri.port.to_s,
         :path       => uri.path,
-        :port       => uri.port,
+        :port       => uri.port.to_s,
         :query      => uri.query,
         :scheme     => uri.scheme,
+        :user       => (URI.decode(uri.user) if uri.user),
+        :password   => (URI.decode(uri.password) if uri.password),
       }).merge!(params)
       # merge does not deep-dup, so make sure headers is not the original
       @data[:headers] = @data[:headers].dup
@@ -74,20 +87,21 @@ module Excon
         @data[:headers]['Authorization'] ||= 'Basic ' << ['' << uri.user.to_s << ':' << uri.password.to_s].pack('m').delete(Excon::CR_NL)
       end
 
-      @socket_key = '' << @data[:host_port]
+      @socket_key = '' << @data[:host] << ':' << @data[:port]
       reset
     end
 
-    def call(datum)
+    def request_call(datum)
       begin
-        response_datum = if datum[:mock]
-          invoke_stub(datum)
+        if datum.has_key?(:response)
+          # we already have data from a middleware, so bail
+          return datum
         else
           socket.data = datum
           # start with "METHOD /path"
           request = datum[:method].to_s.upcase << ' '
           if @data[:proxy]
-            request << datum[:scheme] << '://' << datum[:host_port]
+            request << datum[:scheme] << '://' << @data[:host] << ':' << @data[:port].to_s
           end
           request << datum[:path]
 
@@ -164,24 +178,21 @@ module Excon
               end
             end
           end
-
-          # read the response
-          response_datum = Excon::Response.parse(socket, datum)
-
-          if response_datum[:headers]['Connection'] == 'close'
-            reset
-          end
-
-          response_datum
         end
-      rescue Excon::Errors::StubNotFound, Excon::Errors::Timeout => error
-        raise(error)
-      rescue => socket_error
-        reset
-        raise(Excon::Errors::SocketError.new(socket_error))
+      rescue => error
+        case error
+        when Excon::Errors::StubNotFound, Excon::Errors::Timeout
+          raise(error)
+        else
+          raise(Excon::Errors::SocketError.new(error))
+        end
       end
 
-      response_datum
+      datum
+    end
+
+    def response_call(datum)
+      datum
     end
 
     # Sends the supplied request to the destination host.
@@ -197,9 +208,9 @@ module Excon
     def request(params, &block)
       # @data has defaults, merge in new params to override
       datum = @data.merge(params)
-      datum[:host_port]  = '' << datum[:host] << ':' << datum[:port].to_s
+      assert_valid_keys_for_argument!(params, VALID_CONNECTION_KEYS)
       datum[:headers] = @data[:headers].merge(datum[:headers] || {})
-      datum[:headers]['Host'] = '' << datum[:host_port]
+      datum[:headers]['Host']   ||= '' << datum[:host] << ':' << datum[:port]
       datum[:retries_remaining] ||= datum[:retry_limit]
 
       # if path is empty or doesn't start with '/', insert one
@@ -212,37 +223,50 @@ module Excon
         datum[:response_block] = Proc.new
       end
 
-      datum[:middlewares] = [
-        lambda {|app| Excon::Middleware::Instrumentor.new(app) },
-        lambda {|app| Excon::Middleware::Expects.new(app) }
-      ]
-      stack = datum[:middlewares].reverse.inject(self) do |middlewares, middleware|
+      datum[:connection] = self
+
+      datum[:stack] = datum[:middlewares].map do |middleware|
+        lambda {|stack| middleware.new(stack)}
+      end.reverse.inject(self) do |middlewares, middleware|
         middleware.call(middlewares)
       end
-      response_datum = stack.call(datum)
+      datum = datum[:stack].request_call(datum)
+
+      unless datum[:pipeline]
+        datum = response(datum)
+
+        if datum[:response][:headers]['Connection'] == 'close'
+          reset
+        end
 
-      Excon::Response.new(response_datum)
+        Excon::Response.new(datum[:response])
+      else
+        datum
+      end
     rescue => request_error
+      reset
       if datum[:idempotent] && [Excon::Errors::Timeout, Excon::Errors::SocketError,
-          Excon::Errors::HTTPStatusError].any? {|ex| request_error.kind_of? ex }
+          Excon::Errors::HTTPStatusError].any? {|ex| request_error.kind_of? ex } && datum[:retries_remaining] > 1
         datum[:retries_remaining] -= 1
-        if datum[:retries_remaining] > 0
-          request(datum, &block)
-        else
-          if datum.has_key?(:instrumentor)
-            datum[:instrumentor].instrument("#{datum[:instrumentor_name]}.error", :error => request_error)
-          end
-          raise(request_error)
-        end
+        request(datum, &block)
       else
         if datum.has_key?(:instrumentor)
           datum[:instrumentor].instrument("#{datum[:instrumentor_name]}.error", :error => request_error)
         end
-        reset
         raise(request_error)
       end
     end
 
+    # Sends the supplied requests to the destination host using pipelining.
+    #   @pipeline_params [Array<Hash>] pipeline_params An array of one or more optional params, override defaults set in Connection.new, see #request for details
+    def requests(pipeline_params)
+      pipeline_params.map do |params|
+        request(params.merge!(:pipeline => true))
+      end.map do |datum|
+        Excon::Response.new(response(datum)[:response])
+      end
+    end
+
     def reset
       (old_socket = sockets.delete(@socket_key)) && old_socket.close
     end
@@ -304,67 +328,75 @@ module Excon
       end
     end
 
-    def invoke_stub(datum)
-      # convert File/Tempfile body to string before matching:
-      unless datum[:body].nil? || datum[:body].is_a?(String)
-       if datum[:body].respond_to?(:binmode)
-         datum[:body].binmode
-       end
-       if datum[:body].respond_to?(:rewind)
-         datum[:body].rewind
-       end
-       datum[:body] = datum[:body].read
-      end
-
-      datum[:captures] = {:headers => {}} # setup data to hold captures
-      Excon.stubs.each do |stub, response|
-        headers_match = !stub.has_key?(:headers) || stub[:headers].keys.all? do |key|
-          case value = stub[:headers][key]
-          when Regexp
-            if match = value.match(datum[:headers][key])
-              datum[:captures][:headers][key] = match.captures
-            end
-            match
-          else
-            value == datum[:headers][key]
-          end
-        end
-        non_headers_match = (stub.keys - [:headers]).all? do |key|
-          case value = stub[key]
-          when Regexp
-            if match = value.match(datum[key])
-              datum[:captures][key] = match.captures
-            end
-            match
-          else
-            value == datum[key]
+    def response(datum={})
+      unless datum.has_key?(:response)
+        datum[:response] = {
+          :body       => '',
+          :headers    => {},
+          :status     => socket.read(12)[9, 11].to_i,
+          :remote_ip  => socket.remote_ip
+        }
+        socket.readline # read the rest of the status line and CRLF
+
+        until ((data = socket.readline).chop!).empty?
+          key, value = data.split(/:\s*/, 2)
+          datum[:response][:headers][key] = ([*datum[:response][:headers][key]] << value).compact.join(', ')
+          if key.casecmp('Content-Length') == 0
+            content_length = value.to_i
+          elsif (key.casecmp('Transfer-Encoding') == 0) && (value.casecmp('chunked') == 0)
+            transfer_encoding_chunked = true
           end
         end
-        if headers_match && non_headers_match
-          response_datum = case response
-          when Proc
-            response.call(datum)
-          else
-            response
-          end
 
-          if datum[:expects] && ![*datum[:expects]].include?(response_datum[:status])
-            # don't pass stuff into a block if there was an error
-          elsif datum.has_key?(:response_block) && response_datum.has_key?(:body)
-            body = response_datum.delete(:body)
-            content_length = remaining = body.bytesize
-            i = 0
-            while i < body.length
-              datum[:response_block].call(body[i, datum[:chunk_size]], [remaining - datum[:chunk_size], 0].max, content_length)
-              remaining -= datum[:chunk_size]
-              i += datum[:chunk_size]
+        unless (['HEAD', 'CONNECT'].include?(datum[:method].to_s.upcase)) || NO_ENTITY.include?(datum[:response][:status])
+
+          # check to see if expects was set and matched
+          expected_status = !datum.has_key?(:expects) || [*datum[:expects]].include?(datum[:response][:status])
+
+          # if expects matched and there is a block, use it
+          if expected_status && datum.has_key?(:response_block)
+            if transfer_encoding_chunked
+              # 2 == "/r/n".length
+              while (chunk_size = socket.readline.chop!.to_i(16)) > 0
+                datum[:response_block].call(socket.read(chunk_size + 2).chop!, nil, nil)
+              end
+              socket.read(2)
+            elsif remaining = content_length
+              while remaining > 0
+                datum[:response_block].call(socket.read([datum[:chunk_size], remaining].min), [remaining - datum[:chunk_size], 0].max, content_length)
+                remaining -= datum[:chunk_size]
+              end
+            else
+              while remaining = socket.read(datum[:chunk_size])
+                datum[:response_block].call(remaining, remaining.length, content_length)
+              end
+            end
+          else # no block or unexpected status
+            if transfer_encoding_chunked
+              while (chunk_size = socket.readline.chop!.to_i(16)) > 0
+                datum[:response][:body] << socket.read(chunk_size + 2).chop! # 2 == "/r/n".length
+              end
+              socket.read(2) # 2 == "/r/n".length
+            elsif remaining = content_length
+              while remaining > 0
+                datum[:response][:body] << socket.read([datum[:chunk_size], remaining].min)
+                remaining -= datum[:chunk_size]
+              end
+            else
+              datum[:response][:body] << socket.read
             end
           end
-          return response_datum
         end
       end
-      # if we reach here no stubs matched
-      raise(Excon::Errors::StubNotFound.new('no stubs matched ' << datum.inspect))
+
+      datum[:stack].response_call(datum)
+    rescue => error
+      case error
+      when Excon::Errors::HTTPStatusError, Excon::Errors::Timeout
+        raise(error)
+      else
+        raise(Excon::Errors::SocketError.new(error))
+      end
     end
 
     def socket
@@ -388,9 +420,8 @@ module Excon
         end
         {
           :host       => uri.host,
-          :host_port  => '' << uri.host << ':' << uri.port.to_s,
           :password   => uri.password,
-          :port       => uri.port,
+          :port       => uri.port.to_s,
           :scheme     => uri.scheme,
           :user       => uri.user
         }

data/lib/excon/constants.rb

@@ -29,7 +29,7 @@ module Excon
 
   REDACTED = 'REDACTED'
 
-  VERSION = '0.17.0'
+  VERSION = '0.18.0'
 
   unless ::IO.const_defined?(:WaitReadable)
     class ::IO

data/lib/excon/errors.rb

@@ -120,15 +120,17 @@ module Excon
         503 => [Excon::Errors::ServiceUnavailable, 'Service Unavailable'],
         504 => [Excon::Errors::GatewayTimeout, 'Gateway Timeout']
       }
-      error, message = @errors[response.status] || [Excon::Errors::HTTPStatusError, 'Unknown']
+
+      error, message = @errors[response[:status]] || [Excon::Errors::HTTPStatusError, 'Unknown']
 
       # scrub authorization
+      request = request.dup
+      request.reject! {|key, value| [:connection, :stack].include?(key)}
       if request[:headers].has_key?('Authorization')
-        request = request.dup
         request[:headers] = request[:headers].dup
         request[:headers]['Authorization'] = REDACTED
       end
-      error.new("Expected(#{request[:expects].inspect}) <=> Actual(#{response.status} #{message})\n  request => #{request.inspect}\n  response => #{response.inspect}", request, response)
+      error.new("Expected(#{request[:expects].inspect}) <=> Actual(#{response[:status]} #{message})\n  request => #{request.inspect}\n  response => #{response.inspect}", request, response)
     end
 
   end

data/lib/excon/middlewares/base.rb

@@ -0,0 +1,19 @@
+module Excon
+  module Middleware
+    class Base
+      def initialize(stack)
+        @stack = stack
+      end
+
+      def request_call(datum)
+        # do stuff
+        @stack.request_call(datum)
+      end
+
+      def response_call(datum)
+        @stack.response_call(datum)
+        # do stuff
+      end
+    end
+  end
+end

data/lib/excon/middlewares/expects.rb

@@ -1,17 +1,16 @@
 module Excon
   module Middleware
-    class Expects
-      def initialize(app)
-        @app = app
-      end
-
-      def call(datum)
-        response_datum = @app.call(datum)
-
-        if datum.has_key?(:expects) && ![*datum[:expects]].include?(response_datum[:status])
-          raise(Excon::Errors.status_error(datum, Excon::Response.new(response_datum)))
+    class Expects < Excon::Middleware::Base
+      def response_call(datum)
+        if datum.has_key?(:expects) && ![*datum[:expects]].include?(datum[:response][:status])
+          raise(
+            Excon::Errors.status_error(
+              datum.reject {|key,value| key == :response},
+              datum[:response]
+            )
+          )
         else
-          response_datum
+          @stack.response_call(datum)
         end
       end
     end

data/lib/excon/middlewares/instrumentor.rb

@@ -1,25 +1,26 @@
 module Excon
   module Middleware
-    class Instrumentor
-      def initialize(app)
-        @app = app
-      end
-
-      def call(datum)
+    class Instrumentor < Excon::Middleware::Base
+      def request_call(datum)
         if datum.has_key?(:instrumentor)
           if datum[:retries_remaining] < datum[:retry_limit]
             event_name = "#{datum[:instrumentor_name]}.retry"
           else
             event_name = "#{datum[:instrumentor_name]}.request"
           end
-          response_datum = datum[:instrumentor].instrument(event_name, datum) do
-            @app.call(datum)
+          datum[:instrumentor].instrument(event_name, datum) do
+            @stack.request_call(datum)
           end
-          datum[:instrumentor].instrument("#{datum[:instrumentor_name]}.response", response_datum)
-          response_datum
         else
-          @app.call(datum)
+          @stack.request_call(datum)
+        end
+      end
+
+      def response_call(datum)
+        if datum.has_key?(:instrumentor)
+          datum[:instrumentor].instrument("#{datum[:instrumentor_name]}.response", datum[:response])
         end
+        @stack.response_call(datum)
       end
     end
   end

data/lib/excon/middlewares/mock.rb

@@ -0,0 +1,84 @@
+module Excon
+  module Middleware
+    class Mock < Excon::Middleware::Base
+      def request_call(datum)
+        if datum[:mock]
+          # convert File/Tempfile body to string before matching:
+          unless datum[:body].nil? || datum[:body].is_a?(String)
+           if datum[:body].respond_to?(:binmode)
+             datum[:body].binmode
+           end
+           if datum[:body].respond_to?(:rewind)
+             datum[:body].rewind
+           end
+           datum[:body] = datum[:body].read
+          end
+
+          datum[:captures] = {:headers => {}} # setup data to hold captures
+          Excon.stubs.each do |stub, response|
+            headers_match = !stub.has_key?(:headers) || stub[:headers].keys.all? do |key|
+              case value = stub[:headers][key]
+              when Regexp
+                if match = value.match(datum[:headers][key])
+                  datum[:captures][:headers][key] = match.captures
+                end
+                match
+              else
+                value == datum[:headers][key]
+              end
+            end
+            non_headers_match = (stub.keys - [:headers]).all? do |key|
+              case value = stub[key]
+              when Regexp
+                if match = value.match(datum[key])
+                  datum[:captures][key] = match.captures
+                end
+                match
+              else
+                value == datum[key]
+              end
+            end
+            if headers_match && non_headers_match
+              datum[:response] = {
+                :body       => '',
+                :headers    => {},
+                :status     => 200,
+                :remote_ip  => '127.0.0.1'
+              }
+
+              stub_datum = case response
+              when Proc
+                response.call(datum)
+              else
+                response
+              end
+
+              datum[:response].merge!(stub_datum.reject {|key,value| key == :headers})
+              if stub_datum.has_key?(:headers)
+                datum[:response][:headers].merge!(stub_datum[:headers])
+              end
+
+              if datum[:expects] && ![*datum[:expects]].include?(datum[:response][:status])
+                # don't pass stuff into a block if there was an error
+              elsif datum.has_key?(:response_block) && datum[:response].has_key?(:body)
+                body = datum[:response].delete(:body)
+                content_length = remaining = body.bytesize
+                i = 0
+                while i < body.length
+                  datum[:response_block].call(body[i, datum[:chunk_size]], [remaining - datum[:chunk_size], 0].max, content_length)
+                  remaining -= datum[:chunk_size]
+                  i += datum[:chunk_size]
+                end
+              end
+              return @stack.request_call(datum)
+            end
+          end
+          # if we reach here no stubs matched
+          raise(Excon::Errors::StubNotFound.new('no stubs matched ' << datum.inspect))
+        else
+          @stack.request_call(datum)
+        end
+      end
+    end
+  end
+end

data/lib/excon/response.rb

@@ -1,15 +1,21 @@
 module Excon
   class Response
 
-    attr_accessor :body, :headers, :status, :remote_ip
+    attr_accessor :body, :data, :headers, :status, :remote_ip
 
-    def data
-      {
-        :body      => body,
-        :headers   => headers,
-        :status    => status,
-        :remote_ip => remote_ip
-      }
+    def initialize(params={})
+      @data = {
+        :body     => '',
+        :headers  => {}
+      }.merge(params)
+      @body      = @data[:body]
+      @headers   = @data[:headers]
+      @status    = @data[:status]
+      @remote_ip = @data[:remote_ip]
+    end
+
+    def [](key)
+      @data[key]
     end
 
     def params
@@ -17,75 +23,6 @@ module Excon
       data
     end
 
-    def initialize(params={})
-      @body      = params[:body]    || ''
-      @headers   = params[:headers] || {}
-      @status    = params[:status]
-      @remote_ip = params[:remote_ip]
-    end
-
-    def self.parse(socket, datum={})
-      response_datum = {
-        :body       => '',
-        :headers    => {},
-        :status     => socket.read(12)[9, 11].to_i,
-        :remote_ip  => socket.remote_ip
-      }
-      socket.readline # read the rest of the status line and CRLF
-
-      until ((data = socket.readline).chop!).empty?
-        key, value = data.split(/:\s*/, 2)
-        response_datum[:headers][key] = ([*response_datum[:headers][key]] << value).compact.join(', ')
-        if key.casecmp('Content-Length') == 0
-          content_length = value.to_i
-        elsif (key.casecmp('Transfer-Encoding') == 0) && (value.casecmp('chunked') == 0)
-          transfer_encoding_chunked = true
-        end
-      end
-
-      unless (['HEAD', 'CONNECT'].include?(datum[:method].to_s.upcase)) || NO_ENTITY.include?(response_datum[:status])
-
-        # check to see if expects was set and matched
-        expected_status = !datum.has_key?(:expects) || [*datum[:expects]].include?(response_datum[:status])
-
-        # if expects matched and there is a block, use it
-        if expected_status && datum.has_key?(:response_block)
-          if transfer_encoding_chunked
-            # 2 == "/r/n".length
-            while (chunk_size = socket.readline.chop!.to_i(16)) > 0
-              datum[:response_block].call(socket.read(chunk_size + 2).chop!, nil, nil)
-            end
-            socket.read(2)
-          elsif remaining = content_length
-            while remaining > 0
-              datum[:response_block].call(socket.read([datum[:chunk_size], remaining].min), [remaining - datum[:chunk_size], 0].max, content_length)
-              remaining -= datum[:chunk_size]
-            end
-          else
-            while remaining = socket.read(datum[:chunk_size])
-              datum[:response_block].call(remaining, remaining.length, content_length)
-            end
-          end
-        else # no block or unexpected status
-          if transfer_encoding_chunked
-            while (chunk_size = socket.readline.chop!.to_i(16)) > 0
-              response_datum[:body] << socket.read(chunk_size + 2).chop! # 2 == "/r/n".length
-            end
-            socket.read(2) # 2 == "/r/n".length
-          elsif remaining = content_length
-            while remaining > 0
-              response_datum[:body] << socket.read([datum[:chunk_size], remaining].min)
-              remaining -= datum[:chunk_size]
-            end
-          else
-            response_datum[:body] << socket.read
-          end
-        end
-      end
-
-      response_datum
-    end
-
     # Retrieve a specific header value. Header names are treated case-insensitively.
     #   @param [String] name Header name
     def get_header(name)

data/tests/{stub_tests.rb → middlewares/mock_tests.rb}

@@ -107,7 +107,7 @@ Shindo.tests('Excon stubs') do
 
   tests("stub({:body => File.open(...), :method => :get}, { :status => 200 })") do
 
-    file_path = File.join(File.dirname(__FILE__), 'data', 'xs')
+    file_path = File.join(File.dirname(__FILE__), '..', 'data', 'xs')
 
     Excon.stub(
       { :body => File.read(file_path), :method => :get },

data/tests/proxy_tests.rb

@@ -17,7 +17,7 @@ Shindo.tests('Excon proxy support') do
         connection.data[:proxy][:host]
       end
 
-      tests('connection.data[:proxy][:port]').returns(8080) do
+      tests('connection.data[:proxy][:port]').returns('8080') do
         connection.data[:proxy][:port]
       end
 
@@ -37,7 +37,7 @@ Shindo.tests('Excon proxy support') do
           connection.data[:proxy][:host]
         end
 
-        tests('connection.data[:proxy][:port]').returns(8080) do
+        tests('connection.data[:proxy][:port]').returns('8080') do
           connection.data[:proxy][:port]
         end
 
@@ -53,7 +53,7 @@ Shindo.tests('Excon proxy support') do
           connection.data[:proxy][:host]
         end
 
-        tests('connection.data[:proxy][:port]').returns(8081) do
+        tests('connection.data[:proxy][:port]').returns('8081') do
           connection.data[:proxy][:port]
         end
 
@@ -69,7 +69,7 @@ Shindo.tests('Excon proxy support') do
           connection.data[:proxy][:host]
         end
 
-        tests('connection.data[:proxy][:port]').returns(8080) do
+        tests('connection.data[:proxy][:port]').returns('8080') do
           connection.data[:proxy][:port]
         end
       end
@@ -89,7 +89,7 @@ Shindo.tests('Excon proxy support') do
           connection.data[:proxy][:host]
         end
 
-        tests('connection.data[:proxy][:port]').returns(8080) do
+        tests('connection.data[:proxy][:port]').returns('8080') do
           connection.data[:proxy][:port]
         end
 
@@ -105,7 +105,7 @@ Shindo.tests('Excon proxy support') do
           connection.data[:proxy][:host]
         end
 
-        tests('connection.data[:proxy][:port]').returns(8081) do
+        tests('connection.data[:proxy][:port]').returns('8081') do
           connection.data[:proxy][:port]
         end
 
@@ -121,7 +121,7 @@ Shindo.tests('Excon proxy support') do
           connection.data[:proxy][:host]
         end
 
-        tests('connection.data[:proxy][:port]').returns(8080) do
+        tests('connection.data[:proxy][:port]').returns('8080') do
           connection.data[:proxy][:port]
         end
       end
@@ -141,7 +141,7 @@ Shindo.tests('Excon proxy support') do
           connection.data[:proxy][:host]
         end
 
-        tests('connection.data[:proxy][:port]').returns(8080) do
+        tests('connection.data[:proxy][:port]').returns('8080') do
           connection.data[:proxy][:port]
         end
 

data/tests/requests_tests.rb

@@ -0,0 +1,31 @@
+with_rackup('basic.ru') do
+  Shindo.tests('requests should succeed') do
+
+    connection = Excon.new('http://127.0.0.1:9292')
+
+    tests('HEAD /content-length/100, GET /content-length/100') do
+      responses = connection.requests([
+        {:method => :head, :path => '/content-length/100'},
+        {:method => :get, :path => '/content-length/100'}
+      ])
+
+      tests('head body is empty').returns('') do
+        responses.first.body
+      end
+
+      tests('head content length is 100').returns('100') do
+        responses.first.headers['Content-Length']
+      end
+
+      tests('get body is non-empty').returns('x' * 100) do
+        responses.last.body
+      end
+
+      tests('get content length is 100').returns('100') do
+        responses.last.headers['Content-Length']
+      end
+
+    end
+
+  end
+end

data/tests/test_helper.rb

@@ -19,6 +19,10 @@ def basic_tests(url = 'http://127.0.0.1:9292')
           response.status
         end
 
+        tests('response[:status]').returns(200) do
+          response[:status]
+        end
+
         tests("response.headers['Connection']").returns('Keep-Alive') do
           response.headers['Connection']
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: excon
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.18.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-01 00:00:00.000000000 Z
+date: 2013-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -177,8 +177,10 @@ files:
 - lib/excon/connection.rb
 - lib/excon/constants.rb
 - lib/excon/errors.rb
+- lib/excon/middlewares/base.rb
 - lib/excon/middlewares/expects.rb
 - lib/excon/middlewares/instrumentor.rb
+- lib/excon/middlewares/mock.rb
 - lib/excon/response.rb
 - lib/excon/socket.rb
 - lib/excon/ssl_socket.rb
@@ -190,6 +192,7 @@ files:
 - tests/header_tests.rb
 - tests/idempotent_tests.rb
 - tests/middlewares/instrumentation_tests.rb
+- tests/middlewares/mock_tests.rb
 - tests/proxy_tests.rb
 - tests/query_string_tests.rb
 - tests/rackups/basic.rb
@@ -205,9 +208,9 @@ files:
 - tests/rackups/timeout.ru
 - tests/request_headers_tests.rb
 - tests/request_method_tests.rb
+- tests/requests_tests.rb
 - tests/servers/bad.rb
 - tests/servers/eof.rb
-- tests/stub_tests.rb
 - tests/test_helper.rb
 - tests/thread_safety_tests.rb
 - tests/timeout_tests.rb
@@ -226,7 +229,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4091555892439791383
+      hash: 4265625222715917717
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -235,7 +238,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: excon
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 2
 summary: speed, persistence, http(s)