rspec-mocks 2.99.4 → 3.0.0.beta1

data/lib/rspec/mocks/verifying_message_expecation.rb

@@ -0,0 +1,60 @@
+require 'rspec/mocks/arity_calculator'
+
+module RSpec
+  module Mocks
+
+    # A message expectation that knows about the real implementation of the
+    # message being expected, so that it can verify that any expectations
+    # have the correct arity.
+    class VerifyingMessageExpectation < MessageExpectation
+
+      # A level of indirection is used here rather than just passing in the
+      # method itself, since method look up is expensive and we only want to
+      # do it if actually needed.
+      #
+      # Conceptually the method reference makes more sense as a constructor
+      # argument since it should be immutable, but it is significantly more
+      # straight forward to build the object in pieces so for now it stays as
+      # an accessor.
+      attr_accessor :method_reference
+
+      def initialize(*args)
+        super
+      end
+
+      # @override
+      def with(*args, &block)
+        unless ArgumentMatchers::AnyArgsMatcher === args.first
+          expected_arity = if ArgumentMatchers::NoArgsMatcher === args.first
+            0
+          elsif args.length > 0
+            args.length
+          else
+            # No arguments given, this will raise.
+            super
+          end
+
+          ensure_arity!(expected_arity)
+        end
+        super
+      end
+
+    private
+
+      def ensure_arity!(actual)
+        return if method_reference.nil?
+
+        method_reference.when_defined do |method|
+          calculator = ArityCalculator.new(method)
+          unless calculator.within_range?(actual)
+            # Fail fast is required, otherwise the message expecation will fail
+            # as well ("expected method not called") and clobber this one.
+            @failed_fast = true
+            @error_generator.raise_arity_error(calculator, actual)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/rspec/mocks/verifying_proxy.rb

@@ -0,0 +1,151 @@
+require 'rspec/mocks/verifying_message_expecation'
+require 'rspec/mocks/method_reference'
+
+module RSpec
+  module Mocks
+
+    module VerifyingProxyMethods
+      def add_stub(location, method_name, opts={}, &implementation)
+        ensure_implemented(method_name)
+        super
+      end
+
+      def add_simple_stub(method_name, *args)
+        ensure_implemented(method_name)
+        super
+      end
+
+      def add_message_expectation(location, method_name, opts={}, &block)
+        ensure_implemented(method_name)
+        super
+      end
+
+      def ensure_implemented(method_name)
+        return unless @doubled_module.defined?
+
+        method_reference[method_name].when_unimplemented do
+          @error_generator.raise_unimplemented_error(
+            @doubled_module,
+            method_name
+          )
+        end
+      end
+    end
+
+    # A verifying proxy mostly acts like a normal proxy, except that it
+    # contains extra logic to try and determine the validity of any expectation
+    # set on it. This includes whether or not methods have been defined and the
+    # arity of method calls.
+    #
+    # In all other ways this behaves like a normal proxy. It only adds the
+    # verification behaviour to specific methods then delegates to the parent
+    # implementation.
+    #
+    # These checks are only activated if the doubled class has already been
+    # loaded, otherwise they are disabled. This allows for testing in
+    # isolation.
+    #
+    # @api private
+    class VerifyingProxy < Proxy
+      include VerifyingProxyMethods
+
+      def initialize(object, order_group, name, method_reference_class)
+        super(object, order_group)
+        @object                 = object
+        @doubled_module         = name
+        @method_reference_class = method_reference_class
+
+        # A custom method double is required to pass through a way to lookup
+        # methods to determine their arity. This is only relevant if the doubled
+        # class is loaded.
+        @method_doubles = Hash.new do |h, k|
+          h[k] = VerifyingMethodDouble.new(@object, k, self, method_reference[k])
+        end
+      end
+
+      def method_reference
+        @method_reference ||= Hash.new do |h, k|
+          h[k] = @method_reference_class.new(@doubled_module, k)
+        end
+      end
+    end
+
+    class VerifyingPartialMockProxy < PartialMockProxy
+      include VerifyingProxyMethods
+
+      def initialize(object, expectation_ordering)
+        super(object, expectation_ordering)
+        @doubled_module = DirectObjectReference.new(object)
+
+        # A custom method double is required to pass through a way to lookup
+        # methods to determine their arity.
+        @method_doubles = Hash.new do |h, k|
+          h[k] = VerifyingExistingMethodDouble.new(object, k, self)
+        end
+      end
+
+      def method_reference
+        @method_doubles
+      end
+    end
+
+    # @api private
+    class VerifyingMethodDouble < MethodDouble
+      def initialize(object, method_name, proxy, method_reference)
+        super(object, method_name, proxy)
+        @method_reference = method_reference
+      end
+
+      def message_expectation_class
+        VerifyingMessageExpectation
+      end
+
+      def add_expectation(*arg)
+        super.tap { |x| x.method_reference = @method_reference }
+      end
+
+      def proxy_method_invoked(obj, *args, &block)
+        ensure_arity!(args.length)
+        super
+      end
+
+    private
+
+      def ensure_arity!(arity)
+        @method_reference.when_defined do |method|
+          calculator = ArityCalculator.new(method)
+          unless calculator.within_range?(arity)
+            raise ArgumentError, "wrong number of arguments (#{arity} for #{method.arity})"
+          end
+        end
+      end
+    end
+
+    # @api private
+    #
+    # A VerifyingMethodDouble fetches the method to verify against from the
+    # original object, using a MethodReference. This works for pure doubles,
+    # but when the original object is itself the one being modified we need to
+    # collapse the reference and the method double into a single object so that
+    # we can access the original pristine method definition.
+    class VerifyingExistingMethodDouble < VerifyingMethodDouble
+      def initialize(object, method_name, proxy)
+        super(object, method_name, proxy, self)
+
+        @valid_method = object.respond_to?(method_name)
+
+        # Trigger an eager find of the original method since if we find it any
+        # later we end up getting a stubbed method with incorrect arity.
+        save_original_method!
+      end
+
+      def when_defined
+        yield original_method
+      end
+
+      def when_unimplemented
+        yield unless @valid_method
+      end
+    end
+  end
+end

