rspec-mocks 2.13.1 → 2.14.0.rc1

data/lib/rspec/mocks/method_double.rb

@@ -40,6 +40,14 @@ module RSpec
         end
       end
 
+      class ProcWithBlock < Struct.new(:object, :method_name)
+
+        def call(*args, &block)
+          self.object.__send__(:method_missing, self.method_name, *args, &block)
+        end
+
+      end
+
       # @private
       def original_method
         if @method_stasher.method_is_stashed?
@@ -55,48 +63,58 @@ module RSpec
           # object rather than the proxy method.
           meth
         else
-          begin
-            # Example: an instance method defined on one of @object's ancestors.
-            original_method_from_ancestor(object_singleton_class.ancestors)
-          rescue NameError
-            raise unless @object.respond_to?(:superclass)
-
-            # Example: a singleton method defined on @object's superclass.
-            #
-            # Note: we have to give precedence to instance methods
-            # defined on @object's class, because in a case like:
-            #
-            # `klass.should_receive(:new).and_call_original`
-            #
-            # ...we want `Class#new` bound to `klass` (which will return
-            # an instance of `klass`), not `klass.superclass.new` (which
-            # would return an instance of `klass.superclass`).
-            original_method_from_superclass
-          end
+          # Example: an instance method defined on one of @object's ancestors.
+          original_method_from_ancestry
         end
       rescue NameError
         # We have no way of knowing if the object's method_missing
         # will handle this message or not...but we can at least try.
         # If it's not handled, a `NoMethodError` will be raised, just
         # like normally.
-        Proc.new do |*args, &block|
-          @object.__send__(:method_missing, @method_name, *args, &block)
-        end
+        ProcWithBlock.new(@object,@method_name)
       end
 
       def original_unrecorded_any_instance_method
         return nil unless any_instance_class_recorder_observing_method?(@object.class)
-        alias_name = @object.class.__recorder.build_alias_method_name(@method_name)
+        alias_name = ::RSpec::Mocks.any_instance_recorder_for(@object.class).build_alias_method_name(@method_name)
         @object.method(alias_name)
       end
 
       def any_instance_class_recorder_observing_method?(klass)
-        return true if klass.__recorder.already_observing?(@method_name)
+        return true if ::RSpec::Mocks.any_instance_recorder_for(klass).already_observing?(@method_name)
         superklass = klass.superclass
         return false if superklass.nil?
         any_instance_class_recorder_observing_method?(superklass)
       end
 
+      our_singleton_class = class << self; self; end
+      if our_singleton_class.ancestors.include? our_singleton_class
+        # In Ruby 2.1, ancestors include the correct ancestors, including the singleton classes
+        def original_method_from_ancestry
+          # Lookup in the ancestry, skipping over the singleton class itself
+          original_method_from_ancestor(object_singleton_class.ancestors.drop(1))
+        end
+      else
+        # @private
+        def original_method_from_ancestry
+          original_method_from_ancestor(object_singleton_class.ancestors)
+        rescue NameError
+          raise unless @object.respond_to?(:superclass)
+
+          # Example: a singleton method defined on @object's superclass.
+          #
+          # Note: we have to give precedence to instance methods
+          # defined on @object's class, because in a case like:
+          #
+          # `klass.should_receive(:new).and_call_original`
+          #
+          # ...we want `Class#new` bound to `klass` (which will return
+          # an instance of `klass`), not `klass.superclass.new` (which
+          # would return an instance of `klass.superclass`).
+          original_method_from_superclass
+        end
+      end
+
       def original_method_from_ancestor(ancestors)
         klass, *rest = ancestors
         klass.instance_method(@method_name).bind(@object)
@@ -142,8 +160,6 @@ module RSpec
 
       # @private
       def configure_method
-        RSpec::Mocks::space.add(@object) if RSpec::Mocks::space
-        warn_if_nil_class
         @original_visibility = visibility_for_method
         @method_stasher.stash unless @method_is_proxied
         define_proxy_method
@@ -155,7 +171,7 @@ module RSpec
 
         object_singleton_class.class_eval <<-EOF, __FILE__, __LINE__ + 1
           def #{@method_name}(*args, &block)
-            __mock_proxy.message_received :#{@method_name}, *args, &block
+            ::RSpec::Mocks.proxy_for(self).message_received :#{@method_name}, *args, &block
           end
           #{visibility_for_method}
         EOF
@@ -191,7 +207,6 @@ module RSpec
 
       # @private
       def reset
-        reset_nil_expectations_warning
         restore_original_method
         clear
       end
@@ -220,6 +235,12 @@ module RSpec
         expectation
       end
 
