rspec-mocks 3.0.4 → 3.12.6

data/lib/rspec/mocks/method_double.rb

@@ -2,8 +2,11 @@ module RSpec
   module Mocks
     # @private
     class MethodDouble
+      # @private TODO: drop in favor of FrozenError in ruby 2.5+
+      FROZEN_ERROR_MSG = /can't modify frozen/
+
       # @private
-      attr_reader :method_name, :object, :expectations, :stubs
+      attr_reader :method_name, :object, :expectations, :stubs, :method_stasher
 
       # @private
       def initialize(object, method_name, proxy)
@@ -18,20 +21,31 @@ module RSpec
         @stubs = []
       end
 
-      def original_method
+      def original_implementation_callable
         # If original method is not present, uses the `method_missing`
         # handler of the object. This accounts for cases where the user has not
         # correctly defined `respond_to?`, and also 1.8 which does not provide
         # method handles for missing methods even if `respond_to?` is correct.
+        @original_implementation_callable ||= original_method || method_missing_block
+      end
+
+      alias_method :save_original_implementation_callable!, :original_implementation_callable
+
+      def original_method
         @original_method ||=
           @method_stasher.original_method ||
-          @proxy.original_method_handle_for(method_name) ||
-          Proc.new do |*args, &block|
-            @object.__send__(:method_missing, @method_name, *args, &block)
-          end
+          @proxy.original_method_handle_for(method_name)
       end
 
-      alias_method :save_original_method!, :original_method
+      # @private
+      def method_missing_block
+        block = Proc.new do |*args, &b|
+          @object.__send__(:method_missing, @method_name, *args, &b)
+        end
+        block.ruby2_keywords if block.respond_to?(:ruby2_keywords)
+
+        block
+      end
 
       # @private
       def visibility
@@ -45,7 +59,7 @@ module RSpec
 
       # @private
       def configure_method
-        @original_visibility = [visibility, method_name]
+        @original_visibility = visibility
         @method_stasher.stash unless @method_is_proxied
         define_proxy_method
       end
@@ -54,44 +68,62 @@ module RSpec
       def define_proxy_method
         return if @method_is_proxied
 
-        save_original_method!
-        definition_target.class_exec(self, method_name, visibility) do |method_double, method_name, visibility|
+        save_original_implementation_callable!
+        definition_target.class_exec(self, method_name, @original_visibility || visibility) do |method_double, method_name, visibility|
           define_method(method_name) do |*args, &block|
             method_double.proxy_method_invoked(self, *args, &block)
           end
-          self.__send__ visibility, method_name
+          # This can't be `if respond_to?(:ruby2_keywords, true)`,
+          # see https://github.com/rspec/rspec-mocks/pull/1385#issuecomment-755340298
+          ruby2_keywords(method_name) if Module.private_method_defined?(:ruby2_keywords)
+          __send__(visibility, method_name)
         end
 
         @method_is_proxied = true
+      rescue RuntimeError, TypeError => e
+        # TODO: drop in favor of FrozenError in ruby 2.5+
+        #  RuntimeError (and FrozenError) for ruby 2.x
+        #  TypeError for ruby 1.x
+        if (defined?(FrozenError) && e.is_a?(FrozenError)) || FROZEN_ERROR_MSG === e.message
+          raise ArgumentError, "Cannot proxy frozen objects, rspec-mocks relies on proxies for method stubbing and expectations."
+        end
+        raise
       end
 
       # The implementation of the proxied method. Subclasses may override this
       # method to perform additional operations.
       #
       # @private
-      def proxy_method_invoked(obj, *args, &block)
+      def proxy_method_invoked(_obj, *args, &block)
         @proxy.message_received method_name, *args, &block
       end
+      ruby2_keywords :proxy_method_invoked if respond_to?(:ruby2_keywords, true)
 
       # @private
       def restore_original_method
-        return show_frozen_warning if object_singleton_class.frozen?
         return unless @method_is_proxied
 
-        definition_target.__send__(:remove_method, @method_name)
-
-        if @method_stasher.method_is_stashed?
-          @method_stasher.restore
-        end
+        remove_method_from_definition_target
+        @method_stasher.restore if @method_stasher.method_is_stashed?
         restore_original_visibility
 
         @method_is_proxied = false
