webmock 1.8.6 → 3.14.0

data/lib/webmock/matchers/hash_argument_matcher.rb

@@ -0,0 +1,21 @@
+module WebMock
+  module Matchers
+    # Base class for Hash matchers
+    # https://github.com/rspec/rspec-mocks/blob/master/lib/rspec/mocks/argument_matchers.rb
+    class HashArgumentMatcher
+      def initialize(expected)
+        @expected = Hash[WebMock::Util::HashKeysStringifier.stringify_keys!(expected, deep: true).sort]
+      end
+
+      def ==(_actual, &block)
+        @expected.all?(&block)
+      rescue NoMethodError
+        false
+      end
+
+      def self.from_rspec_matcher(matcher)
+        new(matcher.instance_variable_get(:@expected))
+      end
+    end
+  end
+end

data/lib/webmock/matchers/hash_excluding_matcher.rb

@@ -0,0 +1,15 @@
+module WebMock
+  module Matchers
+    # this is a based on RSpec::Mocks::ArgumentMatchers::HashExcludingMatcher
+    # 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] }
+      end
+
+      def inspect
+        "hash_excluding(#{@expected.inspect})"
+      end
+    end
+  end
+end

data/lib/webmock/matchers/hash_including_matcher.rb

@@ -1,14 +1,10 @@
 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
-
+    # 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 < HashArgumentMatcher
       def ==(actual)
-        @expected.all? {|k,v| actual.has_key?(k) && v == actual[k]}
+        super { |key, value| actual.key?(key) && value === actual[key] }
       rescue NoMethodError
         false
       end
@@ -16,10 +12,6 @@ module WebMock
       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/minitest.rb

@@ -1,7 +1,18 @@
-require 'minitest/unit'
+begin
+  require 'minitest/test'
+  test_class = Minitest::Test
+  assertions = "assertions"
+rescue LoadError
+  require "minitest/unit"
+  test_class = MiniTest::Unit::TestCase
+  assertions = "_assertions"
+end
+
 require 'webmock'
 
-MiniTest::Unit::TestCase.class_eval do
+WebMock.enable!
+
+test_class.class_eval do
   include WebMock::API
 
   alias_method :teardown_without_webmock, :teardown
@@ -10,6 +21,21 @@ MiniTest::Unit::TestCase.class_eval do
     WebMock.reset!
   end
   alias_method :teardown, :teardown_with_webmock
+
+  [:assert_request_requested, :assert_request_not_requested].each do |name|
+    alias_method :"#{name}_without_assertions_count", name
+    define_method :"#{name}_with_assertions_count" do |*args|
+      self.send("#{assertions}=", self.send("#{assertions}") + 1)
+      send :"#{name}_without_assertions_count", *args
+    end
+    alias_method name, :"#{name}_with_assertions_count"
+  end
+end
+
+begin
+  error_class = MiniTest::Assertion
+rescue NameError
+  error_class = Minitest::Assertion
 end
 
-WebMock::AssertionFailure.error_class = MiniTest::Assertion
+WebMock::AssertionFailure.error_class = error_class

data/lib/webmock/rack_response.rb

@@ -10,14 +10,14 @@ module WebMock
       status, headers, response = @app.call(env)
 
       Response.new(
-        :body => body_from_rack_response(response),
-        :headers => headers,
-        :status => status
+        body: body_from_rack_response(response),
+        headers: headers,
+        status: [status, Rack::Utils::HTTP_STATUS_CODES[status]]
       )
     end
 
     def body_from_rack_response(response)
-      body = ""
+      body = "".dup
       response.each { |line| body << line }
       response.close if response.respond_to?(:close)
       return body
@@ -25,28 +25,31 @@ module WebMock
 
     def build_rack_env(request)
       uri = request.uri
-      headers = request.headers || {}
+      headers = (request.headers || {}).dup
       body = request.body || ''
 
       env = {
         # CGI variables specified by Rack
         'REQUEST_METHOD' => request.method.to_s.upcase,
         'CONTENT_TYPE'   => headers.delete('Content-Type'),
-        'CONTENT_LENGTH' => body.size,
+        'CONTENT_LENGTH' => body.bytesize,
         'PATH_INFO'      => uri.path,
         'QUERY_STRING'   => uri.query || '',
         'SERVER_NAME'    => uri.host,
-        'SERVER_PORT'    => uri.port
+        'SERVER_PORT'    => uri.port,
+        'SCRIPT_NAME'    => ""
       }
 
       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
       env['rack.version']    = Rack::VERSION
       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
