webmock 1.7.10 → 1.8.0

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

@@ -189,7 +189,7 @@ if defined?(EventMachine::HttpClient)
         response_string = []
         response_string << "HTTP/1.1 #{status[0]} #{status[1]}"
 
-        headers["Content-Length"] = body.length unless headers["Content-Length"]
+        headers["Content-Length"] = body.bytesize unless headers["Content-Length"]
         headers.each do |header, value|
           value = value.join(", ") if value.is_a?(Array)
 

data/lib/webmock/http_lib_adapters/excon_adapter.rb

@@ -0,0 +1,94 @@
+begin
+  require 'excon'
+rescue LoadError
+  # excon not found
+end
+
+if defined?(Excon)
+
+  module WebMock
+    module HttpLibAdapters
+
+      class ExconAdapter < HttpLibAdapter
+        adapter_for :excon
+
+        def self.enable!
+          Excon.send(:remove_const, :Connection)
+          Excon.send(:const_set, :Connection, ExconConnection)
+        end
+
+        def self.disable!
+          Excon.send(:remove_const, :Connection)
+          Excon.send(:const_set, :Connection, ExconConnection.superclass)
+        end
+
+
+        def self.to_query(hash)
+          string = ""
+          for key, values in hash
+            if values.nil?
+              string << key.to_s << '&'
+            else
+              for value in [*values]
+                string << key.to_s << '=' << CGI.escape(value.to_s) << '&'
+              end
+            end
+          end
+          string.chop! # remove trailing '&'
+        end
+
+        def self.build_request(params)
+          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
+          WebMock::RequestSignature.new method, uri, :body => params[:body], :headers => params[:headers]
+        end
+
+        def self.real_response(mock)
+          raise Excon::Errors::Timeout if mock.should_timeout
+          mock.raise_error_if_any
+          Excon::Response.new \
+            :body    => mock.body,
+            :status  => mock.status[0].to_i,
+            :headers => mock.headers
+        end
+
+        def self.mock_response(real)
+          mock = WebMock::Response.new
+          mock.status  = real.status
+          mock.headers = real.headers
+          mock.body    = real.body
+          mock
+        end
+
+        def self.perform_callbacks(request, response, options = {})
+          return unless WebMock::CallbackRegistry.any_callbacks?
+          WebMock::CallbackRegistry.invoke_callbacks(options.merge(:lib => :excon), request, response)
+        end
+
+      end
+
+      class ExconConnection < ::Excon::Connection
+
+        def request_kernel(params, &block)
+          mock_request  = ExconAdapter.build_request params.dup
+          WebMock::RequestRegistry.instance.requested_signatures.put(mock_request)
+
+          if mock_response = WebMock::StubRegistry.instance.response_for_request(mock_request)
+            ExconAdapter.perform_callbacks(mock_request, mock_response, :real_request => false)
+            ExconAdapter.real_response(mock_response)
+          elsif WebMock.net_connect_allowed?(mock_request.uri)
+            real_response = super
+            ExconAdapter.perform_callbacks(mock_request, ExconAdapter.mock_response(real_response), :real_request => true)
+            real_response
+          else
+            raise WebMock::NetConnectNotAllowedError.new(mock_request)
+          end
+        end
+
+      end
+    end
+  end
+
+end

data/lib/webmock/http_lib_adapters/httpclient_adapter.rb

@@ -38,7 +38,7 @@ if defined?(::HTTPClient)
     end
 
     def do_get_with_webmock(req, proxy, conn, stream = false, &block)
-      request_signature = build_request_signature(req)
+      request_signature = build_request_signature(req, :reuse_existing)
 
       WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
 
@@ -75,6 +75,7 @@ if defined?(::HTTPClient)
     def do_request_async_with_webmock(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)
@@ -111,7 +112,17 @@ if defined?(::HTTPClient)
   def build_webmock_response(httpclient_response)
     webmock_response = WebMock::Response.new
     webmock_response.status = [httpclient_response.status, httpclient_response.reason]
