webmock 1.8.8 → 1.8.9

data/.travis.yml

@@ -7,5 +7,10 @@ rvm:
   - jruby-18mode
   - rbx-18mode
   - rbx-19mode
+matrix:
+  allow_failures:
+    - rvm: rbx-18mode
+    - rvm: rbx-19mode
+    - rvm: jruby-19mode
 
 script: "bundle exec rake && rake em_http_request_0_x_spec"

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.8.9
+
+* Fixed problem with caching nil responses when the same HTTPClient instance is used.
+
+    Thanks to [Myron Marston](https://github.com/myronmarston)
+
+* Added support for Addressable >= 2.3.0. Addressable 2.3.0 removed support for multiple query value notations and broke backwards compatibility.
+
+    https://github.com/sporkmonger/addressable/commit/f51e290b5f68a98293327a7da84eb9e2d5f21c62
+    https://github.com/sporkmonger/addressable/issues/77
+
+
 ## 1.8.8
 
 * Fixed Net::HTTP adapter so that it returns `nil` for an empty body response.

data/Gemfile

@@ -17,5 +17,5 @@ group :test do
 end
 
 platforms :jruby do
-  gem 'jruby-openssl', '~> 0.7.4.0'
+  gem 'jruby-openssl', '~> 0.7.7'
 end

data/README.md

@@ -712,6 +712,7 @@ People who submitted patches and new features or suggested improvements. Many th
 * Julien Boyer
 * Kevin Glowacz
 * Hans Hasselberg
+* Andrew France
 
 For a full list of contributors you can visit the
 [contributors](https://github.com/bblimke/webmock/contributors) page.

data/lib/webmock.rb

@@ -8,6 +8,7 @@ require 'webmock/version'
 
 require 'webmock/errors'
 
+require 'webmock/util/query_mapper'
 require 'webmock/util/uri'
 require 'webmock/util/headers'
 require 'webmock/util/hash_counter'

data/lib/webmock/http_lib_adapters/curb_adapter.rb

@@ -170,117 +170,83 @@ if defined?(Curl)
       ### Mocks of Curl::Easy methods below here.
       ###
 
-      def http_with_webmock(method)
+      def http(method)
         @webmock_method = method
-          http_without_webmock(method)
+        super
       end
-      alias_method :http_without_webmock, :http
-      alias_method :http, :http_with_webmock
 
       %w[ get head delete ].each do |verb|
-        define_method "http_#{verb}_with_webmock" do
+        define_method "http_#{verb}" do
           @webmock_method = verb
-          send( "http_#{verb}_without_webmock" )
+          super()
         end
-
-        alias_method "http_#{verb}_without_webmock", "http_#{verb}"
-        alias_method "http_#{verb}", "http_#{verb}_with_webmock"
       end
 
-      def http_put_with_webmock data = nil
+      def http_put data = nil
         @webmock_method = :put
         @put_data = data if data
-        http_put_without_webmock(data)
+        super
       end
-      alias_method :http_put_without_webmock, :http_put
-      alias_method :http_put, :http_put_with_webmock
 
-      def http_post_with_webmock *data
+      def http_post *data
         @webmock_method = :post
         @post_body = data.join('&') if data && !data.empty?
-        http_post_without_webmock(*data)
+        super
       end
-      alias_method :http_post_without_webmock, :http_post
-      alias_method :http_post, :http_post_with_webmock
-
 
-      def perform_with_webmock
+      def perform
         @webmock_method ||= :get
-        curb_or_webmock do
-          perform_without_webmock
-        end
+        curb_or_webmock { super }
       end
-      alias :perform_without_webmock :perform
-      alias :perform :perform_with_webmock
 
-      def put_data_with_webmock= data
+      def put_data= data
         @webmock_method = :put
         @put_data = data
-        self.put_data_without_webmock = data
+        super
       end
-      alias_method :put_data_without_webmock=, :put_data=
-      alias_method :put_data=, :put_data_with_webmock=
 
-      def post_body_with_webmock= data
+      def post_body= data
         @webmock_method = :post
-        self.post_body_without_webmock = data
+        super
       end
-      alias_method :post_body_without_webmock=, :post_body=
-      alias_method :post_body=, :post_body_with_webmock=
 
-      def delete_with_webmock= value
+      def delete= value
         @webmock_method = :delete if value
-        self.delete_without_webmock = value
+        super
       end
-      alias_method :delete_without_webmock=, :delete=
-      alias_method :delete=, :delete_with_webmock=
 
-      def head_with_webmock= value
+      def head= value
         @webmock_method = :head if value
-        self.head_without_webmock = value
+        super
       end
-      alias_method :head_without_webmock=, :head=
-      alias_method :head=, :head_with_webmock=
 
-      def body_str_with_webmock
-        @body_str || body_str_without_webmock
+      def body_str
+        @body_str || super
       end
-      alias :body_str_without_webmock :body_str
-      alias :body_str :body_str_with_webmock
 
-      def response_code_with_webmock
-        @response_code || response_code_without_webmock
+      def response_code
+        @response_code || super
       end
-      alias :response_code_without_webmock :response_code
-      alias :response_code :response_code_with_webmock
 
-      def header_str_with_webmock
-        @header_str || header_str_without_webmock
+      def header_str
+        @header_str || super
       end
-      alias :header_str_without_webmock :header_str
-      alias :header_str :header_str_with_webmock
 
-      def last_effective_url_with_webmock
-        @last_effective_url || last_effective_url_without_webmock
+      def last_effective_url
+        @last_effective_url || super
       end
-      alias :last_effective_url_without_webmock :last_effective_url
-      alias :last_effective_url :last_effective_url_with_webmock
 
-      def content_type_with_webmock
-        @content_type || content_type_without_webmock
+      def content_type
+        @content_type || super
       end
-      alias :content_type_without_webmock :content_type
-      alias :content_type :content_type_with_webmock
 
       %w[ success failure header body complete progress ].each do |callback|
         class_eval <<-METHOD, __FILE__, __LINE__
-          def on_#{callback}_with_webmock &block
+          def on_#{callback} &block
             @on_#{callback} = block
-            on_#{callback}_without_webmock &block
+            super
           end
         METHOD
-        alias_method "on_#{callback}_without_webmock", "on_#{callback}"
-        alias_method "on_#{callback}", "on_#{callback}_with_webmock"
       end
     end
   end

data/lib/webmock/http_lib_adapters/em_http_request/em_http_request_0_x.rb

@@ -47,7 +47,7 @@ if defined?(EventMachine::HttpRequest)
         end
       end
 
-      def send_request_with_webmock(&block)
+      def send_request(&block)
         request_signature = build_request_signature
 
         WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
@@ -61,7 +61,7 @@ if defined?(EventMachine::HttpRequest)
             webmock_response.should_timeout ? "WebMock timeout error" : nil)
           client
         elsif WebMock.net_connect_allowed?(request_signature.uri)
-          http = send_request_without_webmock(&block)
+          http = super
           http.callback {
             if WebMock::CallbackRegistry.any_callbacks?
               webmock_response = build_webmock_response(http)
@@ -76,10 +76,6 @@ if defined?(EventMachine::HttpRequest)
         end
       end
 
-      alias_method :send_request_without_webmock, :send_request
-      alias_method :send_request, :send_request_with_webmock
-
-
       private
 
       def build_webmock_response(http)

data/lib/webmock/http_lib_adapters/em_http_request/em_http_request_1_x.rb

@@ -48,7 +48,7 @@ if defined?(EventMachine::HttpClient)
     end
 
     class WebMockHttpConnection < HttpConnection
-      def webmock_activate_connection(client)
+      def activate_connection(client)
         request_signature = client.request_signature
 
         if client.stubbed_webmock_response
@@ -65,13 +65,11 @@ if defined?(EventMachine::HttpClient)
           finalize_request(client)
           @conn.set_deferred_status :succeeded
         elsif WebMock.net_connect_allowed?(request_signature.uri)
-          real_activate_connection(client)
+          super
         else
           raise WebMock::NetConnectNotAllowedError.new(request_signature)
         end
       end
-      alias_method :real_activate_connection, :activate_connection
-      alias_method :activate_connection, :webmock_activate_connection
     end
 
     class WebMockHttpClient < EventMachine::HttpClient
@@ -92,7 +90,7 @@ if defined?(EventMachine::HttpClient)
         end
       end
 
-      def send_request_with_webmock(head, body)
+      def send_request(head, body)
         WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
 
         if stubbed_webmock_response
@@ -104,15 +102,12 @@ if defined?(EventMachine::HttpClient)
           }
           self
         elsif WebMock.net_connect_allowed?(request_signature.uri)
-          send_request_without_webmock(head, body)
+          super
         else
           raise WebMock::NetConnectNotAllowedError.new(request_signature)
         end
       end
 
-      alias_method :send_request_without_webmock, :send_request
-      alias_method :send_request, :send_request_with_webmock
-
       def set_deferred_status(status, *args)
         if status == :succeeded && !stubbed_webmock_response && WebMock::CallbackRegistry.any_callbacks?
           webmock_response = build_webmock_response

data/lib/webmock/http_lib_adapters/excon_adapter.rb

@@ -42,7 +42,7 @@ if defined?(Excon)
           params = params.dup
           method  = (params.delete(:method) || :get).to_s.downcase.to_sym
           params[:query] = to_query(params[:query]) if params[:query].is_a?(Hash)
-          uri     = Addressable::URI.new(params).to_s
+          uri = Addressable::URI.new(params).to_s
           WebMock::RequestSignature.new method, uri, :body => params[:body], :headers => params[:headers]
         end
 

data/lib/webmock/http_lib_adapters/httpclient_adapter.rb

@@ -28,16 +28,18 @@ if defined?(::HTTPClient)
 
 
   class WebMockHTTPClient < HTTPClient
+    alias_method :do_get_block_without_webmock, :do_get_block
+    alias_method :do_get_stream_without_webmock, :do_get_stream
 
-    def do_get_block_with_webmock(req, proxy, conn, &block)
-      do_get_with_webmock(req, proxy, conn, false, &block)
+    def do_get_block(req, proxy, conn, &block)
+      do_get(req, proxy, conn, false, &block)
     end
 
-    def do_get_stream_with_webmock(req, proxy, conn, &block)
-      do_get_with_webmock(req, proxy, conn, true, &block)
+    def do_get_stream(req, proxy, conn, &block)
+      do_get(req, proxy, conn, true, &block)
     end
 
-    def do_get_with_webmock(req, proxy, conn, stream = false, &block)
+    def do_get(req, proxy, conn, stream = false, &block)
       request_signature = build_request_signature(req, :reuse_existing)
 
       WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
@@ -53,6 +55,9 @@ if defined?(::HTTPClient)
           {:lib => :httpclient}, request_signature, webmock_response)
         res
       elsif WebMock.net_connect_allowed?(request_signature.uri)