@@ -58,5 +61,9 @@ module WebMock
     def session
       @session ||= {}
     end
+
+    def session_options
+      @session_options ||= {}
+    end
   end
 end

data/lib/webmock/request_body_diff.rb

@@ -0,0 +1,64 @@
+require "hashdiff"
+require "json"
+
+module WebMock
+  class RequestBodyDiff
+
+    def initialize(request_signature, request_stub)
+      @request_signature = request_signature
+      @request_stub      = request_stub
+    end
+
+    def body_diff
+      return {} unless request_signature_diffable? && request_stub_diffable?
+
+      Hashdiff.diff(request_signature_body_hash, request_stub_body_hash)
+    end
+
+    attr_reader :request_signature, :request_stub
+    private :request_signature, :request_stub
+
+    private
+
+    def request_signature_diffable?
+      request_signature.json_headers? && request_signature_parseable_json?
+    end
+
+    def request_stub_diffable?
+      request_stub_body.is_a?(Hash) || request_stub_parseable_json?
+    end
+
+    def request_signature_body_hash
+      JSON.parse(request_signature.body)
+    end
+
+    def request_stub_body_hash
+      return request_stub_body if request_stub_body.is_a?(Hash)
+
+      JSON.parse(request_stub_body)
+    end
+
+    def request_stub_body
+      request_stub.request_pattern &&
+        request_stub.request_pattern.body_pattern &&
+        request_stub.request_pattern.body_pattern.pattern
+    end
+
+    def request_signature_parseable_json?
+      parseable_json?(request_signature.body)
+    end
+
+    def request_stub_parseable_json?
+      parseable_json?(request_stub_body)
+    end
+
+    def parseable_json?(body_pattern)
+      return false unless body_pattern.is_a?(String)
+
+      JSON.parse(body_pattern)
+      true
+    rescue JSON::ParserError
+      false
+    end
+  end
+end

data/lib/webmock/request_execution_verifier.rb

@@ -1,17 +1,26 @@
 module WebMock
   class RequestExecutionVerifier
 
-    attr_accessor :request_pattern, :expected_times_executed, :times_executed
+    attr_accessor :request_pattern, :expected_times_executed, :times_executed, :at_least_times_executed, :at_most_times_executed
 
-    def initialize(request_pattern = nil, expected_times_executed = nil)
+    def initialize(request_pattern = nil, expected_times_executed = nil, at_least_times_executed = nil, at_most_times_executed = nil)
       @request_pattern = request_pattern
       @expected_times_executed = expected_times_executed
+      @at_least_times_executed = at_least_times_executed
+      @at_most_times_executed = at_most_times_executed
     end
 
     def matches?
       @times_executed =
-      RequestRegistry.instance.times_executed(@request_pattern)
-      @times_executed == (@expected_times_executed || 1)
+        RequestRegistry.instance.times_executed(@request_pattern)
+
+      if @at_least_times_executed
+        @times_executed >= @at_least_times_executed
+      elsif @at_most_times_executed
+        @times_executed <= @at_most_times_executed
+      else
+        @times_executed == (@expected_times_executed || 1)
+      end
     end
 
     def does_not_match?
@@ -24,30 +33,42 @@ module WebMock
       end
     end
 
+    def description
+      "request #{request_pattern} #{quantity_phrase.strip}"
+    end
 
     def failure_message
-      expected_times_executed = @expected_times_executed || 1
-      text = %Q(The request #{request_pattern.to_s} was expected to execute #{times(expected_times_executed)} but it executed #{times(times_executed)})
-      text << self.class.executed_requests_message
-      text
+      failure_message_phrase(false)
     end
 
-    def negative_failure_message
-      text = if @expected_times_executed
-        %Q(The request #{request_pattern.to_s} was not expected to execute #{times(expected_times_executed)} but it executed #{times(times_executed)})
-      else
-        %Q(The request #{request_pattern.to_s} was expected to execute 0 times but it executed #{times(times_executed)})
-      end
-      text << self.class.executed_requests_message
-      text
+    def failure_message_when_negated
+      failure_message_phrase(true)
     end
 
     def self.executed_requests_message
-      "\n\nThe following requests were made:\n\n#{RequestRegistry.instance.to_s}\n" + "="*60
+      "\n\nThe following requests were made:\n\n#{RequestRegistry.instance}\n" + "="*60
     end
 
     private
 
+    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)}" +
+        self.class.executed_requests_message
+    end
+
+    def quantity_phrase(is_negated=false)
+      if @at_least_times_executed
+        "at least #{times(@at_least_times_executed)} "
+      elsif @at_most_times_executed
+        "at most #{times(@at_most_times_executed)} "
+      elsif @expected_times_executed
+        "#{times(@expected_times_executed)} "
+      else
+        is_negated ? "" : "#{times(1)} "
+      end
+    end
+
     def times(times)
       "#{times} time#{ (times == 1) ? '' : 's'}"
     end

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,6 +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. 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
@@ -27,6 +32,7 @@ module WebMock
 
     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 || "")) &&
