rspec-mocks 3.2.1 → 3.3.0

data/lib/rspec/mocks/example_methods.rb

@@ -396,13 +396,10 @@ module RSpec
         if RSpec::Mocks.configuration.verify_doubled_constant_names? &&
           !ref.defined?
 
-          raise VerifyingDoubleNotDefinedError,
-                "#{ref.description.inspect} is not a defined constant. " \
-                "Perhaps you misspelt it? " \
-                "Disable check with `verify_doubled_constant_names` configuration option."
+          RSpec::Mocks.error_generator.raise_verifying_double_not_defined_error(ref)
         end
 
-        RSpec::Mocks.configuration.verifying_double_declaration_callbacks.each do |block|
+        RSpec::Mocks.configuration.verifying_double_callbacks.each do |block|
           block.call(ref)
         end
 

data/lib/rspec/mocks/matchers/have_received.rb

@@ -69,9 +69,7 @@ module RSpec
       private
 
         def disallow(type, reason="")
-          raise RSpec::Mocks::MockExpectationError,
-                "Using #{type}(...) with the `have_received` " \
-                "matcher is not supported#{reason}."
+          RSpec::Mocks.error_generator.raise_have_received_disallowed(type, reason)
         end
 
         def expect
@@ -88,8 +86,7 @@ module RSpec
 
         def ensure_count_unconstrained
           return unless count_constraint
-          raise RSpec::Mocks::MockExpectationError,
-                "can't use #{count_constraint} when negative"
+          RSpec::Mocks.error_generator.raise_cant_constrain_count_for_negated_have_received_error(count_constraint)
         end
 
         def count_constraint
@@ -99,10 +96,10 @@ module RSpec
         end
 
         def generate_failure_message
-          mock_proxy.check_for_unexpected_arguments(@expectation)
-          @expectation.generate_error
-        rescue RSpec::Mocks::MockExpectationError => error
-          error.message
+          RSpec::Support.with_failure_notifier(Proc.new { |err, _opt| return err.message }) do
+            mock_proxy.check_for_unexpected_arguments(@expectation)
+            @expectation.generate_error
+          end
         end
 
         def expected_messages_received_in_order?

data/lib/rspec/mocks/message_chain.rb

@@ -30,10 +30,6 @@ module RSpec
 
     private
 
-      def expectation(_object, _message, &_return_block)
-        raise NotImplementedError
-      end
-
       def chain_on(object, *chain, &block)
         initialize(object, *chain, &block)
         setup_chain

data/lib/rspec/mocks/message_expectation.rb

@@ -26,11 +26,13 @@ module RSpec
       end
 
       def verify_messages_received
-        InsertOntoBacktrace.line(@backtrace_line) do
-          unless @received
-            @error_generator.raise_expectation_error(@message, 1, ArgumentListMatcher::MATCH_ALL, 0, nil)
-          end
-        end
+        return if @received
+        @error_generator.raise_expectation_error(
+          @message, 1, ArgumentListMatcher::MATCH_ALL, 0, nil, [], @backtrace_line
+        )
+      end
+
+      def unadvise(_)
       end
     end
 
@@ -115,7 +117,7 @@ module RSpec
           @error_generator.raise_only_valid_on_a_partial_double(:and_call_original)
         else
           warn_about_stub_override if implementation.inner_action
-          @implementation = AndWrapOriginalImplementation.new(@method_double.original_method, block)
+          @implementation = AndWrapOriginalImplementation.new(@method_double.original_implementation_callable, block)
           @yield_receiver_to_implementation_block = false
         end
 
@@ -142,13 +144,9 @@ module RSpec
       #   allow(car).to receive(:go).and_raise(OutOfGas)
       #   allow(car).to receive(:go).and_raise(OutOfGas, "At least 2 oz of gas needed to drive")
       #   allow(car).to receive(:go).and_raise(OutOfGas.new(2, :oz))
-      def and_raise(exception=RuntimeError, message=nil)
+      def and_raise(*args)
         raise_already_invoked_error_if_necessary(__method__)
-        if exception.respond_to?(:exception)
-          exception = message ? exception.exception(message) : exception.exception
-        end
-
-        self.terminal_implementation_action = Proc.new { raise exception }
+        self.terminal_implementation_action = Proc.new { raise(*args) }
         nil
       end
 