+        # in case there is a nil entry in the hash...
+        webmock_responses.delete(request_signature)
+
         res = if stream
           do_get_stream_without_webmock(req, proxy, conn, &block)
         else
@@ -72,27 +77,18 @@ if defined?(::HTTPClient)
       end
     end
 
-    def do_request_async_with_webmock(method, uri, query, body, extheader)
+    def do_request_async(method, uri, query, body, extheader)
       req = create_request(method, uri, query, body, extheader)
       request_signature = build_request_signature(req)
       webmock_request_signatures << request_signature
 
       if webmock_responses[request_signature] || WebMock.net_connect_allowed?(request_signature.uri)
-        do_request_async_without_webmock(method, uri, query, body, extheader)
+        super
       else
         raise WebMock::NetConnectNotAllowedError.new(request_signature)
       end
     end
 
-    alias_method :do_get_block_without_webmock, :do_get_block
-    alias_method :do_get_block, :do_get_block_with_webmock
-
-    alias_method :do_get_stream_without_webmock, :do_get_stream
-    alias_method :do_get_stream, :do_get_stream_with_webmock
-
-    alias_method :do_request_async_without_webmock, :do_request_async
-    alias_method :do_request_async, :do_request_async_with_webmock
-
     def build_httpclient_response(webmock_response, stream = false, &block)
       body = stream ? StringIO.new(webmock_response.body) : webmock_response.body
       response = HTTP::Message.new_response(body)