+      rescue RuntimeError, TypeError => e
+        # TODO: drop in favor of FrozenError in ruby 2.5+
+        #  RuntimeError (and FrozenError) for ruby 2.x
+        #  TypeError for ruby 1.x
+        if (defined?(FrozenError) && e.is_a?(FrozenError)) || FROZEN_ERROR_MSG === e.message
+          return show_frozen_warning
+        end
+        raise
       end
 
       # @private
       def show_frozen_warning
         RSpec.warn_with(
-          "WARNING: rspec-mocks was unable to restore the original `#{@method_name}` method on #{@object.inspect} because it has been frozen.  If you reuse this object, `#{@method_name}` will continue to respond with its stub implementation.",
+          "WARNING: rspec-mocks was unable to restore the original `#{@method_name}` " \
+          "method on #{@object.inspect} because it has been frozen.  If you reuse this " \
+          "object, `#{@method_name}` will continue to respond with its stub implementation.",
           :call_site                      => nil,
           :use_spec_location_as_call_site => true
         )
@@ -102,12 +134,12 @@ module RSpec
         return unless @original_visibility &&
           MethodReference.method_defined_at_any_visibility?(object_singleton_class, @method_name)
 
-        object_singleton_class.__send__(*@original_visibility)
+        object_singleton_class.__send__(@original_visibility, method_name)
       end
 
       # @private
       def verify
-        expectations.each {|e| e.verify_messages_received}
+        expectations.each { |e| e.verify_messages_received }
       end
 
       # @private
@@ -134,7 +166,7 @@ module RSpec
       def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation)
         configure_method
         expectation = message_expectation_class.new(error_generator, expectation_ordering,
-                                             expected_from, self, :expectation, opts, &implementation)
+                                                    expected_from, self, :expectation, opts, &implementation)
         expectations << expectation
         expectation
       end
@@ -149,7 +181,7 @@ module RSpec
       def add_stub(error_generator, expectation_ordering, expected_from, opts={}, &implementation)
         configure_method
         stub = message_expectation_class.new(error_generator, expectation_ordering, expected_from,
-                                      self, :stub, opts, &implementation)
+                                             self, :stub, opts, &implementation)
         stubs.unshift stub
         stub
       end
@@ -172,7 +204,7 @@ module RSpec
       end
 
       # @private
-      def setup_simple_method_double(method_name, response, collection, error_generator = nil, backtrace_line = nil)
+      def setup_simple_method_double(method_name, response, collection, error_generator=nil, backtrace_line=nil)
         define_proxy_method
 
         me = SimpleMessageExpectation.new(method_name, response, error_generator, backtrace_line)
@@ -199,15 +231,13 @@ module RSpec
 
       # @private
       def raise_method_not_stubbed_error
-        raise MockExpectationError, "The method `#{method_name}` was not stubbed or was already unstubbed"
+        RSpec::Mocks.error_generator.raise_method_not_stubbed_error(method_name)
       end
 
-    private
-
       # In Ruby 2.0.0 and above prepend will alter the method lookup chain.
       # We use an object's singleton class to define method doubles upon,
-      # however if the object has had it's singleton class (as opposed to
-      # it's actual class) prepended too then the the method lookup chain
+      # however if the object has had its singleton class (as opposed to
+      # its actual class) prepended too then the the method lookup chain
       # will look in the prepended module first, **before** the singleton
       # class.
       #
@@ -216,6 +246,9 @@ module RSpec
       # of our own.
       #
       if Support::RubyFeatures.module_prepends_supported?
+
+        private
+
         # We subclass `Module` in order to be able to easily detect our prepended module.
         RSpecPrependedModule = Class.new(Module)
 
@@ -247,11 +280,37 @@ module RSpec
 
       else
 
+        private
+
         def definition_target
           object_singleton_class
         end
 
       end
