rspec-mocks 3.1.3 → 3.2.0

data/lib/rspec/mocks/method_double.rb

@@ -78,8 +78,7 @@ module RSpec
         return show_frozen_warning if object_singleton_class.frozen?
         return unless @method_is_proxied
 
-        definition_target.__send__(:remove_method, @method_name)
-
+        remove_method_from_definition_target
         @method_stasher.restore if @method_stasher.method_is_stashed?
         restore_original_visibility
 
@@ -255,6 +254,30 @@ module RSpec
         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/mutate_const.rb

@@ -13,6 +13,8 @@ module RSpec
         @previously_defined = false
         @stubbed = false
         @hidden = false
+        @valid_name = true
+        yield self if block_given?
       end
 
       # @return [String] The fully qualified name of the constant.
@@ -24,7 +26,7 @@ module RSpec
       attr_accessor :original_value
 
       # @private
-      attr_writer :previously_defined, :stubbed, :hidden
+      attr_writer :previously_defined, :stubbed, :hidden, :valid_name
 
       # @return [Boolean] Whether or not the constant was defined
       #   before the current example.
@@ -50,6 +52,12 @@ module RSpec
         @hidden
       end
 
+      # @return [Boolean] Whether or not the provided constant name
+      #   is a valid Ruby constant name.
+      def valid_name?
+        @valid_name
+      end
+
       # The default `to_s` isn't very useful, so a custom version is provided.
       def to_s
         "#<#{self.class.name} #{name}>"
@@ -58,13 +66,16 @@ module RSpec
 
       # @private
       def self.unmutated(name)
-        const = new(name)
-        const.previously_defined = recursive_const_defined?(name)
-        const.stubbed = false
-        const.hidden = false
-        const.original_value = recursive_const_get(name) if const.previously_defined?
-
-        const
+        previously_defined = recursive_const_defined?(name)
+      rescue NameError
+        new(name) do |c|
+          c.valid_name = false
+        end
+      else
+        new(name) do |const|
+          const.previously_defined = previously_defined
+          const.original_value = recursive_const_get(name) if previously_defined
+        end
       end
 
       # Queries rspec-mocks to find out information about the named constant.

data/lib/rspec/mocks/object_reference.rb

@@ -6,8 +6,17 @@ module RSpec
       # on the given argument.
       def self.for(object_module_or_name, allow_direct_object_refs=false)
         case object_module_or_name
-        when Module then DirectModuleReference.new(object_module_or_name)
-        when String then NamedObjectReference.new(object_module_or_name)
+        when Module
+          if anonymous_module?(object_module_or_name)
+            DirectObjectReference.new(object_module_or_name)
+          else
+            # Use a `NamedObjectReference` if it has a name because this
+            # will use the original value of the constant in case it has
+            # been stubbed.
+            NamedObjectReference.new(name_of(object_module_or_name))
+          end
+        when String
+          NamedObjectReference.new(object_module_or_name)
         else
           if allow_direct_object_refs
             DirectObjectReference.new(object_module_or_name)
@@ -17,74 +26,123 @@ module RSpec
           end
         end
       end
+
+      if Module.new.name.nil?
+        def self.anonymous_module?(mod)
+          !name_of(mod)
+        end
+      else # 1.8.7
+        def self.anonymous_module?(mod)
+          name_of(mod) == ""
+        end
+      end
+      private_class_method :anonymous_module?
+
+      def self.name_of(mod)
+        MODULE_NAME_METHOD.bind(mod).call
+      end
+      private_class_method :name_of
+
+      # @private
+      MODULE_NAME_METHOD = Module.instance_method(:name)
     end
 
-    # Used when an object is passed to `object_double`.
+    # An implementation of rspec-mocks' reference interface.
+    # Used when an object is passed to {ExampleMethods#object_double}, or
+    # an anonymous class or module is passed to {ExampleMethods#instance_double}
+    # or {ExampleMethods#class_double}.
     # Represents a reference to that object.
-    #
-    # @private
+    # @see NamedObjectReference
     class DirectObjectReference
+      # @param object [Object] the object to which this refers
       def initialize(object)
         @object = object
       end
 
+      # @return [String] the object's description (via `#inspect`).
       def description
         @object.inspect
       end
 