@@ -136,7 +132,7 @@ if defined?(::HTTPClient)
 
   def build_request_signature(req, reuse_existing = false)
     uri = WebMock::Util::URI.heuristic_parse(req.header.request_uri.to_s)
-    uri.query_values = req.header.request_query if req.header.request_query
+    uri.query = WebMock::Util::QueryMapper.values_to_query(req.header.request_query) if req.header.request_query
     uri.port = req.header.request_uri.port
     uri = uri.omit(:userinfo)
 

data/lib/webmock/http_lib_adapters/net_http.rb

@@ -32,11 +32,9 @@ module WebMock
 
       @webMockNetHTTP = Class.new(Net::HTTP) do
         class << self
-          def socket_type_with_webmock
+          def socket_type
             StubSocket
           end
-          alias_method :socket_type_without_webmock, :socket_type
-          alias_method :socket_type, :socket_type_with_webmock
 
           if Module.method(:const_defined?).arity == 1
             def const_defined?(name)
@@ -63,7 +61,7 @@ module WebMock
           end
         end
 
-        def request_with_webmock(request, body = nil, &block)
+        def request(request, body = nil, &block)
           request_signature = WebMock::NetHTTPUtility.request_signature_from_request(self, request, body)
 
           WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
@@ -88,19 +86,17 @@ module WebMock
             response = if (started? && !WebMock::Config.instance.net_http_connect_on_start) || !started?
               @started = false #otherwise start_with_connect wouldn't execute and connect
               start_with_connect {
-                response = request_without_webmock(request, nil)
+                response = super(request, nil, &nil)
                 after_request.call(response)
               }
             else
