webmock 3.26.4 → 3.34.0

data/lib/webmock/json_body_hint.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "json"
+
+module WebMock
+  # A body declared as a string must match the request body exactly, which for
+  # JSON includes key order and whitespace. When a request fails to match only
+  # because of that, failure messages suggest declaring the body as a hash.
+  # See #485.
+  module JsonBodyHint
+    ADVICE = "A body declared as a string must match exactly. To match it as JSON, " \
+             "declare it as a hash, for example with(body: JSON.parse(json_string))."
+
+    STUB_HINT = "Hint: the request body is the same JSON as the body of this stub, " \
+                "but formatted differently, for example with keys in another order. #{ADVICE}"
+
+    EXPECTATION_HINT = "Hint: a request was made with the same JSON body as expected, " \
+                       "but formatted differently, for example with keys in another order. #{ADVICE}"
+
+    # True when one of the patterns declares its body as a JSON object or array
+    # string, the request has a JSON content type and a body that parses to the
+    # same JSON but is written differently, and the method, URI and headers of
+    # every pattern match the request. Any other patterns the request has to
+    # match, such as the conditions of an RSpec expectation, must not declare
+    # a body of their own.
+    #
+    # Building a failure message must not call a block given to with, which
+    # could raise and replace the failure, or repeat side effects. So there is
+    # no hint when any of the patterns has one.
+    #
+    # The body is checked first, since that runs no user code, so URI and
+    # header matchers are only evaluated when a hint is otherwise possible.
+    def self.applies?(request_pattern, request_signature)
+      patterns = parts_of(request_pattern)
+      return false unless patterns.all? { |pattern| pattern.is_a?(RequestPattern) && pattern.with_block.nil? }
+
+      with_body = patterns.select(&:body_pattern)
+      return false unless with_body.size == 1
+      return false unless body_differs_only_in_formatting?(with_body.first.body_pattern, request_signature)
+
+      patterns.all? { |pattern| matches_except_body?(pattern, request_signature) }
+    end
+
+    # A pattern made of parts that must all match, such as an RSpec expectation
+    # with conditions, responds to #patterns. A stub stands for its pattern.
+    def self.parts_of(request_pattern)
+      parts = request_pattern.respond_to?(:patterns) ? request_pattern.patterns : [request_pattern]
+      parts.map { |part| part.is_a?(RequestStub) ? part.request_pattern : part }
+    end
+
+    def self.body_differs_only_in_formatting?(body_pattern, request_signature)
+      expected = body_pattern.pattern
+      actual = request_signature.body
+      return false unless expected.is_a?(String) && actual.is_a?(String) && expected != actual
+      return false unless request_signature.json_headers?
+
+      expected_json = parse_json(expected)
+      return false unless expected_json.is_a?(Hash) || expected_json.is_a?(Array)
+
+      # eql? compares nested values strictly, so 1 and 1.0 are different.
+      expected_json.eql?(parse_json(actual))
+    end
+
+    def self.matches_except_body?(request_pattern, request_signature)
+      request_pattern.method_pattern.matches?(request_signature.method) &&
+        request_pattern.uri_pattern.matches?(request_signature.uri) &&
+        (request_pattern.headers_pattern.nil? || request_pattern.headers_pattern.matches?(request_signature.headers))
+    end
+
+    def self.parse_json(string)
+      ::JSON.parse(string)
+    rescue ::JSON::JSONError, EncodingError
+      nil
+    end
+    private_class_method :parts_of, :body_differs_only_in_formatting?, :matches_except_body?, :parse_json
+  end
+end

data/lib/webmock/matchers/any_arg_matcher.rb

@@ -10,6 +10,10 @@ module WebMock
       def ==(other)
         true
       end
+
+      def inspect
+        "anything"
+      end
     end
   end
 end

data/lib/webmock/matchers/hash_excluding_matcher.rb

@@ -6,7 +6,7 @@ module WebMock
     # https://github.com/rspec/rspec-mocks/blob/master/lib/rspec/mocks/argument_matchers.rb
     class HashExcludingMatcher < HashArgumentMatcher
       def ==(actual)
-        super { |key, value| !actual.key?(key) || value != actual[key] }
+        super { |key, value| !actual.key?(key) || !(value === actual[key]) }
       end
 
       def inspect

data/lib/webmock/rack_response.rb

@@ -27,47 +27,56 @@ module WebMock
 
     def build_rack_env(request)
       uri = request.uri
+      port = uri.inferred_port
       headers = (request.headers || {}).dup
