webmock 3.0.0 → 3.14.0

data/lib/webmock/request_pattern.rb

@@ -4,6 +4,10 @@ module WebMock
     def rSpecHashIncludingMatcher?(matcher)
       matcher.class.name =~ /R?Spec::Mocks::ArgumentMatchers::HashIncludingMatcher/
     end
+
+    def rSpecHashExcludingMatcher?(matcher)
+      matcher.class.name =~ /R?Spec::Mocks::ArgumentMatchers::HashExcludingMatcher/
+    end
   end
 
   class RequestPattern
@@ -20,7 +24,7 @@ module WebMock
     end
 
     def with(options = {}, &block)
-      raise ArgumentError.new('#with method invoked with no arguments. Either options hash or block must be specified.') if options.empty? && !block_given?
+      raise ArgumentError.new('#with method invoked with no arguments. Either options hash or block must be specified. Created a block with do..end? Try creating it with curly braces {} instead.') if options.empty? && !block_given?
       assign_options(options)
       @with_block = block
       self
@@ -37,7 +41,7 @@ module WebMock
     end
 
     def to_s
-      string = "#{@method_pattern.to_s.upcase}"
+      string = "#{@method_pattern.to_s.upcase}".dup
       string << " #{@uri_pattern.to_s}"
       string << " with body #{@body_pattern.to_s}" if @body_pattern
       string << " with headers #{@headers_pattern.to_s}" if @headers_pattern
@@ -76,6 +80,8 @@ module WebMock
         URIRegexpPattern.new(uri)
       elsif uri.is_a?(Addressable::Template)
         URIAddressablePattern.new(uri)
+      elsif uri.respond_to?(:call)
+        URICallablePattern.new(uri)
       else
         URIStringPattern.new(uri)
       end
@@ -103,11 +109,13 @@ module WebMock
     include RSpecMatcherDetector
 
     def initialize(pattern)
-      @pattern = case pattern
-      when Addressable::URI, Addressable::Template
+      @pattern = if pattern.is_a?(Addressable::URI) \
+                    || pattern.is_a?(Addressable::Template)
+        pattern
+      elsif pattern.respond_to?(:call)
         pattern
       else
-          WebMock::Util::URI.normalize_uri(pattern)
+        WebMock::Util::URI.normalize_uri(pattern)
       end
       @query_params = nil
     end
@@ -115,65 +123,116 @@ module WebMock
     def add_query_params(query_params)
       @query_params = if query_params.is_a?(Hash)
         query_params
-      elsif query_params.is_a?(WebMock::Matchers::HashIncludingMatcher)
+      elsif query_params.is_a?(WebMock::Matchers::HashIncludingMatcher) \
+              || query_params.is_a?(WebMock::Matchers::HashExcludingMatcher)
         query_params
       elsif rSpecHashIncludingMatcher?(query_params)
         WebMock::Matchers::HashIncludingMatcher.from_rspec_matcher(query_params)
+      elsif rSpecHashExcludingMatcher?(query_params)
+        WebMock::Matchers::HashExcludingMatcher.from_rspec_matcher(query_params)
       else
         WebMock::Util::QueryMapper.query_to_values(query_params, notation: Config.instance.query_values_notation)
       end
     end
 
+    def matches?(uri)
+      pattern_matches?(uri) && query_params_matches?(uri)
+    end
+
     def to_s
-      str = @pattern.inspect
+      str = pattern_inspect
       str += " with query params #{@query_params.inspect}" if @query_params
       str
     end
+
+    private
+
+    def pattern_inspect
+      @pattern.inspect
+    end
+
+    def query_params_matches?(uri)
+      @query_params.nil? || @query_params == WebMock::Util::QueryMapper.query_to_values(uri.query, notation: Config.instance.query_values_notation)
+    end
   end
 
-  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 == WebMock::Util::QueryMapper.query_to_values(uri.query, notation: Config.instance.query_values_notation))
+  class URICallablePattern  < URIPattern
+    private
+
+    def pattern_matches?(uri)
+      @pattern.call(uri)
     end