-              response = request_without_webmock(request, nil)
+              response = super(request, nil, &nil)
               after_request.call(response)
             end
           else
             raise WebMock::NetConnectNotAllowedError.new(request_signature)
           end
         end
-        alias_method :request_without_webmock, :request
-        alias_method :request, :request_with_webmock
 
         def start_without_connect
           raise IOError, 'HTTP session already opened' if @started
@@ -116,15 +112,15 @@ module WebMock
           self
         end
 
-        def start_with_conditional_connect(&block)
+        alias_method :start_with_connect, :start
+
+        def start(&block)
           if WebMock::Config.instance.net_http_connect_on_start
-            start_with_connect(&block)
+            super(&block)
           else
             start_without_connect(&block)
           end
         end
-        alias_method :start_with_connect, :start
-        alias_method :start, :start_with_conditional_connect
 
         def build_net_http_response(webmock_response, &block)
           response = Net::HTTPResponse.send(:response_class, webmock_response.status[0].to_s).new("1.0", webmock_response.status[0].to_s, webmock_response.status[1])
@@ -204,7 +200,7 @@ end
 module Net  #:nodoc: all
 
   class WebMockNetBufferedIO < BufferedIO
-    def initialize_with_webmock(io, debug_output = nil)
+    def initialize(io, debug_output = nil)
       @read_timeout = 60
       @rbuf = ''
       @debug_output = debug_output
@@ -217,8 +213,6 @@ module Net  #:nodoc: all
       end
       raise "Unable to create local socket" unless @io
     end
-    alias_method :initialize_without_webmock, :initialize
-    alias_method :initialize, :initialize_with_webmock
   end
 
 end

data/lib/webmock/http_lib_adapters/patron_adapter.rb

@@ -13,7 +13,7 @@ if defined?(::Patron)
         OriginalPatronSession = ::Patron::Session unless const_defined?(:OriginalPatronSession)
 
         class WebMockPatronSession < ::Patron::Session
-          def handle_request_with_webmock(req)
+          def handle_request(req)
             request_signature =
               WebMock::HttpLibAdapters::PatronAdapter.build_request_signature(req)
 
@@ -28,7 +28,7 @@ if defined?(::Patron)
                 {:lib => :patron}, request_signature, webmock_response)
               res
             elsif WebMock.net_connect_allowed?(request_signature.uri)
-              res = handle_request_without_webmock(req)
+              res = super
               if WebMock::CallbackRegistry.any_callbacks?
                 webmock_response = WebMock::HttpLibAdapters::PatronAdapter.
                   build_webmock_response(res)
@@ -41,9 +41,6 @@ if defined?(::Patron)
               raise WebMock::NetConnectNotAllowedError.new(request_signature)
             end
           end
