rspec 1.2.4 → 1.2.5

data/spec/spec/matchers/compatibility_spec.rb

@@ -2,31 +2,25 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 Spec::Matchers.define :have_public_instance_method do |method|
   match do |klass|
-    klass.public_instance_methods.include?(method)
+    klass.public_instance_methods.any? {|m| [method, method.to_sym].include?(m)}
   end
 end
 
-module Spec
-  module Matchers
-    describe Spec::Matchers do
-      (Spec::Matchers.constants.sort).each do |c|
-        if (Class === (klass = Spec::Matchers.const_get(c)))
-          describe klass do
-            if klass.public_instance_methods.include?('failure_message_for_should')
-              describe "called with should" do
-                subject { klass }
-                it { should have_public_instance_method('failure_message_for_should')}
-                it { should have_public_instance_method('failure_message')}
-              end
-            end
-            if klass.public_instance_methods.include?('failure_message_for_should_not')
-              describe "called with should not" do
-                subject { klass }
-                it { should have_public_instance_method('failure_message_for_should_not')}
-                it { should have_public_instance_method('negative_failure_message')}
-              end
-            end
-          end
+(Spec::Matchers.constants.sort).each do |c|
+  if (Class === (klass = Spec::Matchers.const_get(c)))
+    describe klass do
+      if klass.public_instance_methods.any? {|m| ['failure_message_for_should',:failure_message_for_should].include?(m)}
+        describe "called with should" do
+          subject { klass }
+          it { should have_public_instance_method('failure_message_for_should')}
+          it { should have_public_instance_method('failure_message')}
+        end
+      end
+      if klass.public_instance_methods.any? {|m| ['failure_message_for_should_not',:failure_message_for_should_not].include?(m)}
+        describe "called with should not" do
+          subject { klass }
+          it { should have_public_instance_method('failure_message_for_should_not')}
+          it { should have_public_instance_method('negative_failure_message')}
         end
       end
     end

data/spec/spec/matchers/equal_spec.rb

@@ -1,8 +1,12 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
 module Spec
   module Matchers
     describe "equal" do
+      
+      def inspect_object(o)
+        "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
+      end
+      
       it "should match when actual.equal?(expected)" do
         1.should equal(1)
       end
@@ -17,16 +21,36 @@ module Spec
         matcher.description.should == "equal 1"
       end
       
-      it "should provide message, expected and actual on #failure_message" do
-        matcher = equal("1")
-        matcher.matches?(1)
-        matcher.failure_message_for_should.should == "\nexpected \"1\"\n     got 1\n     \n(compared using equal?)\n"
+      it "should provide message on #failure_message" do
+        expected, actual = "1", "1"
+        matcher = equal(expected)
+        matcher.matches?(actual)
+        
+        matcher.failure_message_for_should.should == <<-MESSAGE
+
+expected #{inspect_object(expected)}
+     got #{inspect_object(actual)}
+
+Compared using equal?, which compares object identity,
+but expected and actual are not the same object. Use
+'actual.should == expected' if you don't care about
+object identity in this example.
+
+MESSAGE
       end
       
-      it "should provide message, expected and actual on #negative_failure_message" do
-        matcher = equal(1)
-        matcher.matches?(1)
-        matcher.failure_message_for_should_not.should == "\nexpected 1 not to equal 1\n\n(compared using equal?)\n"
+      it "should provide message on #negative_failure_message" do
+        expected = actual = "1"
+        matcher = equal(expected)
+        matcher.matches?(actual)
+        matcher.failure_message_for_should_not.should == <<-MESSAGE
+
+expected not #{inspect_object(expected)}
+         got #{inspect_object(actual)}
+
+Compared using equal?, which compares object identity.
+
+MESSAGE
       end
     end
   end

data/spec/spec/matchers/have_spec.rb

@@ -356,14 +356,7 @@ end
 module Spec
   module Matchers
     describe Have do
-      it "should have method_missing as private" do
-        with_ruby '1.8' do
-          Have.private_instance_methods.should include("method_missing")
-        end
-        with_ruby '1.9' do
-          Have.private_instance_methods.should include(:method_missing)
-        end
-      end
+      treats_method_missing_as_private :noop => false
       
       describe "respond_to?" do
         before :each do

data/spec/spec/mocks/mock_ordering_spec.rb

@@ -78,6 +78,16 @@ module Spec
         @mock.ignored_1
         @mock.rspec_verify
       end