data/lib/rspec/mocks/version.rb

@@ -1,7 +1,7 @@
 module RSpec
   module Mocks
     module Version
-      STRING = '2.99.4'
+      STRING = '3.0.0.beta1'
     end
   end
 end

data/spec/rspec/mocks/and_call_original_spec.rb

@@ -22,24 +22,36 @@ describe "and_call_original" do
     let(:instance) { klass.new }
 
     it 'passes the received message through to the original method' do
+      expect(instance).to receive(:meth_1).and_call_original
+      expect(instance.meth_1).to eq(:original)
+    end
+
+    it 'ignores prior declared stubs' do
+      instance.stub(:meth_1).and_return(:stubbed_value)
       instance.should_receive(:meth_1).and_call_original
       expect(instance.meth_1).to eq(:original)
     end
 
     it 'passes args and blocks through to the original method' do
-      instance.should_receive(:meth_2).and_call_original
+      expect(instance).to receive(:meth_2).and_call_original
       value = instance.meth_2(:submitted_arg) { |a, b| [a, b] }
       expect(value).to eq([:submitted_arg, :additional_yielded_arg])
     end
 
     it 'errors when you pass through the wrong number of args' do
-      instance.stub(:meth_1).and_call_original
-      instance.stub(:meth_2).and_call_original
+      expect(instance).to receive(:meth_1).and_call_original
+      expect(instance).to receive(:meth_2).twice.and_call_original
       expect { instance.meth_1 :a }.to raise_error ArgumentError
       expect { instance.meth_2 {} }.to raise_error ArgumentError
       expect { instance.meth_2(:a, :b) {}  }.to raise_error ArgumentError
     end
 
+    it 'warns when you override an existing implementation' do
+      expect(RSpec).to receive(:warning).with(/overriding a previous implementation/)
+      expect(instance).to receive(:meth_1) { true }.and_call_original
+      instance.meth_1
+    end
+
     context "for singleton methods" do
       it 'works' do
         def instance.foo; :bar; end
@@ -77,6 +89,15 @@ describe "and_call_original" do
       expect(sub_klass.foo).to eq(:sub_klass_bar)
     end
 