+      # Defined for interface parity with the other object reference
+      # implementations. Raises an `ArgumentError` to indicate that `as_stubbed_const`
+      # is invalid when passing an object argument to `object_double`.
       def const_to_replace
         raise ArgumentError,
-              "Can not perform constant replacement with an object."
+              "Can not perform constant replacement with an anonymous object."
       end
 
+      # The target of the verifying double (the object itself).
+      #
+      # @return [Object]
+      def target
+        @object
+      end
+
+      # Always returns true for an object as the class is defined.
+      #
+      # @return [true]
       def defined?
         true
       end
 
+      # Yields if the reference target is loaded, providing a generic mechanism
+      # to optionally run a bit of code only when a reference's target is
+      # loaded.
+      #
+      # This specific implementation always yields because direct references
+      # are always loaded.
+      #
+      # @yield [Object] the target of this reference.
       def when_loaded
         yield @object
       end
     end
 
-    # Used when a module is passed to `class_double` or `instance_double`.
-    # Represents a reference to that module.
-    #
-    # @private
-    class DirectModuleReference < DirectObjectReference
-      def const_to_replace
-        @object.name
-      end
-      alias description const_to_replace
-    end
-
-    # Used when a string is passed to `class_double`, `instance_double`
-    # or `object_double`.
+    # An implementation of rspec-mocks' reference interface.
+    # Used when a string is passed to {ExampleMethods#object_double},
+    # and when a string, named class or named module is passed to
+    # {ExampleMethods#instance_double}, or {ExampleMethods#class_double}.
     # Represents a reference to the object named (via a constant lookup)
     # by the string.
-    #
-    # @private
+    # @see DirectObjectReference
     class NamedObjectReference
+      # @param const_name [String] constant name
       def initialize(const_name)
         @const_name = const_name
       end
 
+      # @return [Boolean] true if the named constant is defined, false otherwise.
       def defined?
         !!object
       end
 
+      # @return [String] the constant name to replace with a double.
       def const_to_replace
         @const_name
       end
       alias description const_to_replace
 
-      def when_loaded(&_block)
+      # @return [Object, nil] the target of the verifying double (the named object), or
+      #   nil if it is not defined.
+      def target
+        object
+      end
+
+      # Yields if the reference target is loaded, providing a generic mechanism
+      # to optionally run a bit of code only when a reference's target is
+      # loaded.
+      #
+      # @yield [Object] the target object
+      def when_loaded
         yield object if object
       end
 
     private
 
       def object
-        @object ||= Constant.original(@const_name).original_value
+        return @object if defined?(@object)
+        @object = Constant.original(@const_name).original_value
       end
     end
   end

data/lib/rspec/mocks/proxy.rb

@@ -88,7 +88,12 @@ module RSpec
           @error_generator.raise_expectation_on_unstubbed_method(expected_method_name)
         end
 
-        @messages_received.each do |(actual_method_name, args, _)|
+        @messages_received.each do |(actual_method_name, received_arg_list, _)|
+          if expectation.message == actual_method_name
+            expectation.fail_if_problematic_received_arg_mutations(received_arg_list)
+          end
+
+          args = received_arg_list.args
           next unless expectation.matches?(actual_method_name, *args)
 
           expectation.safe_invoke(nil)
@@ -98,7 +103,8 @@ module RSpec
 
       # @private
       def check_for_unexpected_arguments(expectation)
-        @messages_received.each do |(method_name, args, _)|
+        @messages_received.each do |(method_name, received_arg_list, _)|
+          args = received_arg_list.args
           next unless expectation.matches_name_but_not_args(method_name, *args)
 
           raise_unexpected_message_args_error(expectation, *args)
@@ -138,7 +144,11 @@ module RSpec
 
       # @private
       def received_message?(method_name, *args, &block)
-        @messages_received.any? { |array| array == [method_name, args, block] }
+        @messages_received.any? do |(received_method_name, received_arg_list, received_block)|
+          method_name == received_method_name &&
+            args == received_arg_list.args &&
+            block == received_block
+        end
       end
 
       # @private
@@ -149,7 +159,35 @@ module RSpec
       # @private
       def record_message_received(message, *args, &block)
         @order_group.invoked SpecificMessage.new(object, message, args)