-    webmock_response.headers = httpclient_response.header.all
+
+    webmock_response.headers = {}.tap do |hash|
+      httpclient_response.header.all.each do |(key, value)|
+        if hash.has_key?(key)
+          hash[key] = Array(hash[key]) + [value]
+        else
+          hash[key] = value
+        end
+      end
+    end
+
     if  httpclient_response.content.respond_to?(:read)
       webmock_response.body = httpclient_response.content.read
       body = HTTP::Message::Body.new
@@ -123,7 +134,7 @@ if defined?(::HTTPClient)
     webmock_response
   end
 
-  def build_request_signature(req)
+  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.port = req.header.request_uri.port
@@ -149,12 +160,19 @@ if defined?(::HTTPClient)
       uri.userinfo = userinfo
     end
 
-    WebMock::RequestSignature.new(
+    signature = WebMock::RequestSignature.new(
       req.header.request_method.downcase.to_sym,
       uri.to_s,
       :body => req.content,
       :headers => headers
     )
+
+    # reuse a previous identical signature object if we stored one for later use
+    if reuse_existing && previous_signature = previous_signature_for(signature)
+      return previous_signature
+    end
+
+    signature
   end
 
   def webmock_responses
@@ -163,4 +181,13 @@ if defined?(::HTTPClient)
     end
   end
 
+  def webmock_request_signatures
+    @webmock_request_signatures ||= []
+  end
+
+  def previous_signature_for(signature)
+    return nil unless index = webmock_request_signatures.index(signature)
+    webmock_request_signatures.delete_at(index)
+  end
+
 end

data/lib/webmock/http_lib_adapters/net_http.rb

@@ -184,6 +184,8 @@ end
 
 class StubSocket #:nodoc:
 
+  attr_accessor :read_timeout
+
   def initialize(*args)
   end
 

data/lib/webmock/http_lib_adapters/typhoeus_hydra_adapter.rb

@@ -61,6 +61,9 @@ if defined?(Typhoeus)
             :body => body,
             :headers => req.headers
           )
+
+          req.instance_variable_set(:@__webmock_request_signature, request_signature)
+
           request_signature
         end
 
@@ -115,9 +118,7 @@ if defined?(Typhoeus)
         end
 
         AFTER_REQUEST_CALLBACK = Proc.new do |request|
-          request_signature =
-            ::WebMock::HttpLibAdapters::TyphoeusAdapter.
-              build_request_signature(request)
+          request_signature = request.instance_variable_get(:@__webmock_request_signature)
           webmock_response =
             ::WebMock::HttpLibAdapters::TyphoeusAdapter.
               build_webmock_response(request.response)

data/lib/webmock/matchers/hash_including_matcher.rb

@@ -0,0 +1,25 @@
+module WebMock
+  module Matchers
+    #this is a based on RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher
+    #https://github.com/rspec/rspec-mocks/blob/master/lib/rspec/mocks/argument_matchers.rb
+    class HashIncludingMatcher
+      def initialize(expected)
+        @expected = Hash[WebMock::Util::HashKeysStringifier.stringify_keys!(expected).sort]
+      end
+
+      def ==(actual)
+        @expected.all? {|k,v| actual.has_key?(k) && v == actual[k]}
+      rescue NoMethodError
+        false
+      end
+
+      def inspect
+        "hash_including(#{@expected.inspect})"
+      end
+
+      def self.from_rspec_matcher(matcher)
+        new(matcher.instance_variable_get(:@expected))
+      end
+    end
+  end
+end

data/lib/webmock/rack_response.rb

@@ -10,12 +10,19 @@ module WebMock
       status, headers, response = @app.call(env)
 
       Response.new(
-        :body => response.join,
+        :body => body_from_rack_response(response),
         :headers => headers,
         :status => status
       )
     end
 
+    def body_from_rack_response(response)
+      body = ""
+      response.each { |line| body << line }
+      response.close if response.respond_to?(:close)
+      return body
+    end
+
     def build_rack_env(request)
       uri = request.uri
       headers = request.headers || {}

data/lib/webmock/request_pattern.rb

@@ -40,19 +40,19 @@ module WebMock
     private
 
 