@@ -177,6 +175,11 @@ module RSpec
       def and_yield(*args, &block)
         raise_already_invoked_error_if_necessary(__method__)
         yield @eval_context = Object.new if block
+
+        # Initialize args to yield now that it's being used, see also: comment
+        # in constructor.
+        @args_to_yield ||= []
+
         @args_to_yield << args
         self.initial_implementation_action = AndYieldImplementation.new(@args_to_yield, @eval_context, @error_generator)
         self
@@ -248,7 +251,7 @@ module RSpec
       # @example
       #   expect(car).to receive(:stop).never
       def never
-        ErrorGenerator.raise_double_negation_error("expect(obj)") if negative?
+        error_generator.raise_double_negation_error("expect(obj)") if negative?
         @expected_received_count = 0
         self
       end
@@ -371,8 +374,10 @@ module RSpec
           @expectation_type = type
           @ordered = false
           @at_least = @at_most = @exactly = nil
-          @args_to_yield = []
-          @failed_fast = nil
+
+          # Initialized to nil so that we don't allocate an array for every
+          # mock or stub. See also comment in `and_yield`.
+          @args_to_yield = nil
           @eval_context = nil
           @yield_receiver_to_implementation_block = false
 
@@ -426,9 +431,8 @@ module RSpec
         end
 
         def verify_messages_received
-          InsertOntoBacktrace.line(@expected_from) do
-            generate_error unless expected_messages_received? || failed_fast?
-          end
+          return if expected_messages_received?
+          generate_error
         end
 
         def expected_messages_received?
@@ -464,14 +468,28 @@ module RSpec
           similar_messages << args
         end
 
+        def unadvise(args)
+          similar_messages.delete_if { |message| args.include?(message) }
+        end
+
         def generate_error
           if similar_messages.empty?
-            @error_generator.raise_expectation_error(@message, @expected_received_count, @argument_list_matcher, @actual_received_count, expectation_count_type, *expected_args)
+            @error_generator.raise_expectation_error(
+              @message, @expected_received_count, @argument_list_matcher,
+              @actual_received_count, expectation_count_type, expected_args,
+              @expected_from, exception_source_id
+            )
           else
-            @error_generator.raise_similar_message_args_error(self, *@similar_messages)
+            @error_generator.raise_similar_message_args_error(
+              self, @similar_messages, @expected_from
+            )
           end
         end
 
+        def raise_unexpected_message_args_error(args_for_multiple_calls)
+          @error_generator.raise_unexpected_message_args_error(self, args_for_multiple_calls, exception_source_id)
+        end
+
         def expectation_count_type
           return :at_least if @at_least
           return :at_most if @at_most
@@ -481,7 +499,7 @@ module RSpec
         def description_for(verb)
           @error_generator.describe_expectation(
             verb, @message, @expected_received_count,
-            @actual_received_count, *expected_args
+            @actual_received_count, expected_args
           )
         end
 
@@ -512,28 +530,33 @@ module RSpec
 
       private
 
+        def exception_source_id
+          @exception_source_id ||= "#{self.class.name} #{__id__}"
+        end
+
         def invoke_incrementing_actual_calls_by(increment, allowed_to_fail, parent_stub, *args, &block)
           args.unshift(orig_object) if yield_receiver_to_implementation_block?
 
           if negative? || (allowed_to_fail && (@exactly || @at_most) && (@actual_received_count == @expected_received_count))
-            @actual_received_count += increment
-            @failed_fast = true
             # args are the args we actually received, @argument_list_matcher is the
             # list of args we were expecting
-            @error_generator.raise_expectation_error(@message, @expected_received_count, @argument_list_matcher, @actual_received_count, expectation_count_type, *args)
+            @error_generator.raise_expectation_error(
+              @message, @expected_received_count,
+              @argument_list_matcher,
+              @actual_received_count + increment,
+              expectation_count_type, args, nil, exception_source_id
+            )
           end
 
           @order_group.handle_order_constraint self
 
-          begin
-            if implementation.present?
-              implementation.call(*args, &block)
-            elsif parent_stub
-              parent_stub.invoke(nil, *args, &block)
-            end
-          ensure
-            @actual_received_count += increment
+          if implementation.present?
+            implementation.call(*args, &block)
+          elsif parent_stub
+            parent_stub.invoke(nil, *args, &block)
           end
+        ensure
+          @actual_received_count += increment
         end
 
         def has_been_invoked?