+    it "finds the method on the most direct singleton class ancestors even if the method " +
+       "is available on more distant ancestors" do
+      klass.extend Module.new { def foo; :klass_bar; end }
+      sub_klass = Class.new(klass) { def self.foo; :sub_klass_bar; end }
+      sub_sub_klass = Class.new(sub_klass)
+      sub_sub_klass.should_receive(:foo).and_call_original
+      expect(sub_sub_klass.foo).to eq(:sub_klass_bar)
+    end
+
     context 'when using any_instance' do
       it 'works for instance methods defined on the class' do
         klass.any_instance.should_receive(:meth_1).and_call_original
@@ -95,33 +116,16 @@ describe "and_call_original" do
       end
     end
 
-    if RUBY_VERSION.to_f > 1.8
-      it 'works for class methods defined on a superclass' do
-        subclass = Class.new(klass)
-        subclass.should_receive(:new_instance).and_call_original
-        expect(subclass.new_instance).to be_a(subclass)
-      end
-
-      it 'works for class methods defined on a grandparent class' do
-        sub_subclass = Class.new(Class.new(klass))
-        sub_subclass.should_receive(:new_instance).and_call_original
-        expect(sub_subclass.new_instance).to be_a(sub_subclass)
-      end
-    else
-      it 'attempts to work for class methods defined on a superclass but ' +
-         'executes the method with `self` as the superclass' do
-        ::Kernel.stub(:warn)
-        subclass = Class.new(klass)
-        subclass.should_receive(:new_instance).and_call_original
-        expect(subclass.new_instance).to be_an_instance_of(klass)
-       end
+    it 'works for class methods defined on a superclass' do
+      subclass = Class.new(klass)
+      subclass.should_receive(:new_instance).and_call_original
+      expect(subclass.new_instance).to be_a(subclass)
+    end
 
-      it 'prints a warning to notify users that `self` will not be correct' do
-        subclass = Class.new(klass)
-        ::Kernel.should_receive(:warn).with(/may not work correctly/)
-        subclass.should_receive(:new_instance).and_call_original
-        subclass.new_instance
-      end
+    it 'works for class methods defined on a grandparent class' do
+      sub_subclass = Class.new(Class.new(klass))
+      sub_subclass.should_receive(:new_instance).and_call_original
+      expect(sub_subclass.new_instance).to be_a(sub_subclass)
     end
 
     it 'works for class methods defined on the Class class' do
@@ -149,7 +153,7 @@ describe "and_call_original" do
 
     context 'on an object that defines method_missing' do
       before do
-        klass.class_eval do
+        klass.class_exec do
           private
 
           def method_missing(name, *args)

data/spec/rspec/mocks/and_yield_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe RSpec::Mocks::Double do
+describe RSpec::Mocks::Mock do
 
   let(:obj) { double }
 
@@ -25,7 +25,7 @@ describe RSpec::Mocks::Double do
         obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
           evaluated = true
         end
-        expect(evaluated).to be true
+        expect(evaluated).to be_truthy
       end
 
       it "passes an eval context object to the supplied block" do

data/spec/rspec/mocks/any_instance/message_chains_spec.rb

@@ -4,7 +4,7 @@ describe RSpec::Mocks::AnyInstance::MessageChains do
   let(:recorder) { double }
   let(:chains) { RSpec::Mocks::AnyInstance::MessageChains.new }
   let(:stub_chain) { RSpec::Mocks::AnyInstance::StubChain.new recorder }
-  let(:expectation_chain) { RSpec::Mocks::AnyInstance::ExpectationChain.new recorder }
+  let(:expectation_chain) { RSpec::Mocks::AnyInstance::PositiveExpectationChain.new recorder }
 
   it "knows if a method does not have an expectation set on it" do
     chains.add(:method_name, stub_chain)

data/spec/rspec/mocks/any_instance_spec.rb

@@ -37,7 +37,7 @@ module RSpec
         end
 
         context "#stub_chain" do
-          it "raises an error if 'stub_chain' follows 'any_instance'" do
+          it "raises an error if 'stub_chain' follows 'and_return'" do
             expect { klass.any_instance.and_return("1").stub_chain(:foo, :bar) }.to raise_error(NoMethodError)
           end
         end