+      
+      it "should pass when duplicates exist" do
+        @mock.should_receive(:a).ordered
+        @mock.should_receive(:b).ordered
+        @mock.should_receive(:a).ordered
+        
+        @mock.a
+        @mock.b
+        @mock.a
+      end
             
     end
   end

data/spec/spec/mocks/mock_spec.rb

@@ -3,29 +3,31 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 module Spec
   module Mocks
     describe Mock do
+      treats_method_missing_as_private :subject => Mock.new, :noop => false
+      
       before(:each) do
         @mock = mock("test mock")
       end
-      
+
       after(:each) do
         @mock.rspec_reset
       end
-      
+
       describe "deprecated #stub_everything method" do
         before(:each) do
           Kernel.stub!(:warn)
         end
-        
+
         it "creates a mock that behaves as a null object" do
           stub_everything.should be_null_object
         end
-        
+
         it "provides deprecation warning" do
           Kernel.should_receive(:warn).with(/DEPRECATION: stub_everything.* is deprecated./)
           stub_everything
         end
       end
-      
+
       it "should report line number of expectation of unreceived message" do
         expected_error_line = __LINE__; @mock.should_receive(:wont_happen).with("x", 3)
         begin
@@ -36,7 +38,7 @@ module Spec
           e.backtrace[0].should match(/#{File.basename(__FILE__)}:#{expected_error_line}/)
         end
       end
-      
+
       it "should report line number of expectation of unreceived message after #should_receive after similar stub" do
         @mock.stub!(:wont_happen)
         expected_error_line = __LINE__; @mock.should_receive(:wont_happen).with("x", 3)
@@ -48,19 +50,19 @@ module Spec
           e.backtrace[0].should match(/#{File.basename(__FILE__)}:#{expected_error_line}/)
         end
       end
-      
+
       it "should pass when not receiving message specified as not to be received" do
         @mock.should_not_receive(:not_expected)
         @mock.rspec_verify
       end
-      
+
       it "should pass when receiving message specified as not to be received with different args" do
         @mock.should_not_receive(:message).with("unwanted text")
         @mock.should_receive(:message).with("other text")
         @mock.message "other text"
         @mock.rspec_verify
       end
-      
+
       it "should fail when receiving message specified as not to be received" do
         @mock.should_not_receive(:not_expected)
         lambda {
@@ -68,7 +70,7 @@ module Spec
           violated
         }.should raise_error(MockExpectationError, "Mock 'test mock' expected :not_expected with (no args) 0 times, but received it once")
       end
-      
+
       it "should fail when receiving message specified as not to be received with args" do
         @mock.should_not_receive(:not_expected).with("unexpected text")
         lambda {
@@ -76,31 +78,31 @@ module Spec
           violated
         }.should raise_error(MockExpectationError, "Mock 'test mock' expected :not_expected with (\"unexpected text\") 0 times, but received it once")
       end
-      
+
       it "should pass when receiving message specified as not to be received with wrong args" do
         @mock.should_not_receive(:not_expected).with("unexpected text")
         @mock.not_expected "really unexpected text"
         @mock.rspec_verify
       end
-      
+
       it "should allow 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.rspec_verify
       end
-      
+
       it "should allow parameter as return value" do
         @mock.should_receive(:something).with("a","b","c").and_return("booh")
         @mock.something("a","b","c").should == "booh"
         @mock.rspec_verify
       end
-      
+
       it "should return nil if no return value set" do
         @mock.should_receive(:something).with("a","b","c")
         @mock.something("a","b","c").should be_nil
         @mock.rspec_verify
       end
-      
+
       it "should raise exception if args don't match when method called" do
         @mock.should_receive(:something).with("a","b","c").and_return("booh")
         lambda {
@@ -108,7 +110,7 @@ module Spec
           violated
         }.should raise_error(MockExpectationError, "Mock 'test mock' expected :something with (\"a\", \"b\", \"c\") but received it with (\"a\", \"d\", \"c\")")
       end
-           
+
       it "should raise exception if args don't match when method called even when the method is stubbed" do
         @mock.stub!(:something)
         @mock.should_receive(:something).with("a","b","c")
@@ -117,7 +119,7 @@ module Spec
           @mock.rspec_verify
         }.should raise_error(MockExpectationError, "Mock 'test mock' expected :something with (\"a\", \"b\", \"c\") but received it with ([\"a\", \"d\", \"c\"])")
       end
-           
+
       it "should raise exception if args don't match when method called even when using null_object" do
         @mock = mock("test mock", :null_object => true)
         @mock.should_receive(:something).with("a","b","c")
@@ -126,14 +128,14 @@ module Spec
           @mock.rspec_verify
         }.should raise_error(MockExpectationError, "Mock 'test mock' expected :something with (\"a\", \"b\", \"c\") but received it with ([\"a\", \"d\", \"c\"])")
       end
