rspec-mocks 3.0.4 → 3.12.6

data/README.md

@@ -1,5 +1,4 @@
-# RSpec Mocks [![Build Status](https://secure.travis-ci.org/rspec/rspec-mocks.png?branch=master)](http://travis-ci.org/rspec/rspec-mocks) [![Code Climate](https://codeclimate.com/github/rspec/rspec-mocks.png)](https://codeclimate.com/github/rspec/rspec-mocks) [![Inline docs](http://inch-pages.github.io/github/rspec/rspec-mocks.png)](http://inch-pages.github.io/github/rspec/rspec-mocks)
-
+# RSpec Mocks [![Build Status](https://github.com/rspec/rspec-mocks/workflows/RSpec%20CI/badge.svg)](https://github.com/rspec/rspec-mocks/actions) [![Code Climate](https://codeclimate.com/github/rspec/rspec-mocks.svg)](https://codeclimate.com/github/rspec/rspec-mocks)
 rspec-mocks is a test-double framework for rspec with support for method stubs,
 fakes, and message expectations on generated test-doubles and real objects
 alike.
@@ -9,6 +8,29 @@ alike.
     gem install rspec       # for rspec-core, rspec-expectations, rspec-mocks
     gem install rspec-mocks # for rspec-mocks only
 
+Want to run against the `main` branch? You'll need to include the dependent
+RSpec repos as well. Add the following to your `Gemfile`:
+
+```ruby
+%w[rspec-core rspec-expectations rspec-mocks rspec-support].each do |lib|
+  gem lib, :git => "https://github.com/rspec/#{lib}.git", :branch => 'main'
+end
+```
+## Contributing
+
+Once you've set up the environment, you'll need to cd into the working
+directory of whichever repo you want to work in. From there you can run the
+specs and cucumber features, and make patches.
+
+NOTE: You do not need to use rspec-dev to work on a specific RSpec repo. You
+can treat each RSpec repo as an independent project.
+
+For information about contributing to RSpec, please refer to the following markdown files:
+* [Build details](BUILD_DETAIL.md)
+* [Code of Conduct](CODE_OF_CONDUCT.md)
+* [Detailed contributing guide](CONTRIBUTING.md)
+* [Development setup guide](DEVELOPMENT.md)
+
 ## Test Doubles
 
 A test double is an object that stands in for another object in your system