@@ -48,12 +48,12 @@ module RSpec
           end
 
           it "raises an error if 'with' follows 'and_return'" do
-            skip "see Github issue #42"
+            pending "see Github issue #42"
             expect { klass.any_instance.should_receive(:foo).and_return(1).with("1") }.to raise_error(NoMethodError)
           end
 
           it "raises an error if 'with' follows 'and_raise'" do
-            skip "see Github issue #42"
+            pending "see Github issue #42"
             expect { klass.any_instance.should_receive(:foo).and_raise(1).with("1") }.to raise_error(NoMethodError)
           end
         end
@@ -214,8 +214,6 @@ module RSpec
         end
 
         context "with a block" do
-          before { allow_unavoidable_1_8_deprecation }
-
           it "stubs a method" do
             klass.any_instance.stub(:foo) { 1 }
             expect(klass.new.foo).to eq(1)
@@ -227,6 +225,24 @@ module RSpec
           end
         end
 
+        context "when partially mocking objects" do
+          let(:obj) { klass.new }
+
+          it "resets partially mocked objects correctly" do
+            allow_any_instance_of(klass).to receive(:existing_method).and_return("stubbed value")
+
+            # Simply resetting the proxy doesn't work
+            # what we need to have happen is
+            # ::RSpec::Mocks.any_instance_recorder_for(klass).stop_all_observation!
+            # but that is never invoked in ::
+            expect {
+              RSpec::Mocks.space.verify_all
+            }.to(
+              change { obj.existing_method }.from("stubbed value").to(:existing_method_return_value)
+            )
+          end
+        end
+
         context "core ruby objects" do
           it "works uniformly across *everything*" do
             Object.any_instance.stub(:foo).and_return(1)
@@ -267,22 +283,6 @@ module RSpec
         end
       end
 
-      context "with #stub!" do
-        it "raises with a message instructing the user to use stub instead" do
-          expect do
-            klass.any_instance.stub!(:foo)
-          end.to raise_error(/Use stub instead/)
-        end
-      end
-
-      context "with #unstub!" do
-        it "raises with a message instructing the user to use unstub instead" do
-          expect do
-            klass.any_instance.unstub!(:foo)
-          end.to raise_error(/Use unstub instead/)
-        end
-      end
-
       context "unstub implementation" do
         it "replaces the stubbed method with the original method" do
           klass.any_instance.stub(:existing_method)
@@ -377,7 +377,6 @@ module RSpec
             klass.any_instance.should_not_receive(:bar)
             klass.new.foo
             RSpec::Mocks.space.verify_all
-            RSpec::Mocks.space.reset_all
           end
         end
 
@@ -400,36 +399,24 @@ module RSpec
 
           it "fails if an instance is created but no invocation occurs" do
             expect do
-              begin
-                klass.any_instance.should_receive(:foo)
-                klass.new
-                RSpec::Mocks.space.verify_all
-              ensure
-                RSpec::Mocks.space.reset_all
-              end
+              klass.any_instance.should_receive(:foo)
+              klass.new
+              RSpec::Mocks.space.verify_all
             end.to raise_error(RSpec::Mocks::MockExpectationError, foo_expectation_error_message)
           end
 
           it "fails if no instance is created" do
             expect do
-              begin
-                klass.any_instance.should_receive(:foo).and_return(1)
-                RSpec::Mocks.space.verify_all
-              ensure
-                RSpec::Mocks.space.reset_all
-              end
+              klass.any_instance.should_receive(:foo).and_return(1)
+              RSpec::Mocks.space.verify_all
             end.to raise_error(RSpec::Mocks::MockExpectationError, foo_expectation_error_message)
           end
 
           it "fails if no instance is created and there are multiple expectations" do
             expect do
-              begin
-                klass.any_instance.should_receive(:foo)
-                klass.any_instance.should_receive(:bar)
-                RSpec::Mocks.space.verify_all
-              ensure
-                RSpec::Mocks.space.reset_all
-              end
+              klass.any_instance.should_receive(:foo)
+              klass.any_instance.should_receive(:bar)
+              RSpec::Mocks.space.verify_all
             end.to raise_error(RSpec::Mocks::MockExpectationError, 'Exactly one instance should have received the following message(s) but didn\'t: bar, foo')
           end
 
