rspec-mocks 2.6.0 → 2.7.0

data/spec/rspec/mocks/any_instance_spec.rb

@@ -8,7 +8,10 @@ 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
+          private
+          def private_method; :private_method_return_value; end
         end
       end
       let(:existing_method_return_value){ :existing_method_return_value }
@@ -31,7 +34,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 +57,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 +108,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
@@ -119,7 +196,7 @@ module RSpec
             klass.new.foo.should 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)
@@ -160,6 +237,42 @@ module RSpec
         end
       end
 
+      context "with #stub!" do
+        it "raises with a message instructing the user to use stub instead" do
+          expect do
+            klass.any_instance.stub!(:foo)
+          end.to raise_error(/Use stub instead/)
+        end
+      end
+      
+      context "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 +405,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
@@ -490,39 +644,80 @@ module RSpec
           end
 
           context "with stubbing" do
-            before(:each) do
-              klass.any_instance.stub(:existing_method).and_return(1)
-              klass.method_defined?(:__existing_method_without_any_instance__).should be_true
-            end
+            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
+              end
 
-            it "restores the class to its original state after each example when no instance is created" do
-              space.verify_all
+              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)
-            end
+                klass.method_defined?(:__existing_method_without_any_instance__).should be_false
+                klass.new.existing_method.should 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
+              it "restores the class to its original state after each example when one instance is created" do
+                klass.new.existing_method
 
-              space.verify_all
+                space.verify_all
 
-              klass.method_defined?(:__existing_method_without_any_instance__).should be_false
-              klass.new.existing_method.should eq(existing_method_return_value)
-            end
+                klass.method_defined?(:__existing_method_without_any_instance__).should be_false
+                klass.new.existing_method.should 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
+              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
+                space.verify_all
 
-              klass.method_defined?(:__existing_method_without_any_instance__).should be_false
-              klass.new.existing_method.should eq(existing_method_return_value)
+                klass.method_defined?(:__existing_method_without_any_instance__).should be_false
+                klass.new.existing_method.should 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
+              end
+              
+              it "restores a stubbed private method after the spec is run" do
+                klass.private_method_defined?(:private_method).should 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)
+              end
             end
           end
 
           context "with expectations" do
+            context "private methods" do
+              before :each do
+                klass.any_instance.should_receive(:private_method).and_return(:something)
+                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
+              end
+
+              it "restores a stubbed private method after the spec is run" do
+                klass.private_method_defined?(:private_method).should 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)
+              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
                 it "first spec" 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