-
-          alias_method :handle_request_without_webmock, :handle_request
-          alias_method :handle_request, :handle_request_with_webmock
         end
 
         def self.enable!

data/lib/webmock/request_pattern.rb

@@ -95,7 +95,7 @@ module WebMock
       elsif rSpecHashIncludingMatcher?(query_params)
         WebMock::Matchers::HashIncludingMatcher.from_rspec_matcher(query_params)
       else
-        Addressable::URI.parse('?' + query_params).query_values
+        WebMock::Util::QueryMapper.query_to_values(query_params)
       end
     end
 
@@ -109,7 +109,7 @@ module WebMock
   class URIRegexpPattern  < URIPattern
     def matches?(uri)
       WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u| u.match(@pattern) } &&
-        (@query_params.nil? || @query_params == uri.query_values)
+        (@query_params.nil? || @query_params == WebMock::Util::QueryMapper.query_to_values(uri.query))
     end
 
     def to_s
@@ -123,7 +123,8 @@ module WebMock
     def matches?(uri)
       if @pattern.is_a?(Addressable::URI)
         if @query_params
-          uri.omit(:query) === @pattern && (@query_params.nil? || @query_params == uri.query_values)
+          uri.omit(:query) === @pattern &&
+          (@query_params.nil? || @query_params == WebMock::Util::QueryMapper.query_to_values(uri.query))
         else
           uri === @pattern
         end
@@ -135,7 +136,8 @@ module WebMock
     def add_query_params(query_params)
       super
       if @query_params.is_a?(Hash) || @query_params.is_a?(String)
-        @pattern.query_values = (@pattern.query_values || {}).merge(@query_params)
+        query_hash = (WebMock::Util::QueryMapper.query_to_values(@pattern.query) || {}).merge(@query_params)
+        @pattern.query = WebMock::Util::QueryMapper.values_to_query(query_hash)
         @query_params = nil
       end
     end
@@ -199,7 +201,7 @@ module WebMock
       when :xml then
         Crack::XML.parse(body)
       else
-        Addressable::URI.parse('?' + body).query_values
+        WebMock::Util::QueryMapper.query_to_values(body)
       end
     end
 

data/lib/webmock/request_stub.rb

@@ -81,7 +81,7 @@ module WebMock
 
       if signature.body.to_s != ''
         body = if signature.url_encoded?
-          Addressable::URI.parse('?' + signature.body).query_values
+          WebMock::Util::QueryMapper.query_to_values(signature.body)
         else
           signature.body
         end

data/lib/webmock/util/query_mapper.rb

