any_instance_spec.rb in rspec-mocks-2.12.2

- old
+ new

@@ -17,97 +17,97 @@
       let(:existing_method_return_value){ :existing_method_return_value }
 
       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
 
       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
 
         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
 
         context "with argument matching" do
           before do
@@ -115,12 +115,12 @@
             klass.any_instance.stub(:foo).with(:param_three, :param_four).and_return(:result_two)
           end
 
           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
             expect do
               klass.new.foo(:param_one, :param_three)
@@ -134,107 +134,107 @@
             klass.any_instance.stub(:bar).and_return(2)
           end
 
           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
 
         context "with #and_yield" do
           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
 
       context "with #stub!" do
@@ -247,61 +247,61 @@
 
       context "unstub implementation" do
         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
           klass.any_instance.should_receive(:existing_method_with_arguments).with(3).and_return(:three)
           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
 
       context "with #should_receive" do
@@ -309,11 +309,11 @@
         let(:existing_method_expectation_error_message) { 'Exactly one instance should have received the following message(s) but didn\'t: existing_method' }
 
         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
             expect do
               klass.any_instance.should_receive(:foo)
@@ -341,11 +341,11 @@
             klass.any_instance.should_receive(:foo)
             klass.new.foo
 
             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
             it "passes if subsequent invocations do not receive that message" do
               klass.any_instance.should_receive(:foo)
@@ -371,28 +371,28 @@
                 klass.any_instance.should_receive(:foo)
                 klass.should_receive(:woot)
                 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
 
 
             it "pass when expectations are met" do
               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
 
         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
             expect do
               klass.any_instance.should_receive(:existing_method)
@@ -442,30 +442,30 @@
             klass.any_instance.should_receive(:foo).with(:param_three, :param_four).and_return(:result_two)
           end
 
           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
             instances.each { |instance| instance.rspec_reset }
           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
             instance = klass.new
             expect do
@@ -613,11 +613,11 @@
 
             context "when combined with other expectations" do
               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
                 expect do
                   klass.any_instance.should_receive(:foo).never
@@ -642,18 +642,18 @@
             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)
-              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
                 expect do
                   klass.any_instance.should_receive(:foo).any_number_of_times
@@ -676,56 +676,56 @@
 
           context "with stubbing" do
             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
                 klass.new.existing_method
 
                 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
                 klass.new.existing_method
                 klass.new.existing_method
 
                 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
 
             context "private methods" do
               before :each do
                 klass.any_instance.stub(:private_method).and_return(:something)
                 space.verify_all
               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
 
           context "with expectations" do
@@ -735,19 +735,19 @@
                 klass.new.private_method
                 space.verify_all
               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
 
             context "ensures that the subsequent specs do not see expectations set in previous specs" do
               context "when the instance created after the expectation is set" do
@@ -755,11 +755,11 @@
                   klass.any_instance.should_receive(:existing_method).and_return(Object.new)
                   klass.new.existing_method
                 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
 
               context "when the instance created before the expectation is set" do
                 before :each do
@@ -770,55 +770,55 @@
                   klass.any_instance.should_receive(:existing_method).and_return(Object.new)
                   @instance.existing_method
                 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
 
             it "ensures that the next spec does not see that expectation" do
               klass.any_instance.should_receive(:existing_method).and_return(Object.new)
               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
 
         context "with multiple calls to any_instance in the same example" do
           it "does not prevent the change from being rolled back" do
             klass.any_instance.stub(:existing_method).and_return(false)
             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
 
       context 'when used in conjunction with a `dup`' do
         it "doesn't cause an infinite loop" do
           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
           klass = Class.new do
             undef_method :dup
@@ -832,20 +832,20 @@
             end
           end
 
           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
 
       context "when directed at a method defined on a superclass" do
         let(:sub_klass) { Class.new(klass) }
 
         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
           instance_one = sub_klass.new
           instance_two = sub_klass.new
@@ -860,28 +860,28 @@
       context "when a class overrides Object#method" do
         let(:http_request_class) { Struct.new(:method, :uri) }
 
         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
 
       context "when used after the test has finished" do
         it "restores the original behavior of a stubbed method" do
           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
   end
 end