rspec-mocks 2.6.0 → 2.7.0.rc1

data/spec/rspec/mocks/any_instance_spec.rb

@@ -1,3 +1,4 @@
+
 require 'spec_helper'
 
 module RSpec
@@ -8,6 +9,7 @@ module RSpec
       let(:klass) do
         Class.new do
           def existing_method; :existing_method_return_value; end
+          def existing_method_with_arguments(arg_one, arg_two = nil); :existing_method_with_arguments_return_value; end
           def another_existing_method; end
         end
       end
@@ -31,7 +33,13 @@ module RSpec
             lambda{ klass.any_instance.stub(:foo).and_yield(1).with("1") }.should 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)
+          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)
@@ -48,13 +56,44 @@ module RSpec
           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)
         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')
+          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')
+          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)
+            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)
+            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)
+            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)
@@ -68,6 +107,43 @@ module RSpec
             instance.foo.should eq(result)
           end
         end
+        
+        context "with argument matching" do
+          before do 
+            klass.any_instance.stub(:foo).with(:param_one, :param_two).and_return(:result_one)
+            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)
+          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)
+            end.to(raise_error(RSpec::Mocks::MockExpectationError))
+          end
+        end
+        
+        context "with multiple stubs" do
+          before do 
+            klass.any_instance.stub(:foo).and_return(1) 
+            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)
+          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)
+          end
+        end
 
         context "with #and_return" do
           it "stubs a method that doesn't exist" do
@@ -159,7 +235,35 @@ module RSpec
           end
         end
       end
+      
+      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)
+        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)
+        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
+        end
 
+        it "raises a MockExpectationError if the method has not been stubbed" do
+          lambda do
+            klass.any_instance.unstub(:existing_method)
+          end.should raise_error(RSpec::Mocks::MockExpectationError, 'The method `existing_method` was not stubbed or was already unstubbed')
+        end
+      end
       context "with #should_receive" do
         let(:foo_expectation_error_message) { 'Exactly one instance should have received the following message(s) but didn\'t: foo' }
         let(:existing_method_expectation_error_message) { 'Exactly one instance should have received the following message(s) but didn\'t: existing_method' }
@@ -292,6 +396,47 @@ module RSpec
           end
         end
 
+        context "with argument matching" do
+          before do 
+            klass.any_instance.should_receive(:foo).with(:param_one, :param_two).and_return(:result_one)
+            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)
+          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)
+            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)
+            instance = klass.new
+            instance.foo(:param_one, :param_two).should eq(:result_one)
+            instance.foo(:param_three, :param_four).should eq(:result_two)
+          end
+          
+          it "fails when arguments do not match" do
+            instance = klass.new
+            expect do
+              instance.foo(:param_one, :param_three)
+            end.to raise_error(RSpec::Mocks::MockExpectationError)
+
+            # ignore the fact that should_receive expectations were not met
+            instance.rspec_reset
+          end
+        end
+
         context "message count" do
           context "the 'once' constraint" do
             it "passes for one invocation" do

data/spec/rspec/mocks/any_number_of_times_spec.rb

@@ -24,7 +24,7 @@ describe "AnyNumberOfTimes" do
   it "returns the mocked value when called after a similar stub" do
     @mock.stub(:message).and_return :stub_value
     @mock.should_receive(:message).any_number_of_times.and_return(:mock_value)
-    @mock.message.should == :mock_value
-    @mock.message.should == :mock_value
+    @mock.message.should eq :mock_value
+    @mock.message.should eq :mock_value
   end
 end

data/spec/rspec/mocks/argument_expectation_spec.rb

@@ -3,12 +3,23 @@ require 'spec_helper'
 module RSpec
   module Mocks
     describe ArgumentExpectation do
-      it "considers an object that responds to #matches? and #description to be a matcher" do
+      
+      it "considers an object that responds to #matches? and #failure_message_for_should to be a matcher" do
         argument_expecatation = RSpec::Mocks::ArgumentExpectation.new
         obj = double("matcher")
         obj.stub(:respond_to?).with(:__rspec_double_acting_as_null_object?).and_return(false)
         obj.stub(:respond_to?).with(:matches?).and_return(true)