@@ -31,7 +53,17 @@ book = instance_double("Book", :pages => 250)
 Verifying doubles have some clever tricks to enable you to both test in
 isolation without your dependencies loaded while still being able to validate
 them against real objects. More detail is available in [their
-documentation](https://github.com/rspec/rspec-mocks/blob/master/features/verifying_doubles).
+documentation](https://github.com/rspec/rspec-mocks/blob/main/features/verifying_doubles).
+
+Verifying doubles can also accept custom identifiers, just like double(), e.g.:
+
+```ruby
+books = []
+books << instance_double("Book", :rspec_book, :pages => 250)
+books << instance_double("Book", "(Untitled)", :pages => 5000)
+
+puts books.inspect # with names, it's clearer which were actually added
+```
 
 ## Method Stubs
 
@@ -42,6 +74,9 @@ rspec-mocks supports 3 forms for declaring method stubs:
 ```ruby
 allow(book).to receive(:title) { "The RSpec Book" }
 allow(book).to receive(:title).and_return("The RSpec Book")
+allow(book).to receive_messages(
+    :title => "The RSpec Book",
+    :subtitle => "Behaviour-Driven Development with RSpec, Cucumber, and Friends")
 ```
 
 You can also use this shortcut, which creates a test double and declares a
@@ -66,6 +101,21 @@ that iterates through them:
 order.calculate_total_price(double(:price => 1.99), double(:price => 2.99))
 ```
 
+### Stubbing a chain of methods
+
+You can use `receive_message_chain` in place of `receive` to stub a chain of messages:
+
+```ruby
+allow(double).to receive_message_chain("foo.bar") { :baz }
+allow(double).to receive_message_chain(:foo, :bar => :baz)
+allow(double).to receive_message_chain(:foo, :bar) { :baz }
+
+# Given any of the above forms:
+double.foo.bar # => :baz
+```
+
+Chains can be arbitrarily long, which makes it quite painless to violate the Law of Demeter in violent ways, so you should consider any use of `receive_message_chain` a code smell. Even though not all code smells indicate real problems (think fluent interfaces), `receive_message_chain` still results in brittle examples. For example, if you write `allow(foo).to receive_message_chain(:bar, :baz => 37)` in a spec and then the implementation calls `foo.baz.bar`, the stub will not work.
+
 ## Consecutive return values
 
 When a stub might be invoked more than once, you can provide additional
@@ -102,24 +152,51 @@ zipcode.valid?
 
 ## Test Spies
 
-Verifies the given object received the expected message during the course of the
-test. The method must have previously been stubbed in order for messages to be
-verified.
+Verifies the given object received the expected message during the course of
+the test. For a message to be verified, the given object must be setup to spy
+on it, either by having it explicitly stubbed or by being a null object double
+(e.g. `double(...).as_null_object`). Convenience methods are provided to easily
+create null object doubles for this purpose:
+
+```ruby
+spy("invitation") # => same as `double("invitation").as_null_object`
+instance_spy("Invitation") # => same as `instance_double("Invitation").as_null_object`
+class_spy("Invitation") # => same as `class_double("Invitation").as_null_object`
+object_spy("Invitation") # => same as `object_double("Invitation").as_null_object`
+```
 
-Stubbing and verifying messages received in this way implements the Test Spy
-pattern.
+Verifying messages received in this way implements the Test Spy pattern.
 
 ```ruby
-  invitation = double('invitation', :accept => true)
+invitation = spy('invitation')
 
-  user.accept_invitation(invitation)
+user.accept_invitation(invitation)
+
+expect(invitation).to have_received(:accept)
+
+# You can also use other common message expectations. For example:
+expect(invitation).to have_received(:accept).with(mailer)
+expect(invitation).to have_received(:accept).twice
+expect(invitation).to_not have_received(:accept).with(mailer)
+
+# One can specify a return value on the spy the same way one would a double.
+invitation = spy('invitation', :accept => true)
+expect(invitation).to have_received(:accept).with(mailer)
+expect(invitation.accept).to eq(true)
+```
+
+Note that `have_received(...).with(...)` is unable to work properly when
+passed arguments are mutated after the spy records the received message.
+For example, this does not work properly:
+
+```ruby
+greeter = spy("greeter")
 
-  expect(invitation).to have_received(:accept)
+message = "Hello"
+greeter.greet_with(message)
+message << ", World"
 
-  # You can also use other common message expectations. For example:
-  expect(invitation).to have_received(:accept).with(mailer)
-  expect(invitation).to have_received(:accept).twice
-  expect(invitation).to_not have_received(:accept).with(mailer)
+expect(greeter).to have_received(:greet_with).with("Hello")
 ```
 
 ## Nomenclature
@@ -180,7 +257,7 @@ expect(double).to receive(:msg).with("B", 2, 4)
 ## Argument Matchers
 
 Arguments that are passed to `with` are compared with actual arguments
-received using ==. In cases in which you want to specify things about the
+received using ===. In cases in which you want to specify things about the
 arguments rather than the arguments themselves, you can use any of the
 matchers that ship with rspec-expectations. They don't all make syntactic
 sense (they were primarily designed for use with RSpec::Expectations), but
@@ -190,14 +267,17 @@ rspec-mocks also adds some keyword Symbols that you can use to
 specify certain kinds of arguments:
 
 ```ruby
-expect(double).to receive(:msg).with(no_args())
-expect(double).to receive(:msg).with(any_args())
+expect(double).to receive(:msg).with(no_args)
+expect(double).to receive(:msg).with(any_args)
+expect(double).to receive(:msg).with(1, any_args) # any args acts like an arg splat and can go anywhere
 expect(double).to receive(:msg).with(1, kind_of(Numeric), "b") #2nd argument can be any kind of Numeric
 expect(double).to receive(:msg).with(1, boolean(), "b") #2nd argument can be true or false
 expect(double).to receive(:msg).with(1, /abc/, "b") #2nd argument can be any String matching the submitted Regexp
 expect(double).to receive(:msg).with(1, anything(), "b") #2nd argument can be anything at all
-expect(double).to receive(:msg).with(1, duck_type(:abs, :div), "b")
-                    #2nd argument can be object that responds to #abs and #div
+expect(double).to receive(:msg).with(1, duck_type(:abs, :div), "b") #2nd argument can be object that responds to #abs and #div
+expect(double).to receive(:msg).with(hash_including(:a => 5)) # first arg is a hash with a: 5 as one of the key-values
+expect(double).to receive(:msg).with(array_including(5)) # first arg is an array with 5 as one of the key-values
+expect(double).to receive(:msg).with(hash_excluding(:a => 5)) # first arg is a hash without a: 5 as one of the key-values
 ```
 
 ## Receive Counts
@@ -205,14 +285,16 @@ expect(double).to receive(:msg).with(1, duck_type(:abs, :div), "b")
 ```ruby
 expect(double).to receive(:msg).once
 expect(double).to receive(:msg).twice
+expect(double).to receive(:msg).exactly(n).time
 expect(double).to receive(:msg).exactly(n).times
 expect(double).to receive(:msg).at_least(:once)
 expect(double).to receive(:msg).at_least(:twice)
+expect(double).to receive(:msg).at_least(n).time
 expect(double).to receive(:msg).at_least(n).times
 expect(double).to receive(:msg).at_most(:once)
 expect(double).to receive(:msg).at_most(:twice)
+expect(double).to receive(:msg).at_most(n).time
 expect(double).to receive(:msg).at_most(n).times
-expect(double).to receive(:msg).any_number_of_times
 ```
 
 ## Ordering
@@ -248,7 +330,7 @@ expect(double).to receive(:msg).and_return(value)
 expect(double).to receive(:msg).exactly(3).times.and_return(value1, value2, value3)
   # returns value1 the first time, value2 the second, etc
 expect(double).to receive(:msg).and_raise(error)
-  # error can be an instantiated object or a class
+  # `error` can be an instantiated object (e.g. `StandardError.new(some_arg)`) or a class (e.g. `StandardError`)
   # if it is a class, it must be instantiable with no args
 expect(double).to receive(:msg).and_throw(:msg)
 expect(double).to receive(:msg).and_yield(values, to, yield)
@@ -296,7 +378,7 @@ end
 ## Delegating to the Original Implementation
 
 When working with a partial mock object, you may occasionally
-want to set a message expecation without interfering with how
+want to set a message expectation without interfering with how
 the object responds to the message. You can use `and_call_original`
 to achieve this:
 
@@ -321,7 +403,7 @@ your code.
 ## Stubbing and Hiding Constants
 
 See the [mutating constants
-README](https://github.com/rspec/rspec-mocks/blob/master/features/mutating_constants/README.md)
+README](https://github.com/rspec/rspec-mocks/blob/main/features/mutating_constants/README.md)
 for info on this feature.
 
 ## Use `before(:example)`, not `before(:context)`
@@ -349,7 +431,7 @@ general we discourage its use for a number of reasons:
 
 * The `rspec-mocks` API is designed for individual object instances, but this
   feature operates on entire classes of objects. As a result there are some
-  sematically confusing edge cases. For example in
+  semantically confusing edge cases. For example in
   `expect_any_instance_of(Widget).to receive(:name).twice` it isn't clear
   whether each specific instance is expected to receive `name` twice, or if two
   receives total are expected. (It's the former.)
@@ -367,14 +449,15 @@ There are many different viewpoints about the meaning of mocks and stubs. If
 you are interested in learning more, here is some recommended reading:
 
 * Mock Objects: http://www.mockobjects.com/
-* Endo-Testing: http://stalatest.googlecode.com/svn/trunk/Literatur/mockobjects.pdf
-* Mock Roles, Not Objects: http://jmock.org/oopsla2004.pdf
+* Endo-Testing: http://www.ccs.neu.edu/research/demeter/related-work/extreme-programming/MockObjectsFinal.PDF
+* Mock Roles, Not Objects: http://www.jmock.org/oopsla2004.pdf
 * Test Double: http://www.martinfowler.com/bliki/TestDouble.html
 * Test Double Patterns: http://xunitpatterns.com/Test%20Double%20Patterns.html
 * Mocks aren't stubs: http://www.martinfowler.com/articles/mocksArentStubs.html
 
 ## Also see
 
-* [http://github.com/rspec/rspec](http://github.com/rspec/rspec)
-* [http://github.com/rspec/rspec-core](http://github.com/rspec/rspec-core)
-* [http://github.com/rspec/rspec-expectations](http://github.com/rspec/rspec-expectations)
+* [https://github.com/rspec/rspec](https://github.com/rspec/rspec)
+* [https://github.com/rspec/rspec-core](https://github.com/rspec/rspec-core)
+* [https://github.com/rspec/rspec-expectations](https://github.com/rspec/rspec-expectations)
+* [https://github.com/rspec/rspec-rails](https://github.com/rspec/rspec-rails)

data/lib/rspec/mocks/any_instance/chain.rb

@@ -34,12 +34,14 @@ module RSpec
           record :and_throw
           record :and_yield
           record :and_call_original
+          record :and_wrap_original
           record :with
           record :once
           record :twice
-          record :any_number_of_times
+          record :thrice
           record :exactly
           record :times
+          record :time
           record :never
           record :at_least
           record :at_most
@@ -75,7 +77,7 @@ module RSpec
         end
 
         def never
-          ErrorGenerator.raise_double_negation_error("expect_any_instance_of(MyClass)") if negated?
+          AnyInstance.error_generator.raise_double_negation_error("expect_any_instance_of(MyClass)") if negated?
           super
         end
 
@@ -84,7 +86,7 @@ module RSpec
           super
         end
 
-        private
+      private
 
         def negated?
           messages.any? { |(message, *_), _| message == :never }

data/lib/rspec/mocks/any_instance/error_generator.rb

@@ -0,0 +1,31 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @private
+      class ErrorGenerator < ::RSpec::Mocks::ErrorGenerator
+        def raise_second_instance_received_message_error(unfulfilled_expectations)
+          __raise "Exactly one instance should have received the following " \
+                  "message(s) but didn't: #{unfulfilled_expectations.sort.join(', ')}"
+        end
+
+        def raise_does_not_implement_error(klass, method_name)
+          __raise "#{klass} does not implement ##{method_name}"
+        end
+
+        def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance)
+          __raise "The message '#{method_name}' was received by #{object_inspect} " \
+                  "but has already been received by #{invoked_instance}"
+        end
+
+        def raise_not_supported_with_prepend_error(method_name, problem_mod)
+          __raise "Using `any_instance` to stub a method (#{method_name}) that has been " \
+                  "defined on a prepended module (#{problem_mod}) is not supported."
+        end
+      end
+
+      def self.error_generator
+        @error_generator ||= ErrorGenerator.new
+      end
+    end
+  end
+end

data/lib/rspec/mocks/any_instance/expect_chain_chain.rb

@@ -23,11 +23,7 @@ module RSpec
         end
 
         def invocation_order
-          @invocation_order ||= {
-            :and_return => [nil],
-            :and_raise => [nil],
-            :and_yield => [nil]
-          }
+          EmptyInvocationOrder
         end
       end
     end

data/lib/rspec/mocks/any_instance/expectation_chain.rb

@@ -4,7 +4,7 @@ module RSpec
       # @private
       class ExpectationChain < Chain
         def expectation_fulfilled?
-          @expectation_fulfilled || constrained_to_any_of?(:never, :any_number_of_times)
+          @expectation_fulfilled || constrained_to_any_of?(:never)
         end
 
         def initialize(*args, &block)
@@ -14,13 +14,12 @@ module RSpec
 
       private
 
-        def verify_invocation_order(rspec_method_name, *args, &block)
+        def verify_invocation_order(_rspec_method_name, *_args, &_block)
         end
       end
 
       # @private
       class PositiveExpectationChain < ExpectationChain
-
       private
 
         def create_message_expectation_on(instance)
@@ -36,12 +35,14 @@ module RSpec
           me
         end
 
-        def invocation_order
-          @invocation_order ||= {
-            :with => [nil],
+        ExpectationInvocationOrder =
+          {
             :and_return => [:with, nil],
-            :and_raise => [:with, nil]
-          }
+            :and_raise => [:with, nil],
+          }.freeze
+
+        def invocation_order
+          ExpectationInvocationOrder
         end
       end
     end

data/lib/rspec/mocks/any_instance/message_chains.rb

@@ -35,15 +35,13 @@ module RSpec
         # @private
         def each_unfulfilled_expectation_matching(method_name, *args)
           @chains_by_method_name[method_name].each do |chain|
-            if !chain.expectation_fulfilled? && chain.matches_args?(*args)
-              yield chain
-            end
+            yield chain if !chain.expectation_fulfilled? && chain.matches_args?(*args)
           end
         end
 
         # @private
         def all_expectations_fulfilled?
-          @chains_by_method_name.all? do |method_name, chains|
+          @chains_by_method_name.all? do |_method_name, chains|
             chains.all? { |chain| chain.expectation_fulfilled? }
           end
         end
@@ -51,7 +49,7 @@ module RSpec
         # @private
         def unfulfilled_expectations
           @chains_by_method_name.map do |method_name, chains|
-            method_name.to_s if ExpectationChain === chains.last unless chains.last.expectation_fulfilled?
+            method_name.to_s if ExpectationChain === chains.last && !chains.last.expectation_fulfilled?
           end.compact
         end
 
@@ -74,9 +72,10 @@ module RSpec
 
         def raise_if_second_instance_to_receive_message(instance)
           @instance_with_expectation ||= instance if ExpectationChain === instance
-          if ExpectationChain === instance && !@instance_with_expectation.equal?(instance)
-            raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{unfulfilled_expectations.sort.join(', ')}"
-          end
+          return unless ExpectationChain === instance
+          return if @instance_with_expectation.equal?(instance)
+
+          AnyInstance.error_generator.raise_second_instance_received_message_error(unfulfilled_expectations)
         end
       end
     end

data/lib/rspec/mocks/any_instance/proxy.rb

@@ -10,7 +10,7 @@ module RSpec
       #
       # This proxy sits in front of the recorder and delegates both to it
       # and to the `RSpec::Mocks::Proxy` for each already mocked or stubbed
-      # instance of the class, in order to propogates changes to the instances.
+      # instance of the class, in order to propagates changes to the instances.
       #
       # Note that unlike `RSpec::Mocks::Proxy`, this proxy class is stateless
       # and is not persisted in `RSpec::Mocks.space`.
@@ -83,6 +83,15 @@ module RSpec
         end
       end
 
+      unless defined?(BasicObject)
+        class BasicObject
+          # Remove all methods except those expected to be defined on BasicObject
+          (instance_methods.map(&:to_sym) - [:__send__, :"!", :instance_eval, :==, :instance_exec, :"!=", :equal?, :__id__, :__binding__, :object_id]).each do |method|
+            undef_method method
+          end
+        end
+      end
+
       # @private
       # Delegates messages to each of the given targets in order to
       # provide the fluent interface that is available off of message
@@ -91,17 +100,17 @@ module RSpec
       # `targets` will typically contain 1 of the `AnyInstance::Recorder`
       # return values and N `MessageExpectation` instances (one per instance
       # of the `any_instance` klass).
-      class FluentInterfaceProxy
+      class FluentInterfaceProxy < BasicObject
         def initialize(targets)
           @targets = targets
         end
 
-        if RUBY_VERSION.to_f > 1.8
-          def respond_to_missing?(method_name, include_private = false)
+        if ::RUBY_VERSION.to_f > 1.8
+          def respond_to_missing?(method_name, include_private=false)
             super || @targets.first.respond_to?(method_name, include_private)
           end
         else
-          def respond_to?(method_name, include_private = false)
+          def respond_to?(method_name, include_private=false)
             super || @targets.first.respond_to?(method_name, include_private)
           end
         end

data/lib/rspec/mocks/any_instance/recorder.rb

@@ -15,11 +15,17 @@ module RSpec
 
         def initialize(klass)
           @message_chains = MessageChains.new
-          @stubs = Hash.new { |hash,key| hash[key] = [] }
+          @stubs = Hash.new { |hash, key| hash[key] = [] }
           @observed_methods = []
           @played_methods = {}
+          @backed_up_method_owner = {}
           @klass = klass
           @expectation_set = false
+
+          return unless RSpec::Mocks.configuration.verify_partial_doubles?
+          RSpec::Mocks.configuration.verifying_double_callbacks.each do |block|
+            block.call(ObjectReference.for(klass))
+          end
         end
 
         # Initializes the recording a stub to be played back against any
@@ -76,7 +82,7 @@ module RSpec
         # @see Methods#unstub
         def unstub(method_name)
           unless @observed_methods.include?(method_name.to_sym)
-            raise RSpec::Mocks::MockExpectationError, "The method `#{method_name}` was not stubbed or was already unstubbed"
+            AnyInstance.error_generator.raise_method_not_stubbed_error(method_name)
           end
           message_chains.remove_stub_chains_for!(method_name)
           stubs[method_name].clear
@@ -88,14 +94,15 @@ module RSpec
         # Used internally to verify that message expectations have been
         # fulfilled.
         def verify
-          if @expectation_set && !message_chains.all_expectations_fulfilled?
-            raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{message_chains.unfulfilled_expectations.sort.join(', ')}"
-          end
+          return unless @expectation_set
+          return if message_chains.all_expectations_fulfilled?
+
+          AnyInstance.error_generator.raise_second_instance_received_message_error(message_chains.unfulfilled_expectations)
         end
 
         # @private
         def stop_all_observation!
-          @observed_methods.each {|method_name| restore_method!(method_name)}
+          @observed_methods.each { |method_name| restore_method!(method_name) }
         end
 
         # @private
@@ -122,7 +129,7 @@ module RSpec
         end
 
         # @private
-        def notify_received_message(object, message, args, blk)
+        def notify_received_message(_object, message, args, _blk)
           has_expectation = false
 
           message_chains.each_unfulfilled_expectation_matching(message, *args) do |expectation|
@@ -130,10 +137,10 @@ module RSpec
             expectation.expectation_fulfilled!
           end
 
-          if has_expectation
-            restore_method!(message)
-            mark_invoked!(message)
-          end
+          return unless has_expectation
+
+          restore_method!(message)
+          mark_invoked!(message)
         end
 
       protected
@@ -167,7 +174,7 @@ module RSpec
         end
 
         def normalize_chain(*args)
-          args.shift.to_s.split('.').map {|s| s.to_sym}.reverse.each {|a| args.unshift a}
+          args.shift.to_s.split('.').map { |s| s.to_sym }.reverse.each { |a| args.unshift a }
           yield args.first, args
         end
 
@@ -186,13 +193,34 @@ module RSpec
         end
 
         def restore_original_method!(method_name)
-          if @klass.instance_method(method_name).owner == @klass
-            alias_method_name = build_alias_method_name(method_name)
-            @klass.class_exec do
-              remove_method method_name
-              alias_method  method_name, alias_method_name
-              remove_method alias_method_name
+          return unless @klass.instance_method(method_name).owner == @klass
+
+          alias_method_name = build_alias_method_name(method_name)
+          @klass.class_exec(@backed_up_method_owner) do |backed_up_method_owner|
+            remove_method method_name
+
+            # A @klass can have methods implemented (see Method#owner) in @klass
+            # or inherited from a superclass. In ruby 2.2 and earlier, we can copy
+            # a method regardless of the 'owner' and restore it to @klass after
+            # because a call to 'super' from @klass's copied method would end up
+            # calling the original class's superclass's method.
+            #
+            # With the commit below, available starting in 2.3.0, ruby changed
+            # this behavior and a call to 'super' from the method copied to @klass
+            # will call @klass's superclass method, which is the original
+            # implementer of this method!  This leads to very strange errors
+            # if @klass's copied method calls 'super', since it would end up
+            # calling itself, the original method implemented in @klass's
+            # superclass.
+            #
+            # For ruby 2.3 and above, we need to only restore methods that
+            # @klass originally owned.
+            #
+            # https://github.com/ruby/ruby/commit/c8854d2ca4be9ee6946e6d17b0e17d9ef130ee81
+            if RUBY_VERSION < "2.3" || backed_up_method_owner[method_name.to_sym] == self
+              alias_method method_name, alias_method_name
             end
+            remove_method alias_method_name
           end
         end
 
@@ -203,10 +231,13 @@ module RSpec
         end
 
         def backup_method!(method_name)
+          return unless public_protected_or_private_method_defined?(method_name)
+
           alias_method_name = build_alias_method_name(method_name)
+          @backed_up_method_owner[method_name.to_sym] ||= @klass.instance_method(method_name).owner
           @klass.class_exec do
             alias_method alias_method_name, method_name
-          end if public_protected_or_private_method_defined?(method_name)
+          end
         end
 
         def public_protected_or_private_method_defined?(method_name)
@@ -216,10 +247,9 @@ module RSpec
         def observe!(method_name)
           allow_no_prepended_module_definition_of(method_name)
 
-          if RSpec::Mocks.configuration.verify_partial_doubles?
+          if RSpec::Mocks.configuration.verify_partial_doubles? && !Mocks.configuration.temporarily_suppress_partial_double_verification
             unless public_protected_or_private_method_defined?(method_name)
-              raise MockExpectationError,
-                "#{@klass} does not implement ##{method_name}"
+              AnyInstance.error_generator.raise_does_not_implement_error(@klass, method_name)
             end
           end
 
@@ -229,36 +259,36 @@ module RSpec
           recorder = self
           @klass.__send__(:define_method, method_name) do |*args, &blk|
             recorder.playback!(self, method_name)
-            self.__send__(method_name, *args, &blk)
+            __send__(method_name, *args, &blk)
           end
+          @klass.__send__(:ruby2_keywords, method_name) if @klass.respond_to?(:ruby2_keywords, true)
         end
 
         def mark_invoked!(method_name)
           backup_method!(method_name)
           recorder = self
-          @klass.__send__(:define_method, method_name) do |*args, &blk|
+          @klass.__send__(:define_method, method_name) do |*_args, &_blk|
             invoked_instance = recorder.instance_that_received(method_name)
             inspect = "#<#{self.class}:#{object_id} #{instance_variables.map { |name| "#{name}=#{instance_variable_get name}" }.join(', ')}>"
-            raise RSpec::Mocks::MockExpectationError, "The message '#{method_name}' was received by #{inspect} but has already been received by #{invoked_instance}"
+            AnyInstance.error_generator.raise_message_already_received_by_other_instance_error(
+              method_name, inspect, invoked_instance
+            )
           end
         end
 
         if Support::RubyFeatures.module_prepends_supported?
           def allow_no_prepended_module_definition_of(method_name)
-            prepended_modules = @klass.ancestors.take_while { |mod| !(Class === mod) }
+            prepended_modules = RSpec::Mocks::Proxy.prepended_modules_of(@klass)
             problem_mod = prepended_modules.find { |mod| mod.method_defined?(method_name) }
             return unless problem_mod
 
-            raise RSpec::Mocks::MockExpectationError,
-              "Using `any_instance` to stub a method (#{method_name}) that has been " +
-              "defined on a prepended module (#{problem_mod}) is not supported."
+            AnyInstance.error_generator.raise_not_supported_with_prepend_error(method_name, problem_mod)
           end
         else
-          def allow_no_prepended_module_definition_of(method_name)
+          def allow_no_prepended_module_definition_of(_method_name)
             # nothing to do; prepends aren't supported on this version of ruby
           end
         end
-
       end
     end
   end