rspec-mocks 3.0.4 → 3.12.6

data/lib/rspec/mocks/proxy.rb

@@ -2,29 +2,45 @@ module RSpec
   module Mocks
     # @private
     class Proxy
+      # @private
       SpecificMessage = Struct.new(:object, :message, :args) do
         def ==(expectation)
           expectation.orig_object == object && expectation.matches?(message, *args)
         end
       end
 
+      unless defined?(Mutex)
+        Support.require_rspec_support 'mutex'
+        Mutex = Support::Mutex
+      end
+
       # @private
-      def ensure_implemented(*args)
+      def ensure_implemented(*_args)
         # noop for basic proxies, see VerifyingProxy for behaviour.
       end
 
       # @private
-      def initialize(object, order_group, name=nil, options={})
+      def initialize(object, order_group, options={})
+        ensure_can_be_proxied!(object)
+
         @object = object
         @order_group = order_group
-        @name = name
-        @error_generator = ErrorGenerator.new(object, name)
+        @error_generator = ErrorGenerator.new(object)
         @messages_received = []
+        @messages_received_mutex = Mutex.new
         @options = options
         @null_object = false
         @method_doubles = Hash.new { |h, k| h[k] = MethodDouble.new(@object, k, self) }
       end
 
+      # @private
+      def ensure_can_be_proxied!(object)
+        return unless object.is_a?(Symbol)
+
+        msg = "Cannot proxy frozen objects. Symbols such as #{object} cannot be mocked or stubbed."
+        raise ArgumentError, msg
+      end
+
       # @private
       attr_reader :object
 
@@ -42,12 +58,14 @@ module RSpec
       end
 
       # @private
-      def original_method_handle_for(message)
+      def original_method_handle_for(_message)
         nil
       end
 
+      DEFAULT_MESSAGE_EXPECTATION_OPTS = {}.freeze
+
       # @private
-      def add_message_expectation(method_name, opts={}, &block)
+      def add_message_expectation(method_name, opts=DEFAULT_MESSAGE_EXPECTATION_OPTS, &block)
         location = opts.fetch(:expected_from) { CallerFilter.first_non_rspec_line }
         meth_double = method_double_for(method_name)
 
@@ -88,21 +106,30 @@ module RSpec
           @error_generator.raise_expectation_on_unstubbed_method(expected_method_name)
         end
 
-        @messages_received.each do |(actual_method_name, args, _)|
-          if expectation.matches?(actual_method_name, *args)
-            expectation.invoke(nil)
-            block.call(*args) if block
+        @messages_received_mutex.synchronize do
+          @messages_received.each do |(actual_method_name, args, received_block)|
+            next unless expectation.matches?(actual_method_name, *args)
+
+            expectation.safe_invoke(nil)
+            block.call(*args, &received_block) if block
           end
         end
-
       end
 
       # @private
       def check_for_unexpected_arguments(expectation)
-        @messages_received.each do |(method_name, args, _)|
-          if expectation.matches_name_but_not_args(method_name, *args)
-            raise_unexpected_message_args_error(expectation, *args)
+        @messages_received_mutex.synchronize do
+          return if @messages_received.empty?
+
+          return if @messages_received.any? { |method_name, args, _| expectation.matches?(method_name, *args) }
+
+          name_but_not_args, others = @messages_received.partition do |(method_name, args, _)|
+            expectation.matches_name_but_not_args(method_name, *args)
           end
+
+          return if name_but_not_args.empty? && !others.empty?
+
+          expectation.raise_unexpected_message_args_error(name_but_not_args.map { |args| args[1] })
         end
       end
 
@@ -129,29 +156,43 @@ module RSpec
 
       # @private
       def verify
-        @method_doubles.each_value {|d| d.verify}
+        @method_doubles.each_value { |d| d.verify }
       end
 
       # @private
       def reset
-        @messages_received.clear
+        @messages_received_mutex.synchronize do
+          @messages_received.clear
+        end
       end
 
       # @private
       def received_message?(method_name, *args, &block)