-        obj.stub(:respond_to?).with(:description).and_return(true)
+        obj.stub(:respond_to?).with(:failure_message_for_should).and_return(true)
+        argument_expecatation.is_matcher?(obj).should be_true
+      end
+      
+      it "considers an object that responds to #matches? and #failure_message to be a matcher for backward compatibility" do
+        argument_expecatation = RSpec::Mocks::ArgumentExpectation.new
+        obj = double("matcher")
+        obj.stub(:respond_to?).with(:__rspec_double_acting_as_null_object?).and_return(false)
+        obj.stub(:respond_to?).with(:matches?).and_return(true)
+        obj.stub(:respond_to?).with(:failure_message_for_should).and_return(false)
+        obj.stub(:respond_to?).with(:failure_message).and_return(true)
         argument_expecatation.is_matcher?(obj).should be_true
       end
 
@@ -17,7 +28,8 @@ module RSpec
         obj = double("matcher")
         obj.stub(:respond_to?).with(:__rspec_double_acting_as_null_object?).and_return(false)
         obj.stub(:respond_to?).with(:matches?).and_return(true)
-        obj.stub(:respond_to?).with(:description).and_return(false)
+        obj.stub(:respond_to?).with(:failure_message_for_should).and_return(false)
+        obj.stub(:respond_to?).with(:failure_message).and_return(false)
         argument_expecatation.is_matcher?(obj).should be_false
       end
     end

data/spec/rspec/mocks/at_least_spec.rb

@@ -95,7 +95,7 @@ module RSpec
 
       it "returns the value given by a block when the at least once method is called" do
         @mock.should_receive(:to_s).at_least(:once) { "testing" }
-        @mock.to_s.should == "testing"
+        @mock.to_s.should eq "testing"
         @mock.rspec_verify
       end
     end

data/spec/rspec/mocks/at_most_spec.rb

@@ -91,7 +91,7 @@ module RSpec
 
       it "returns the value given by a block when the at most once method is called" do
         @mock.should_receive(:to_s).at_most(:once) { "testing" }
-        @mock.to_s.should == "testing"
+        @mock.to_s.should eq "testing"
         @mock.rspec_verify
       end
     end

data/spec/rspec/mocks/bug_report_10263_spec.rb

@@ -18,7 +18,7 @@ describe "Double" do
     begin
       test_double.foobar
     rescue Exception => e
-      e.message.should == "Double received unexpected message :foobar with (no args)"
+      e.message.should eq "Double received unexpected message :foobar with (no args)"
     end
   end 
 end

data/spec/rspec/mocks/bug_report_7611_spec.rb

@@ -10,7 +10,7 @@ module Bug7611
     end
 
     it "should" do
-      Bar.new.class.should == Bar
+      Bar.new.class.should eq Bar
     end 
   end
 end

data/spec/rspec/mocks/bug_report_8165_spec.rb

@@ -17,7 +17,7 @@ describe "An object where respond_to? is true and does not have method" do
     obj.should_receive(:respond_to?).with(:foobar).and_return(true)
     obj.should_receive(:foobar).and_return(:baz)
     obj.respond_to?(:foobar).should be_true
-    obj.foobar.should == :baz
+    obj.foobar.should eq :baz
   end
 
   it "does not raise an exception for mock" do
@@ -25,7 +25,7 @@ describe "An object where respond_to? is true and does not have method" do
     obj.should_receive(:respond_to?).with(:foobar).and_return(true)
     obj.should_receive(:foobar).and_return(:baz)
     obj.respond_to?(:foobar).should be_true
-    obj.foobar.should == :baz
+    obj.foobar.should eq :baz
   end
 
 end

data/spec/rspec/mocks/bug_report_957_spec.rb

@@ -11,11 +11,11 @@ module RSpec
       end
 
       it "returns the value for the stub on the base class" do
-        @base_class.find.should == "stubbed_value"
+        @base_class.find.should eq "stubbed_value"
       end
 
       it "returns the value for the descendent class" do
-        @concrete_class.find.should == "stubbed_value"
+        @concrete_class.find.should eq "stubbed_value"
       end
     end
   end

data/spec/rspec/mocks/failing_argument_matchers_spec.rb

@@ -85,7 +85,7 @@ module RSpec
 
       it "fails with block matchers" do
         expect do
-          @double.should_receive(:msg).with {|arg| arg.should == :received }
+          @double.should_receive(:msg).with {|arg| arg.should eq :received }
           @double.msg :no_msg_for_you
         end.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/)
       end

data/spec/rspec/mocks/hash_including_matcher_spec.rb

@@ -6,51 +6,51 @@ module RSpec
       describe HashIncludingMatcher do
         
         it "describes itself properly" do
-          HashIncludingMatcher.new(:a => 1).description.should == "hash_including(:a=>1)"
+          HashIncludingMatcher.new(:a => 1).description.should eq "hash_including(:a=>1)"
         end      
 
         describe "passing" do
           it "matches the same hash" do