-      body = request.body || ''
+      body = (request.body || '').b
+      content_type = headers.delete('Content-Type')
+      headers.delete('Content-Length')
+      # The body is already decoded, as a server passes it on.
+      headers.delete('Transfer-Encoding')
 
       env = {
         # CGI variables specified by Rack
-        'REQUEST_METHOD' => request.method.to_s.upcase,
-        'CONTENT_TYPE'   => headers.delete('Content-Type'),
-        'CONTENT_LENGTH' => body.bytesize,
-        'PATH_INFO'      => uri.path,
-        'QUERY_STRING'   => uri.query || '',
-        'SERVER_NAME'    => uri.host,
-        'SERVER_PORT'    => uri.port,
-        'SCRIPT_NAME'    => ""
+        'REQUEST_METHOD'  => request.method.to_s.upcase,
+        'CONTENT_LENGTH'  => body.bytesize.to_s,
+        'PATH_INFO'       => uri.path,
+        'QUERY_STRING'    => uri.query || '',
+        'SERVER_NAME'     => uri.host,
+        'SERVER_PORT'     => port.to_s,
+        'SERVER_PROTOCOL' => 'HTTP/1.1',
+        'SCRIPT_NAME'     => ""
       }
+      env['CONTENT_TYPE'] = header_value('Content-Type', content_type) if content_type
 
       env['HTTP_AUTHORIZATION'] = 'Basic ' + [uri.userinfo].pack('m').delete("\r\n") if uri.userinfo
 
       # Rack-specific variables
       env['rack.input']      = StringIO.new(body)
       env['rack.errors']     = $stderr
-      if !Rack.const_defined?(:RELEASE) || Rack::RELEASE < "3"
-        env['rack.version']    = Rack::VERSION
+      if !Rack.const_defined?(:RELEASE) || Gem::Version.new(Rack::RELEASE) < Gem::Version.new("3")
+        env['rack.version']      = Rack::VERSION
+        env['rack.multithread']  = false
+        env['rack.multiprocess'] = false
       end
       env['rack.url_scheme'] = uri.scheme
       env['rack.run_once']   = true
-      env['rack.session']    = session
-      env['rack.session.options'] = session_options
 
       headers.each do |k, v|
-        env["HTTP_#{k.tr('-','_').upcase}"] = v
+        env["HTTP_#{k.tr('-','_').upcase}"] = header_value(k, v)
       end
 
+      # Many clients add Host only when sending, so fill it in as they would.
+      env['HTTP_HOST'] ||= port == uri.default_port ? uri.host : "#{uri.host}:#{port}"
+
       env
     end
 
-    def session
-      @session ||= {}
-    end
+    private
 
-    def session_options
-      @session_options ||= {}
+    # Like a server, pass header values as bytes and join repeated ones. Rack
+    # splits cookies on "; ", so join those that way.
+    def header_value(name, value)
+      Array(value).map { |v| v.to_s.b }.join(name == 'Cookie' ? '; ' : WebMock::Util::Headers::JOIN)
     end
   end
 end

data/lib/webmock/request_execution_verifier.rb

@@ -56,9 +56,31 @@ module WebMock
     def failure_message_phrase(is_negated=false)
       negation = is_negated ? "was not" : "was"
       "The request #{request_pattern} #{negation} expected to execute #{quantity_phrase(is_negated)}but it executed #{times(times_executed)}" +
+        (is_negated ? "" : json_body_hint) +
         self.class.executed_requests_message
     end
 
+    # Only when too few requests matched: with too many, declaring the body
+    # as a hash would match even more of them.
+    def json_body_hint
+      return "" unless WebMock.show_body_diff? && too_few_requests_executed?
+
+      requests = RequestRegistry.instance.requested_signatures.select do |request_signature, _|
+        JsonBodyHint.applies?(request_pattern, request_signature)
+      end
+      requests.empty? ? "" : "\n\n#{JsonBodyHint::EXPECTATION_HINT}"
+    end
+
+    def too_few_requests_executed?
+      if @at_least_times_executed
+        times_executed < @at_least_times_executed
+      elsif @at_most_times_executed
+        false
+      else
+        times_executed < (@expected_times_executed || 1)
+      end
+    end
+
     def quantity_phrase(is_negated=false)
       if @at_least_times_executed
         "at least #{times(@at_least_times_executed)} "

data/lib/webmock/request_pattern.rb

@@ -10,11 +10,15 @@ module WebMock
     def rSpecHashExcludingMatcher?(matcher)
       matcher.class.name =~ /R?Spec::Mocks::ArgumentMatchers::HashExcludingMatcher/
     end