-        @messages_received.any? {|array| array == [method_name, args, block]}
+        @messages_received_mutex.synchronize do
+          @messages_received.any? { |array| array == [method_name, args, block] }
+        end
+      end
+
+      # @private
+      def messages_arg_list
+        @messages_received_mutex.synchronize do
+          @messages_received.map { |_, args, _| args }
+        end
       end
 
       # @private
       def has_negative_expectation?(message)
-        method_double_for(message).expectations.detect {|expectation| expectation.negative_expectation_for?(message)}
+        method_double_for(message).expectations.find { |expectation| expectation.negative_expectation_for?(message) }
       end
 
       # @private
       def record_message_received(message, *args, &block)
         @order_group.invoked SpecificMessage.new(object, message, args)
-        @messages_received << [message, args, block]
+        @messages_received_mutex.synchronize do
+          @messages_received << [message, args, block]
+        end
       end
+      ruby2_keywords :record_message_received if respond_to?(:ruby2_keywords, true)
 
       # @private
       def message_received(message, *args, &block)
@@ -162,57 +203,67 @@ module RSpec
 
         if (stub && expectation && expectation.called_max_times?) || (stub && !expectation)
           expectation.increase_actual_received_count! if expectation && expectation.actual_received_count_matters?
-          if expectation = find_almost_matching_expectation(message, *args)
+          if (expectation = find_almost_matching_expectation(message, *args))
             expectation.advise(*args) unless expectation.expected_messages_received?
           end
           stub.invoke(nil, *args, &block)
         elsif expectation
+          expectation.unadvise(messages_arg_list)
           expectation.invoke(stub, *args, &block)
-        elsif expectation = find_almost_matching_expectation(message, *args)
+        elsif (expectation = find_almost_matching_expectation(message, *args))
           expectation.advise(*args) if null_object? unless expectation.expected_messages_received?
-          raise_unexpected_message_args_error(expectation, *args) unless (has_negative_expectation?(message) or null_object?)
-        elsif stub = find_almost_matching_stub(message, *args)
+
+          if null_object? || !has_negative_expectation?(message)
+            expectation.raise_unexpected_message_args_error([args])
+          end
+        elsif (stub = find_almost_matching_stub(message, *args))
           stub.advise(*args)
-          raise_missing_default_stub_error(stub, *args)
+          raise_missing_default_stub_error(stub, [args])
         elsif Class === @object
           @object.superclass.__send__(message, *args, &block)
         else
           @object.__send__(:method_missing, message, *args, &block)
         end
       end
+      ruby2_keywords :message_received if respond_to?(:ruby2_keywords, true)
 
       # @private
-      def raise_unexpected_message_error(method_name, *args)
-        @error_generator.raise_unexpected_message_error method_name, *args
+      def raise_unexpected_message_error(method_name, args)
+        @error_generator.raise_unexpected_message_error method_name, args
       end
 
       # @private
-      def raise_unexpected_message_args_error(expectation, *args)
-        @error_generator.raise_unexpected_message_args_error(expectation, *args)
+      def raise_missing_default_stub_error(expectation, args_for_multiple_calls)
+        @error_generator.raise_missing_default_stub_error(expectation, args_for_multiple_calls)
       end
 
       # @private
-      def raise_missing_default_stub_error(expectation, *args)
-        @error_generator.raise_missing_default_stub_error(expectation, *args)
-      end
-
-      # @private
-      def visibility_for(method_name)
+      def visibility_for(_method_name)
         # This is the default (for test doubles). Subclasses override this.
         :public
       end
 
       if Support::RubyFeatures.module_prepends_supported?
+        def self.prepended_modules_of(klass)
+          ancestors = klass.ancestors
+
+          # `|| 0` is necessary for Ruby 2.0, where the singleton class
+          # is only in the ancestor list when there are prepended modules.
+          singleton_index = ancestors.index(klass) || 0
+
+          ancestors[0, singleton_index]
+        end
+
         def prepended_modules_of_singleton_class