+  end
 
-    def to_s
-      str = @pattern.inspect
-      str += " with query params #{@query_params.inspect}" if @query_params
-      str
+  class URIRegexpPattern  < URIPattern
+    private
+
+    def pattern_matches?(uri)
+      WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u| u.match(@pattern) }
     end
   end
 
   class URIAddressablePattern  < URIPattern
-    def matches?(uri)
+    def add_query_params(query_params)
+      @@add_query_params_warned ||= false
+      if not @@add_query_params_warned
+        @@add_query_params_warned = true
+        warn "WebMock warning: ignoring query params in RFC 6570 template and checking them with WebMock"
+      end
+      super(query_params)
+    end
+
+    private
+
+    def pattern_matches?(uri)
       if @query_params.nil?
         # Let Addressable check the whole URI
-        WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u| @pattern.match(u) }
+        matches_with_variations?(uri)
       else
         # WebMock checks the query, Addressable checks everything else
-        WebMock::Util::URI.variations_of_uri_as_strings(uri.omit(:query)).any? { |u| @pattern.match(u) } &&
-          @query_params == WebMock::Util::QueryMapper.query_to_values(uri.query)
+        matches_with_variations?(uri.omit(:query))
       end
     end
 
-    def add_query_params(query_params)
-      warn "WebMock warning: ignoring query params in RFC 6570 template and checking them with WebMock"
-      super(query_params)
+    def pattern_inspect
+      @pattern.pattern.inspect
     end
 
-    def to_s
-      str = @pattern.pattern.inspect
-      str += " with variables #{@pattern.variables.inspect}" if @pattern.variables
-      str
+    def matches_with_variations?(uri)
+      template =
+        begin
+          Addressable::Template.new(WebMock::Util::URI.heuristic_parse(@pattern.pattern))
+        rescue Addressable::URI::InvalidURIError
+          Addressable::Template.new(@pattern.pattern)
+        end
+      WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u|
+        template_matches_uri?(template, u)
+      }
+    end
+
+    def template_matches_uri?(template, uri)
+      template.match(uri)
+    rescue Addressable::URI::InvalidURIError
+      false
     end
   end
 
   class URIStringPattern < URIPattern
-    def matches?(uri)
+    def add_query_params(query_params)
+      super
+      if @query_params.is_a?(Hash) || @query_params.is_a?(String)
+        query_hash = (WebMock::Util::QueryMapper.query_to_values(@pattern.query, notation: Config.instance.query_values_notation) || {}).merge(@query_params)
+        @pattern.query = WebMock::Util::QueryMapper.values_to_query(query_hash, notation: WebMock::Config.instance.query_values_notation)
+        @query_params = nil
+      end
+    end
+
+    private
+
+    def pattern_matches?(uri)
       if @pattern.is_a?(Addressable::URI)
         if @query_params
-          uri.omit(:query) === @pattern &&
-          (@query_params.nil? || @query_params == WebMock::Util::QueryMapper.query_to_values(uri.query, notation: Config.instance.query_values_notation))
+          uri.omit(:query) === @pattern
         else
           uri === @pattern
         end
@@ -182,19 +241,8 @@ module WebMock
       end
     end
 
-    def add_query_params(query_params)
-      super
-      if @query_params.is_a?(Hash) || @query_params.is_a?(String)
-        query_hash = (WebMock::Util::QueryMapper.query_to_values(@pattern.query, notation: Config.instance.query_values_notation) || {}).merge(@query_params)
-        @pattern.query = WebMock::Util::QueryMapper.values_to_query(query_hash, notation: WebMock::Config.instance.query_values_notation)
-        @query_params = nil
-      end
-    end
-
-    def 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
+    def pattern_inspect
+      WebMock::Util::URI.strip_default_port_from_uri_string(@pattern.to_s)
     end
   end
 