-        @messages_received << [message, args, block]
+        @messages_received << [message, ReceivedArgList.new(args), block]
+      end
+
+      class ReceivedArgList
+        attr_reader :args
+
+        def initialize(args)
+          @args          = args
+          @original_hash = hash_of(args)
+        end
+
+        def has_mutations?
+          @original_hash != hash_of(args)
+        end
+
+      private
+
+        def hash_of(arg)
+          arg.hash
+        rescue Exception
+          # While `Object#hash` is a built-in ruby method that we expect args to
+          # support, there's no guarantee that all args will. For example, a
+          # `BasicObject` instance will raise a `NoMethodError`. Given that
+          # we use the hash only to advise the user of a rare case we don't
+          # support involving mutations, it seems better to ignore this error
+          # and use a static value in its place (which will make us assume no
+          # mutation has occurred).
+          :failed_to_get_hash
+        end
       end
 
       # @private

data/lib/rspec/mocks/standalone.rb

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

data/lib/rspec/mocks/verifying_double.rb

@@ -28,6 +28,8 @@ module RSpec
           else
             __mock_proxy.ensure_publicly_implemented(message, self)
           end
+
+          __mock_proxy.validate_arguments!(message, args)
         end
 
         super
@@ -47,8 +49,17 @@ module RSpec
         __send__(name, *args, &block)
       end
 
-      def initialize(*args)
-        super
+      def initialize(doubled_module, *args)
+        @doubled_module = doubled_module
+
+        possible_name = args.first
+        name = if String === possible_name || Symbol === possible_name
+                 args.shift
+               else
+                 @description
+               end
+
+        super(name, *args)
         @__sending_message = nil
       end
     end
@@ -63,12 +74,8 @@ module RSpec
       include VerifyingDouble
 
       def initialize(doubled_module, *args)
-        @doubled_module = doubled_module
-
-        super(
-          "#{doubled_module.description} (instance)",
-          *args
-        )
+        @description = "#{doubled_module.description} (instance)"
+        super
       end
 
       def __build_mock_proxy(order_group)
@@ -95,8 +102,8 @@ module RSpec
     private
 
       def initialize(doubled_module, *args)
-        @doubled_module = doubled_module
-        super(doubled_module.description, *args)
+        @description = doubled_module.description
+        super
       end
 
       def __build_mock_proxy(order_group)

data/lib/rspec/mocks/verifying_message_expecation.rb

@@ -23,31 +23,23 @@ module RSpec
 
       # @private
       def with(*args, &block)
-        unless ArgumentMatchers::AnyArgsMatcher === args.first
-          expected_args = if ArgumentMatchers::NoArgsMatcher === args.first
-                            []
-                          elsif args.length > 0
-                            args
-                          else
-                            # No arguments given, this will raise.
-                            super
-                          end
-
-          validate_expected_arguments!(expected_args)
+        super(*args, &block).tap do
+          validate_expected_arguments! do |signature|
+            example_call_site_args = [:an_arg] * signature.min_non_kw_args
+            example_call_site_args << :kw_args_hash if signature.required_kw_args.any?
+            @argument_list_matcher.resolve_expected_args_based_on(example_call_site_args)
+          end
         end
-        super
       end
 
     private
 
-      def validate_expected_arguments!(actual_args)
+      def validate_expected_arguments!
         return if method_reference.nil?
 
         method_reference.with_signature do |signature|
-          verifier = Support::LooseSignatureVerifier.new(
-            signature,
-            actual_args
-          )
+          args     = yield signature
+          verifier = Support::LooseSignatureVerifier.new(signature, args)
 
           unless verifier.valid?
             # Fail fast is required, otherwise the message expecation will fail

data/lib/rspec/mocks/verifying_proxy.rb

@@ -78,6 +78,10 @@ module RSpec
       def visibility_for(method_name)
         method_reference[method_name].visibility
       end
+
+      def validate_arguments!(method_name, args)
+        @method_doubles[method_name].validate_arguments!(args)
+      end
     end
 
     # @private
@@ -131,8 +135,6 @@ module RSpec
         super
       end
 
-    private
-
       def validate_arguments!(actual_args)
         @method_reference.with_signature do |signature|
           verifier = Support::StrictSignatureVerifier.new(signature, actual_args)