@@ -0,0 +1,188 @@
+module WebMock::Util
+  class QueryMapper
+    #This class is based on Addressable::URI pre 2.3.0
+
+    ##
+    # Converts the query component to a Hash value.
+    #
+    # @option [Symbol] notation
+    #   May be one of <code>:flat</code>, <code>:dot</code>, or
+    #   <code>:subscript</code>. The <code>:dot</code> notation is not
+    #   supported for assignment. Default value is <code>:subscript</code>.
+    #
+    # @return [Hash, Array] The query string parsed as a Hash or Array object.
+    #
+    # @example
+    #   WebMock::Util::QueryMapper.query_to_values("?one=1&two=2&three=3")
+    #   #=> {"one" => "1", "two" => "2", "three" => "3"}
+    #   WebMock::Util::QueryMapper("?one[two][three]=four").query_values
+    #   #=> {"one" => {"two" => {"three" => "four"}}}
+    #   WebMock::Util::QueryMapper.query_to_values("?one.two.three=four",
+    #     :notation => :dot
+    #   )
+    #   #=> {"one" => {"two" => {"three" => "four"}}}
+    #   WebMock::Util::QueryMapper.query_to_values("?one[two][three]=four",
+    #     :notation => :flat
+    #   )
+    #   #=> {"one[two][three]" => "four"}
+    #   WebMock::Util::QueryMapper.query_to_values("?one.two.three=four",
+    #     :notation => :flat
+    #   )
+    #   #=> {"one.two.three" => "four"}
+    #   WebMock::Util::QueryMapper(
+    #     "?one[two][three][]=four&one[two][three][]=five"
+    #   )
+    #   #=> {"one" => {"two" => {"three" => ["four", "five"]}}}
+    #   WebMock::Util::QueryMapper.query_to_values(
+    #     "?one=two&one=three").query_values(:notation => :flat_array)
+    #   #=> [['one', 'two'], ['one', 'three']]
+    def self.query_to_values(query, options={})
+      defaults = {:notation => :subscript}
+      options = defaults.merge(options)
+      if ![:flat, :dot, :subscript, :flat_array].include?(options[:notation])
+        raise ArgumentError,
+          "Invalid notation. Must be one of: " +
+          "[:flat, :dot, :subscript, :flat_array]."
+      end
+      dehash = lambda do |hash|
+        hash.each do |(key, value)|
+          if value.kind_of?(Hash)
+            hash[key] = dehash.call(value)
+          end
+        end
+        if hash != {} && hash.keys.all? { |key| key =~ /^\d+$/ }
+          hash.sort.inject([]) do |accu, (_, value)|
+            accu << value; accu
+          end
+        else
+          hash
+        end
+      end
+      return nil if query == nil
+      empty_accumulator = :flat_array == options[:notation] ? [] : {}
+      return ((query.split("&").map do |pair|
+                 pair.split("=", 2) if pair && !pair.empty?
+              end).compact.inject(empty_accumulator.dup) do |accumulator, (key, value)|
+                value = true if value.nil?
+                key = Addressable::URI.unencode_component(key)
+                if value != true
+                  value = Addressable::URI.unencode_component(value.gsub(/\+/, " "))
+                end
+                if options[:notation] == :flat
+                  if accumulator[key]
+                    raise ArgumentError, "Key was repeated: #{key.inspect}"
+                  end
+                  accumulator[key] = value
+                elsif options[:notation] == :flat_array
+                  accumulator << [key, value]
+                else
+                  if options[:notation] == :dot
+                    array_value = false
+                    subkeys = key.split(".")
+                  elsif options[:notation] == :subscript
+                    array_value = !!(key =~ /\[\]$/)
+                    subkeys = key.split(/[\[\]]+/)
+                  end
+                  current_hash = accumulator
+                  for i in 0...(subkeys.size - 1)
+                    subkey = subkeys[i]
+                    current_hash[subkey] = {} unless current_hash[subkey]
+                    current_hash = current_hash[subkey]
+                  end
+                  if array_value
+                    current_hash[subkeys.last] = [] unless current_hash[subkeys.last]
+                    current_hash[subkeys.last] << value
+                  else
+                    current_hash[subkeys.last] = value
+                  end
+                end
+                accumulator
+      end).inject(empty_accumulator.dup) do |accumulator, (key, value)|
+        if options[:notation] == :flat_array
+          accumulator << [key, value]
+        else
+          accumulator[key] = value.kind_of?(Hash) ? dehash.call(value) : value
+        end
+        accumulator
+      end
+    end
+
+    ##
+    # Sets the query component for this URI from a Hash object.
+    # This method produces a query string using the :subscript notation.
+    # An empty Hash will result in a nil query.
+    #
+    # @param [Hash, #to_hash, Array] new_query_values The new query values.
+    def self.values_to_query(new_query_values)
+      if new_query_values == nil
+        return nil
+      end
+
+      if !new_query_values.is_a?(Array)
+        if !new_query_values.respond_to?(:to_hash)
+          raise TypeError,
+            "Can't convert #{new_query_values.class} into Hash."
+        end
+        new_query_values = new_query_values.to_hash
+        new_query_values = new_query_values.map do |key, value|
+          key = key.to_s if key.kind_of?(Symbol)
+          [key, value]
+        end
+        # Useful default for OAuth and caching.
+        # Only to be used for non-Array inputs. Arrays should preserve order.
+        new_query_values.sort!
+      end
+
+      ##
+      # Joins and converts parent and value into a properly encoded and
+      # ordered URL query.
+      #
+      # @private
+      # @param [String] parent an URI encoded component.
+      # @param [Array, Hash, Symbol, #to_str] value
+      #
+      # @return [String] a properly escaped and ordered URL query.
+      to_query = lambda do |parent, value|
+        if value.is_a?(Hash)
+          value = value.map do |key, val|
+            [
+              Addressable::URI.encode_component(key, Addressable::URI::CharacterClasses::UNRESERVED),
+              val
+            ]
+          end
+          value.sort!
+          buffer = ""
+          value.each do |key, val|
+            new_parent = "#{parent}[#{key}]"
+            buffer << "#{to_query.call(new_parent, val)}&"
+          end
+          return buffer.chop
+        elsif value.is_a?(Array)
+          buffer = ""
+          value.each_with_index do |val, i|
+            new_parent = "#{parent}[#{i}]"
+            buffer << "#{to_query.call(new_parent, val)}&"
+          end
+          return buffer.chop
+        elsif value == true
+          return parent
+        else
+          encoded_value = Addressable::URI.encode_component(
+            value, Addressable::URI::CharacterClasses::UNRESERVED
+          )
+          return "#{parent}=#{encoded_value}"
+        end
+      end
+
+      # new_query_values have form [['key1', 'value1'], ['key2', 'value2']]
+      buffer = ""
+      new_query_values.each do |parent, value|
+        encoded_parent = Addressable::URI.encode_component(
+          parent, Addressable::URI::CharacterClasses::UNRESERVED
+        )
+        buffer << "#{to_query.call(encoded_parent, value)}&"
+      end
+      return buffer.chop
+    end
+  end
+end