+
+    def rSpecAnyArgMatcher?(matcher)
+      matcher.class.name =~ /R?Spec::Mocks::ArgumentMatchers::AnyArgMatcher/
+    end
   end
 
   class RequestPattern
 
-    attr_reader :method_pattern, :uri_pattern, :body_pattern, :headers_pattern
+    attr_reader :method_pattern, :uri_pattern, :body_pattern, :headers_pattern, :with_block
 
     def initialize(method, uri, options = {})
       @method_pattern  = MethodPattern.new(method)
@@ -33,11 +37,9 @@ module WebMock
     end
 
     def matches?(request_signature)
-      content_type = request_signature.headers['Content-Type'] if request_signature.headers
-      content_type = content_type.split(';').first if content_type
       @method_pattern.matches?(request_signature.method) &&
         @uri_pattern.matches?(request_signature.uri) &&
-        (@body_pattern.nil? || @body_pattern.matches?(request_signature.body, content_type || "")) &&
+        (@body_pattern.nil? || @body_pattern.matches?(request_signature.body, request_signature.content_type)) &&
         (@headers_pattern.nil? || @headers_pattern.matches?(request_signature.headers)) &&
         (@with_block.nil? || @with_block.call(request_signature))
     end
@@ -96,8 +98,11 @@ module WebMock
 
 
   class MethodPattern
+    # Request signatures store the method as a lower case Symbol, so a method
+    # given as a String or in upper case, like "get" or :GET, matches too.
+    # Anything else, such as nil, is kept as given and never matches.
     def initialize(pattern)
-      @pattern = pattern
+      @pattern = pattern.respond_to?(:to_sym) ? pattern.to_sym.downcase : pattern
     end
 
     def matches?(method)
@@ -128,6 +133,10 @@ module WebMock
     def add_query_params(query_params)
       @query_params = if query_params.is_a?(Hash)
         query_params
+      elsif query_params.equal?(:any) \
+              || query_params.is_a?(WebMock::Matchers::AnyArgMatcher) \
+              || rSpecAnyArgMatcher?(query_params)
+        WebMock::Matchers::AnyArgMatcher.new(nil)
       elsif query_params.is_a?(WebMock::Matchers::HashIncludingMatcher) \
               || query_params.is_a?(WebMock::Matchers::HashExcludingMatcher)
         query_params
@@ -135,8 +144,10 @@ module WebMock
         WebMock::Matchers::HashIncludingMatcher.from_rspec_matcher(query_params)
       elsif rSpecHashExcludingMatcher?(query_params)
         WebMock::Matchers::HashExcludingMatcher.from_rspec_matcher(query_params)
-      else
+      elsif query_params.nil? || query_params.is_a?(String)
         WebMock::Util::QueryMapper.query_to_values(query_params, notation: Config.instance.query_values_notation)
+      else
+        raise ArgumentError, "Query should be a String, Hash, :any, nil, or a hash_including or hash_excluding matcher. Got: #{query_params.class}"
       end
     end
 
@@ -152,6 +163,10 @@ module WebMock
 
     private
 
+    def raise_any_query_with_uri_query
+      raise ArgumentError, "query: :any can't be combined with a query in the URI #{pattern_inspect}, because no request would match. Remove the query from the URI."
+    end
+
     def pattern_inspect
       @pattern.inspect
     end
@@ -179,12 +194,17 @@ module WebMock
 
   class URIAddressablePattern  < URIPattern
     def add_query_params(query_params)
+      super(query_params)
+      # With query params, the template is matched against the URI without its
+      # query, so a literal query in the template can never match.
+      if @query_params.is_a?(WebMock::Matchers::AnyArgMatcher) && @pattern.pattern.gsub(/\{[^}]*\}/, '').include?('?')
+        raise_any_query_with_uri_query
+      end
       @@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
@@ -229,6 +249,9 @@ module WebMock
         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
+      elsif @query_params.is_a?(WebMock::Matchers::AnyArgMatcher) && @pattern.query
+        # The URI is then compared without its query, so it could never match.
+        raise_any_query_with_uri_query
       end
     end
 
@@ -255,18 +278,8 @@ module WebMock
   class BodyPattern
     include RSpecMatcherDetector
 
-    BODY_FORMATS = {
-      'text/xml'               => :xml,
-      'application/xml'        => :xml,
-      'application/json'       => :json,
-      'text/json'              => :json,
-      'application/javascript' => :json,
-      'text/javascript'        => :json,
-      'text/html'              => :html,
-      'application/x-yaml'     => :yaml,
-      'text/yaml'              => :yaml,
-      'text/plain'             => :plain
-    }
+    # Kept so existing references to the constant still resolve.
+    BODY_FORMATS = WebMock::Util::ContentType::BODY_FORMATS
 
     attr_reader :pattern
 