@@ -491,36 +478,24 @@ module RSpec
 
           it "fails if an instance is created but no invocation occurs" do
             expect do
-              begin
-                klass.any_instance.should_receive(:existing_method)
-                klass.new
-                RSpec::Mocks.space.verify_all
-              ensure
-                RSpec::Mocks.space.reset_all
-              end
+              klass.any_instance.should_receive(:existing_method)
+              klass.new
+              RSpec::Mocks.space.verify_all
             end.to raise_error(RSpec::Mocks::MockExpectationError, existing_method_expectation_error_message)
           end
 
           it "fails if no instance is created" do
             expect do
-              begin
-                klass.any_instance.should_receive(:existing_method)
-                RSpec::Mocks.space.verify_all
-              ensure
-                RSpec::Mocks.space.reset_all
-              end
+              klass.any_instance.should_receive(:existing_method)
+              RSpec::Mocks.space.verify_all
             end.to raise_error(RSpec::Mocks::MockExpectationError, existing_method_expectation_error_message)
           end
 
           it "fails if no instance is created and there are multiple expectations" do
             expect do
-              begin
-                klass.any_instance.should_receive(:existing_method)
-                klass.any_instance.should_receive(:another_existing_method)
-                RSpec::Mocks.space.verify_all
-              ensure
-                RSpec::Mocks.space.reset_all
-              end
+              klass.any_instance.should_receive(:existing_method)
+              klass.any_instance.should_receive(:another_existing_method)
+              RSpec::Mocks.space.verify_all
             end.to raise_error(RSpec::Mocks::MockExpectationError, 'Exactly one instance should have received the following message(s) but didn\'t: another_existing_method, existing_method')
           end
 
@@ -613,24 +588,16 @@ module RSpec
 
             it "fails when no instances are declared" do
               expect do
-                begin
-                  klass.any_instance.should_receive(:foo).once
-                  RSpec::Mocks.space.verify_all
-                ensure
-                  RSpec::Mocks.space.reset_all
-                end
+                klass.any_instance.should_receive(:foo).once
+                RSpec::Mocks.space.verify_all
               end.to raise_error(RSpec::Mocks::MockExpectationError, foo_expectation_error_message)
             end
 
             it "fails when an instance is declared but there are no invocations" do
               expect do
-                begin
-                  klass.any_instance.should_receive(:foo).once
-                  klass.new
-                  RSpec::Mocks.space.verify_all
-                ensure
-                  RSpec::Mocks.space.reset_all
-                end
+                klass.any_instance.should_receive(:foo).once
+                klass.new
+                RSpec::Mocks.space.verify_all
               end.to raise_error(RSpec::Mocks::MockExpectationError, foo_expectation_error_message)
             end
 
@@ -755,55 +722,9 @@ module RSpec
 
               it "fails when the other expecations are not met" do
                 expect do
-                  begin
-                    klass.any_instance.should_receive(:foo).never
-                    klass.any_instance.should_receive(:existing_method).and_return(5)
-                    RSpec::Mocks.space.verify_all
-                  ensure
-                    RSpec::Mocks.space.reset_all
-                  end
-                end.to raise_error(RSpec::Mocks::MockExpectationError, existing_method_expectation_error_message)
-              end
-            end
-          end
-
-          context "the 'any_number_of_times' constraint" do
-            it "passes for 0 invocations" do
-              klass.any_instance.should_receive(:foo).any_number_of_times
-              verify klass.new
-            end
-
-            it "passes for a non-zero number of invocations" do
-              allow(RSpec).to receive(:deprecate).with("any_number_of_times", :replacement => "stub")
-
-              klass.any_instance.should_receive(:foo).any_number_of_times
-              instance = klass.new
-              instance.foo
-              verify instance
-            end
-
-            it "does not interfere with other expectations" do
-              klass.any_instance.should_receive(:foo).any_number_of_times
-              klass.any_instance.should_receive(:existing_method).and_return(5)
-              expect(klass.new.existing_method).to eq(5)
-            end
-
-            context "when combined with other expectations" do
-              it "passes when the other expecations are met" do
-                klass.any_instance.should_receive(:foo).any_number_of_times
-                klass.any_instance.should_receive(:existing_method).and_return(5)
-                expect(klass.new.existing_method).to eq(5)
-              end
-
-              it "fails when the other expecations are not met" do
-                expect do
-                  begin
-                    klass.any_instance.should_receive(:foo).any_number_of_times
-                    klass.any_instance.should_receive(:existing_method).and_return(5)
-                    RSpec::Mocks.space.verify_all
-                  ensure
-                    RSpec::Mocks.space.reset_all
-                  end
+                  klass.any_instance.should_receive(:foo).never
+                  klass.any_instance.should_receive(:existing_method).and_return(5)
+                  RSpec::Mocks.space.verify_all
                 end.to raise_error(RSpec::Mocks::MockExpectationError, existing_method_expectation_error_message)
               end
             end