@@ -232,7 +280,7 @@ module WebMock
 
       if (@pattern).is_a?(Hash)
         return true if @pattern.empty?
-        matching_hashes?(body_as_hash(body, content_type), @pattern)
+        matching_body_hashes?(body_as_hash(body, content_type), @pattern, content_type)
       elsif (@pattern).is_a?(WebMock::Matchers::HashIncludingMatcher)
         @pattern == body_as_hash(body, content_type)
       else
@@ -247,8 +295,9 @@ module WebMock
     end
 
     private
+
     def body_as_hash(body, content_type)
-      case BODY_FORMATS[content_type]
+      case body_format(content_type)
       when :json then
         WebMock::Util::JSON.parse(body)
       when :xml then
@@ -258,6 +307,11 @@ module WebMock
       end
     end
 
+    def body_format(content_type)
+      normalized_content_type = content_type.sub(/\A(application\/)[a-zA-Z0-9.-]+\+(json|xml)\Z/,'\1\2')
+      BODY_FORMATS[normalized_content_type]
+    end
+
     def assert_non_multipart_body(content_type)
       if content_type =~ %r{^multipart/form-data}
         raise ArgumentError.new("WebMock does not support matching body for multipart/form-data requests yet :(")
@@ -287,15 +341,16 @@ module WebMock
     #
     # @return [Boolean] true if the paramaters match the comparison
     #   hash, false if not.
-    def matching_hashes?(query_parameters, pattern)
+    def matching_body_hashes?(query_parameters, pattern, content_type)
       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)
+          return false unless matching_body_hashes?(actual, expected, content_type)
         else
+          expected = WebMock::Util::ValuesStringifier.stringify_values(expected) if url_encoded_body?(content_type)
           return false unless expected === actual
         end
       end
@@ -310,6 +365,9 @@ module WebMock
       Hash[WebMock::Util::HashKeysStringifier.stringify_keys!(hash, deep: true).sort]
     end
 
+    def url_encoded_body?(content_type)
+      content_type =~ %r{^application/x-www-form-urlencoded}
+    end
   end
 
   class HeadersPattern
@@ -333,6 +391,10 @@ module WebMock
       WebMock::Util::Headers.sorted_headers_string(@pattern)
     end
 
+    def pp_to_s
+      WebMock::Util::Headers.pp_headers_string(@pattern)
+    end
+
     private
 
     def empty_headers?(headers)

data/lib/webmock/request_registry.rb

@@ -23,7 +23,7 @@ module WebMock
       if requested_signatures.hash.empty?
         "No requests were made."
       else
-        text = ""
+        text = "".dup
         self.requested_signatures.each do |request_signature, times_executed|
           text << "#{request_signature} was made #{times_executed} time#{times_executed == 1 ? '' : 's' }\n"
         end

data/lib/webmock/request_signature.rb

@@ -12,7 +12,7 @@ module WebMock
     end
 
     def to_s
-      string = "#{self.method.to_s.upcase}"
+      string = "#{self.method.to_s.upcase}".dup
       string << " #{WebMock::Util::URI.strip_default_port_from_uri_string(self.uri.to_s)}"
       string << " with body '#{body.to_s}'" if body && body.to_s != ''
       if headers && !headers.empty?

data/lib/webmock/request_signature_snippet.rb

@@ -13,14 +13,14 @@ module WebMock
     def stubbing_instructions
       return unless WebMock.show_stubbing_instructions?
 
-      text = "You can stub this request with the following snippet:\n\n"
-      text << WebMock::StubRequestSnippet.new(request_stub).to_s
+      "You can stub this request with the following snippet:\n\n" +
+        WebMock::StubRequestSnippet.new(request_stub).to_s
     end
 
     def request_stubs
       return if WebMock::StubRegistry.instance.request_stubs.empty?
 
-      text = "registered request stubs:\n"
+      text = "registered request stubs:\n".dup
       WebMock::StubRegistry.instance.request_stubs.each do |stub|
         text << "\n#{WebMock::StubRequestSnippet.new(stub).to_s(false)}"
         add_body_diff(stub, text) if WebMock.show_body_diff?
