webmock 3.7.1

data/lib/webmock/rack_response.rb

@@ -0,0 +1,69 @@
+module WebMock
+  class RackResponse < Response
+    def initialize(app)
+      @app = app
+    end
+
+    def evaluate(request)
+      env = build_rack_env(request)
+
+      status, headers, response = @app.call(env)
+
+      Response.new(
+        body: body_from_rack_response(response),
+        headers: headers,
+        status: [status, Rack::Utils::HTTP_STATUS_CODES[status]]
+      )
+    end
+
+    def body_from_rack_response(response)
+      body = "".dup
+      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 || {}).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.bytesize,
+        'PATH_INFO'      => uri.path,
+        'QUERY_STRING'   => uri.query || '',
+        'SERVER_NAME'    => uri.host,
+        '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
+      end
+
+      env
+    end
+
+    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

@@ -0,0 +1,77 @@
+module WebMock
+  class RequestExecutionVerifier
+
+    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, 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)
+
+      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?
+      @times_executed =
+      RequestRegistry.instance.times_executed(@request_pattern)
+      if @expected_times_executed
+        @times_executed != @expected_times_executed
+      else
+        @times_executed == 0
+      end
+    end
+
+    def description
+      "request #{request_pattern} #{quantity_phrase.strip}"
+    end
+
+    def failure_message
+      failure_message_phrase(false)
+    end
+
+    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}\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
+
+  end
+end

data/lib/webmock/request_pattern.rb

@@ -0,0 +1,370 @@
+module WebMock
+
+  module RSpecMatcherDetector
+    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
+
+    attr_reader :method_pattern, :uri_pattern, :body_pattern, :headers_pattern
+
+    def initialize(method, uri, options = {})
+      @method_pattern  = MethodPattern.new(method)
+      @uri_pattern     = create_uri_pattern(uri)
+      @body_pattern    = nil
+      @headers_pattern = nil
+      @with_block      = nil
+      assign_options(options)
+    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
+    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 || "")) &&
+        (@headers_pattern.nil? || @headers_pattern.matches?(request_signature.headers)) &&
+        (@with_block.nil? || @with_block.call(request_signature))
+    end
+
+    def to_s
+      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
+      string << " with given block" if @with_block
+      string
+    end
+
+    private
+
+
+    def assign_options(options)
+      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)
+      else
+        URIStringPattern.new(uri)
+      end
+    end
+
+  end
+
+
+  class MethodPattern
+    def initialize(pattern)
+      @pattern = pattern
+    end
+
+    def matches?(method)
+      @pattern == method || @pattern == :any
+    end
+
+    def to_s
+      @pattern.to_s
+    end
+  end
+
+
+  class URIPattern
+    include RSpecMatcherDetector
+
+    def initialize(pattern)
+      @pattern = case pattern
+      when Addressable::URI, Addressable::Template
+        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) \
+              || 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 to_s
+      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))
+    end
+
+    def to_s
+      str = @pattern.inspect
+      str += " with query params #{@query_params.inspect}" if @query_params
+      str
+    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
+    end
+
+    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.pattern.inspect
+      str += " with variables #{@pattern.variables.inspect}" if @pattern.variables
+      str
+    end
+
+    private
+
+    def matches_with_variations?(uri)
+      normalized_template = Addressable::Template.new(WebMock::Util::URI.heuristic_parse(@pattern.pattern))
+
+      WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u| normalized_template.match(u) }
+    end
+  end
+
+  class URIStringPattern < URIPattern
+    def 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))
+        else
+          uri === @pattern
+        end
+      else
+        false
+      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
+    end
+  end
+
+
+  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
+    }
+
+    attr_reader :pattern
+
+    def initialize(pattern)
+      @pattern = if pattern.is_a?(Hash)
+        normalize_hash(pattern)
+      elsif rSpecHashIncludingMatcher?(pattern)
+        WebMock::Matchers::HashIncludingMatcher.from_rspec_matcher(pattern)
+      else
+        pattern
+      end
+    end
+
+    def matches?(body, content_type = "")
+      assert_non_multipart_body(content_type)
+
+      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)
+        @pattern == body_as_hash(body, content_type)
+      else
+        empty_string?(@pattern) && empty_string?(body) ||
+          @pattern == body ||
+          @pattern === body
+      end
+    end
+
+    def to_s
+      @pattern.inspect
+    end
+
+    private
+    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
+        WebMock::Util::QueryMapper.query_to_values(body, notation: Config.instance.query_values_notation)
+      end
+    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
+
+    # 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_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_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
+      true
+    end
+
+    def empty_string?(string)
+      string.nil? || string == ""
+    end
+
+    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
+    def initialize(pattern)
+      @pattern = WebMock::Util::Headers.normalize_headers(pattern) || {}
+    end
+
+    def matches?(headers)
+      if empty_headers?(@pattern)
+        empty_headers?(headers)
+      else
+        return false if empty_headers?(headers)
+        @pattern.each do |key, value|
+          return false unless headers.has_key?(key) && value === headers[key]
+        end
+        true
+      end
+    end
+
+    def to_s
+      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)
+      headers.nil? || headers == {}
+    end
+  end
+
+end