@@ -823,14 +744,13 @@ module RSpec
             context "public methods" do
               before(:each) do
                 klass.any_instance.stub(:existing_method).and_return(1)
-                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be true
+                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_truthy
               end
 
               it "restores the class to its original state after each example when no instance is created" do
                 space.verify_all
-                space.reset_all
 
-                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be false
+                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_falsey
                 expect(klass.new.existing_method).to eq(existing_method_return_value)
               end
 
@@ -838,9 +758,8 @@ module RSpec
                 klass.new.existing_method
 
                 space.verify_all
-                space.reset_all
 
-                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be false
+                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_falsey
                 expect(klass.new.existing_method).to eq(existing_method_return_value)
               end
 
@@ -849,9 +768,8 @@ module RSpec
                 klass.new.existing_method
 
                 space.verify_all
-                space.reset_all
 
-                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be false
+                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_falsey
                 expect(klass.new.existing_method).to eq(existing_method_return_value)
               end
             end
@@ -860,15 +778,14 @@ module RSpec
               before :each do
                 klass.any_instance.stub(:private_method).and_return(:something)
                 space.verify_all
-                space.reset_all
               end
 
               it "cleans up the backed up method" do
-                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be false
+                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_falsey
               end
 
               it "restores a stubbed private method after the spec is run" do
-                expect(klass.private_method_defined?(:private_method)).to be true
+                expect(klass.private_method_defined?(:private_method)).to be_truthy
               end
 
               it "ensures that the restored method behaves as it originally did" do
@@ -883,15 +800,14 @@ module RSpec
                 klass.any_instance.should_receive(:private_method).and_return(:something)
                 klass.new.private_method
                 space.verify_all
-                space.reset_all
               end
 
               it "cleans up the backed up method" do
-                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be false
+                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_falsey
               end
 
               it "restores a stubbed private method after the spec is run" do
-                expect(klass.private_method_defined?(:private_method)).to be true
+                expect(klass.private_method_defined?(:private_method)).to be_truthy
               end
 
               it "ensures that the restored method behaves as it originally did" do
@@ -931,7 +847,6 @@ module RSpec
               klass.any_instance.should_receive(:existing_method).and_return(Object.new)
               klass.new.existing_method
               space.verify_all
-              space.reset_all
 
               expect(klass.new.existing_method).to eq(existing_method_return_value)
             end
@@ -944,7 +859,6 @@ module RSpec
             klass.any_instance.stub(:existing_method).and_return(true)
 
             RSpec::Mocks.space.verify_all
-            RSpec::Mocks.space.reset_all
             expect(klass.new).to respond_to(:existing_method)
             expect(klass.new.existing_method).to eq(existing_method_return_value)
           end
@@ -1034,126 +948,6 @@ module RSpec
             end
           end
         end