-            hash_including(:a => 1).should == {:a => 1}
+            hash_including(:a => 1).should eq({:a => 1})
           end
 
           it "matches a hash with extra stuff" do
-            hash_including(:a => 1).should == {:a => 1, :b => 2}
+            hash_including(:a => 1).should eq({:a => 1, :b => 2})
           end
           
           describe "when matching against other matchers" do
             it "matches an int against anything()" do
-              hash_including(:a => anything, :b => 2).should == {:a => 1, :b => 2}
+              hash_including(:a => anything, :b => 2).should eq({:a => 1, :b => 2})
             end
 
             it "matches a string against anything()" do
-              hash_including(:a => anything, :b => 2).should == {:a => "1", :b => 2}
+              hash_including(:a => anything, :b => 2).should eq({:a => "1", :b => 2})
             end
           end
           
           describe "when passed only keys or keys mixed with key/value pairs" do
             it "matches if the key is present" do
-              hash_including(:a).should == {:a => 1, :b => 2}
+              hash_including(:a).should eq({:a => 1, :b => 2})
             end
             
             it "matches if more keys are present" do
-              hash_including(:a, :b).should == {:a => 1, :b => 2, :c => 3}
+              hash_including(:a, :b).should eq({:a => 1, :b => 2, :c => 3})
             end
 
             it "matches a string against a given key" do
-              hash_including(:a).should == {:a => "1", :b => 2}
+              hash_including(:a).should eq({:a => "1", :b => 2})
             end
 
             it "matches if passed one key and one key/value pair" do
-              hash_including(:a, :b => 2).should == {:a => 1, :b => 2}
+              hash_including(:a, :b => 2).should eq({:a => 1, :b => 2})
             end
             
             it "matches if passed many keys and one key/value pair" do
-              hash_including(:a, :b, :c => 3).should == {:a => 1, :b => 2, :c => 3, :d => 4}
+              hash_including(:a, :b, :c => 3).should eq({:a => 1, :b => 2, :c => 3, :d => 4})
             end
             
             it "matches if passed many keys and many key/value pairs" do
-              hash_including(:a, :b, :c => 3, :e => 5).should == {:a => 1, :b => 2, :c => 3, :d => 4, :e => 5}
+              hash_including(:a, :b, :c => 3, :e => 5).should eq({:a => 1, :b => 2, :c => 3, :d => 4, :e => 5})
             end
           end
         end

data/spec/rspec/mocks/hash_not_including_matcher_spec.rb

@@ -6,28 +6,28 @@ module RSpec
       describe HashNotIncludingMatcher do
         
         it "describes itself properly" do
-          HashNotIncludingMatcher.new(:a => 5).description.should == "hash_not_including(:a=>5)"
+          HashNotIncludingMatcher.new(:a => 5).description.should eq "hash_not_including(:a=>5)"
         end      
 
         describe "passing" do
           it "matches a hash without the specified key" do
-            hash_not_including(:c).should == {:a => 1, :b => 2}
+            hash_not_including(:c).should eq({:a => 1, :b => 2})
           end
           
           it "matches a hash with the specified key, but different value" do
-            hash_not_including(:b => 3).should == {:a => 1, :b => 2}
+            hash_not_including(:b => 3).should eq({:a => 1, :b => 2})
           end
                     
           it "matches a hash without the specified key, given as anything()" do
-            hash_not_including(:c => anything).should == {:a => 1, :b => 2}
+            hash_not_including(:c => anything).should eq({:a => 1, :b => 2})
           end
 
           it "matches an empty hash" do
-            hash_not_including(:a).should == {}
+            hash_not_including(:a).should eq({})
           end
           
           it "matches a hash without any of the specified keys" do
-            hash_not_including(:a, :b, :c).should == { :d => 7}
+            hash_not_including(:a, :b, :c).should eq({ :d => 7})
           end
           
         end

data/spec/rspec/mocks/mock_spec.rb

@@ -78,20 +78,20 @@ module RSpec
 
       it "allows block to calculate return values" do
         @mock.should_receive(:something).with("a","b","c").and_return { |a,b,c| c+b+a }
-        @mock.something("a","b","c").should == "cba"
+        @mock.something("a","b","c").should eq "cba"
         @mock.rspec_verify
       end
 
       it "allows parameter as return value" do
         @mock.should_receive(:something).with("a","b","c").and_return("booh")
-        @mock.something("a","b","c").should == "booh"
+        @mock.something("a","b","c").should eq "booh"
         @mock.rspec_verify
       end
 
       it "returns the previously stubbed value if no return value is set" do