data/lib/webmock/util/uri.rb

@@ -1,23 +1,22 @@
-module Addressable
-  class URI
-    module CharacterClasses
-      USERINFO = UNRESERVED + SUB_DELIMS + "\\:"
-    end
-  end
-end
-
 module WebMock
 
   module Util
 
     class URI
+      module CharacterClasses
+        USERINFO = Addressable::URI::CharacterClasses::UNRESERVED + Addressable::URI::CharacterClasses::SUB_DELIMS + "\\:"
+      end
+
       ADDRESSABLE_URIS = Hash.new do |hash, key|
         hash[key] = Addressable::URI.heuristic_parse(key)
       end
 
       NORMALIZED_URIS = Hash.new do |hash, uri|
         normalized_uri = WebMock::Util::URI.heuristic_parse(uri)
-        normalized_uri.query_values = sort_query_values(normalized_uri.query_values) if normalized_uri.query_values
+        if normalized_uri.query_values
+          sorted_query_values = sort_query_values(WebMock::Util::QueryMapper.query_to_values(normalized_uri.query) || {})
+          normalized_uri.query = WebMock::Util::QueryMapper.values_to_query(sorted_query_values)
+        end
         normalized_uri = normalized_uri.normalize #normalize! is slower
         normalized_uri.port = normalized_uri.inferred_port unless normalized_uri.port
         hash[uri] = normalized_uri
@@ -63,7 +62,7 @@ module WebMock
       end
 
       def self.encode_unsafe_chars_in_userinfo(userinfo)
-        Addressable::URI.encode_component(userinfo, Addressable::URI::CharacterClasses::USERINFO)
+        Addressable::URI.encode_component(userinfo, WebMock::Util::URI::CharacterClasses::USERINFO)
       end
 
       def self.is_uri_localhost?(uri)

data/lib/webmock/version.rb

@@ -1,3 +1,3 @@
 module WebMock
-  VERSION = '1.8.8' unless defined?(::WebMock::VERSION)
+  VERSION = '1.8.9' unless defined?(::WebMock::VERSION)
 end

data/spec/acceptance/httpclient/httpclient_spec.rb

@@ -73,4 +73,31 @@ describe "HTTPClient" do
     end
   end
 
+  context 'when a client instance is re-used for another identical request' do
+    let(:client) { HTTPClient.new }
+    let(:webmock_server_url) {"http://#{WebMockServer.instance.host_with_port}/"}
+
+    before { WebMock.allow_net_connect! }
+
+    it 'invokes the global_stub_request hook for each request' do
+      request_signatures = []
+      WebMock.globally_stub_request do |request_sig|
+        request_signatures << request_sig
+        nil # to let the request be made for real
+      end
+
+      # To make two requests that have the same request signature, the headers must match.
+      # Since the webmock server has a Set-Cookie header, the 2nd request will automatically
+      # include a Cookie header (due to how httpclient works), so we have to set the header
+      # manually on the first request but not on the 2nd request.
+      http_request(:get, webmock_server_url, :client => client,
+                         :headers => { "Cookie" => "bar=; foo=" })
+      http_request(:get, webmock_server_url, :client => client)
+
+      request_signatures.should have(2).signatures
+      # Verify the request signatures were identical as needed by this example
+      request_signatures.first.should eq(request_signatures.last)
+    end
+  end
+
 end