-          @prepended_modules_of_singleton_class ||= begin
-            singleton_class = @object.singleton_class
-            singleton_class.ancestors.take_while do |mod|
-              !(Class === mod || @object.equal?(mod))
-            end
-          end
+          @prepended_modules_of_singleton_class ||= RSpec::Mocks::Proxy.prepended_modules_of(@object.singleton_class)
         end
       end
 
+      # @private
+      def method_double_if_exists_for_message(message)
+        method_double_for(message) if @method_doubles.key?(message.to_sym)
+      end
+
     private
 
       def method_double_for(message)
@@ -224,12 +275,14 @@ module RSpec
           expectation.matches?(method_name, *args)
         end
       end
+      ruby2_keywords :find_matching_expectation if respond_to?(:ruby2_keywords, true)
 
       def find_almost_matching_expectation(method_name, *args)
         find_best_matching_expectation_for(method_name) do |expectation|
           expectation.matches_name_but_not_args(method_name, *args)
         end
       end
+      ruby2_keywords :find_almost_matching_expectation if respond_to?(:ruby2_keywords, true)
 
       def find_best_matching_expectation_for(method_name)
         first_match = nil
@@ -244,12 +297,14 @@ module RSpec
       end
 
       def find_matching_method_stub(method_name, *args)
-        method_double_for(method_name).stubs.find {|stub| stub.matches?(method_name, *args)}
+        method_double_for(method_name).stubs.find { |stub| stub.matches?(method_name, *args) }
       end
+      ruby2_keywords :find_matching_method_stub if respond_to?(:ruby2_keywords, true)
 
       def find_almost_matching_stub(method_name, *args)
-        method_double_for(method_name).stubs.find {|stub| stub.matches_name_but_not_args(method_name, *args)}
+        method_double_for(method_name).stubs.find { |stub| stub.matches_name_but_not_args(method_name, *args) }
       end
+      ruby2_keywords :find_almost_matching_stub if respond_to?(:ruby2_keywords, true)
     end
 
     # @private
@@ -295,7 +350,7 @@ module RSpec
       end
 
       def reset
-        @method_doubles.each_value {|d| d.reset}
+        @method_doubles.each_value { |d| d.reset }
         super
       end
 
@@ -305,6 +360,7 @@ module RSpec
         end
         super
       end
+      ruby2_keywords :message_received if respond_to?(:ruby2_keywords, true)
 
     private
 
@@ -356,27 +412,43 @@ module RSpec
 
         return super unless unbound_method
         unbound_method.bind(object)
+        # :nocov:
+      rescue TypeError
+        if RUBY_VERSION == '1.8.7'
+          # In MRI 1.8.7, a singleton method on a class cannot be rebound to its subclass
+          if unbound_method && unbound_method.owner.ancestors.first != unbound_method.owner
+            # This is a singleton method; we can't do anything with it
+            # But we can work around this using a different implementation
+            double = method_double_from_ancestor_for(message)
+            return object.method(double.method_stasher.stashed_method_name)
+          end
+        end
+        raise
+        # :nocov:
       end
 
     protected
 
       def original_unbound_method_handle_from_ancestor_for(message)
-        method_double = @method_doubles.fetch(message) do
+        double = method_double_from_ancestor_for(message)
+        double && double.original_method.unbind
+      end
+
+      def method_double_from_ancestor_for(message)
+        @method_doubles.fetch(message) do
           # The fact that there is no method double for this message indicates
           # that it has not been redefined by rspec-mocks. We need to continue
           # looking up the ancestor chain.
           return superclass_proxy &&
-            superclass_proxy.original_unbound_method_handle_from_ancestor_for(message)
+            superclass_proxy.method_double_from_ancestor_for(message)
         end
-
-        method_double.original_method.unbind
       end
 
       def superclass_proxy
         return @superclass_proxy if defined?(@superclass_proxy)
 
         if (superclass = object.superclass)