@@ -50,7 +50,7 @@ module WebMock
     end
 
     def pretty_print_to_string(string_to_print)
-      StringIO.open("") do |stream|
+      StringIO.open("".dup) do |stream|
         PP.pp(string_to_print, stream)
         stream.rewind
         stream.read

data/lib/webmock/response.rb

@@ -91,10 +91,10 @@ module WebMock
 
     def ==(other)
       self.body == other.body &&
-      self.headers === other.headers &&
-      self.status == other.status &&
-      self.exception == other.exception &&
-      self.should_timeout == other.should_timeout
+        self.headers === other.headers &&
+        self.status == other.status &&
+        self.exception == other.exception &&
+        self.should_timeout == other.should_timeout
     end
 
     private
@@ -111,7 +111,13 @@ module WebMock
       valid_types = [Proc, IO, Pathname, String, Array]
       return if @body.nil?
       return if valid_types.any? { |c| @body.is_a?(c) }
-      raise InvalidBody, "must be one of: #{valid_types}. '#{@body.class}' given"
+
+      if @body.class.is_a?(Hash)
+        raise InvalidBody, "must be one of: #{valid_types}, but you've used a #{@body.class}' instead." \
+          "\n What shall we encode it to? try calling .to_json .to_xml instead on the hash instead, or otherwise convert it to a string."
+      else
+        raise InvalidBody, "must be one of: #{valid_types}. '#{@body.class}' given"
+      end
     end
 
     def read_raw_response(raw_response)

data/lib/webmock/rspec.rb

@@ -20,14 +20,21 @@ end
 
 require 'webmock/rspec/matchers'
 
-WebMock.enable!
-
 RSPEC_CONFIGURER.configure { |config|
 
   config.include WebMock::API
   config.include WebMock::Matchers
 
-  config.after(:each) do
+  config.before(:suite) do
+    WebMock.enable!
+  end
+
+  config.after(:suite) do
+    WebMock.disable!
+  end
+
+  config.around(:each) do |example|
+    example.run
     WebMock.reset!
   end
 }

data/lib/webmock/stub_registry.rb

@@ -10,25 +10,39 @@ module WebMock
     end
 
     def global_stubs
-      @global_stubs ||= []
+      @global_stubs ||= Hash.new { |h, k| h[k] = [] }
     end
 
     def reset!
       self.request_stubs = []
     end
 
-    def register_global_stub(&block)
+    def register_global_stub(order = :before_local_stubs, &block)
+      unless %i[before_local_stubs after_local_stubs].include?(order)
+        raise ArgumentError.new("Wrong order. Use :before_local_stubs or :after_local_stubs")
+      end
+
       # This hash contains the responses returned by the block,
       # keyed by the exact request (using the object_id).
       # That way, there's no race condition in case #to_return
       # doesn't run immediately after stub.with.
       responses = {}
-
-      stub = ::WebMock::RequestStub.new(:any, /.*/).with { |request|
-        responses[request.object_id] = block.call(request)
-      }.to_return(lambda { |request| responses.delete(request.object_id) })
-
-      global_stubs.push stub
+      response_lock = Mutex.new
+
+      stub = ::WebMock::RequestStub.new(:any, ->(uri) { true }).with { |request|
+        update_response = -> { responses[request.object_id] = yield(request) }
+
+        # The block can recurse, so only lock if we don't already own it
+        if response_lock.owned?
+          update_response.call
+        else
+          response_lock.synchronize(&update_response)
+        end
+      }.to_return(lambda { |request|
+        response_lock.synchronize { responses.delete(request.object_id) }
+      })
+
+      global_stubs[order].push stub
     end
 
     def register_request_stub(stub)
@@ -54,9 +68,10 @@ module WebMock
     private
 
     def request_stub_for(request_signature)