-           
+
       it "should fail if unexpected method called" do
         lambda {
           @mock.something("a","b","c")
           violated
         }.should raise_error(MockExpectationError, "Mock 'test mock' received unexpected message :something with (\"a\", \"b\", \"c\")")
       end
-        
+
       it "should use block for expectation if provided" do
         @mock.should_receive(:something) do | a, b |
           a.should == "a"
@@ -143,35 +145,35 @@ module Spec
         @mock.something("a", "b").should == "booh"
         @mock.rspec_verify
       end
-        
+
       it "should fail if expectation block fails" do
         @mock.should_receive(:something) {| bool | bool.should be_true}
         lambda {
           @mock.something false
         }.should raise_error(MockExpectationError, /Mock 'test mock' received :something but passed block failed with: expected true, got false/)
       end
-        
+
       it "should fail right away when method defined as never is received" do
         @mock.should_receive(:not_expected).never
         lambda {
           @mock.not_expected
         }.should raise_error(MockExpectationError, "Mock 'test mock' expected :not_expected with (no args) 0 times, but received it once")
       end
-      
+
       it "should eventually fail when method defined as never is received" do
         @mock.should_receive(:not_expected).never
         lambda {
           @mock.not_expected
         }.should raise_error(MockExpectationError, "Mock 'test mock' expected :not_expected with (no args) 0 times, but received it once")
       end
-    
+
       it "should raise when told to" do
         @mock.should_receive(:something).and_raise(RuntimeError)
         lambda do
           @mock.something
         end.should raise_error(RuntimeError)
       end
-       
+
       it "should raise passed an Exception instance" do
         error = RuntimeError.new("error message")
         @mock.should_receive(:something).and_raise(error)
@@ -179,28 +181,28 @@ module Spec
           @mock.something
         }.should raise_error(RuntimeError, "error message")
       end
-      
+
       it "should raise RuntimeError with passed message" do
         @mock.should_receive(:something).and_raise("error message")
         lambda {
           @mock.something
         }.should raise_error(RuntimeError, "error message")
       end
-       
+
       it "should not raise when told to if args dont match" do
         @mock.should_receive(:something).with(2).and_raise(RuntimeError)
         lambda {
           @mock.something 1
         }.should raise_error(MockExpectationError)
       end
-       
+
       it "should throw when told to" do
         @mock.should_receive(:something).and_throw(:blech)
         lambda {
           @mock.something
         }.should throw_symbol(:blech)
       end
-      
+
       it "should raise when explicit return and block constrained" do
         lambda {
           @mock.should_receive(:fruit) do |colour|
@@ -208,7 +210,7 @@ module Spec
           end.and_return :apple
         }.should raise_error(AmbiguousReturnError)
       end
-      
+
       it "should ignore args on any args" do
         @mock.should_receive(:something).at_least(:once).with(any_args)
         @mock.something
@@ -217,27 +219,27 @@ module Spec
         @mock.something [], {}, "joe", 7
         @mock.rspec_verify
       end
-      
+
       it "should fail on no args if any args received" do
         @mock.should_receive(:something).with(no_args())
         lambda {
           @mock.something 1
         }.should raise_error(MockExpectationError, "Mock 'test mock' expected :something with (no args) but received it with (1)")
       end
-    
+
       it "should fail when args are expected but none are received" do
         @mock.should_receive(:something).with(1)
         lambda {
           @mock.something
         }.should raise_error(MockExpectationError, "Mock 'test mock' expected :something with (1) but received it with (no args)")
       end
-    
+
       it "should return value from block by default" do
         @mock.stub!(:method_that_yields).and_yield
         @mock.method_that_yields { :returned_obj }.should == :returned_obj
         @mock.rspec_verify
       end
-    
+
       it "should yield 0 args to blocks that take a variable number of arguments" do
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield
         a = nil