-          @superclass_proxy = @source_space.proxy_for(superclass)
+          @superclass_proxy = @source_space.superclass_proxy_for(superclass)
         else
           @superclass_proxy = nil
         end
@@ -391,33 +463,57 @@ module RSpec
     # @private
     class ProxyForNil < PartialDoubleProxy
       def initialize(order_group)
-        @warn_about_expectations = true
+        set_expectation_behavior
         super(nil, order_group)
       end
 
+      attr_accessor :disallow_expectations
       attr_accessor :warn_about_expectations
-      alias warn_about_expectations? warn_about_expectations
 
       def add_message_expectation(method_name, opts={}, &block)
-        warn(method_name) if warn_about_expectations?
-        super
-      end
-
-      def add_negative_message_expectation(location, method_name, &implementation)
-        warn(method_name) if warn_about_expectations?
+        warn_or_raise!(method_name)
         super
       end
 
       def add_stub(method_name, opts={}, &implementation)
-        warn(method_name) if warn_about_expectations?
+        warn_or_raise!(method_name)
         super
       end
 
     private
 
-      def warn method_name
-        source = CallerFilter.first_non_rspec_line
-        Kernel.warn("An expectation of :#{method_name} was set on nil. Called from #{source}. Use allow_message_expectations_on_nil to disable warnings.")
+      def set_expectation_behavior
+        case RSpec::Mocks.configuration.allow_message_expectations_on_nil
+        when false
+          @warn_about_expectations = false
+          @disallow_expectations = true
+        when true
+          @warn_about_expectations = false
+          @disallow_expectations = false
+        else
+          @warn_about_expectations = true
+          @disallow_expectations = false
+        end
+      end
+
+      def warn_or_raise!(method_name)
+        # This method intentionally swallows the message when
+        # neither disallow_expectations nor warn_about_expectations
+        # are set to true.
+        if disallow_expectations
+          raise_error(method_name)
+        elsif warn_about_expectations
+          warn(method_name)
+        end
+      end
+
+      def warn(method_name)
+        warning_msg = @error_generator.expectation_on_nil_message(method_name)
+        RSpec.warning(warning_msg)
+      end
+
+      def raise_error(method_name)
+        @error_generator.raise_expectation_on_nil_error(method_name)
       end
     end
   end

data/lib/rspec/mocks/space.rb

@@ -1,3 +1,5 @@
+RSpec::Support.require_rspec_support 'reentrant_mutex'
+
 module RSpec
   module Mocks
     # @private
@@ -5,23 +7,23 @@ module RSpec
     # the scope of an example. Called "root" because it serves
     # as the root of the space stack.
     class RootSpace
-      def proxy_for(*args)
+      def proxy_for(*_args)
         raise_lifecycle_message
       end
 
-      def any_instance_recorder_for(*args)
+      def any_instance_recorder_for(*_args)
         raise_lifecycle_message
       end
 
-      def any_instance_proxy_for(*args)
+      def any_instance_proxy_for(*_args)
         raise_lifecycle_message
       end
 
-      def register_constant_mutator(mutator)
+      def register_constant_mutator(_mutator)
         raise_lifecycle_message
       end
 
-      def any_instance_recorders_from_ancestry_of(object)
+      def any_instance_recorders_from_ancestry_of(_object)
         raise_lifecycle_message
       end
 
@@ -31,10 +33,14 @@ module RSpec
       def verify_all
       end
 
-      def registered?(object)
+      def registered?(_object)
         false
       end
 
+      def superclass_proxy_for(*_args)
+        raise_lifecycle_message
+      end
+
       def new_scope
         Space.new
       end
@@ -43,7 +49,7 @@ module RSpec
 
       def raise_lifecycle_message
         raise OutsideOfExampleError,
-          "The use of doubles or partial doubles from rspec-mocks outside of the per-test lifecycle is not supported."
+              "The use of doubles or partial doubles from rspec-mocks outside of the per-test lifecycle is not supported."
       end
     end
 
@@ -71,9 +77,9 @@ module RSpec
 
       def reset_all
         proxies.each_value { |proxy| proxy.reset }
