webmock 1.8.6 → 3.14.0

data/lib/webmock/request_signature.rb

@@ -6,13 +6,13 @@ module WebMock
     attr_reader :headers
 
     def initialize(method, uri, options = {})
-      self.method = method
+      self.method = method.to_sym
       self.uri = uri.is_a?(Addressable::URI) ? uri : WebMock::Util::URI.normalize_uri(uri)
       assign_options(options)
     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?
@@ -35,7 +35,11 @@ module WebMock
     alias == eql?
 
     def url_encoded?
-      headers && headers['Content-Type'] == 'application/x-www-form-urlencoded'
+      !!(headers && headers['Content-Type'] == 'application/x-www-form-urlencoded')
+    end
+
+    def json_headers?
+      !!(headers && headers['Content-Type'] == 'application/json')
     end
 
     private

data/lib/webmock/request_signature_snippet.rb

@@ -0,0 +1,61 @@
+require "pp"
+
+module WebMock
+  class RequestSignatureSnippet
+
+    attr_reader :request_signature, :request_stub
+
+    def initialize(request_signature)
+      @request_signature = request_signature
+      @request_stub = RequestStub.from_request_signature(request_signature)
+    end
+
+    def stubbing_instructions
+      return unless WebMock.show_stubbing_instructions?
+
+      "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".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?
+      end
+      text
+    end
+
+    private
+
+    def add_body_diff(stub, text)
+      body_diff_str = signature_stub_body_diff(stub)
+      text << "\n\n#{body_diff_str}" unless body_diff_str.empty?
+    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)
+        stream.rewind
+        stream.read
+      end
+    end
+
+  end
+end

data/lib/webmock/request_stub.rb

@@ -22,6 +22,7 @@ module WebMock
       end
       self
     end
+    alias_method :and_return, :to_return
 
     def to_rack(app, options={})
       @responses_sequences << ResponsesSequence.new([RackResponse.new(app)])
@@ -29,15 +30,17 @@ module WebMock
 
     def to_raise(*exceptions)
       @responses_sequences << ResponsesSequence.new([*exceptions].flatten.map {|e|
-        ResponseFactory.response_for(:exception => e)
+        ResponseFactory.response_for(exception: e)
       })
       self
     end
+    alias_method :and_raise, :to_raise
 
     def to_timeout
-      @responses_sequences << ResponsesSequence.new([ResponseFactory.response_for(:should_timeout => true)])
+      @responses_sequences << ResponsesSequence.new([ResponseFactory.response_for(should_timeout: true)])
       self
     end
+    alias_method :and_timeout, :to_timeout
 
     def response
       if @responses_sequences.empty?
@@ -59,7 +62,7 @@ module WebMock
     end
 
     def times(number)
-      raise "times(N) accepts integers >= 1 only" if !number.is_a?(Fixnum) || number < 1
+      raise "times(N) accepts integers >= 1 only" if !number.is_a?(Integer) || number < 1
       if @responses_sequences.empty?
         raise "Invalid WebMock stub declaration." +
           " times(N) can be declared only after response declaration."
@@ -81,15 +84,15 @@ module WebMock
 
       if signature.body.to_s != ''
         body = if signature.url_encoded?
-          Addressable::URI.parse('?' + signature.body).query_values
+          WebMock::Util::QueryMapper.query_to_values(signature.body, notation: Config.instance.query_values_notation)
         else
           signature.body
         end
-        stub.with(:body => body)
+        stub.with(body: body)
       end
 
       if (signature.headers && !signature.headers.empty?)
-        stub.with(:headers => signature.headers)
+        stub.with(headers: signature.headers)
       end
       stub
     end

data/lib/webmock/response.rb

@@ -1,7 +1,4 @@
-#compatibility with Ruby 1.9.2 preview1 to allow reading raw responses
-class StringIO
-  alias_method :read_nonblock, :sysread
-end
+require "pathname"
 
 module WebMock
 
@@ -41,6 +38,7 @@ module WebMock
 
     def body=(body)
       @body = body
+      assert_valid_body!
       stringify_body!
     end
 
@@ -73,11 +71,13 @@ module WebMock
     end
 
     def options=(options)