+      # @private
+      def build_expectation(error_generator, expectation_ordering)
+        expected_from = IGNORED_BACKTRACE_LINE
+        MessageExpectation.new(error_generator, expectation_ordering, expected_from, self)
+      end
+
       # @private
       def add_stub(error_generator, expectation_ordering, expected_from, opts={}, &implementation)
         configure_method
@@ -241,27 +262,13 @@ module RSpec
         expectations.empty? ? reset : stubs.clear
       end
 
-      # @private
-      def proxy_for_nil_class?
-        NilClass === @object
-      end
-
-      # @private
-      def warn_if_nil_class
-        if proxy_for_nil_class? & RSpec::Mocks::Proxy.warn_about_expectations_on_nil
-          Kernel.warn("An expectation of :#{@method_name} was set on nil. Called from #{caller[4]}. Use allow_message_expectations_on_nil to disable warnings.")
-        end
-      end
-
       # @private
       def raise_method_not_stubbed_error
-        raise MockExpectationError, "The method `#{method_name}` was not stubbed or was already unstubbed" 
+        raise MockExpectationError, "The method `#{method_name}` was not stubbed or was already unstubbed"
       end
 
       # @private
-      def reset_nil_expectations_warning
-        RSpec::Mocks::Proxy.warn_about_expectations_on_nil = true if proxy_for_nil_class?
-      end
+      IGNORED_BACKTRACE_LINE = 'this backtrace line is ignored'
     end
   end
 end

data/lib/rspec/mocks/mutate_const.rb

@@ -83,6 +83,9 @@ module RSpec
       # @api private
       def initialize(name)
         @name = name
+        @previously_defined = false
+        @stubbed = false
+        @hidden = false
       end
 
       # @return [String] The fully qualified name of the constant.
@@ -222,7 +225,7 @@ module RSpec
           @context = recursive_const_get(@context_parts.join('::'))
           @original_value = get_const_defined_on(@context, @const_name)
 
-          @context.send(:remove_const, @const_name)
+          @context.__send__(:remove_const, @const_name)
         end
 
         def to_constant
@@ -248,7 +251,7 @@ module RSpec
 
           constants_to_transfer = verify_constants_to_transfer!
 
-          @context.send(:remove_const, @const_name)
+          @context.__send__(:remove_const, @const_name)
           @context.const_set(@const_name, @mutated_value)
 
           transfer_nested_constants(constants_to_transfer)
@@ -263,7 +266,7 @@ module RSpec
         end
 
         def rspec_reset
-          @context.send(:remove_const, @const_name)
+          @context.__send__(:remove_const, @const_name)
           @context.const_set(@const_name, @original_value)
         end
 
@@ -333,7 +336,7 @@ module RSpec
         end
 
         def rspec_reset
-          @deepest_defined_const.send(:remove_const, @const_to_remove)
+          @deepest_defined_const.__send__(:remove_const, @const_to_remove)
         end
       end
 
@@ -345,27 +348,13 @@ module RSpec
       def self.mutate(mutator)
         register_mutator(mutator)
         mutator.mutate
-        ensure_registered_with_mocks_space
-      end
-
-      # Ensures the constant stubbing is registered with
-      # rspec-mocks space so that stubbed constants can
-      # be restored when examples finish.
-      #
-      # @api private
-      def self.ensure_registered_with_mocks_space
-        return if defined?(@registered_with_mocks_space) && @registered_with_mocks_space
-        ::RSpec::Mocks.space.add(self)
-        @registered_with_mocks_space = true
       end
 
       # Resets all stubbed constants. This is called automatically
       # by rspec-mocks when an example finishes.
       #
       # @api private
-      def self.rspec_reset
-        @registered_with_mocks_space = false
-
+      def self.reset_all
         # We use reverse order so that if the same constant
         # was stubbed multiple times, the original value gets
         # properly restored.
@@ -412,4 +401,3 @@ module RSpec
     ConstantStubber = ConstantMutator
   end
 end
-

data/lib/rspec/mocks/proxy.rb

@@ -2,31 +2,6 @@ module RSpec
   module Mocks
     # @private
     class Proxy
-      class << self
-        # @private
-        def warn_about_expectations_on_nil
-          defined?(@warn_about_expectations_on_nil) ? @warn_about_expectations_on_nil : true
-        end
-
-        # @private
-        def warn_about_expectations_on_nil=(new_value)
-          @warn_about_expectations_on_nil = new_value
-        end
-
-        # @private
-        def allow_message_expectations_on_nil
-          @warn_about_expectations_on_nil = false
-
-          # ensure nil.rspec_verify is called even if an expectation is not set in the example
-          # otherwise the allowance would effect subsequent examples
-          RSpec::Mocks::space.add(nil) unless RSpec::Mocks::space.nil?
-        end
-
-        # @private
-        def allow_message_expectations_on_nil?
-          !warn_about_expectations_on_nil
-        end
-      end
 
       # @private
       def initialize(object, name=nil, options={})