-
-        context "by default" do
-          def block_regex(line)
-            /as the first block argument.*#{__FILE__}:#{line}/m
-          end
-
-          it "is off" do
-            expect(RSpec::Mocks.configuration.yield_receiver_to_any_instance_implementation_blocks?).to be false
-          end
-
-          it "will warn about allowances receiving blocks in 3.0" do
-            klass = Struct.new(:bees)
-
-            expect(RSpec).to receive(:warn_deprecation).with(block_regex(__LINE__ + 1))
-            allow_any_instance_of(klass).to receive(:foo) { |args| }
-            klass.new(:faces).foo
-          end
-
-          it "will warn about expectations receiving blocks in 3.0" do
-            klass = Struct.new(:bees)
-
-            expect(RSpec).to receive(:warn_deprecation).with(block_regex(__LINE__ + 1))
-            expect_any_instance_of(klass).to receive(:foo) { |args| }
-            klass.new(:faces).foo
-          end
-
-          it 'includes the line of the block declaration in the warning, ' +
-             'even when it is different from the `any_instance` line', :unless => (RUBY_VERSION.to_f < 1.9) do
-            klass = Class.new
-            expect(RSpec).to receive(:warn_deprecation).with(block_regex(__LINE__ + 3))
-            stub = klass.any_instance.stub(:foo)
-
-            stub.with("bar") { |args| }
-            klass.new.foo("bar")
-          end
-
-          it "will warn about expectations receiving blocks with a times restriction" do
-            klass = Struct.new(:bees)
-
-            expect(RSpec).to receive(:warn_deprecation).with(block_regex(__LINE__ + 1))
-            klass.any_instance.should_receive(:foo).exactly(3).times { |a| :some_return_value }
-
-            instance = klass.new(:faces)
-            3.times { instance.foo }
-          end
-
-          it "will warn about expectations receiving blocks with an argument expectation" do
-            klass = Struct.new(:bees)
-
-            expect(RSpec).to receive(:warn_deprecation).with(block_regex(__LINE__ + 1))
-            klass.any_instance.should_receive(:foo).with(3) { |b| :some_return_value }
-
-            instance = klass.new(:faces)
-            instance.foo(3)
-          end
-
-          it "works with a do end style block" do
-            klass = Struct.new(:bees)
-
-            expect(RSpec).to receive(:warn_deprecation).with(block_regex(__LINE__ + 1))
-            klass.any_instance.should_receive(:foo).with(3) do |a|
-              :some_return_value
-            end
-
-            instance = klass.new(:faces)
-            instance.foo(3)
-          end
-
-          it "won't warn if there is no implementation block on an expectation" do
-            expect(RSpec).not_to receive(:warn_deprecation)
-
-            klass = Struct.new(:bees)
-
-            allow_any_instance_of(klass).to receive(:foo)
-            klass.new(:faces).foo
-          end
-
-          it "won't warn if the implementation block ignores arguments", :if => (RUBY_VERSION.to_f > 1.8) do
-            expect(RSpec).not_to receive(:warn_deprecation)
-
-            klass = Struct.new(:bees)
-            allow_any_instance_of(klass).to receive(:foo) { 5 }
-            klass.new(:faces).foo
-          end
-
-          it "warns if the implementation block accepts a splat" do
-            klass = Struct.new(:bees)
-
-            expect(RSpec).to receive(:warn_deprecation).with(block_regex(__LINE__ + 1))
-            allow_any_instance_of(klass).to receive(:foo) { |*a| 5 }
-
-            klass.new(:faces).foo
-          end
-
-          it "warns if it the implementation is a lambda that expects no arguments" do
-            klass = Struct.new(:bees)
-
-            expect(RSpec).to receive(:warn_deprecation).with(block_regex(__LINE__ + 1))
-            allow_any_instance_of(klass).to receive(:foo, &lambda { 5 })
-
-            klass.new(:faces).foo
-          end
-
-          it "will warn about stubs receiving blocks in 3.0" do
-            klass = Struct.new(:bees)
-
-            expect(RSpec).to receive(:warn_deprecation).with(block_regex(__LINE__ + 1))
-            expect_any_instance_of(klass).to receive(:foo) { |args| }
-            klass.new(:faces).foo
-          end
-
-          it "won't warn if there is no implementation block on an stub" do
-            expect(RSpec).not_to receive(:warn_deprecation)
-
-            klass = Struct.new(:bees)
-
-            allow_any_instance_of(klass).to receive(:foo)
-            klass.new(:faces).foo
-          end
-        end
       end
 
       context 'when used in conjunction with a `dup`' do
@@ -1226,7 +1020,6 @@ module RSpec
           expect(instance.existing_method).to eq :stubbed_return_value
 
           RSpec::Mocks.verify
-          RSpec::Mocks.teardown
 
           expect(instance.existing_method).to eq :existing_method_return_value
         end