webmock 3.5.0 → 3.25.0

data/lib/webmock/request_pattern.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WebMock
 
   module RSpecMatcherDetector
@@ -24,7 +26,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
@@ -80,11 +82,16 @@ module WebMock
         URIRegexpPattern.new(uri)
       elsif uri.is_a?(Addressable::Template)
         URIAddressablePattern.new(uri)
-      else
+      elsif uri.respond_to?(:call)
+        URICallablePattern.new(uri)
+      elsif uri.is_a?(::URI::Generic)
+        URIStringPattern.new(uri.to_s)
+      elsif uri.is_a?(String)
         URIStringPattern.new(uri)
+      else
+        raise ArgumentError.new("URI should be a String, Regexp, Addressable::Template or a callable object. Got: #{uri.class}")
       end
     end
-
   end
 
 
@@ -107,11 +114,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
@@ -131,38 +140,44 @@ module WebMock
       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
-  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))
+    private
+
+    def pattern_inspect
+      @pattern.inspect
     end
 
-    def to_s
-      str = @pattern.inspect
-      str += " with query params #{@query_params.inspect}" if @query_params
-      str
+    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 URIAddressablePattern  < URIPattern
-    def matches?(uri)
-      if @query_params.nil?
-        # Let Addressable check the whole URI
-        matches_with_variations?(uri)
-      else
-        # WebMock checks the query, Addressable checks everything else
-        matches_with_variations?(uri.omit(:query)) &&
-          @query_params == WebMock::Util::QueryMapper.query_to_values(uri.query)
-      end
+  class URICallablePattern  < URIPattern
+    private
+
+    def pattern_matches?(uri)
+      @pattern.call(uri)
     end
+  end
 
+  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 add_query_params(query_params)
       @@add_query_params_warned ||= false
       if not @@add_query_params_warned
@@ -172,28 +187,57 @@ module WebMock
       super(query_params)
     end
 
-    def to_s
-      str = @pattern.pattern.inspect
-      str += " with variables #{@pattern.variables.inspect}" if @pattern.variables
-      str
+    private
+
+    def pattern_matches?(uri)
+      if @query_params.nil?
+        # Let Addressable check the whole URI
+        matches_with_variations?(uri)
+      else
+        # WebMock checks the query, Addressable checks everything else
+        matches_with_variations?(uri.omit(:query))
+      end
     end
 
-    private
+    def pattern_inspect
+      @pattern.pattern.inspect
+    end
 
     def matches_with_variations?(uri)
-      normalized_template = Addressable::Template.new(WebMock::Util::URI.heuristic_parse(@pattern.pattern))
+      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
 
-      WebMock::Util::URI.variations_of_uri_as_strings(uri, only_with_scheme: true)
-        .any? { |u| normalized_template.match(u) }
+    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
@@ -202,19 +246,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
 
@@ -253,7 +286,9 @@ module WebMock
       if (@pattern).is_a?(Hash)
         return true if @pattern.empty?
         matching_body_hashes?(body_as_hash(body, content_type), @pattern, content_type)
-      elsif (@pattern).is_a?(WebMock::Matchers::HashIncludingMatcher)
+      elsif (@pattern).is_a?(Array)
+        matching_body_array?(body_as_hash(body, content_type), @pattern, content_type)
+      elsif (@pattern).is_a?(WebMock::Matchers::HashArgumentMatcher)
         @pattern == body_as_hash(body, content_type)
       else
         empty_string?(@pattern) && empty_string?(body) ||
@@ -267,15 +302,23 @@ 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)
+        WebMock::Util::Parsers::JSON.parse(body)
       when :xml then
-        Crack::XML.parse(body)
+        WebMock::Util::Parsers::XML.parse(body)
       else
         WebMock::Util::QueryMapper.query_to_values(body, notation: Config.instance.query_values_notation)
       end
+    rescue WebMock::Util::Parsers::ParseError
+      nil
+    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)
@@ -310,19 +353,33 @@ module WebMock
     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|
+
+      query_parameters.all? do |key, actual|
         expected = pattern[key]
+        matching_values(actual, expected, content_type)
+      end
+    end
 
-        if actual.is_a?(Hash) && expected.is_a?(Hash)
-          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
+    def matching_body_array?(query_parameters, pattern, content_type)
+      return false unless query_parameters.is_a?(Array)
+      return false unless query_parameters.length == pattern.length
+
+      query_parameters.each_with_index do |actual, index|
+        expected = pattern[index]
+        return false unless matching_values(actual, expected, content_type)
       end
+
       true
     end
 
+    def matching_values(actual, expected, content_type)
+      return matching_body_hashes?(actual, expected, content_type) if actual.is_a?(Hash) && expected.is_a?(Hash)
+      return matching_body_array?(actual, expected, content_type) if actual.is_a?(Array) && expected.is_a?(Array)
+
+      expected = WebMock::Util::ValuesStringifier.stringify_values(expected) if url_encoded_body?(content_type)
+      expected === actual
+    end
+
     def empty_string?(string)
       string.nil? || string == ""
     end

data/lib/webmock/request_registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WebMock
 
   class RequestRegistry

data/lib/webmock/request_signature.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WebMock
 
   class RequestSignature
@@ -35,11 +37,11 @@ module WebMock
     alias == eql?
 
     def url_encoded?
-      !!(headers && headers['Content-Type'] == 'application/x-www-form-urlencoded')
+      !!(headers&.fetch('Content-Type', nil)&.start_with?('application/x-www-form-urlencoded'))
     end
 
     def json_headers?