@@ -81,6 +56,45 @@ module RSpec
         method_double[method_name].add_negative_expectation @error_generator, @expectation_ordering, location, &implementation
       end
 
+      # @private
+      def build_expectation(method_name)
+        meth_double = method_double[method_name]
+
+        meth_double.build_expectation(
+          @error_generator,
+          @expectation_ordering
+        )
+      end
+
+      # @private
+      def replay_received_message_on(expectation)
+        expected_method_name = expectation.message
+        meth_double = method_double[expected_method_name]
+
+        if meth_double.expectations.any?
+          @error_generator.raise_expectation_on_mocked_method(expected_method_name)
+        end
+
+        unless null_object? || meth_double.stubs.any?
+          @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)
+          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)
+          end
+        end
+      end
+
       # @private
       def add_stub(location, method_name, opts={}, &implementation)
         method_double[method_name].add_stub @error_generator, @expectation_ordering, location, opts, &implementation
@@ -101,6 +115,7 @@ module RSpec
       # @private
       def reset
         method_doubles.each {|d| d.reset}
+        @messages_received.clear
       end
 
       # @private
@@ -120,6 +135,7 @@ module RSpec
 
       # @private
       def message_received(message, *args, &block)
+        record_message_received message, *args, &block
         expectation = find_matching_expectation(message, *args)
         stub = find_matching_method_stub(message, *args)
 

data/lib/rspec/mocks/proxy_for_nil.rb

@@ -0,0 +1,36 @@
+module RSpec
+  module Mocks
+    # @private
+    class ProxyForNil < Proxy
+
+      def initialize
+        @warn_about_expectations = true
+        super nil
+      end
+      attr_accessor :warn_about_expectations
+      alias warn_about_expectations? warn_about_expectations
+
+      def add_message_expectation(location, 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?
+        super
+      end
+
+      def add_stub(location, method_name, opts={}, &implementation)
+        warn(method_name) if warn_about_expectations?
+        super
+      end
+
+      private
+
+      def warn method_name
+        Kernel.warn("An expectation of :#{method_name} was set on nil. Called from #{caller[2]}. Use allow_message_expectations_on_nil to disable warnings.")
+      end
+
+    end
+  end
+end

data/lib/rspec/mocks/space.rb

@@ -2,21 +2,32 @@ module RSpec
   module Mocks
     # @api private
     class Space
-      def add(obj)
-        receivers << obj unless receivers.detect {|m| m.equal? obj}
+      attr_reader :proxies, :any_instance_recorders
+
+      def initialize
+        @proxies = {}
+        @any_instance_recorders = {}
       end
 
       def verify_all
-        receivers.each do |mock|
-          mock.rspec_verify
+        proxies.each_value do |object|
+          object.verify
+        end
+
+        any_instance_recorders.each_value do |recorder|
+          recorder.verify
         end
       end
 
       def reset_all
-        receivers.each do |mock|
-          mock.rspec_reset
+        ConstantMutator.reset_all
+
+        proxies.each_value do |object|
+          object.reset
         end
-        receivers.clear
+
+        proxies.clear
+        any_instance_recorders.clear
         expectation_ordering.clear
       end
 
@@ -24,10 +35,52 @@ module RSpec
         @expectation_ordering ||= OrderGroup.new
       end
 
-    private
-    
-      def receivers
-        @receivers ||= []
+      def any_instance_recorder_for(klass)
+        id = klass.__id__
+        any_instance_recorders.fetch(id) do
+          any_instance_recorders[id] = AnyInstance::Recorder.new(klass)
+        end
+      end
+
+      def remove_any_instance_recorder_for(klass)
+        any_instance_recorders.delete(klass.__id__)
+      end
+
+      def proxy_for(object)
+        id = id_for(object)
+        proxies.fetch(id) do
+          proxies[id] = case object
+                        when NilClass   then ProxyForNil.new
+                        when TestDouble then object.__build_mock_proxy
+                        else
+                          Proxy.new(object)
+                        end
+        end
+      end
+
+      alias ensure_registered proxy_for
+
+      def registered?(object)
+        proxies.has_key?(id_for object)
+      end
+
+      if defined?(::BasicObject) && !::BasicObject.method_defined?(:__id__) # for 1.9.2
+        require 'securerandom'
+
+        def id_for(object)
+          id = object.__id__
+
+          return id if object.equal?(::ObjectSpace._id2ref(id))
+          # this suggests that object.__id__ is proxying through to some wrapped object
+
+          object.instance_eval do
+            @__id_for_rspec_mocks_space ||= ::SecureRandom.uuid
+          end
+        end
+      else
+        def id_for(object)
+          object.__id__
+        end
       end
     end
   end