+
+    private
+
+      def remove_method_from_definition_target
+        definition_target.__send__(:remove_method, @method_name)
+      rescue NameError
+        # This can happen when the method has been monkeyed with by
+        # something outside RSpec. This happens, for example, when
+        # `file.write` has been stubbed, and then `file.reopen(other_io)`
+        # is later called, as `File#reopen` appears to redefine `write`.
+        #
+        # Note: we could avoid rescuing this by checking
+        # `definition_target.instance_method(@method_name).owner == definition_target`,
+        # saving us from the cost of the expensive exception, but this error is
+        # extremely rare (it was discovered on 2014-12-30, only happens on
+        # RUBY_VERSION < 2.0 and our spec suite only hits this condition once),
+        # so we'd rather avoid the cost of that check for every method double,
+        # and risk the rare situation where this exception will get raised.
+        RSpec.warn_with(
+          "WARNING: RSpec could not fully restore #{@object.inspect}." \
+          "#{@method_name}, possibly because the method has been redefined " \
+          "by something outside of RSpec."
+        )
+      end
     end
   end
 end

data/lib/rspec/mocks/method_reference.rb

@@ -1,3 +1,5 @@
+RSpec::Support.require_rspec_support 'comparable_version'
+
 module RSpec
   module Mocks
     # Represents a method on an object that may or may not be defined.
@@ -6,6 +8,10 @@ module RSpec
     #
     # @private
     class MethodReference
+      def self.for(object_reference, method_name)
+        new(object_reference, method_name)
+      end
+
       def initialize(object_reference, method_name)
         @object_reference = object_reference
         @method_name = method_name
@@ -27,7 +33,7 @@ module RSpec
       # cases when we don't know if a method is implemented and
       # both `implemented?` and `unimplemented?` will return false.
       def unimplemented?
-        @object_reference.when_loaded do |m|
+        @object_reference.when_loaded do |_m|
           return !implemented?
         end
 
@@ -44,9 +50,8 @@ module RSpec
       end
 
       def with_signature
-        if original = original_method
-          yield Support::MethodSignature.new(original)
-        end
+        return unless (original = original_method)
+        yield Support::MethodSignature.new(original)
       end
 
       def visibility
@@ -59,14 +64,6 @@ module RSpec
         :public
       end
 
-      private
-
-      def original_method
-        @object_reference.when_loaded do |m|
-          self.defined? && find_method(m)
-        end
-      end
-
       def self.instance_method_visibility_for(klass, method_name)
         if klass.public_method_defined?(method_name)
           :public
@@ -82,23 +79,40 @@ module RSpec
       end
 
       def self.method_visibility_for(object, method_name)
-        instance_method_visibility_for(class << object; self; end, method_name).tap do |vis|
-          # If the method is not defined on the class, `instance_method_visibility_for`
-          # returns `nil`. However, it may be handled dynamically by `method_missing`,
-          # so here we check `respond_to` (passing false to not check private methods).
-          #
-          # This only considers the public case, but I don't think it's possible to
-          # write `method_missing` in such a way that it handles a dynamic message
-          # with private or protected visibility. Ruby doesn't provide you with
-          # the caller info.
-          return :public if vis.nil? && object.respond_to?(method_name, false)
+        vis = instance_method_visibility_for(class << object; self; end, method_name)
+
+        # If the method is not defined on the class, `instance_method_visibility_for`
+        # returns `nil`. However, it may be handled dynamically by `method_missing`,
+        # so here we check `respond_to` (passing false to not check private methods).
+        #
+        # This only considers the public case, but I don't think it's possible to
+        # write `method_missing` in such a way that it handles a dynamic message
+        # with private or protected visibility. Ruby doesn't provide you with
+        # the caller info.
+        return vis unless vis.nil?
+
+        proxy = RSpec::Mocks.space.proxy_for(object)
+        respond_to = proxy.method_double_if_exists_for_message(:respond_to?)
+
+        visible = respond_to && respond_to.original_method.call(method_name) ||
+          object.respond_to?(method_name)
+
+        return :public if visible
+      end
+
+    private
+
+      def original_method
+        @object_reference.when_loaded do |m|
+          self.defined? && find_method(m)
         end
       end
     end
 
     # @private
     class InstanceMethodReference < MethodReference
-      private
+    private
+
       def method_implemented?(mod)
         MethodReference.method_defined_at_any_visibility?(mod, @method_name)
       end
@@ -116,7 +130,7 @@ module RSpec
       #
       # This is necessary due to a bug in JRuby prior to 1.7.5 fixed in:
       # https://github.com/jruby/jruby/commit/99a0613fe29935150d76a9a1ee4cf2b4f63f4a27