-        @mock.stub!(:something).with("a","b","c").and_return(:stubbed_value)
+        @mock.stub(:something).with("a","b","c").and_return(:stubbed_value)
         @mock.should_receive(:something).with("a","b","c")
-        @mock.something("a","b","c").should == :stubbed_value
+        @mock.something("a","b","c").should eq :stubbed_value
         @mock.rspec_verify
       end
 
@@ -137,7 +137,19 @@ module RSpec
           @mock.rspec_verify
         }.should raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"a\", \"b\", \"c\")\n       got: (\"a\", \"d\", \"c\")")
       end
-
+      
+      describe 'with a method that has a default argument' do
+        it "raises an exception if the arguments don't match when the method is called, correctly reporting the offending arguments" do
+          def @mock.method_with_default_argument(arg={}); end
+          @mock.should_receive(:method_with_default_argument).with({})
+          
+          expect {
+            @mock.method_with_default_argument(nil)
+            @mock.rspec_verify
+          }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :method_with_default_argument with unexpected arguments\n  expected: ({})\n       got: (nil)")
+        end
+      end
+      
       it "fails if unexpected method called" do
         lambda {
           @mock.something("a","b","c")
@@ -147,11 +159,11 @@ module RSpec
 
       it "uses block for expectation if provided" do
         @mock.should_receive(:something) do | a, b |
-          a.should == "a"
-          b.should == "b"
+          a.should eq "a"
+          b.should eq "b"
           "booh"
         end
-        @mock.something("a", "b").should == "booh"
+        @mock.something("a", "b").should eq "booh"
         @mock.rspec_verify
       end
 
@@ -169,8 +181,8 @@ module RSpec
         eval("@mock.should_receive(:something) { |&block| a = block }")
         b = lambda { }
         @mock.something(&b)
-        a.should == b
-        @moc.rspec_verify
+        a.should eq b
+        @mock.rspec_verify
       end
 
       it "fails right away when method defined as never is received" do
@@ -258,7 +270,7 @@ module RSpec
 
       it "returns value from block by default" do
         @mock.stub(:method_that_yields).and_yield
-        @mock.method_that_yields { :returned_obj }.should == :returned_obj
+        @mock.method_that_yields { :returned_obj }.should eq :returned_obj
         @mock.rspec_verify
       end
 
@@ -266,17 +278,16 @@ module RSpec
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield
         a = nil
         @mock.yield_back {|*x| a = x}
-        a.should == []
+        a.should eq []
         @mock.rspec_verify
       end
 
       it "yields 0 args multiple times to blocks that take a variable number of arguments" do
         @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield.
                                                                     and_yield
-        a = nil
         b = []
         @mock.yield_back {|*a| b << a}
-        b.should == [ [], [] ]
+        b.should eq [ [], [] ]
         @mock.rspec_verify
       end
 
@@ -284,7 +295,7 @@ module RSpec
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99)
         a = nil
         @mock.yield_back {|*x| a = x}
-        a.should == [99]
+        a.should eq [99]
         @mock.rspec_verify
       end
 
@@ -292,10 +303,9 @@ module RSpec
         @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield(99).
                                                                     and_yield(43).
                                                                     and_yield("something fruity")
-        a = nil
         b = []
         @mock.yield_back {|*a| b << a}
-        b.should == [[99], [43], ["something fruity"]]
+        b.should eq [[99], [43], ["something fruity"]]
         @mock.rspec_verify
       end
 
@@ -303,7 +313,7 @@ module RSpec
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99, 27, "go")
         a = nil
         @mock.yield_back {|*x| a = x}
-        a.should == [99, 27, "go"]
+        a.should eq [99, 27, "go"]
         @mock.rspec_verify
       end
 
@@ -311,10 +321,9 @@ module RSpec
         @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield(99, :green, "go").
                                                                     and_yield("wait", :amber).
                                                                     and_yield("stop", 12, :red)
-        a = nil
         b = []
         @mock.yield_back {|*a| b << a}
-        b.should == [[99, :green, "go"], ["wait", :amber], ["stop", 12, :red]]
+        b.should eq [[99, :green, "go"], ["wait", :amber], ["stop", 12, :red]]
         @mock.rspec_verify
       end
 
@@ -322,7 +331,7 @@ module RSpec
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99)
         a = nil
         @mock.yield_back {|x| a = x}
-        a.should == 99
+        a.should eq 99
         @mock.rspec_verify
       end
 
@@ -330,10 +339,9 @@ module RSpec
         @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield(99).
                                                                     and_yield(43).
                                                                     and_yield("something fruity")
