rspec-mocks 2.6.0 → 2.7.0

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
 

data/spec/rspec/mocks/multiple_return_value_spec.rb

@@ -10,15 +10,15 @@ module RSpec
       end
 
       it "returns values in order to consecutive calls" do
-        @mock.message.should == @return_values[0]
-        @mock.message.should == @return_values[1]
-        @mock.message.should == @return_values[2]
+        @mock.message.should eq @return_values[0]
+        @mock.message.should eq @return_values[1]
+        @mock.message.should eq @return_values[2]
         @mock.rspec_verify
       end
 
       it "complains when there are too few calls" do
-        @mock.message.should == @return_values[0]
-        @mock.message.should == @return_values[1]
+        @mock.message.should eq @return_values[0]
+        @mock.message.should eq @return_values[1]
         expect { @mock.rspec_verify }.to raise_error(
           RSpec::Mocks::MockExpectationError,
           %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 2 times|
@@ -26,10 +26,10 @@ module RSpec
       end
 
       it "complains when there are too many calls" do
-        @mock.message.should == @return_values[0]
-        @mock.message.should == @return_values[1]
-        @mock.message.should == @return_values[2]
-        @mock.message.should == @return_values[2]
+        @mock.message.should eq @return_values[0]
+        @mock.message.should eq @return_values[1]
+        @mock.message.should eq @return_values[2]
+        @mock.message.should eq @return_values[2]
         expect { @mock.rspec_verify }.to raise_error(
           RSpec::Mocks::MockExpectationError,
           %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 4 times|
@@ -38,10 +38,10 @@ module RSpec
 
       it "doesn't complain when there are too many calls but method is stubbed too" do
         @mock.stub(:message).and_return :stub_result
-        @mock.message.should == @return_values[0]
-        @mock.message.should == @return_values[1]
-        @mock.message.should == @return_values[2]
-        @mock.message.should == :stub_result
+        @mock.message.should eq @return_values[0]
+        @mock.message.should eq @return_values[1]
+        @mock.message.should eq @return_values[2]
+        @mock.message.should eq :stub_result
         expect { @mock.rspec_verify }.to_not raise_error(RSpec::Mocks::MockExpectationError)
       end
     end
@@ -54,16 +54,16 @@ module RSpec
       end
 
       it "returns values in order to consecutive calls" do
-        @mock.message.should == @return_values[0]
-        @mock.message.should == @return_values[1]
-        @mock.message.should == @return_values[2]
+        @mock.message.should eq @return_values[0]
+        @mock.message.should eq @return_values[1]
+        @mock.message.should eq @return_values[2]
         @mock.rspec_verify
       end
 
       it "complains when there are too few calls" do
         third = Object.new
-        @mock.message.should == @return_values[0]
-        @mock.message.should == @return_values[1]
+        @mock.message.should eq @return_values[0]
+        @mock.message.should eq @return_values[1]
         expect { @mock.rspec_verify }.to raise_error(
           RSpec::Mocks::MockExpectationError,
           %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 2 times|
@@ -72,10 +72,10 @@ module RSpec
 
       it "complains when there are too many calls" do
         third = Object.new
-        @mock.message.should == @return_values[0]
-        @mock.message.should == @return_values[1]
-        @mock.message.should == @return_values[2]
-        @mock.message.should == @return_values[2]
+        @mock.message.should eq @return_values[0]
+        @mock.message.should eq @return_values[1]
+        @mock.message.should eq @return_values[2]
+        @mock.message.should eq @return_values[2]
         expect { @mock.rspec_verify }.to raise_error(
           RSpec::Mocks::MockExpectationError,
           %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 4 times|
@@ -85,10 +85,10 @@ module RSpec
       it "complains when there are too many calls and method is stubbed too" do
         third = Object.new
         @mock.stub(:message).and_return :stub_result
-        @mock.message.should == @return_values[0]
-        @mock.message.should == @return_values[1]
-        @mock.message.should == @return_values[2]
-        @mock.message.should == :stub_result
+        @mock.message.should eq @return_values[0]
+        @mock.message.should eq @return_values[1]
+        @mock.message.should eq @return_values[2]
+        @mock.message.should eq :stub_result
         expect { @mock.rspec_verify }.to raise_error(
           RSpec::Mocks::MockExpectationError,
           %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 4 times|

data/spec/rspec/mocks/partial_mock_spec.rb

@@ -84,9 +84,10 @@ module RSpec
       it "uses reports nil in the error message" do
         allow_message_expectations_on_nil
         
-        @this_will_resolve_to_nil.should_receive(:foobar)
+        @nil = nil
+        @nil.should_receive(:foobar)
         expect {
-          @this_will_resolve_to_nil.rspec_verify
+          @nil.rspec_verify
         }.to raise_error(
           RSpec::Mocks::MockExpectationError, 
           %Q|(nil).foobar(any args)\n    expected: 1 time\n    received: 0 times|

data/spec/rspec/mocks/partial_mock_using_mocks_directly_spec.rb

@@ -5,6 +5,7 @@ module RSpec::Mocks
     let(:klass) do
       Class.new do
         module MethodMissing
+          remove_method :method_missing rescue nil
           def method_missing(m, *a, &b)
             if m == :captured_by_method_missing
               "response generated by method missing"

data/spec/rspec/mocks/passing_argument_matchers_spec.rb

@@ -87,11 +87,11 @@ module RSpec
       context "handling block matchers" do
         it "matches arguments against RSpec expectations" do
           @double.should_receive(:random_call).with {|arg1, arg2, arr, *rest|
-            arg1.should == 5
+            arg1.should eq 5
             arg2.should have_at_least(3).characters
             arg2.should have_at_most(10).characters
-            arr.map {|i| i * 2}.should == [2,4,6]
-            rest.should == [:fee, "fi", 4]
+            arr.map {|i| i * 2}.should eq [2,4,6]
+            rest.should eq [:fee, "fi", 4]
           }
           @double.random_call 5, "hello", [1,2,3], :fee, "fi", 4
         end

data/spec/rspec/mocks/precise_counts_spec.rb

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

data/spec/rspec/mocks/serialization_spec.rb

@@ -64,7 +64,12 @@ module RSpec
       end
 
       with_yaml_loaded do
-        compiled_with_psych = RbConfig::CONFIG['configure_args'] =~ /with-libyaml/
+        compiled_with_psych = begin
+          require 'psych'
+          true
+        rescue LoadError => e
+          false
+        end
 
         if compiled_with_psych
           context 'using Syck as the YAML engine' do
@@ -98,7 +103,7 @@ module RSpec
 
         it 'does not interfere with its marshalling' do
           marshalled_copy = Marshal.load(Marshal.dump(subject))
-          marshalled_copy.should == subject
+          marshalled_copy.should eq subject
         end
       end
     end

data/spec/rspec/mocks/stub_implementation_spec.rb

@@ -7,7 +7,7 @@ module RSpec
         it "execs the block when called" do
           obj = stub()
           obj.stub(:foo) { :bar }
-          obj.foo.should == :bar
+          obj.foo.should eq :bar
         end
       end
 
@@ -15,7 +15,7 @@ module RSpec
         it "execs the block with that arg when called" do
           obj = stub()
           obj.stub(:foo) {|given| given}
-          obj.foo(:bar).should == :bar
+          obj.foo(:bar).should eq :bar
         end
       end
 
@@ -23,7 +23,7 @@ module RSpec
         it "execs the block when called" do
           obj = stub()
           obj.stub(:foo) {|*given| given.first}
-          obj.foo(:bar).should == :bar
+          obj.foo(:bar).should eq :bar
         end        
       end
     end
@@ -35,7 +35,7 @@ module RSpec
         def obj.foo; :original; end
         obj.stub(:foo)
         obj.unstub(:foo)
-        obj.foo.should == :original
+        obj.foo.should eq :original
       end
     
       it "removes all stubs with the supplied method name" do
@@ -44,7 +44,7 @@ module RSpec
         obj.stub(:foo).with(1)
         obj.stub(:foo).with(2)
         obj.unstub(:foo)
-        obj.foo.should == :original
+        obj.foo.should eq :original
       end
     
       it "does not remove any expectations with the same method name" do
@@ -54,7 +54,7 @@ module RSpec
         obj.stub(:foo).with(1)
         obj.stub(:foo).with(2)
         obj.unstub(:foo)
-        obj.foo(3).should == :three
+        obj.foo(3).should eq :three
       end
     
       it "raises a MockExpectationError if the method has not been stubbed" do

data/spec/rspec/mocks/stub_spec.rb

@@ -134,7 +134,7 @@ module RSpec
         @instance.stub(:method_that_yields).and_yield(:yielded_obj)
         current_value = :value_before
         @instance.method_that_yields {|val| current_value = val}
-        current_value.should == :yielded_obj
+        current_value.should eq :yielded_obj
         @instance.rspec_verify
       end
 
@@ -143,7 +143,7 @@ module RSpec
                                                        and_yield(:another_value)
         current_value = []
         @instance.method_that_yields_multiple_times {|val| current_value << val}
-        current_value.should == [:yielded_value, :another_value]
+        current_value.should eq [:yielded_value, :another_value]
         @instance.rspec_verify
       end
       
@@ -151,7 +151,7 @@ module RSpec
         yielded_obj = double("my mock")
         yielded_obj.should_receive(:foo).with(:bar)
         @instance.stub(:method_that_yields_and_returns).and_yield(yielded_obj).and_return(:baz)
-        @instance.method_that_yields_and_returns { |o| o.foo :bar }.should == :baz
+        @instance.method_that_yields_and_returns { |o| o.foo :bar }.should eq :baz
       end
 
       it "throws when told to" do
@@ -163,13 +163,13 @@ module RSpec
       
       it "overrides a pre-existing method" do
         @stub.stub(:existing_instance_method).and_return(:updated_stub_value)
-        @stub.existing_instance_method.should == :updated_stub_value
+        @stub.existing_instance_method.should eq :updated_stub_value
       end
 
       it "overrides a pre-existing stub" do
         @stub.stub(:foo) { 'bar' }
         @stub.stub(:foo) { 'baz' }
-        @stub.foo.should == 'baz'
+        @stub.foo.should eq 'baz'
       end
       
       it "allows a stub and an expectation" do
@@ -181,7 +181,7 @@ module RSpec
 
       it "calculates return value by executing block passed to #and_return" do
         @stub.stub(:something).with("a","b","c").and_return { |a,b,c| c+b+a }
-        @stub.something("a","b","c").should == "cba"
+        @stub.something("a","b","c").should eq "cba"
         @stub.rspec_verify
       end
     end

data/spec/rspec/mocks/to_ary_spec.rb

@@ -7,11 +7,20 @@ describe "a double receiving to_ary" do
         obj.to_ary.should be_nil
       end.to raise_error(NoMethodError)
     end
+    
+    it "doesn't respond" do
+      obj.should_not respond_to(:to_ary)
+    end
 
     it "can be overridden with a stub" do
       obj.stub(:to_ary) { :non_nil_value }
       obj.to_ary.should be(:non_nil_value)
     end
+    
+    it "responds when overriden" do
+      obj.stub(:to_ary) { :non_nil_value }
+      obj.should respond_to(:to_ary)
+    end
 
     it "supports Array#flatten" do
       obj = double('foo')