@@ -245,7 +247,7 @@ module Spec
         a.should == []
         @mock.rspec_verify
       end
-      
+
       it "should yield 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
@@ -255,7 +257,7 @@ module Spec
         b.should == [ [], [] ]
         @mock.rspec_verify
       end
-      
+
       it "should yield one arg to blocks that take a variable number of arguments" do
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99)
         a = nil
@@ -263,7 +265,7 @@ module Spec
         a.should == [99]
         @mock.rspec_verify
       end
-      
+
       it "should yield one arg 3 times consecutively to blocks that take a variable number of arguments" do
         @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield(99).
                                                                     and_yield(43).
@@ -274,7 +276,7 @@ module Spec
         b.should == [[99], [43], ["something fruity"]]
         @mock.rspec_verify
       end
-      
+
       it "should yield many args to blocks that take a variable number of arguments" do
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99, 27, "go")
         a = nil
@@ -282,7 +284,7 @@ module Spec
         a.should == [99, 27, "go"]
         @mock.rspec_verify
       end
-    
+
       it "should yield many args 3 times consecutively to blocks that take a variable number of arguments" do
         @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield(99, :green, "go").
                                                                     and_yield("wait", :amber).
@@ -293,7 +295,7 @@ module Spec
         b.should == [[99, :green, "go"], ["wait", :amber], ["stop", 12, :red]]
         @mock.rspec_verify
       end
-      
+
       it "should yield single value" do
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99)
         a = nil
@@ -301,7 +303,7 @@ module Spec
         a.should == 99
         @mock.rspec_verify
       end
-      
+
       it "should yield single value 3 times consecutively" do
         @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield(99).
                                                                     and_yield(43).
@@ -312,7 +314,7 @@ module Spec
         b.should == [99, 43, "something fruity"]
         @mock.rspec_verify
       end
-      
+
       it "should yield two values" do
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
         a, b = nil
@@ -321,7 +323,7 @@ module Spec
         b.should == 'zup'
         @mock.rspec_verify
       end
-      
+
       it "should yield two values 3 times consecutively" do
         @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield('wha', 'zup').
                                                                     and_yield('not', 'down').
@@ -332,14 +334,14 @@ module Spec
         c.should == [['wha', 'zup'], ['not', 'down'], [14, 65]]
         @mock.rspec_verify
       end
-      
+
       it "should fail when calling yielding method with wrong arity" do
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
         lambda {
           @mock.yield_back {|a|}
         }.should raise_error(MockExpectationError, "Mock 'test mock' yielded |\"wha\", \"zup\"| to block with arity of 1")
       end
-      
+
       it "should fail when calling yielding method consecutively with wrong arity" do
         @mock.should_receive(:yield_back).once.with(no_args()).once.and_yield('wha', 'zup').
                                                                     and_yield('down').
@@ -350,32 +352,32 @@ module Spec
           @mock.yield_back {|a,b| c << [a, b]}
         }.should raise_error(MockExpectationError, "Mock 'test mock' yielded |\"down\"| to block with arity of 2")
       end
-      
+
       it "should fail when calling yielding method without block" do
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
         lambda {
           @mock.yield_back
         }.should raise_error(MockExpectationError, "Mock 'test mock' asked to yield |[\"wha\", \"zup\"]| but no block was passed")
       end
-      
+
       it "should be able to mock send" do
         @mock.should_receive(:send).with(any_args)
         @mock.send 'hi'
         @mock.rspec_verify
       end
-      
+
       it "should be able to raise from method calling yielding mock" do
         @mock.should_receive(:yield_me).and_yield 44
-        
+
         lambda {
           @mock.yield_me do |x|
             raise "Bang"
           end
         }.should raise_error(StandardError, "Bang")
-      
+
         @mock.rspec_verify
       end
-      
+
       it "should clear expectations after verify" do
         @mock.should_receive(:foobar)
         @mock.foobar
@@ -384,43 +386,43 @@ module Spec
           @mock.foobar
         }.should raise_error(MockExpectationError, "Mock 'test mock' received unexpected message :foobar with (no args)")
       end
-      
+
       it "should restore objects to their original state on rspec_reset" do
         mock = mock("this is a mock")
         mock.should_receive(:blah)
         mock.rspec_reset
         mock.rspec_verify #should throw if reset didn't work
       end