@@ -275,12 +288,16 @@ module WebMock
         normalize_hash(pattern)
       elsif rSpecHashIncludingMatcher?(pattern)
         WebMock::Matchers::HashIncludingMatcher.from_rspec_matcher(pattern)
+      elsif rSpecHashExcludingMatcher?(pattern)
+        WebMock::Matchers::HashExcludingMatcher.from_rspec_matcher(pattern)
       else
         pattern
       end
     end
 
     def matches?(body, content_type = "")
+      # Checked on the raw value, so body patterns used with mixed case
+      # multipart content types keep working as in earlier versions.
       assert_non_multipart_body(content_type)
 
       if (@pattern).is_a?(Hash)
@@ -304,7 +321,9 @@ module WebMock
     private
 
     def body_as_hash(body, content_type)
-      case body_format(content_type)
+      return if body.nil?
+
+      case WebMock::Util::ContentType.body_format(content_type)
       when :json then
         WebMock::Util::Parsers::JSON.parse(body)
       when :xml then
@@ -316,11 +335,6 @@ module WebMock
       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)
       if content_type =~ %r{^multipart/form-data}
         raise ArgumentError.new("WebMock does not support matching body for multipart/form-data requests yet :(")
@@ -376,7 +390,7 @@ module WebMock
       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 = WebMock::Util::ValuesStringifier.stringify_values(expected) if WebMock::Util::ContentType.url_encoded?(content_type)
       expected === actual
     end
 
@@ -387,10 +401,6 @@ module WebMock
     def normalize_hash(hash)
       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

data/lib/webmock/request_signature.rb

@@ -4,11 +4,11 @@ module WebMock
 
   class RequestSignature
 
-    attr_accessor :method, :uri, :body
-    attr_reader :headers
+    attr_accessor :uri, :body
+    attr_reader :method, :headers
 
     def initialize(method, uri, options = {})
-      self.method = method.to_sym
+      self.method = method
       self.uri = uri.is_a?(Addressable::URI) ? uri : WebMock::Util::URI.normalize_uri(uri)
       assign_options(options)
     end
@@ -23,6 +23,10 @@ module WebMock
       string
     end
 
+    def method=(method)
+      @method = method.to_sym.downcase
+    end
+
     def headers=(headers)
       @headers = WebMock::Util::Headers.normalize_headers(headers)
     end
@@ -36,12 +40,18 @@ module WebMock
     end
     alias == eql?
 
+    # A request can carry Content-Type more than once, in which case the
+    # normalized header value is an Array. Use its first value.
+    def content_type
+      Array(headers&.fetch('Content-Type', nil)).first
+    end
+
     def url_encoded?
-      !!(headers&.fetch('Content-Type', nil)&.start_with?('application/x-www-form-urlencoded'))
+      WebMock::Util::ContentType.url_encoded?(content_type)
     end
 
     def json_headers?
-      !!(headers&.fetch('Content-Type', nil)&.start_with?('application/json'))
+      WebMock::Util::ContentType.body_format(content_type) == :json
     end
 
     private

data/lib/webmock/request_signature_snippet.rb

@@ -25,7 +25,10 @@ module WebMock
       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?
+        if WebMock.show_body_diff?
+          add_body_diff(stub, text)
+          add_json_body_hint(stub, text)
+        end
       end
       text
     end
@@ -37,20 +40,17 @@ module WebMock
       text << "\n\n#{body_diff_str}" unless body_diff_str.empty?
     end
 
+    def add_json_body_hint(stub, text)
+      return unless JsonBodyHint.applies?(stub.request_pattern, request_signature)
+
+      text << "\n\n#{JsonBodyHint::STUB_HINT}\n"
+    end
+
     def signature_stub_body_diff(stub)
       diff = RequestBodyDiff.new(request_signature, stub).body_diff
       diff.empty? ? "" : "Body diff:\n #{pretty_print_to_string(diff)}"
     end
 
-    def request_params
-      @request_params ||=
-        if request_signature.json_headers?
-          JSON.parse(request_signature.body)
-        else
-          ""
-        end
-    end
-
     def pretty_print_to_string(string_to_print)
       StringIO.open("".dup) do |stream|
         PP.pp(string_to_print, stream)

data/lib/webmock/request_stub.rb

@@ -39,13 +39,10 @@ module WebMock
             else
               body.call
             end
-            b = b.to_json unless b.is_a?(String)
-            b
+            json_response_body(b)
           }
-        elsif !body.is_a?(String)
-          body.to_json
         else