-      (global_stubs + request_stubs).detect { |registered_request_stub|
-        registered_request_stub.request_pattern.matches?(request_signature)
-      }
+      (global_stubs[:before_local_stubs] + request_stubs + global_stubs[:after_local_stubs])
+        .detect { |registered_request_stub|
+          registered_request_stub.request_pattern.matches?(request_signature)
+        }
     end
 
     def evaluate_response_for_request(response, request_signature)

data/lib/webmock/stub_request_snippet.rb

@@ -10,23 +10,27 @@ module WebMock
 
     def to_s(with_response = true)
       request_pattern = @request_stub.request_pattern
-      string = "stub_request(:#{request_pattern.method_pattern.to_s},"
+      string = "stub_request(:#{request_pattern.method_pattern.to_s},".dup
       string << " \"#{request_pattern.uri_pattern.to_s}\")"
 
-      with = ""
+      with = "".dup
 
       if (request_pattern.body_pattern)
-        with << "body: #{request_pattern.body_pattern.to_s}"
+        with << "\n    body: #{request_pattern.body_pattern.to_s}"
       end
 
       if (request_pattern.headers_pattern)
-        with << ",\n       " unless with.empty?
+        with << "," unless with.empty?
 
-        with << "headers: #{request_pattern.headers_pattern.to_s}"
+        with << "\n    headers: #{request_pattern.headers_pattern.pp_to_s}"
       end
       string << ".\n  with(#{with})" unless with.empty?
       if with_response
-        string << ".\n  to_return(status: 200, body: \"\", headers: {})"
+        if request_pattern.headers_pattern && request_pattern.headers_pattern.matches?({ 'Accept' => "application/json" })
+          string << ".\n  to_return(status: 200, body: \"{}\", headers: {})"
+        else
+          string << ".\n  to_return(status: 200, body: \"\", headers: {})"
+        end
       end
       string
     end

data/lib/webmock/test_unit.rb

@@ -8,12 +8,10 @@ module Test
     class TestCase
       include WebMock::API
 
-      alias_method :teardown_without_webmock, :teardown
+      teardown
       def teardown_with_webmock
-        teardown_without_webmock
         WebMock.reset!
       end
-      alias_method :teardown, :teardown_with_webmock
 
     end
   end

data/lib/webmock/util/hash_counter.rb

@@ -2,7 +2,7 @@ require 'thread'
 
 module WebMock
   module Util
-    class Util::HashCounter
+    class HashCounter
       attr_accessor :hash
       def initialize
         self.hash = {}
@@ -25,13 +25,13 @@ module WebMock
       def select(&block)
         return unless block_given?
         @lock.synchronize do
-          hash.select &block
+          hash.select(&block)
         end
       end
 
       def each(&block)
-        @order.to_a.sort {|a, b| a[1] <=> b[1]}.each do |a|
-          block.call(a[0], hash[a[0]])
+        @order.to_a.sort_by { |a| a[1] }.each do |a|
+          yield(a[0], hash[a[0]])
         end
       end
     end

data/lib/webmock/util/headers.rb

@@ -12,7 +12,7 @@ module WebMock
           [name.to_s.split(/_|-/).map { |segment| segment.capitalize }.join("-"),
            case value
             when Regexp then value
-            when Array then (value.size == 1) ? value.first : value.map {|v| v.to_s}.sort
+            when Array then (value.size == 1) ? value.first.to_s : value.map {|v| v.to_s}.sort
             else value.to_s
            end
           ]
@@ -22,7 +22,7 @@ module WebMock
 
       def self.sorted_headers_string(headers)
         headers = WebMock::Util::Headers.normalize_headers(headers)
-        str = '{'
+        str = '{'.dup
         str << headers.map do |k,v|
           v = case v
             when Regexp then v.inspect
@@ -34,6 +34,21 @@ module WebMock
         str << '}'
       end
 