-      self.headers = options[:headers]
-      self.status = options[:status]
-      self.body = options[:body]
-      self.exception = options[:exception]
-      @should_timeout = options[:should_timeout]
+      options = WebMock::Util::HashKeysStringifier.stringify_keys!(options)
+      HashValidator.new(options).validate_keys('headers', 'status', 'body', 'exception', 'should_timeout')
+      self.headers = options['headers']
+      self.status = options['status']
+      self.body = options['body']
+      self.exception = options['exception']
+      @should_timeout = options['should_timeout']
     end
 
     def evaluate(request_signature)
@@ -91,19 +91,32 @@ 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
 
     def stringify_body!
-      if @body.is_a?(IO)
+      if @body.is_a?(IO) || @body.is_a?(Pathname)
         io = @body
         @body = io.read
-        io.close
+        io.close if io.respond_to?(:close)
+      end
+    end
+
+    def assert_valid_body!
+      valid_types = [Proc, IO, Pathname, String, Array]
+      return if @body.nil?
+      return if valid_types.any? { |c| @body.is_a?(c) }
+
+      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
 
@@ -127,6 +140,8 @@ module WebMock
       options
     end
 
+    InvalidBody = Class.new(StandardError)
+
   end
 
   class DynamicResponse < Response

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

@@ -20,6 +20,36 @@ module WebMock
       self
     end
 
+    def at_least_once
+      @request_execution_verifier.at_least_times_executed = 1
+      self
+    end
+
+    def at_least_twice
+      @request_execution_verifier.at_least_times_executed = 2
+      self
+    end
+
+    def at_least_times(times)
+      @request_execution_verifier.at_least_times_executed = times.to_i
+      self
+    end
+
+    def at_most_once
+      @request_execution_verifier.at_most_times_executed = 1
+      self
+    end
+
+    def at_most_twice
+      @request_execution_verifier.at_most_times_executed = 2
+      self
+    end
+
+    def at_most_times(times)
+      @request_execution_verifier.at_most_times_executed = times.to_i
+      self
+    end
+
     def matches?(request_pattern)
       @request_execution_verifier.request_pattern = request_pattern
       @request_execution_verifier.matches?
@@ -34,9 +64,15 @@ module WebMock
       @request_execution_verifier.failure_message
     end
 
+    def failure_message_when_negated
+      @request_execution_verifier.failure_message_when_negated
+    end
 
-    def negative_failure_message
-      @request_execution_verifier.negative_failure_message
+    def description
+      @request_execution_verifier.description
     end
+
+    # RSpec 2 compatibility:
+    alias_method :negative_failure_message, :failure_message_when_negated
   end
 end

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

@@ -16,6 +16,21 @@ module WebMock
       self
     end
 
+    def at_least_once
+      @request_execution_verifier.at_least_times_executed = 1
+      self
+    end
+
+    def at_least_twice
+      @request_execution_verifier.at_least_times_executed = 2
+      self
+    end
+
+    def at_least_times(times)
+      @request_execution_verifier.at_least_times_executed = times
+      self
+    end
+
     def with(options = {}, &block)
       @request_execution_verifier.request_pattern.with(options, &block)
       self
@@ -38,9 +53,15 @@ module WebMock
       @request_execution_verifier.failure_message
     end
 
+    def failure_message_when_negated
+      @request_execution_verifier.failure_message_when_negated
+    end
 
-    def negative_failure_message
-      @request_execution_verifier.negative_failure_message
+    def description
+      @request_execution_verifier.description
     end
+
+    # RSpec 2 compatibility:
+    alias_method :negative_failure_message, :failure_message_when_negated
   end
 end

data/lib/webmock/rspec/matchers.rb

@@ -12,7 +12,6 @@ module WebMock
       WebMock::RequestPatternMatcher.new
     end
 
-
     def have_not_been_made
       WebMock::RequestPatternMatcher.new.times(0)
     end

data/lib/webmock/rspec.rb

@@ -1,7 +1,7 @@
 require 'webmock'
 
 # RSpec 1.x and 2.x compatibility
-if defined?(RSpec) && defined?(RSpec::Expectations)
+if defined?(RSpec::Expectations::ExpectationNotMetError)
   RSPEC_NAMESPACE = RSPEC_CONFIGURER = RSpec
 elsif defined?(Spec) && defined?(Spec.configure)
   RSPEC_NAMESPACE = Spec