-        @constant_mutators.reverse.each { |mut| mut.idempotently_reset }
         any_instance_recorders.each_value { |recorder| recorder.stop_all_observation! }
         any_instance_recorders.clear
+        @constant_mutators.reverse.each { |mut| mut.idempotently_reset }
       end
 
       def register_constant_mutator(mutator)
@@ -84,7 +90,7 @@ module RSpec
         @constant_mutators.find { |m| m.full_constant_name == name }
       end
 
-      def any_instance_recorder_for(klass, only_return_existing = false)
+      def any_instance_recorder_for(klass, only_return_existing=false)
         any_instance_mutex.synchronize do
           id = klass.__id__
           any_instance_recorders.fetch(id) do
@@ -109,10 +115,17 @@ module RSpec
         end
       end
 
+      def superclass_proxy_for(klass)
+        proxy_mutex.synchronize do
+          id = id_for(klass)
+          proxies.fetch(id) { superclass_proxy_not_found_for(id, klass) }
+        end
+      end
+
       alias ensure_registered proxy_for
 
       def registered?(object)
-        proxies.has_key?(id_for object)
+        proxies.key?(id_for object)
       end
 
       def any_instance_recorders_from_ancestry_of(object)
@@ -131,36 +144,40 @@ module RSpec
 
     private
 
-      # We don't want to depend on the stdlib ourselves, but if the user is
-      # using threads then a Mutex will be available to us. If not, we don't
-      # need to synchronize anyway.
       def new_mutex
-        defined?(::Mutex) ? ::Mutex.new : FakeMutex
-      end
-
-      # @private
-      module FakeMutex
-        def self.synchronize
-          yield
-        end
+        Support::ReentrantMutex.new
       end
 
       def proxy_not_found_for(id, object)
         proxies[id] = case object
-          when NilClass   then ProxyForNil.new(@expectation_ordering)
-          when TestDouble then object.__build_mock_proxy_unless_expired(@expectation_ordering)
-          when Class
-            if RSpec::Mocks.configuration.verify_partial_doubles?
-              VerifyingPartialClassDoubleProxy.new(self, object, @expectation_ordering)
-            else
-              PartialClassDoubleProxy.new(self, object, @expectation_ordering)
-            end
-          else
-            if RSpec::Mocks.configuration.verify_partial_doubles?
-              VerifyingPartialDoubleProxy.new(object, @expectation_ordering)
-            else
-              PartialDoubleProxy.new(object, @expectation_ordering)
-            end
+                      when NilClass   then ProxyForNil.new(@expectation_ordering)
+                      when TestDouble then object.__build_mock_proxy_unless_expired(@expectation_ordering)
+                      when Class
+                        class_proxy_with_callback_verification_strategy(object, CallbackInvocationStrategy.new)
+                      else
+                        if RSpec::Mocks.configuration.verify_partial_doubles?
+                          VerifyingPartialDoubleProxy.new(object, @expectation_ordering)
+                        else
+                          PartialDoubleProxy.new(object, @expectation_ordering)
+                        end
+                      end
+      end
+
+      def superclass_proxy_not_found_for(id, object)
+        raise "superclass_proxy_not_found_for called with something that is not a class" unless Class === object
+        proxies[id] = class_proxy_with_callback_verification_strategy(object, NoCallbackInvocationStrategy.new)
+      end
+
+      def class_proxy_with_callback_verification_strategy(object, strategy)
+        if RSpec::Mocks.configuration.verify_partial_doubles?
+          VerifyingPartialClassDoubleProxy.new(
+            self,
+            object,
+            @expectation_ordering,
+            strategy
+          )
+        else
+          PartialClassDoubleProxy.new(self, object, @expectation_ordering)
         end
       end
 

data/lib/rspec/mocks/standalone.rb

@@ -1,3 +1,3 @@
 require 'rspec/mocks'
-include RSpec::Mocks::ExampleMethods
+extend RSpec::Mocks::ExampleMethods
 RSpec::Mocks.setup