data/spec/acceptance/httpclient/httpclient_spec_helper.rb

@@ -5,11 +5,11 @@ module HTTPClientSpecHelper
 
   def http_request(method, uri, options = {}, &block)
     uri = Addressable::URI.heuristic_parse(uri)
-    c = HTTPClient.new
+    c = options.fetch(:client) { HTTPClient.new }
     c.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
     c.set_basic_auth(nil, uri.user, uri.password) if uri.user
     params = [method, "#{uri.omit(:userinfo, :query).normalize.to_s}",
-      uri.query_values, options[:body], options[:headers] || {}]
+      WebMock::Util::QueryMapper.query_to_values(uri.query), options[:body], options[:headers] || {}]
     if HTTPClientSpecHelper.async_mode
       connection = c.request_async(*params)
       connection.join

data/spec/unit/util/uri_spec.rb

@@ -170,19 +170,19 @@ describe WebMock::Util::URI do
     it "should successfully handle array parameters" do
       uri_string = 'http://www.example.com:80/path?a[]=b&a[]=c'
       uri = WebMock::Util::URI.normalize_uri(uri_string)
-      uri.query_values.should == {"a"=>["b", "c"]}
+      WebMock::Util::QueryMapper.query_to_values(uri.query).should == {"a"=>["b", "c"]}
     end
 
     it "should successfully handle hash parameters" do
       uri_string = 'http://www.example.com:80/path?a[d]=b&a[e]=c&a[b][c]=1'
       uri = WebMock::Util::URI.normalize_uri(uri_string)
-      uri.query_values.should == {"a"=>{"d"=>"b", "e"=>"c", "b"=>{"c"=>"1"}}}
+      WebMock::Util::QueryMapper.query_to_values(uri.query).should == {"a"=>{"d"=>"b", "e"=>"c", "b"=>{"c"=>"1"}}}
     end
 
     it "should successfully handle nested hash parameters" do
       uri_string = 'http://www.example.com:80/path?one[two][three][]=four&one[two][three][]=five'
       uri = WebMock::Util::URI.normalize_uri(uri_string)
-      uri.query_values.should == {"one"=>{"two"=>{"three" => ["four", "five"]}}}
+      WebMock::Util::QueryMapper.query_to_values(uri.query).should == {"one"=>{"two"=>{"three" => ["four", "five"]}}}
     end
   end
 

data/webmock.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = 'webmock'
 
-  s.add_dependency 'addressable', '~> 2.2.8'
+  s.add_dependency 'addressable', '>= 2.2.7'
   s.add_dependency 'crack', '>=0.1.7'
 
   s.add_development_dependency 'rspec',           '~> 2.10'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: webmock
 version: !ruby/object:Gem::Version 
-  hash: 39
+  hash: 37
   prerelease: 
   segments: 
   - 1
   - 8
-  - 8
-  version: 1.8.8
+  - 9
+  version: 1.8.9
 platform: ruby
 authors: 
 - Bartosz Blimke
@@ -15,21 +15,21 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-07-23 00:00:00 Z
+date: 2012-08-15 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: addressable
   version_requirements: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 23
+        hash: 9
         segments: 
         - 2
         - 2
-        - 8
-        version: 2.2.8
+        - 7
+        version: 2.2.7
   type: :runtime
   prerelease: false
   requirement: *id001
@@ -254,6 +254,7 @@ files:
 - lib/webmock/util/hash_keys_stringifier.rb
 - lib/webmock/util/headers.rb
 - lib/webmock/util/json.rb
+- lib/webmock/util/query_mapper.rb
 - lib/webmock/util/uri.rb
 - lib/webmock/util/version_checker.rb
 - lib/webmock/version.rb