-    def assign_options(options)
-      @body_pattern = BodyPattern.new(options[:body]) if options.has_key?(:body)
-      @headers_pattern = HeadersPattern.new(options[:headers]) if options.has_key?(:headers)
-      @uri_pattern.add_query_params(options[:query]) if options.has_key?(:query)
-    end
+      def assign_options(options)
+        @body_pattern = BodyPattern.new(options[:body]) if options.has_key?(:body)
+        @headers_pattern = HeadersPattern.new(options[:headers]) if options.has_key?(:headers)
+        @uri_pattern.add_query_params(options[:query]) if options.has_key?(:query)
+      end
 
-    def create_uri_pattern(uri)
-      if uri.is_a?(Regexp)
-        URIRegexpPattern.new(uri)
-      else
-        URIStringPattern.new(uri)
+      def create_uri_pattern(uri)
+        if uri.is_a?(Regexp)
+          URIRegexpPattern.new(uri)
+        else
+          URIStringPattern.new(uri)
+        end
       end
-    end
 
   end
 
@@ -76,9 +76,31 @@ module WebMock
     def initialize(pattern)
       @pattern = pattern.is_a?(Addressable::URI) ? pattern : WebMock::Util::URI.normalize_uri(pattern)
     end
+
+    def add_query_params(query_params)
+      @query_params = if query_params.is_a?(Hash)
+        query_params
+      elsif query_params.is_a?(WebMock::Matchers::HashIncludingMatcher)
+        query_params
+      elsif defined?(RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher) && query_params.is_a?(RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher)
+        WebMock::Matchers::HashIncludingMatcher.from_rspec_matcher(query_params)
+      else
+        Addressable::URI.parse('?' + query_params).query_values
+      end
+    end
+
+    def to_s
+      str = @pattern.inspect
+      str += " with query params #{@query_params.inspect}" if @query_params
+      str
+    end
   end
 
   class URIRegexpPattern  < URIPattern
+    def initialize *args, &block
+      @query_params = nil
+      super
+    end
 
     def matches?(uri)
       WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u| u.match(@pattern) } &&
@@ -90,33 +112,34 @@ module WebMock
       str += " with query params #{@query_params.inspect}" if @query_params
       str
     end
-
-    def add_query_params(query_params)
-      @query_params = query_params.is_a?(Hash) ? query_params : Addressable::URI.parse('?' + query_params).query_values
-    end
-
   end
 
   class URIStringPattern < URIPattern
     def matches?(uri)
       if @pattern.is_a?(Addressable::URI)
-        uri === @pattern
+        if @query_params
+          uri.omit(:query) === @pattern && (@query_params.nil? || @query_params == uri.query_values)
+        else
+          uri === @pattern
+        end
       else
         false
       end
     end
 
     def add_query_params(query_params)
-      if !query_params.is_a?(Hash)
-        query_params = Addressable::URI.parse('?' + query_params).query_values
+      super
+      if @query_params.is_a?(Hash) || @query_params.is_a?(String)
+        @pattern.query_values = (@pattern.query_values || {}).merge(@query_params)
+        @query_params = nil
       end
-      @pattern.query_values = (@pattern.query_values || {}).merge(query_params)
     end
 
     def to_s
-      WebMock::Util::URI.strip_default_port_from_uri_string(@pattern.to_s)
+      str = WebMock::Util::URI.strip_default_port_from_uri_string(@pattern.to_s)
+      str += " with query params #{@query_params.inspect}" if @query_params
+      str
     end
-
   end
 
 
@@ -136,24 +159,21 @@ module WebMock
     }
 
     def initialize(pattern)
-      @pattern = pattern
-      if (@pattern).is_a?(Hash)
-        @pattern = normalize_hash(@pattern)
+      @pattern = if pattern.is_a?(Hash)
+        normalize_hash(pattern)
+      elsif defined?(RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher) && pattern.is_a?(RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher)
+        WebMock::Matchers::HashIncludingMatcher.from_rspec_matcher(pattern)
+      else
+        pattern
       end
     end
 
     def matches?(body, content_type = "")
       if (@pattern).is_a?(Hash)
         return true if @pattern.empty?