@@ -35,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
@@ -47,14 +53,35 @@ module WebMock
 
 
     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)
+      options = WebMock::Util::HashKeysStringifier.stringify_keys!(options, deep: true)
+      HashValidator.new(options).validate_keys('body', 'headers', 'query', 'basic_auth')
+      set_basic_auth_as_headers!(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 set_basic_auth_as_headers!(options)
+      if basic_auth = options.delete('basic_auth')
+        validate_basic_auth!(basic_auth)
+        options['headers'] ||= {}
+        options['headers']['Authorization'] = WebMock::Util::Headers.basic_auth_header(basic_auth[0],basic_auth[1])
+      end
+    end
+
+    def validate_basic_auth!(basic_auth)
+      if !basic_auth.is_a?(Array) || basic_auth.map{|e| e.is_a?(String)}.uniq != [true]
+        raise "The basic_auth option value should be an array which contains 2 strings: username and password"
+      end
     end
 
     def create_uri_pattern(uri)
       if uri.is_a?(Regexp)
         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
@@ -82,51 +109,130 @@ module WebMock
     include RSpecMatcherDetector
 
     def initialize(pattern)
-      @pattern = pattern.is_a?(Addressable::URI) ? pattern : WebMock::Util::URI.normalize_uri(pattern)
+      @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)
+      end
+      @query_params = nil
     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)
+      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
-        Addressable::URI.parse('?' + query_params).query_values
+        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 URICallablePattern  < URIPattern
+    private
+
+    def pattern_matches?(uri)
+      @pattern.call(uri)
+    end
   end
 
   class URIRegexpPattern  < URIPattern
-    def initialize *args, &block
-      @query_params = nil
-      super
+    private
+
+    def pattern_matches?(uri)
+      WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u| u.match(@pattern) }
     end
+  end
 
-    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)
+  class URIAddressablePattern  < URIPattern
+    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
 
-    def to_s
-      str = @pattern.inspect
-      str += " with query params #{@query_params.inspect}" if @query_params
-      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
+
+    def pattern_inspect
+      @pattern.pattern.inspect
+    end
+
+    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 == uri.query_values)
+          uri.omit(:query) === @pattern
         else
           uri === @pattern
         end
@@ -135,18 +241,8 @@ module WebMock
       end
     end
 
-    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_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
 
@@ -167,6 +263,8 @@ module WebMock
       'text/plain'             => :plain
     }
 
+    attr_reader :pattern
+
     def initialize(pattern)
       @pattern = if pattern.is_a?(Hash)
         normalize_hash(pattern)
@@ -178,9 +276,11 @@ module WebMock
     end
 
     def matches?(body, content_type = "")
+      assert_non_multipart_body(content_type)
+
       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
@@ -195,14 +295,26 @@ 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
         Crack::XML.parse(body)
       else
-        Addressable::URI.parse('?' + body).query_values
+        WebMock::Util::QueryMapper.query_to_values(body, notation: Config.instance.query_values_notation)
+      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 :(")
       end
     end
 
@@ -229,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
@@ -249,9 +362,12 @@ module WebMock
     end
 
     def normalize_hash(hash)
-      Hash[WebMock::Util::HashKeysStringifier.stringify_keys!(hash).sort]
+      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
@@ -275,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

@@ -14,16 +14,16 @@ module WebMock
     end
 
     def times_executed(request_pattern)
-      self.requested_signatures.hash.select { |request_signature, times_executed|
+      self.requested_signatures.select do |request_signature|
         request_pattern.matches?(request_signature)
-      }.inject(0) {|sum, (_, times_executed)| sum + times_executed }
+      end.inject(0) { |sum, (_, times_executed)| sum + times_executed }
     end
 
     def to_s
       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