-          body
+          json_response_body(body)
         end
 
         resp_h.merge(
@@ -130,5 +127,16 @@ module WebMock
       end
       stub
     end
+
+    private
+
+    def json_response_body(body)
+      case body
+      when String, IO, Pathname
+        body
+      else
+        body.to_json
+      end
+    end
   end
 end

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

@@ -52,13 +52,22 @@ module WebMock
       self
     end
 
+    # Counts only the requests that also match the given conditions, which
+    # take the same options and block as RequestPattern#with. Like
+    # RequestPattern#with, calling it again adds to the conditions. The stub
+    # or request pattern under test is not changed.
+    def with(options = {}, &block)
+      (@conditions ||= RequestPattern.new(:any, ANY_URI)).with(options, &block)
+      self
+    end
+
     def matches?(request_pattern)
-      @request_execution_verifier.request_pattern = request_pattern
+      @request_execution_verifier.request_pattern = with_conditions(request_pattern)
       @request_execution_verifier.matches?
     end
 
     def does_not_match?(request_pattern)
-      @request_execution_verifier.request_pattern = request_pattern
+      @request_execution_verifier.request_pattern = with_conditions(request_pattern)
       @request_execution_verifier.does_not_match?
     end
 
@@ -76,5 +85,41 @@ module WebMock
 
     # RSpec 2 compatibility:
     alias_method :negative_failure_message, :failure_message_when_negated
+
+    private
+
+    ANY_URI = ->(_uri) { true }
+    private_constant :ANY_URI
+
+    # How the description of conditions starts when nothing was given to
+    # #with. What was given follows it, as in ' with body "abc"'.
+    EMPTY_CONDITIONS = RequestPattern.new(:any, ANY_URI).to_s.freeze
+    private_constant :EMPTY_CONDITIONS
+
+    def with_conditions(request_pattern)
+      @conditions ? PatternWithConditions.new(request_pattern, @conditions) : request_pattern
+    end
+
+    # Matches a request when both the pattern and the conditions match it.
+    class PatternWithConditions
+      def initialize(pattern, conditions)
+        @pattern = pattern
+        @conditions = conditions
+      end
+
+      # The parts that must all match, so JsonBodyHint can check each of them.
+      def patterns
+        [@pattern, @conditions]
+      end
+
+      def matches?(request_signature)
+        @pattern.matches?(request_signature) && @conditions.matches?(request_signature)
+      end
+
+      def to_s
+        "#{@pattern} (only requests#{@conditions.to_s.delete_prefix(EMPTY_CONDITIONS)})"
+      end
+    end
+    private_constant :PatternWithConditions
   end
 end

data/lib/webmock/util/content_type.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module WebMock
+  module Util
+    module ContentType
+      BODY_FORMATS = {
+        'text/xml'               => :xml,
+        'application/xml'        => :xml,
+        'application/json'       => :json,
+        'text/json'              => :json,
+        'application/javascript' => :json,
+        'text/javascript'        => :json,
+        'text/html'              => :html,
+        'application/x-yaml'     => :yaml,
+        'text/yaml'              => :yaml,
+        'text/plain'             => :plain
+      }
+
+      def self.media_type(content_type)
+        content_type.to_s.scrub.split(';', 2).first.to_s.strip.downcase
+      end
+
+      def self.url_encoded?(content_type)
+        media_type(content_type) == 'application/x-www-form-urlencoded'
+      end
+
+      def self.body_format(content_type)
+        type = media_type(content_type)
+
+        BODY_FORMATS.fetch(type) do
+          case type
+          when %r{\A[^/\s]+/[^/\s]+\+json\z} then :json
+          when %r{\A[^/\s]+/[^/\s]+\+xml\z} then :xml
+          end
+        end
+      end
+    end
+  end
+end

data/lib/webmock/util/uri.rb

@@ -58,8 +58,8 @@ module WebMock
 
       def self.strip_default_port_from_uri_string(uri_string)
         case uri_string
-        when %r{^http://}  then uri_string.sub(%r{:80(/|$)}, '\1')
-        when %r{^https://} then uri_string.sub(%r{:443(/|$)}, '\1')
+        when %r{^http://}  then uri_string.sub(%r{\A(http://[^/?#]+):80(?=[/?#]|\z)}, '\1')
+        when %r{^https://} then uri_string.sub(%r{\A(https://[^/?#]+):443(?=[/?#]|\z)}, '\1')
         else uri_string
         end
       end

data/lib/webmock/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module WebMock
-  VERSION = '3.26.4' unless defined?(::WebMock::VERSION)
+  VERSION = '3.34.0' unless defined?(::WebMock::VERSION)
 end