@@ -543,15 +566,7 @@ module RSpec
         def raise_already_invoked_error_if_necessary(calling_customization)
           return unless has_been_invoked?
 
-          error_message = "The message expectation for #{orig_object.inspect}.#{message} has already been invoked " \
-            "and cannot be modified further (e.g. using `#{calling_customization}`). All message expectation " \
-            "customizations must be applied before it is used for the first time."
-
-          raise MockExpectationAlreadyInvokedError, error_message
-        end
-
-        def failed_fast?
-          @failed_fast
+          error_generator.raise_already_invoked_error(message, calling_customization)
         end
 
         def set_expected_received_count(relativity, n)
@@ -698,17 +713,5 @@ module RSpec
           "to call the original implementation, and cannot be modified further."
       end
     end
-
-    # Insert original locations into stacktraces
-    #
-    # @private
-    class InsertOntoBacktrace
-      def self.line(location)
-        yield
-      rescue RSpec::Mocks::MockExpectationError => error
-        error.backtrace.insert(0, location)
-        Kernel.raise error
-      end
-    end
   end
 end

data/lib/rspec/mocks/method_double.rb

@@ -18,20 +18,24 @@ 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_method ||=
-          @method_stasher.original_method ||
-          @proxy.original_method_handle_for(method_name) ||
+        @original_implementation_callable ||= original_method ||
           Proc.new do |*args, &block|
             @object.__send__(:method_missing, @method_name, *args, &block)
           end
       end
 
-      alias_method :save_original_method!, :original_method
+      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)
+      end
 
       # @private
       def visibility
@@ -45,7 +49,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,7 +58,7 @@ module RSpec
       def define_proxy_method
         return if @method_is_proxied
 
-        save_original_method!
+        save_original_implementation_callable!
         definition_target.class_exec(self, method_name, visibility) do |method_double, method_name, visibility|
           define_method(method_name) do |*args, &block|
             method_double.proxy_method_invoked(self, *args, &block)
@@ -101,7 +105,7 @@ 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
@@ -198,7 +202,7 @@ 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
 
       # In Ruby 2.0.0 and above prepend will alter the method lookup chain.

data/lib/rspec/mocks/method_reference.rb

@@ -6,6 +6,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
@@ -133,6 +137,14 @@ module RSpec
 
     # @private
     class ObjectMethodReference < MethodReference
+      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)
@@ -151,5 +163,30 @@ 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 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.
+        klass.method(:new).owner == ::Class
+      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/proxy.rb

@@ -14,11 +14,10 @@ module RSpec
       end
 
       # @private
-      def initialize(object, order_group, name=nil, options={})
+      def initialize(object, order_group, options={})
         @object = object
         @order_group = order_group
-        @name = name
-        @error_generator = ErrorGenerator.new(object, name)
+        @error_generator = ErrorGenerator.new(object)
         @messages_received = []
         @options = options
         @null_object = false
@@ -46,8 +45,10 @@ module RSpec
         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)
 
@@ -98,11 +99,17 @@ module RSpec
 
       # @private
       def check_for_unexpected_arguments(expectation)
-        @messages_received.each do |(method_name, args, _)|
-          next unless expectation.matches_name_but_not_args(method_name, *args)
+        return if @messages_received.empty?
+
+        return if @messages_received.any? { |method_name, args, _| expectation.matches?(method_name, *args) }
 
-          raise_unexpected_message_args_error(expectation, *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
 
       # @private
@@ -141,6 +148,11 @@ module RSpec
         @messages_received.any? { |array| array == [method_name, args, block] }
       end
 
+      # @private
+      def messages_arg_list
+        @messages_received.map { |_, args, _| args }
+      end
+
       # @private
       def has_negative_expectation?(message)
         method_double_for(message).expectations.find { |expectation| expectation.negative_expectation_for?(message) }
@@ -166,16 +178,17 @@ module RSpec
           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))
           expectation.advise(*args) if null_object? unless expectation.expected_messages_received?
 
           if null_object? || !has_negative_expectation?(message)
-            raise_unexpected_message_args_error(expectation, *args)
+            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
@@ -184,18 +197,13 @@ module RSpec
       end
 
       # @private
-      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_unexpected_message_error(method_name, args)
+        @error_generator.raise_unexpected_message_error method_name, args
       end
 
       # @private
-      def raise_missing_default_stub_error(expectation, *args)
-        @error_generator.raise_missing_default_stub_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