-        a = nil
         b = []
         @mock.yield_back {|a| b << a}
-        b.should == [99, 43, "something fruity"]
+        b.should eq [99, 43, "something fruity"]
         @mock.rspec_verify
       end
 
@@ -341,8 +349,8 @@ module RSpec
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
         a, b = nil
         @mock.yield_back {|x,y| a=x; b=y}
-        a.should == 'wha'
-        b.should == 'zup'
+        a.should eq 'wha'
+        b.should eq 'zup'
         @mock.rspec_verify
       end
 
@@ -350,10 +358,9 @@ module RSpec
         @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield('wha', 'zup').
                                                                     and_yield('not', 'down').
                                                                     and_yield(14, 65)
-        a, b = nil
         c = []
         @mock.yield_back {|a,b| c << [a, b]}
-        c.should == [['wha', 'zup'], ['not', 'down'], [14, 65]]
+        c.should eq [['wha', 'zup'], ['not', 'down'], [14, 65]]
         @mock.rspec_verify
       end
 
@@ -369,7 +376,6 @@ module RSpec
                                                                     and_yield('down').
                                                                     and_yield(14, 65)
         lambda {
-          a, b = nil
           c = []
           @mock.yield_back {|a,b| c << [a, b]}
         }.should raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" yielded |\"down\"| to block with arity of 2")
@@ -496,8 +502,8 @@ module RSpec
       it "does not mess with the stub's yielded values when also mocked" do
         @mock.stub(:yield_back).and_yield(:stub_value)
         @mock.should_receive(:yield_back).and_yield(:mock_value)
-        @mock.yield_back{|v| v.should == :mock_value }
-        @mock.yield_back{|v| v.should == :stub_value }
+        @mock.yield_back{|v| v.should eq :mock_value }
+        @mock.yield_back{|v| v.should eq :stub_value }
         @mock.rspec_verify
       end
 
@@ -506,14 +512,14 @@ module RSpec
         File.should_receive(:open).and_yield(:first_call).and_yield(:second_call)
         yielded_args = []
         File.open {|v| yielded_args << v }
-        yielded_args.should == [:first_call, :second_call]
-        File.open {|v| v.should == :stub_value }
+        yielded_args.should eq [:first_call, :second_call]
+        File.open {|v| v.should eq :stub_value }
         File.rspec_verify
       end
 
       it "assigns stub return values" do
         mock = RSpec::Mocks::Mock.new('name', :message => :response)
-        mock.message.should == :response
+        mock.message.should eq :response
       end
 
     end
@@ -533,7 +539,7 @@ module RSpec
 
         @mock.foo
 
-        @calls.should == 1
+        @calls.should eq 1
       end
 
       it "calls the block after #should_receive after a similar stub" do
@@ -542,7 +548,7 @@ module RSpec
 
         @mock.foo
 
-        @calls.should == 1
+        @calls.should eq 1
       end
 
       it "calls the block after #once" do
@@ -550,7 +556,7 @@ module RSpec
 
         @mock.foo
 
-        @calls.should == 1
+        @calls.should eq 1
       end
 
       it "calls the block after #twice" do
@@ -559,7 +565,7 @@ module RSpec
         @mock.foo
         @mock.foo
 
-        @calls.should == 2
+        @calls.should eq 2
       end
 
       it "calls the block after #times" do
@@ -567,7 +573,7 @@ module RSpec
 
         (1..10).each { @mock.foo }
 
-        @calls.should == 10
+        @calls.should eq 10
       end
 
       it "calls the block after #any_number_of_times" do
@@ -575,7 +581,7 @@ module RSpec
 
         (1..7).each { @mock.foo }
 
-        @calls.should == 7
+        @calls.should eq 7
       end
 
       it "calls the block after #ordered" do
@@ -585,7 +591,7 @@ module RSpec
         @mock.foo
         @mock.bar
 
-        @calls.should == 2
+        @calls.should eq 2
       end
     end
 
@@ -600,7 +606,7 @@ module RSpec
     describe "string representation generated by #to_str" do
       it "looks the same as #to_s" do
         double = double("Foo")
-        double.to_str.should == double.to_s
+        double.to_str.should eq double.to_s
       end
     end
 
@@ -612,8 +618,8 @@ module RSpec
       
       it "does respond to initially stubbed methods" do
         double = double(:foo => "woo", :bar => "car")
-        double.foo.should == "woo"
-        double.bar.should == "car"
+        double.foo.should eq "woo"
+        double.bar.should eq "car"
       end
     end