-    
+
       it "should work even after method_missing starts raising NameErrors instead of NoMethodErrors" do
         # Object#method_missing throws either NameErrors or NoMethodErrors.
         #
-        # On a fresh ruby program Object#method_missing: 
+        # On a fresh ruby program Object#method_missing:
         #  * raises a NoMethodError when called directly
         #  * raises a NameError when called indirectly
         #
         # Once Object#method_missing has been called at least once (on any object)
-        # it starts behaving differently: 
+        # it starts behaving differently:
         #  * raises a NameError when called directly
         #  * raises a NameError when called indirectly
         #
         # There was a bug in Mock#method_missing that relied on the fact
         # that calling Object#method_missing directly raises a NoMethodError.
         # This example tests that the bug doesn't exist anymore.
-        
-        
+
+
         # Ensures that method_missing always raises NameErrors.
         a_method_that_doesnt_exist rescue
-        
-        
+
+
         @mock.should_receive(:foobar)
         @mock.foobar
         @mock.rspec_verify
-                
+
         lambda { @mock.foobar }.should_not raise_error(NameError)
         lambda { @mock.foobar }.should raise_error(MockExpectationError)
       end
-    
+
       it "should temporarily replace a method stub on a mock" do
         @mock.stub!(:msg).and_return(:stub_value)
         @mock.should_receive(:msg).with(:arg).and_return(:mock_value)
@@ -484,80 +486,80 @@ module Spec
         mock = Mock.new('name', :message => :response)
         mock.message.should == :response
       end
-      
+
     end
-    
+
     describe "a mock message receiving a block" do
       before(:each) do
         @mock = mock("mock")
         @calls = 0
       end
-      
+
       def add_call
         @calls = @calls + 1
       end
-      
+
       it "should call the block after #should_receive" do
         @mock.should_receive(:foo) { add_call }
-    
+
         @mock.foo
-    
+
         @calls.should == 1
       end
-    
+
       it "should call the block after #should_receive after a similar stub" do
         @mock.stub!(:foo).and_return(:bar)
         @mock.should_receive(:foo) { add_call }
-    
+
         @mock.foo
-    
+
         @calls.should == 1
       end
-    
+
       it "should call the block after #once" do
         @mock.should_receive(:foo).once { add_call }
-    
+
         @mock.foo
-    
+
         @calls.should == 1
       end
-    
+
       it "should call the block after #twice" do
         @mock.should_receive(:foo).twice { add_call }
-    
+
         @mock.foo
         @mock.foo
-    
+
         @calls.should == 2
       end
-    
+
       it "should call the block after #times" do
         @mock.should_receive(:foo).exactly(10).times { add_call }
-        
+
         (1..10).each { @mock.foo }
-    
+
         @calls.should == 10
       end
-    
+
       it "should call the block after #any_number_of_times" do
         @mock.should_receive(:foo).any_number_of_times { add_call }
-        
+
         (1..7).each { @mock.foo }
-    
+
         @calls.should == 7
       end
-    
+
       it "should call the block after #ordered" do
         @mock.should_receive(:foo).ordered { add_call }
         @mock.should_receive(:bar).ordered { add_call }
-        
+
         @mock.foo
         @mock.bar
-    
+
         @calls.should == 2
       end
     end
-    
+
     describe 'string representation generated by #to_s' do
       it 'should not contain < because that might lead to invalid HTML in some situations' do
         mock = mock("Dog")
@@ -565,21 +567,32 @@ module Spec
         valid_html_str.should_not include('<')
       end
     end
-    
+
+    describe "mock created with no name" do
+      it "should name itself 'mock'" do
+        mock.to_s.should include('mock')
+      end
+
+      it "should name itself after initially stubbed methods" do
+        string = mock(:foo => "woo", :bar => "car").to_s
+        string.should include('foo: \"woo\"', 'bar: \"car\"')
+      end
+
+      it "should respond to initially stubbed methods" do
+        mock = mock(:foo => "woo", :bar => "car")
+        mock.foo.should == "woo"
+        mock.bar.should == "car"
+      end
+    end
+
     describe "==" do
       it "sends '== self' to the comparison object" do
         first = mock('first')
         second = mock('second')
-        
+
         first.should_receive(:==).with(second)
         second == first
       end
     end
-
-    describe "method_missing" do
-      it "should be private" do
-        Mock.private_instance_methods.should include("method_missing")
-      end
-    end
   end
 end