+      def self.pp_headers_string(headers)
+        headers = WebMock::Util::Headers.normalize_headers(headers)
+        seperator = "\n\t "
+        str = "{#{seperator} ".dup
+        str << headers.map do |k,v|
+          v = case v
+            when Regexp then v.inspect
+            when Array then "["+v.map{|w| "'#{w.to_s}'"}.join(", ")+"]"
+            else "'#{v.to_s}'"
+          end
+          "'#{k}'=>#{v}"
+        end.sort.join(",#{seperator} ")
+        str << "\n    }"
+      end
+
       def self.decode_userinfo_from_header(header)
         header.sub(/^Basic /, "").unpack("m").first
       end

data/lib/webmock/util/json.rb

@@ -24,13 +24,12 @@ module WebMock
 
       # Ensure that ":" and "," are always followed by a space
       def self.convert_json_to_yaml(json) #:nodoc:
-        scanner, quoting, marks, pos, times = StringScanner.new(json), false, [], nil, []
+        scanner, quoting, marks, times = StringScanner.new(json), false, [], []
         while scanner.scan_until(/(\\['"]|['":,\\]|\\.)/)
           case char = scanner[1]
           when '"', "'"
             if !quoting
               quoting = char
-              pos = scanner.pos
             elsif quoting == char
               quoting = false
             end

data/lib/webmock/util/query_mapper.rb

@@ -81,7 +81,7 @@ module WebMock::Util
           value = if value.nil?
                     nil
                   else
-                    ::Addressable::URI.unencode_component(value.gsub(/\+/, ' '))
+                    ::Addressable::URI.unencode_component(value.tr('+', ' '))
                   end
           key = Addressable::URI.unencode_component(key)
           key = key.dup.force_encoding(Encoding::ASCII_8BIT) if key.respond_to?(:force_encoding)
@@ -122,7 +122,7 @@ module WebMock::Util
 
       def fill_accumulator_for_subscript(accumulator, key, value)
         current_node = accumulator
-        subkeys = key.split(/(?=\[\w)/)
+        subkeys = key.split(/(?=\[[^\[\]]+)/)
         subkeys[0..-2].each do |subkey|
           node = subkey =~ /\[\]\z/ ? [] : {}
           subkey = subkey.gsub(/[\[\]]/, '')
@@ -161,7 +161,7 @@ module WebMock::Util
         else
           if array_value
             current_node[last_key] ||= []
-            current_node[last_key] << value
+            current_node[last_key] << value unless value.nil?
           else
             current_node[last_key] = value
           end
@@ -186,7 +186,9 @@ module WebMock::Util
           new_query_values = new_query_values.to_hash
           new_query_values = new_query_values.inject([]) do |object, (key, value)|
             key = key.to_s if key.is_a?(::Symbol) || key.nil?
-            if value.is_a?(Array)
+            if value.is_a?(Array) && value.empty?
+              object << [key.to_s + '[]']
+            elsif value.is_a?(Array)
               value.each { |v| object << [key.to_s + '[]', v] }
             elsif value.is_a?(Hash)
               value.each { |k, v| object << ["#{key.to_s}[#{k}]", v]}
@@ -204,7 +206,7 @@ module WebMock::Util
           end
         end
 
-        buffer = ''
+        buffer = ''.dup
         new_query_values.each do |parent, value|
           encoded_parent = ::Addressable::URI.encode_component(
               parent.dup, ::Addressable::URI::CharacterClasses::UNRESERVED
@@ -251,14 +253,14 @@ module WebMock::Util
             ]
           end
           value.sort!
-          buffer = ''
+          buffer = ''.dup
           value.each do |key, val|
             new_parent = options[:notation] != :flat_array ? "#{parent}[#{key}]" : parent
             buffer << "#{to_query(new_parent, val, options)}&"
           end
           buffer.chop
         when ::Array
-          buffer = ''
+          buffer = ''.dup
           value.each_with_index do |val, i|
             new_parent = options[:notation] != :flat_array ? "#{parent}[#{i}]" : parent
             buffer << "#{to_query(new_parent, val, options)}&"