-      !!(headers && headers['Content-Type'] == 'application/json')
+      !!(headers&.fetch('Content-Type', nil)&.start_with?('application/json'))
     end
 
     private

data/lib/webmock/request_signature_snippet.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "pp"
 
 module WebMock

data/lib/webmock/request_stub.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WebMock
   class RequestStub
 
@@ -24,6 +26,38 @@ module WebMock
     end
     alias_method :and_return, :to_return
 
+    def to_return_json(*response_hashes)
+      raise ArgumentError, '#to_return_json does not support passing a block' if block_given?
+
+      json_response_hashes = [*response_hashes].flatten.map do |resp_h|
+        headers, body = resp_h.values_at(:headers, :body)
+
+        json_body = if body.respond_to?(:call)
+          ->(request_signature) {
+            b = if body.respond_to?(:arity) && body.arity == 1
+              body.call(request_signature)
+            else
+              body.call
+            end
+            b = b.to_json unless b.is_a?(String)
+            b
+          }
+        elsif !body.is_a?(String)
+          body.to_json
+        else
+          body
+        end
+
+        resp_h.merge(
+          headers: {content_type: 'application/json'}.merge(headers.to_h),
+          body: json_body
+        )
+      end
+
+      to_return(json_response_hashes)
+    end
+    alias_method :and_return_json, :to_return_json
+
     def to_rack(app, options={})
       @responses_sequences << ResponsesSequence.new([RackResponse.new(app)])
     end

data/lib/webmock/response.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "pathname"
 
 module WebMock
@@ -14,8 +16,11 @@ module WebMock
 
   class Response
     def initialize(options = {})
-      if options.is_a?(IO) || options.is_a?(String)
+      case options
+      when IO, StringIO
         self.options = read_raw_response(options)
+      when String
+        self.options = read_raw_response(StringIO.new(options))
       else
         self.options = options
       end
@@ -33,7 +38,7 @@ module WebMock
     end
 
     def body
-      @body || ''
+      @body || String.new("")
     end
 
     def body=(body)
@@ -91,10 +96,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,16 +116,17 @@ 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"
-    end
 
-    def read_raw_response(raw_response)
-      if raw_response.is_a?(IO)
-        string = raw_response.read
-        raw_response.close
-        raw_response = string
+      if @body.is_a?(Hash)
+        raise InvalidBody, "must be one of: #{valid_types}, but you've used a #{@body.class}. " \
+          "Please convert it by calling .to_json .to_xml, or otherwise convert it to a string."
+      else
+        raise InvalidBody, "must be one of: #{valid_types}. '#{@body.class}' given."
       end
-      socket = ::Net::BufferedIO.new(raw_response)
+    end
+
+    def read_raw_response(io)
+      socket = ::Net::BufferedIO.new(io)
       response = ::Net::HTTPResponse.read_new(socket)
       transfer_encoding = response.delete('transfer-encoding') #chunks were already read by curl
       response.reading_body(socket, true) {}
@@ -132,6 +138,8 @@ module WebMock
       options[:body] = response.read_body
       options[:status] = [response.code.to_i, response.message]
       options
+    ensure
+      socket.close
     end
 
     InvalidBody = Class.new(StandardError)

data/lib/webmock/responses_sequence.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WebMock
 
   class ResponsesSequence

data/lib/webmock/rspec/matchers/request_pattern_matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WebMock
   class RequestPatternMatcher
 

data/lib/webmock/rspec/matchers/webmock_matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WebMock
   class WebMockMatcher
 

data/lib/webmock/rspec/matchers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'webmock'
 require 'webmock/rspec/matchers/request_pattern_matcher'
 require 'webmock/rspec/matchers/webmock_matcher'

data/lib/webmock/rspec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'webmock'
 
 # RSpec 1.x and 2.x compatibility
@@ -33,7 +35,8 @@ RSPEC_CONFIGURER.configure { |config|
     WebMock.disable!
   end
 
-  config.after(:each) do
+  config.around(:each) do |example|
+    example.run
     WebMock.reset!
   end
 }

data/lib/webmock/stub_registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WebMock
 
   class StubRegistry
@@ -10,25 +12,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] = yield(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 +70,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WebMock
   class StubRequestSnippet
     def initialize(request_stub)

data/lib/webmock/test_unit.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test/unit'
 require 'webmock'
 
@@ -8,12 +10,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

@@ -1,29 +1,35 @@
+# frozen_string_literal: true
+
 require 'thread'
 
 module WebMock
   module Util
     class HashCounter
       attr_accessor :hash
+
       def initialize
-        self.hash = {}
+        self.hash = Hash.new(0)
         @order = {}
         @max = 0
         @lock = ::Mutex.new
       end
-      def put key, num=1
+
+      def put(key, num=1)
         @lock.synchronize do
-          hash[key] = (hash[key] || 0) + num
-          @order[key] = @max = @max + 1
+          hash[key] += num
+          @order[key] = @max += 1
         end
       end
-      def get key
+
+      def get(key)
         @lock.synchronize do
-          hash[key] || 0
+          hash[key]
         end
       end
 
       def select(&block)
         return unless block_given?
+
         @lock.synchronize do
           hash.select(&block)
         end

data/lib/webmock/util/hash_keys_stringifier.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WebMock
   module Util
     class HashKeysStringifier

data/lib/webmock/util/hash_validator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WebMock
   class HashValidator
     def initialize(hash)