-      if RUBY_PLATFORM == 'java' && JRUBY_VERSION.split('.')[-1].to_i < 5
+      if RUBY_PLATFORM == 'java' && RSpec::Support::ComparableVersion.new(JRUBY_VERSION) < '1.7.5'
         def find_method(mod)
           mod.dup.instance_method(@method_name)
         end
@@ -133,7 +147,16 @@ module RSpec
 
     # @private
     class ObjectMethodReference < MethodReference
-      private
+      def self.for(object_reference, method_name)
+        if ClassNewMethodReference.applies_to?(method_name) { object_reference.when_loaded { |o| o } }
+          ClassNewMethodReference.new(object_reference, method_name)
+        else
+          super
+        end
+      end
+
+    private
+
       def method_implemented?(object)
         object.respond_to?(@method_name, true)
       end
@@ -150,5 +173,42 @@ module RSpec
         MethodReference.method_visibility_for(object, @method_name)
       end
     end
+
+    # When a class's `.new` method is stubbed, we want to use the method
+    # signature from `#initialize` because `.new`'s signature is a generic
+    # `def new(*args)` and it simply delegates to `#initialize` and forwards
+    # all args...so the method with the actually used signature is `#initialize`.
+    #
+    # This method reference implementation handles that specific case.
+    # @private
+    class ClassNewMethodReference < ObjectMethodReference
+      def self.applies_to?(method_name)
+        return false unless method_name == :new
+        klass = yield
+        return false unless ::Class === klass && klass.respond_to?(:new, true)
+
+        # We only want to apply our special logic to normal `new` methods.
+        # Methods that the user has monkeyed with should be left as-is.
+        uses_class_new?(klass)
+      end
+
+      if RUBY_VERSION.to_i >= 3
+        CLASS_NEW = ::Class.instance_method(:new)
+
+        def self.uses_class_new?(klass)
+          ::RSpec::Support.method_handle_for(klass, :new) == CLASS_NEW.bind(klass)
+        end
+      else # Ruby 2's Method#== is too strict
+        def self.uses_class_new?(klass)
+          ::RSpec::Support.method_handle_for(klass, :new).owner == ::Class
+        end
+      end
+
+      def with_signature
+        @object_reference.when_loaded do |klass|
+          yield Support::MethodSignature.new(klass.instance_method(:initialize))
+        end
+      end
+    end
   end
 end

data/lib/rspec/mocks/minitest_integration.rb

@@ -0,0 +1,68 @@
+require 'rspec/mocks'
+
+module RSpec
+  module Mocks
+    # @private
+    module MinitestIntegration
+      include ::RSpec::Mocks::ExampleMethods
+
+      def before_setup
+        ::RSpec::Mocks.setup
+        super
+      end
+
+      def after_teardown
+        super
+
+        # Only verify if there's not already an error. Otherwise
+        # we risk getting the same failure twice, since negative
+        # expectation violations raise both when the message is
+        # unexpectedly received, and also during `verify` (in case
+        # the first failure was caught by user code via a
+        # `rescue Exception`).
+        ::RSpec::Mocks.verify unless failures.any?
+      ensure
+        ::RSpec::Mocks.teardown
+      end
+    end
+  end
+end
+
+Minitest::Test.send(:include, RSpec::Mocks::MinitestIntegration)
+
+if defined?(::Minitest::Expectation)
+  if defined?(::RSpec::Expectations) && ::Minitest::Expectation.method_defined?(:to)
+    # rspec/expectations/minitest_integration has already been loaded and
+    # has defined `to`/`not_to`/`to_not` on `Minitest::Expectation` so we do
+    # not want to here (or else we would interfere with rspec-expectations' definition).
+  else
+    # ...otherwise, define those methods now. If `rspec/expectations/minitest_integration`
+    # is loaded after this file, it'll override the definition here.
+    Minitest::Expectation.class_eval do
+      include RSpec::Mocks::ExpectationTargetMethods
+
+      def to(*args)
+        ctx.assertions += 1
+        super
+      end
+
+      def not_to(*args)
+        ctx.assertions += 1
+        super
+      end
+
+      def to_not(*args)
+        ctx.assertions += 1
+        super
+      end
+    end
+  end
+end
+
+module RSpec
+  module Mocks
+    remove_const :MockExpectationError
+    # Raised when a message expectation is not satisfied.
+    MockExpectationError = ::Minitest::Assertion
+  end
+end