@@ -25,7 +25,16 @@ 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 = {}
+      response_lock = Mutex.new
+
+      stub = ::WebMock::RequestStub.new(:any, ->(uri) { true }).with { |request|
+        update_response = -> { responses[request.object_id] = yield(request) }
 
-      stub = ::WebMock::RequestStub.new(:any, /.*/).with { |request|
-        responses[request.object_id] = block.call(request)
-      }.to_return(lambda { |request| responses.delete(request.object_id) })
+        # 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.push stub
+      global_stubs[order].push stub
     end
 
     def register_request_stub(stub)
@@ -36,6 +50,12 @@ module WebMock
       stub
     end
 
+    def remove_request_stub(stub)
+      if not request_stubs.delete(stub)
+        raise "Request stub \n\n #{stub.to_s} \n\n is not registered."
+      end
+    end
+
     def registered_request?(request_signature)
       request_stub_for(request_signature)
     end
@@ -48,13 +68,14 @@ 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)
-      response.evaluate(request_signature)
+      response.dup.evaluate(request_signature)
     end
 
   end

data/lib/webmock/stub_request_snippet.rb

@@ -4,25 +4,33 @@ module WebMock
       @request_stub = request_stub
     end
 
+    def body_pattern
+      request_pattern.body_pattern
+    end
+
     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

@@ -1,20 +1,20 @@
 require 'test/unit'
 require 'webmock'
 
+WebMock.enable!
+
 module Test
   module Unit
     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
 end
 
-WebMock::AssertionFailure.error_class = Test::Unit::AssertionFailedError rescue MiniTest::Assertion # ruby1.9 compat
+WebMock::AssertionFailure.error_class = Test::Unit::AssertionFailedError

data/lib/webmock/util/hash_counter.rb

@@ -1,23 +1,37 @@
+require 'thread'
+
 module WebMock
   module Util
-    class Util::HashCounter
+    class HashCounter
       attr_accessor :hash
       def initialize
         self.hash = {}
         @order = {}
         @max = 0
+        @lock = ::Mutex.new
       end
       def put key, num=1
-        hash[key] = (hash[key] || 0) + num
-        @order[key] = @max = @max + 1
+        @lock.synchronize do
+          hash[key] = (hash[key] || 0) + num
+          @order[key] = @max = @max + 1
+        end
       end
       def get key
-        hash[key] || 0
+        @lock.synchronize do
+          hash[key] || 0
+        end
+      end
+
+      def select(&block)
+        return unless block_given?
+        @lock.synchronize do
+          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/hash_keys_stringifier.rb

@@ -2,15 +2,17 @@ module WebMock
   module Util
     class HashKeysStringifier
 
-      def self.stringify_keys!(arg)
+      def self.stringify_keys!(arg, options = {})
         case arg
         when Array
-          arg.map { |elem| stringify_keys!(elem) }
+          arg.map { |elem|
+            options[:deep] ? stringify_keys!(elem, options) : elem
+          }
         when Hash
           Hash[
             *arg.map { |key, value|
               k = key.is_a?(Symbol) ? key.to_s : key
-              v = stringify_keys!(value)
+              v = (options[:deep] ? stringify_keys!(value, options) : value)
               [k,v]
             }.inject([]) {|r,x| r + x}]
         else

data/lib/webmock/util/hash_validator.rb

@@ -0,0 +1,17 @@
+module WebMock
+  class HashValidator
+    def initialize(hash)
+      @hash = hash
+    end
+
+    #This code is based on https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/hash/keys.rb
+    def validate_keys(*valid_keys)
+      valid_keys.flatten!
+      @hash.each_key do |k|
+        unless valid_keys.include?(k)
+          raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
+        end
+      end
+    end
+  end
+end

data/lib/webmock/util/headers.rb

@@ -1,3 +1,5 @@
+require 'base64'
+
 module WebMock
 
   module Util
@@ -10,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
           ]
@@ -20,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
@@ -32,10 +34,29 @@ 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
 
+      def self.basic_auth_header(*credentials)
+        "Basic #{Base64.strict_encode64(credentials.join(':')).chomp}"
+      end
+
     end
 
   end