rspec-mocks 2.12.1 → 2.12.2

data/Changelog.md

@@ -1,3 +1,18 @@
+### 2.12.2 / 2013-01-27
+[full changelog](http://github.com/rspec/rspec-mocks/compare/v2.12.1...v.2.12.2)
+
+Bug fixes
+
+* Fix `and_call_original` to work properly for methods defined
+  on a module extended onto an object instance (Myron Marston).
+* Fix `stub_const` with an undefined constnat name to work properly
+  with constant strings that are prefixed with `::` -- and edge case
+  I missed in the bug fix in the 2.12.1 release (Myron Marston).
+* Ensure method visibility on a partial mock is restored after reseting
+  method stubs, even on a singleton module (created via `extend self`)
+  when the method visibility differs between the instance and singleton
+  versions (Andy Lindeman).
+
 ### 2.12.1 / 2012-12-21
 [full changelog](http://github.com/rspec/rspec-mocks/compare/v2.12.0...v2.12.1)
 
@@ -7,6 +22,8 @@ Bug fixes
   (Myron Marston)
 * Properly restore stubbed aliased methods on rubies
   that report the incorrect owner (Myron Marston and Andy Lindeman).
+* Fix `hide_const` and `stub_const` with a defined constnat name to
+  work properly with constant strings that are prefixed with `::` (Myron Marston).
 
 ### 2.12.0 / 2012-11-12
 [full changelog](http://github.com/rspec/rspec-mocks/compare/v2.11.3...v2.12.0)

data/lib/rspec/mocks.rb

@@ -27,6 +27,14 @@ module RSpec
         @configuration ||= Configuration.new
       end
 
+      # @api private
+      # Used internally by RSpec to display custom deprecation warnings.  This
+      # is also defined in rspec-core, but we can't assume it's loaded since
+      # rspec-expectations should be usable w/o rspec-core.
+      def warn_deprecation(message)
+        warn(message)
+      end
+
     private
 
       def add_extensions

data/lib/rspec/mocks/message_expectation.rb

@@ -20,8 +20,6 @@ module RSpec
         @expected_received_count = expected_received_count
         @argument_list_matcher = ArgumentListMatcher.new(ArgumentMatchers::AnyArgsMatcher.new)
         @consecutive = false
-        @exception_to_raise = nil
-        @args_to_throw = []
         @order_group = expectation_ordering
         @at_least = @at_most = @exactly = nil
         @args_to_yield = []
@@ -141,10 +139,10 @@ module RSpec
       #   car.stub(:go).and_raise(OutOfGas.new(2, :oz))
       def and_raise(exception = RuntimeError, message = nil)
         if exception.respond_to?(:exception)
-          @exception_to_raise = message ? exception.exception(message) : exception.exception
-        else
-          @exception_to_raise = exception
+          exception = message ? exception.exception(message) : exception.exception
         end
+
+        self.implementation = Proc.new { raise exception }
       end
 
       # @overload and_throw(symbol)
@@ -157,8 +155,8 @@ module RSpec
       #
       #   car.stub(:go).and_throw(:out_of_gas)
       #   car.stub(:go).and_throw(:out_of_gas, :level => 0.1)
-      def and_throw(symbol, object = nil)
-        @args_to_throw = [symbol, object].compact
+      def and_throw(*args)
+        self.implementation = Proc.new { throw *args }
       end
 
       # Tells the object to yield one or more args to a block when the message
@@ -195,9 +193,6 @@ module RSpec
         @order_group.handle_order_constraint self
 
         begin
-          raise(@exception_to_raise) unless @exception_to_raise.nil?
-          Kernel::throw(*@args_to_throw) unless @args_to_throw.empty?
-
           default_return_val = call_with_yield(&block) if !@args_to_yield.empty? || @eval_context
 
           if @consecutive
@@ -493,7 +488,7 @@ module RSpec
       def and_return(*)
         # no-op
         # @deprecated and_return is not supported with negative message expectations.
-        RSpec.warn_deprecation <<-MSG
+        RSpec::Mocks.warn_deprecation <<-MSG
 
 DEPRECATION: `and_return` with `should_not_receive` is deprecated. Called from #{caller(0)[1]}
 MSG

data/lib/rspec/mocks/method_double.rb

@@ -56,8 +56,8 @@ module RSpec
           meth
         else
           begin
-            # Example: an instance method defined on @object's class.
-            @object.class.instance_method(@method_name).bind(@object)
+            # Example: an instance method defined on one of @object's ancestors.
+            original_method_from_ancestor(object_singleton_class.ancestors)
           rescue NameError
             raise unless @object.respond_to?(:superclass)
 
@@ -97,6 +97,14 @@ module RSpec
         any_instance_class_recorder_observing_method?(superklass)
       end
 
+      def original_method_from_ancestor(ancestors)
+        klass, *rest = ancestors
+        klass.instance_method(@method_name).bind(@object)
+      rescue NameError
+        raise if rest.empty?
+        original_method_from_ancestor(rest)
+      end
+
       if RUBY_VERSION.to_f > 1.8
         # @private
         def original_method_from_superclass
@@ -145,6 +153,7 @@ module RSpec
       def configure_method
         RSpec::Mocks::space.add(@object) if RSpec::Mocks::space
         warn_if_nil_class
+        @original_visibility = visibility_for_method
         @method_stasher.stash unless @method_is_proxied
         define_proxy_method
       end
@@ -173,9 +182,17 @@ module RSpec
 
         object_singleton_class.__send__(:remove_method, @method_name)
         @method_stasher.restore
+        restore_original_visibility
+
         @method_is_proxied = false
       end
 
+      # @private
+      def restore_original_visibility
+        return unless object_singleton_class.method_defined?(@method_name) || object_singleton_class.private_method_defined?(@method_name)
+        object_singleton_class.class_eval(@original_visibility, __FILE__, __LINE__)
+      end
+
       # @private
       def verify
         expectations.each {|e| e.verify_messages_received}

data/lib/rspec/mocks/mutate_const.rb

@@ -199,7 +199,7 @@ module RSpec
         attr_reader :original_value, :full_constant_name
 
         def initialize(full_constant_name, mutated_value, transfer_nested_constants)
-          @full_constant_name        = full_constant_name
+          @full_constant_name        = normalize_const_name(full_constant_name)
           @mutated_value             = mutated_value
           @transfer_nested_constants = transfer_nested_constants
           @context_parts             = @full_constant_name.split('::')

data/lib/rspec/mocks/proxy.rb

@@ -64,7 +64,7 @@ module RSpec
       end
 
       # @private
-      def add_message_expectation(location, method_name, opts={}, &block)        
+      def add_message_expectation(location, method_name, opts={}, &block)
         meth_double = method_double[method_name]
 
         if null_object? && !block

data/lib/rspec/mocks/version.rb

@@ -1,7 +1,7 @@
 module RSpec
   module Mocks
     module Version
-      STRING = '2.12.1'
+      STRING = '2.12.2'
     end
   end
 end

data/lib/spec/mocks.rb

@@ -1,2 +1,6 @@
 # For backward compatibility with rspec-1
 require 'rspec/mocks'
+
+RSpec::Mocks.warn_deprecation "\nDEPRECATION: `require 'spec/mocks' " +
+ " is deprecated. Please require 'rspec/mocks' instead."
+

data/spec/rspec/mocks/and_call_original_spec.rb

@@ -37,6 +37,28 @@ describe "and_call_original" do
       expect(instance.foo).to eq(:bar)
     end
 
+    it 'works for methods added through an extended module' do
+      instance.extend Module.new { def foo; :bar; end }
+      instance.should_receive(:foo).and_call_original
+      expect(instance.foo).to eq(:bar)
+    end
+
+    it "works for method added through an extended module onto a class's ancestor" do
+      sub_sub_klass = Class.new(Class.new(klass))
+      klass.extend Module.new { def foo; :bar; end }
+      sub_sub_klass.should_receive(:foo).and_call_original
+      expect(sub_sub_klass.foo).to eq(:bar)
+    end
+
+    it "finds the method on the most direct ancestor 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)
+      sub_klass.extend Module.new { def foo; :sub_klass_bar; end }
+      sub_klass.should_receive(:foo).and_call_original
+      expect(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

data/spec/rspec/mocks/and_yield_spec.rb

@@ -6,18 +6,18 @@ describe RSpec::Mocks::Mock do
 
   describe "#and_yield" do
     context "with eval context as block argument" do
-      
+
       it "evaluates the supplied block as it is read" do
         evaluated = false
         obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
           evaluated = true
         end
-        evaluated.should be_true
+        expect(evaluated).to be_true
       end
 
       it "passes an eval context object to the supplied block" do
         obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
-          eval_context.should_not be_nil
+          expect(eval_context).not_to be_nil
         end
       end
 
@@ -33,7 +33,7 @@ describe RSpec::Mocks::Mock do
           actual_eval_context = self
         end
 
-        actual_eval_context.should equal(expected_eval_context)
+        expect(actual_eval_context).to equal(expected_eval_context)
       end
 
       context "and no yielded arguments" do
@@ -63,7 +63,7 @@ describe RSpec::Mocks::Mock do
             # foo is not called here
           end
 
-          lambda {configured_eval_context.rspec_verify}.should raise_error(RSpec::Mocks::MockExpectationError)
+          expect { configured_eval_context.rspec_verify }.to raise_error(RSpec::Mocks::MockExpectationError)
         end
 
       end
@@ -102,8 +102,8 @@ describe RSpec::Mocks::Mock do
             # foo is not called here
           end
 
-          lambda {configured_eval_context.rspec_verify}.should raise_error(RSpec::Mocks::MockExpectationError)
-          lambda {yielded_arg.rspec_verify}.should raise_error(RSpec::Mocks::MockExpectationError)
+          expect { configured_eval_context.rspec_verify }.to raise_error(RSpec::Mocks::MockExpectationError)
+          expect { yielded_arg.rspec_verify }.to raise_error(RSpec::Mocks::MockExpectationError)
         end
 
       end

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

@@ -7,13 +7,13 @@ describe RSpec::Mocks::AnyInstance::MessageChains do
 
   it "knows if a method does not have an expectation set on it" do
     chains.add(:method_name, stub_chain)
-    chains.has_expectation?(:method_name).should be_false
+    expect(chains.has_expectation?(:method_name)).to be_false
   end
 
   it "knows if a method has an expectation set on it" do
     chains.add(:method_name, stub_chain)
     chains.add(:method_name, expectation_chain)
-    chains.has_expectation?(:method_name).should be_true
+    expect(chains.has_expectation?(:method_name)).to be_true
   end
 
   it "can remove all stub chains" do
@@ -22,19 +22,19 @@ describe RSpec::Mocks::AnyInstance::MessageChains do
     chains.add(:method_name, RSpec::Mocks::AnyInstance::StubChain.new)
 
     chains.remove_stub_chains_for!(:method_name)
-    chains[:method_name].should eq([expectation_chain])
+    expect(chains[:method_name]).to eq([expectation_chain])
   end
-  
+
   context "creating stub chains" do
     it "understands how to add a stub chain for a method" do
       chains.add(:method_name, stub_chain)
-      chains[:method_name].should eq([stub_chain])
+      expect(chains[:method_name]).to eq([stub_chain])
     end
 
     it "allows multiple stub chains for a method" do
       chains.add(:method_name, stub_chain)
       chains.add(:method_name, another_stub_chain = RSpec::Mocks::AnyInstance::StubChain.new)
-      chains[:method_name].should eq([stub_chain, another_stub_chain])
+      expect(chains[:method_name]).to eq([stub_chain, another_stub_chain])
     end
   end
 end

data/spec/rspec/mocks/any_instance_spec.rb

@@ -19,41 +19,41 @@ module RSpec
       context "invocation order" do
         context "#stub" do
           it "raises an error if 'stub' follows 'with'" do
-            lambda{ klass.any_instance.with("1").stub(:foo) }.should raise_error(NoMethodError)
+            expect { klass.any_instance.with("1").stub(:foo) }.to raise_error(NoMethodError)
           end
 
           it "raises an error if 'with' follows 'and_return'" do
-            lambda{ klass.any_instance.stub(:foo).and_return(1).with("1") }.should raise_error(NoMethodError)
+            expect { klass.any_instance.stub(:foo).and_return(1).with("1") }.to raise_error(NoMethodError)
           end
 
           it "raises an error if 'with' follows 'and_raise'" do
-            lambda{ klass.any_instance.stub(:foo).and_raise(1).with("1") }.should raise_error(NoMethodError)
+            expect { klass.any_instance.stub(:foo).and_raise(1).with("1") }.to raise_error(NoMethodError)
           end
 
           it "raises an error if 'with' follows 'and_yield'" do
-            lambda{ klass.any_instance.stub(:foo).and_yield(1).with("1") }.should raise_error(NoMethodError)
+            expect { klass.any_instance.stub(:foo).and_yield(1).with("1") }.to raise_error(NoMethodError)
           end
         end
 
         context "#stub_chain" do
           it "raises an error if 'stub_chain' follows 'any_instance'" do
-            lambda{ klass.any_instance.and_return("1").stub_chain(:foo, :bar) }.should raise_error(NoMethodError)
+            expect { klass.any_instance.and_return("1").stub_chain(:foo, :bar) }.to raise_error(NoMethodError)
           end
         end
 
         context "#should_receive" do
           it "raises an error if 'should_receive' follows 'with'" do
-            lambda{ klass.any_instance.with("1").should_receive(:foo) }.should raise_error(NoMethodError)
+            expect { klass.any_instance.with("1").should_receive(:foo) }.to raise_error(NoMethodError)
           end
 
           it "raises an error if 'with' follows 'and_return'" do
             pending "see Github issue #42"
-            lambda{ klass.any_instance.should_receive(:foo).and_return(1).with("1") }.should raise_error(NoMethodError)
+            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
             pending "see Github issue #42"
-            lambda{ klass.any_instance.should_receive(:foo).and_raise(1).with("1") }.should raise_error(NoMethodError)
+            expect { klass.any_instance.should_receive(:foo).and_raise(1).with("1") }.to raise_error(NoMethodError)
           end
         end
       end
@@ -61,36 +61,36 @@ module RSpec
       context "with #stub" do
         it "does not suppress an exception when a method that doesn't exist is invoked" do
           klass.any_instance.stub(:foo)
-          lambda{ klass.new.bar }.should raise_error(NoMethodError)
+          expect { klass.new.bar }.to raise_error(NoMethodError)
         end
 
         context 'multiple methods' do
           it "allows multiple methods to be stubbed in a single invocation" do
             klass.any_instance.stub(:foo => 'foo', :bar => 'bar')
             instance = klass.new
-            instance.foo.should eq('foo')
-            instance.bar.should eq('bar')
+            expect(instance.foo).to eq('foo')
+            expect(instance.bar).to eq('bar')
           end
 
           it "adheres to the contract of multiple method stubbing withou any instance" do
-            Object.new.stub(:foo => 'foo', :bar => 'bar').should eq(:foo => 'foo', :bar => 'bar')
-            klass.any_instance.stub(:foo => 'foo', :bar => 'bar').should eq(:foo => 'foo', :bar => 'bar')
+            expect(Object.new.stub(:foo => 'foo', :bar => 'bar')).to eq(:foo => 'foo', :bar => 'bar')
+            expect(klass.any_instance.stub(:foo => 'foo', :bar => 'bar')).to eq(:foo => 'foo', :bar => 'bar')
           end
 
           context "allows a chain of methods to be stubbed using #stub_chain" do
             it "given symbols representing the methods" do
               klass.any_instance.stub_chain(:one, :two, :three).and_return(:four)
-              klass.new.one.two.three.should eq(:four)
+              expect(klass.new.one.two.three).to eq(:four)
             end
 
             it "given a hash as the last argument uses the value as the expected return value" do
               klass.any_instance.stub_chain(:one, :two, :three => :four)
-              klass.new.one.two.three.should eq(:four)
+              expect(klass.new.one.two.three).to eq(:four)
             end
 
             it "given a string of '.' separated method names representing the chain" do
               klass.any_instance.stub_chain('one.two.three').and_return(:four)
-              klass.new.one.two.three.should eq(:four)
+              expect(klass.new.one.two.three).to eq(:four)
             end
           end
         end
@@ -98,14 +98,14 @@ module RSpec
         context "behaves as 'every instance'" do
           it "stubs every instance in the spec" do
             klass.any_instance.stub(:foo).and_return(result = Object.new)
-            klass.new.foo.should eq(result)
-            klass.new.foo.should eq(result)
+            expect(klass.new.foo).to eq(result)
+            expect(klass.new.foo).to eq(result)
           end
 
           it "stubs instance created before any_instance was called" do
             instance = klass.new
             klass.any_instance.stub(:foo).and_return(result = Object.new)
-            instance.foo.should eq(result)
+            expect(instance.foo).to eq(result)
           end
         end
 
@@ -117,8 +117,8 @@ module RSpec
 
           it "returns the stubbed value when arguments match" do
             instance = klass.new
-            instance.foo(:param_one, :param_two).should eq(:result_one)
-            instance.foo(:param_three, :param_four).should eq(:result_two)
+            expect(instance.foo(:param_one, :param_two)).to eq(:result_one)
+            expect(instance.foo(:param_three, :param_four)).to eq(:result_two)
           end
 
           it "fails the spec with an expectation error when the arguments do not match" do
@@ -136,32 +136,32 @@ module RSpec
 
           it "stubs a method" do
             instance = klass.new
-            instance.foo.should eq(1)
-            instance.bar.should eq(2)
+            expect(instance.foo).to eq(1)
+            expect(instance.bar).to eq(2)
           end
 
           it "returns the same value for calls on different instances" do
-            klass.new.foo.should eq(klass.new.foo)
-            klass.new.bar.should eq(klass.new.bar)
+            expect(klass.new.foo).to eq(klass.new.foo)
+            expect(klass.new.bar).to eq(klass.new.bar)
           end
         end
 
         context "with #and_return" do
           it "stubs a method that doesn't exist" do
             klass.any_instance.stub(:foo).and_return(1)
-            klass.new.foo.should eq(1)
+            expect(klass.new.foo).to eq(1)
           end
 
           it "stubs a method that exists" do
             klass.any_instance.stub(:existing_method).and_return(1)
-            klass.new.existing_method.should eq(1)
+            expect(klass.new.existing_method).to eq(1)
           end
 
           it "returns the same object for calls on different instances" do
             return_value = Object.new
             klass.any_instance.stub(:foo).and_return(return_value)
-            klass.new.foo.should be(return_value)
-            klass.new.foo.should be(return_value)
+            expect(klass.new.foo).to be(return_value)
+            expect(klass.new.foo).to be(return_value)
           end
         end
 
@@ -169,70 +169,70 @@ module RSpec
           it "yields the value specified" do
             yielded_value = Object.new
             klass.any_instance.stub(:foo).and_yield(yielded_value)
-            klass.new.foo{|value| value.should be(yielded_value)}
+            klass.new.foo{|value| expect(value).to be(yielded_value)}
           end
         end
 
         context "with #and_raise" do
           it "stubs a method that doesn't exist" do
             klass.any_instance.stub(:foo).and_raise(CustomErrorForAnyInstanceSpec)
-            lambda{ klass.new.foo}.should raise_error(CustomErrorForAnyInstanceSpec)
+            expect { klass.new.foo}.to raise_error(CustomErrorForAnyInstanceSpec)
           end
 
           it "stubs a method that exists" do
             klass.any_instance.stub(:existing_method).and_raise(CustomErrorForAnyInstanceSpec)
-            lambda{ klass.new.existing_method}.should raise_error(CustomErrorForAnyInstanceSpec)
+            expect { klass.new.existing_method}.to raise_error(CustomErrorForAnyInstanceSpec)
           end
         end
 
         context "with a block" do
           it "stubs a method" do
             klass.any_instance.stub(:foo) { 1 }
-            klass.new.foo.should eq(1)
+            expect(klass.new.foo).to eq(1)
           end
 
           it "returns the same computed value for calls on different instances" do
             klass.any_instance.stub(:foo) { 1 + 2 }
-            klass.new.foo.should eq(klass.new.foo)
+            expect(klass.new.foo).to eq(klass.new.foo)
           end
         end
 
         context "core ruby objects" do
           it "works uniformly across *everything*" do
             Object.any_instance.stub(:foo).and_return(1)
-            Object.new.foo.should eq(1)
+            expect(Object.new.foo).to eq(1)
           end
 
           it "works with the non-standard constructor []" do
             Array.any_instance.stub(:foo).and_return(1)
-            [].foo.should eq(1)
+            expect([].foo).to eq(1)
           end
 
           it "works with the non-standard constructor {}" do
             Hash.any_instance.stub(:foo).and_return(1)
-            {}.foo.should eq(1)
+            expect({}.foo).to eq(1)
           end
 
           it "works with the non-standard constructor \"\"" do
             String.any_instance.stub(:foo).and_return(1)
-            "".foo.should eq(1)
+            expect("".foo).to eq(1)
           end
 
           it "works with the non-standard constructor \'\'" do
             String.any_instance.stub(:foo).and_return(1)
-            ''.foo.should eq(1)
+            expect(''.foo).to eq(1)
           end
 
           it "works with the non-standard constructor module" do
             Module.any_instance.stub(:foo).and_return(1)
             module RSpec::SampleRspecTestModule;end
-            RSpec::SampleRspecTestModule.foo.should eq(1)
+            expect(RSpec::SampleRspecTestModule.foo).to eq(1)
           end
 
           it "works with the non-standard constructor class" do
             Class.any_instance.stub(:foo).and_return(1)
             class RSpec::SampleRspecTestClass;end
-            RSpec::SampleRspecTestClass.foo.should eq(1)
+            expect(RSpec::SampleRspecTestClass.foo).to eq(1)
           end
         end
       end
@@ -249,14 +249,14 @@ module RSpec
         it "replaces the stubbed method with the original method" do
           klass.any_instance.stub(:existing_method)
           klass.any_instance.unstub(:existing_method)
-          klass.new.existing_method.should eq(:existing_method_return_value)
+          expect(klass.new.existing_method).to eq(:existing_method_return_value)
         end
 
         it "removes all stubs with the supplied method name" do
           klass.any_instance.stub(:existing_method).with(1)
           klass.any_instance.stub(:existing_method).with(2)
           klass.any_instance.unstub(:existing_method)
-          klass.new.existing_method.should eq(:existing_method_return_value)
+          expect(klass.new.existing_method).to eq(:existing_method_return_value)
         end
 
         it "does not remove any expectations with the same method name" do
@@ -264,42 +264,42 @@ module RSpec
           klass.any_instance.stub(:existing_method_with_arguments).with(1)
           klass.any_instance.stub(:existing_method_with_arguments).with(2)
           klass.any_instance.unstub(:existing_method_with_arguments)
-          klass.new.existing_method_with_arguments(3).should eq(:three)
+          expect(klass.new.existing_method_with_arguments(3)).to eq(:three)
         end
 
         it "raises a MockExpectationError if the method has not been stubbed" do
-          lambda do
+          expect {
             klass.any_instance.unstub(:existing_method)
-          end.should raise_error(RSpec::Mocks::MockExpectationError, 'The method `existing_method` was not stubbed or was already unstubbed')
+          }.to raise_error(RSpec::Mocks::MockExpectationError, 'The method `existing_method` was not stubbed or was already unstubbed')
         end
       end
 
       context "with #should_not_receive" do
         it "fails if the method is called" do
           klass.any_instance.should_not_receive(:existing_method)
-          lambda { klass.new.existing_method }.should raise_error(RSpec::Mocks::MockExpectationError)
+          expect { klass.new.existing_method }.to raise_error(RSpec::Mocks::MockExpectationError)
         end
 
         it "passes if no method is called" do
-          lambda { klass.any_instance.should_not_receive(:existing_method) }.should_not raise_error
+          expect { klass.any_instance.should_not_receive(:existing_method) }.to_not raise_error
         end
 
         it "passes if only a different method is called" do
           klass.any_instance.should_not_receive(:existing_method)
-          lambda { klass.new.another_existing_method }.should_not raise_error
+          expect { klass.new.another_existing_method }.to_not raise_error
         end
 
         context "with constraints" do
           it "fails if the method is called with the specified parameters" do
             klass.any_instance.should_not_receive(:existing_method_with_arguments).with(:argument_one, :argument_two)
-            lambda do
+            expect {
               klass.new.existing_method_with_arguments(:argument_one, :argument_two)
-            end.should raise_error(RSpec::Mocks::MockExpectationError)
+            }.to raise_error(RSpec::Mocks::MockExpectationError)
           end
 
           it "passes if the method is called with different parameters" do
             klass.any_instance.should_not_receive(:existing_method_with_arguments).with(:argument_one, :argument_two)
-            lambda { klass.new.existing_method_with_arguments(:argument_three, :argument_four) }.should_not raise_error
+            expect { klass.new.existing_method_with_arguments(:argument_three, :argument_four) }.to_not raise_error
           end
         end
       end
@@ -311,7 +311,7 @@ module RSpec
         context "with an expectation is set on a method which does not exist" do
           it "returns the expected value" do
             klass.any_instance.should_receive(:foo).and_return(1)
-            klass.new.foo(1).should eq(1)
+            expect(klass.new.foo(1)).to eq(1)
           end
 
           it "fails if an instance is created but no invocation occurs" do
@@ -343,7 +343,7 @@ module RSpec
 
             instance = klass.new
             instance.should_receive(:foo).and_return(result = Object.new)
-            instance.foo.should eq(result)
+            expect(instance.foo).to eq(result)
           end
 
           context "behaves as 'exactly one instance'" do
@@ -373,7 +373,7 @@ module RSpec
                 klass.new.foo
                 klass.rspec_verify
               end.to(raise_error(RSpec::Mocks::MockExpectationError) do |error|
-                error.message.should_not eq(existing_method_expectation_error_message)
+                expect(error.message).not_to eq(existing_method_expectation_error_message)
               end)
             end
 
@@ -382,7 +382,7 @@ module RSpec
               klass.any_instance.should_receive(:foo)
               klass.should_receive(:woot).and_return(result = Object.new)
               klass.new.foo
-              klass.woot.should eq(result)
+              expect(klass.woot).to eq(result)
             end
           end
         end
@@ -390,7 +390,7 @@ module RSpec
         context "with an expectation is set on a method that exists" do
           it "returns the expected value" do
             klass.any_instance.should_receive(:existing_method).and_return(1)
-            klass.new.existing_method(1).should eq(1)
+            expect(klass.new.existing_method(1)).to eq(1)
           end
 
           it "fails if an instance is created but no invocation occurs" do
@@ -444,15 +444,15 @@ module RSpec
 
           it "returns the expected value when arguments match" do
             instance = klass.new
-            instance.foo(:param_one, :param_two).should eq(:result_one)
-            instance.foo(:param_three, :param_four).should eq(:result_two)
+            expect(instance.foo(:param_one, :param_two)).to eq(:result_one)
+            expect(instance.foo(:param_three, :param_four)).to eq(:result_two)
           end
 
           it "fails when the arguments match but different instances are used" do
             instances = Array.new(2) { klass.new }
             expect do
-              instances[0].foo(:param_one, :param_two).should eq(:result_one)
-              instances[1].foo(:param_three, :param_four).should eq(:result_two)
+              expect(instances[0].foo(:param_one, :param_two)).to eq(:result_one)
+              expect(instances[1].foo(:param_three, :param_four)).to eq(:result_two)
             end.to raise_error(RSpec::Mocks::MockExpectationError)
 
             # ignore the fact that should_receive expectations were not met
@@ -460,10 +460,10 @@ module RSpec
           end
 
           it "is not affected by the invocation of existing methods on other instances" do
-            klass.new.existing_method_with_arguments(:param_one, :param_two).should eq(:existing_method_with_arguments_return_value)
+            expect(klass.new.existing_method_with_arguments(:param_one, :param_two)).to eq(:existing_method_with_arguments_return_value)
             instance = klass.new
-            instance.foo(:param_one, :param_two).should eq(:result_one)
-            instance.foo(:param_three, :param_four).should eq(:result_two)
+            expect(instance.foo(:param_one, :param_two)).to eq(:result_one)
+            expect(instance.foo(:param_three, :param_four)).to eq(:result_two)
           end
 
           it "fails when arguments do not match" do
@@ -615,7 +615,7 @@ module RSpec
               it "passes when the other expecations are met" do
                 klass.any_instance.should_receive(:foo).never
                 klass.any_instance.should_receive(:existing_method).and_return(5)
-                klass.new.existing_method.should eq(5)
+                expect(klass.new.existing_method).to eq(5)
               end
 
               it "fails when the other expecations are not met" do
@@ -644,14 +644,14 @@ module RSpec
             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)
-              klass.new.existing_method.should eq(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)
-                klass.new.existing_method.should eq(5)
+                expect(klass.new.existing_method).to eq(5)
               end
 
               it "fails when the other expecations are not met" do
@@ -678,14 +678,14 @@ module RSpec
             context "public methods" do
               before(:each) do
                 klass.any_instance.stub(:existing_method).and_return(1)
-                klass.method_defined?(:__existing_method_without_any_instance__).should be_true
+                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_true
               end
 
               it "restores the class to its original state after each example when no instance is created" do
                 space.verify_all
 
-                klass.method_defined?(:__existing_method_without_any_instance__).should be_false
-                klass.new.existing_method.should eq(existing_method_return_value)
+                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_false
+                expect(klass.new.existing_method).to eq(existing_method_return_value)
               end
 
               it "restores the class to its original state after each example when one instance is created" do
@@ -693,8 +693,8 @@ module RSpec
 
                 space.verify_all
 
-                klass.method_defined?(:__existing_method_without_any_instance__).should be_false
-                klass.new.existing_method.should eq(existing_method_return_value)
+                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_false
+                expect(klass.new.existing_method).to eq(existing_method_return_value)
               end
 
               it "restores the class to its original state after each example when more than one instance is created" do
@@ -703,8 +703,8 @@ module RSpec
 
                 space.verify_all
 
-                klass.method_defined?(:__existing_method_without_any_instance__).should be_false
-                klass.new.existing_method.should eq(existing_method_return_value)
+                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_false
+                expect(klass.new.existing_method).to eq(existing_method_return_value)
               end
             end
 
@@ -715,15 +715,15 @@ module RSpec
               end
 
               it "cleans up the backed up method" do
-                klass.method_defined?(:__existing_method_without_any_instance__).should be_false
+                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_false
               end
 
               it "restores a stubbed private method after the spec is run" do
-                klass.private_method_defined?(:private_method).should be_true
+                expect(klass.private_method_defined?(:private_method)).to be_true
               end
 
               it "ensures that the restored method behaves as it originally did" do
-                klass.new.send(:private_method).should eq(:private_method_return_value)
+                expect(klass.new.send(:private_method)).to eq(:private_method_return_value)
               end
             end
           end
@@ -737,15 +737,15 @@ module RSpec
               end
 
               it "cleans up the backed up method" do
-                klass.method_defined?(:__existing_method_without_any_instance__).should be_false
+                expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_false
               end
 
               it "restores a stubbed private method after the spec is run" do
-                klass.private_method_defined?(:private_method).should be_true
+                expect(klass.private_method_defined?(:private_method)).to be_true
               end
 
               it "ensures that the restored method behaves as it originally did" do
-                klass.new.send(:private_method).should eq(:private_method_return_value)
+                expect(klass.new.send(:private_method)).to eq(:private_method_return_value)
               end
             end
 
@@ -757,7 +757,7 @@ module RSpec
                 end
 
                 it "second spec" do
-                  klass.new.existing_method.should eq(existing_method_return_value)
+                  expect(klass.new.existing_method).to eq(existing_method_return_value)
                 end
               end
 
@@ -772,7 +772,7 @@ module RSpec
                 end
 
                 it "second spec" do
-                  @instance.existing_method.should eq(existing_method_return_value)
+                  expect(@instance.existing_method).to eq(existing_method_return_value)
                 end
               end
             end
@@ -782,7 +782,7 @@ module RSpec
               klass.new.existing_method
               space.verify_all
 
-              klass.new.existing_method.should eq(existing_method_return_value)
+              expect(klass.new.existing_method).to eq(existing_method_return_value)
             end
           end
         end
@@ -793,21 +793,21 @@ module RSpec
             klass.any_instance.stub(:existing_method).and_return(true)
 
             klass.rspec_verify
-            klass.new.should respond_to(:existing_method)
-            klass.new.existing_method.should eq(existing_method_return_value)
+            expect(klass.new).to respond_to(:existing_method)
+            expect(klass.new.existing_method).to eq(existing_method_return_value)
           end
         end
 
         it "adds an class to the current space when #any_instance is invoked" do
           klass.any_instance
-          RSpec::Mocks::space.send(:receivers).should include(klass)
+          expect(RSpec::Mocks::space.send(:receivers)).to include(klass)
         end
 
         it "adds an instance to the current space when stubbed method is invoked" do
           klass.any_instance.stub(:foo)
           instance = klass.new
           instance.foo
-          RSpec::Mocks::space.send(:receivers).should include(instance)
+          expect(RSpec::Mocks::space.send(:receivers)).to include(instance)
         end
       end
 
@@ -816,7 +816,7 @@ module RSpec
           Object.any_instance.stub(:some_method)
           o = Object.new
           o.some_method
-          lambda { o.dup.some_method }.should_not raise_error(SystemStackError)
+          expect { o.dup.some_method }.to_not raise_error(SystemStackError)
         end
 
         it "doesn't bomb if the object doesn't support `dup`" do
@@ -834,7 +834,7 @@ module RSpec
 
           klass.any_instance
 
-          lambda { klass.new.dup('Dup dup dup') }.should_not raise_error(ArgumentError)
+          expect { klass.new.dup('Dup dup dup') }.to_not raise_error(ArgumentError)
         end
       end
 
@@ -843,7 +843,7 @@ module RSpec
 
         it "stubs the method correctly" do
           klass.any_instance.stub(:existing_method).and_return("foo")
-          sub_klass.new.existing_method.should == "foo"
+          expect(sub_klass.new.existing_method).to eq "foo"
         end
 
         it "mocks the method correctly" do
@@ -862,12 +862,12 @@ module RSpec
 
         it "stubs the method correctly" do
           http_request_class.any_instance.stub(:existing_method).and_return("foo")
-          http_request_class.new.existing_method.should == "foo"
+          expect(http_request_class.new.existing_method).to eq "foo"
         end
 
         it "mocks the method correctly" do
           http_request_class.any_instance.should_receive(:existing_method).and_return("foo")
-          http_request_class.new.existing_method.should == "foo"
+          expect(http_request_class.new.existing_method).to eq "foo"
         end
       end
 
@@ -876,11 +876,11 @@ module RSpec
           klass.any_instance.stub(:existing_method).and_return(:stubbed_return_value)
 
           instance = klass.new
-          instance.existing_method.should == :stubbed_return_value
+          expect(instance.existing_method).to eq :stubbed_return_value
 
           RSpec::Mocks.verify
 
-          instance.existing_method.should == :existing_method_return_value
+          expect(instance.existing_method).to eq :existing_method_return_value
         end
       end
     end