-
-        case BODY_FORMATS[content_type]
-        when :json then
-          matching_hashes?(WebMock::Util::JSON.parse(body), @pattern)
-        when :xml then
-          matching_hashes?(Crack::XML.parse(body), @pattern)
-        else
-          matching_hashes?(Addressable::URI.parse('?' + body).query_values, @pattern)
-        end
+        matching_hashes?(body_as_hash(body, content_type), @pattern)
+      elsif (@pattern).is_a?(WebMock::Matchers::HashIncludingMatcher)
+        @pattern == body_as_hash(body, content_type)
       else
         empty_string?(@pattern) && empty_string?(body) ||
           @pattern == body ||
@@ -166,51 +186,62 @@ module WebMock
     end
 
     private
-
-    # Compare two hashes for equality
-    #
-    # For two hashes to match they must have the same length and all
-    # values must match when compared using `#===`.
-    #
-    # The following hashes are examples of matches:
-    #
-    #     {a: /\d+/} and {a: '123'}
-    #
-    #     {a: '123'} and {a: '123'}
-    #
-    #     {a: {b: /\d+/}} and {a: {b: '123'}}
-    #
-    #     {a: {b: 'wow'}} and {a: {b: 'wow'}}
-    #
-    # @param [Hash] query_parameters typically the result of parsing
-    #   JSON, XML or URL encoded parameters.
-    #
-    # @param [Hash] pattern which contains keys with a string, hash or
-    #   regular expression value to use for comparison.
-    #
-    # @return [Boolean] true if the paramaters match the comparison
-    #   hash, false if not.
-    def matching_hashes?(query_parameters, pattern)
-      return false unless query_parameters.size == pattern.size
-      query_parameters.each do |key, actual|
-        expected = pattern[key]
-
-        if actual.is_a?(Hash) && expected.is_a?(Hash)
-          return false unless matching_hashes?(actual, expected)
+      def body_as_hash(body, content_type)
+        case BODY_FORMATS[content_type]
+        when :json then
+          WebMock::Util::JSON.parse(body)
+        when :xml then
+          Crack::XML.parse(body)
         else
-          return false unless expected === actual
+          Addressable::URI.parse('?' + body).query_values
         end
       end
-      true
-    end
 
-    def empty_string?(string)
-      string.nil? || string == ""
-    end
+      # Compare two hashes for equality
+      #
+      # For two hashes to match they must have the same length and all
+      # values must match when compared using `#===`.
+      #
+      # The following hashes are examples of matches:
+      #
+      #     {a: /\d+/} and {a: '123'}
+      #
+      #     {a: '123'} and {a: '123'}
+      #
+      #     {a: {b: /\d+/}} and {a: {b: '123'}}
+      #
+      #     {a: {b: 'wow'}} and {a: {b: 'wow'}}
+      #
+      # @param [Hash] query_parameters typically the result of parsing
+      #   JSON, XML or URL encoded parameters.
+      #
+      # @param [Hash] pattern which contains keys with a string, hash or
+      #   regular expression value to use for comparison.
+      #
+      # @return [Boolean] true if the paramaters match the comparison
+      #   hash, false if not.
+      def matching_hashes?(query_parameters, pattern)
+        return false unless query_parameters.is_a?(Hash)
+        return false unless query_parameters.keys.sort == pattern.keys.sort
+        query_parameters.each do |key, actual|
+          expected = pattern[key]
+
+          if actual.is_a?(Hash) && expected.is_a?(Hash)
+            return false unless matching_hashes?(actual, expected)
+          else
+            return false unless expected === actual
+          end
+        end
+        true
+      end
 
-    def normalize_hash(hash)
-      WebMock::Util::HashKeysStringifier.stringify_keys!(hash)
-    end
+      def empty_string?(string)
+        string.nil? || string == ""
+      end
+
+      def normalize_hash(hash)
+        Hash[WebMock::Util::HashKeysStringifier.stringify_keys!(hash).sort]
+      end
 
   end
 
@@ -237,9 +268,9 @@ module WebMock
 
     private
 
-    def empty_headers?(headers)
-      headers.nil? || headers == {}
-    end
+      def empty_headers?(headers)
+        headers.nil? || headers == {}
+      end
   end
 
 end