typo 5.1.3 → 5.1.98

data/vendor/plugins/rspec/spec/spec/matchers/respond_to_spec.rb

@@ -8,8 +8,8 @@ describe "should respond_to(:sym)" do
   
   it "should fail target does not respond to :sym" do
     lambda {
-      Object.new.should respond_to(:some_method)
-    }.should fail_with("expected target to respond to :some_method")
+      "this string".should respond_to(:some_method)
+    }.should fail_with("expected \"this string\" to respond to :some_method")
   end
   
 end
@@ -23,19 +23,19 @@ describe "should respond_to(message1, message2)" do
   it "should fail target does not respond to first message" do
     lambda {
       Object.new.should respond_to('method_one', 'inspect')
-    }.should fail_with('expected target to respond to "method_one"')
+    }.should fail_with(/expected #<Object:.*> to respond to "method_one"/)
   end
   
   it "should fail target does not respond to second message" do
     lambda {
       Object.new.should respond_to('inspect', 'method_one')
-    }.should fail_with('expected target to respond to "method_one"')
+    }.should fail_with(/expected #<Object:.*> to respond to "method_one"/)
   end
   
   it "should fail target does not respond to either message" do
     lambda {
       Object.new.should respond_to('method_one', 'method_two')
-    }.should fail_with('expected target to respond to "method_one", "method_two"')
+    }.should fail_with(/expected #<Object:.*> to respond to "method_one", "method_two"/)
   end
 end
 
@@ -48,7 +48,7 @@ describe "should_not respond_to(:sym)" do
   it "should fail target responds to :sym" do
     lambda {
       Object.new.should_not respond_to(:methods)
-    }.should fail_with("expected target not to respond to :methods")
+    }.should fail_with(/expected #<Object:.*> not to respond to :methods/)
   end
   
 end

data/vendor/plugins/rspec/spec/spec/matchers/simple_matcher_spec.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 module Spec
   module Matchers
     describe SimpleMatcher do
-      it "should match pass match arg to block" do
+      it "should pass match arg to block" do
         actual = nil
         matcher = simple_matcher("message") do |given| actual = given end
         matcher.matches?("foo")
@@ -22,10 +22,72 @@ module Spec
         matcher.negative_failure_message.should =~ /expected not to get \"thing\", but got \"other\"/
       end
       
-      it "should provide a description" do
+      it "should provide the given description" do
         matcher = simple_matcher("thing") do end
         matcher.description.should =="thing"
       end
+      
+      it "should fail if a wrapped 'should' fails" do
+        matcher = simple_matcher("should fail") do
+          2.should == 3
+        end
+        lambda do
+          matcher.matches?("anything").should be_true
+        end.should fail_with(/expected: 3/)
+      end
+    end
+    
+    describe "with arity of 2" do
+      it "should provide the matcher so you can access its messages" do
+        provided_matcher = nil
+        matcher = simple_matcher("thing") do |given, matcher|
+          provided_matcher = matcher
+        end
+        matcher.matches?("anything")
+        provided_matcher.should equal(matcher)
+      end
+      
+      it "should support a custom failure message" do
+        matcher = simple_matcher("thing") do |given, matcher|
+          matcher.failure_message = "custom message"
+        end
+        matcher.matches?("other")
+        matcher.failure_message.should == "custom message"
+      end
+
+      it "should complain when asked for a failure message if you don't give it a description or a message" do
+        matcher = simple_matcher do |given, matcher| end
+        matcher.matches?("other")
+        matcher.failure_message.should =~ /No description provided/
+      end
+
+      it "should support a custom negative failure message" do
+        matcher = simple_matcher("thing") do |given, matcher|
+          matcher.negative_failure_message = "custom message"
+        end
+        matcher.matches?("other")
+        matcher.negative_failure_message.should == "custom message"
+      end
+      
+      it "should complain when asked for a negative failure message if you don't give it a description or a message" do
+        matcher = simple_matcher do |given, matcher| end
+        matcher.matches?("other")
+        matcher.negative_failure_message.should =~ /No description provided/
+      end
+
+      it "should support a custom description" do
+        matcher = simple_matcher("thing") do |given, matcher|
+          matcher.description = "custom message"
+        end
+        matcher.matches?("description")
+        matcher.description.should == "custom message"
+      end
+
+      it "should tell you no description was provided when it doesn't receive one" do
+        matcher = simple_matcher do end
+        matcher.description.should =~ /No description provided/
+      end
     end
+    
   end
 end

data/vendor/plugins/rspec/spec/spec/mocks/any_number_of_times_spec.rb

@@ -23,6 +23,13 @@ module Spec
       it "should pass if any number of times method is not called" do
         @mock.should_receive(:random_call).any_number_of_times
       end
+
+      it "should return 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
+      end
     end
 
   end

data/vendor/plugins/rspec/spec/spec/mocks/bug_report_11545_spec.rb

@@ -1,6 +1,8 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 class LiarLiarPantsOnFire
+  include Spec::MetaClass
+  extend Spec::MetaClass
   def respond_to?(sym)
     true
   end

data/vendor/plugins/rspec/spec/spec/mocks/bug_report_496.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+class BaseClass
+end
+
+class SubClass < BaseClass
+end
+
+describe "a message expectation on a base class object" do
+  it "should correctly pick up message sent to it subclass" do
+    pending("fix for http://rspec.lighthouseapp.com/projects/5645-rspec/tickets/496") do
+      BaseClass.should_receive(:new).once
+      SubClass.new
+    end
+  end
+end
+

data/vendor/plugins/rspec/spec/spec/mocks/failing_mock_argument_constraints_spec.rb

@@ -75,41 +75,21 @@ module Spec
           @mock.msg(37)
         end.should raise_error(MockExpectationError, "Mock 'test mock' expected :msg with (no args) but received it with (37)")
       end
-    end
       
-    describe "failing deprecated MockArgumentConstraints" do
-      before(:each) do
-        @mock = mock("test mock")
-        @reporter = Mock.new("reporter", :null_object => true)
-        Kernel.stub!(:warn)
+      it "should fail hash_including with missing key" do
+         lambda do
+           @mock.should_receive(:msg).with(hash_including(:a => 1))
+           @mock.msg({})
+         end.should raise_error(MockExpectationError, "Mock 'test mock' expected :msg with (hash_including(:a=>1)) but received it with ({})")
       end
 
-      after(:each) do
-        @mock.rspec_reset
-      end
-
-      it "should reject non boolean" do
-        @mock.should_receive(:random_call).with(:boolean)
+      it "should fail with block constraints" do
         lambda do
-          @mock.random_call("false")
-        end.should raise_error(MockExpectationError)
+          @mock.should_receive(:msg).with {|arg| arg.should == :received }
+          @mock.msg :no_msg_for_you
+        end.should raise_error(Spec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/)
       end
-      
-      it "should reject non numeric" do
-        @mock.should_receive(:random_call).with(:numeric)
-        lambda do
-          @mock.random_call("1")
-        end.should raise_error(MockExpectationError)
-      end
-      
-      it "should reject non string" do
-        @mock.should_receive(:random_call).with(:string)
-        lambda do
-          @mock.random_call(123)
-        end.should raise_error(MockExpectationError)
-      end
-      
-
+            
     end
   end
 end

data/vendor/plugins/rspec/spec/spec/mocks/hash_including_matcher_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    module ArgumentConstraints
+      describe HashIncludingConstraint do
+        
+        it "should describe itself properly" do
+          HashIncludingConstraint.new(:a => 1).description.should == "hash_including(:a=>1)"
+        end      
+
+        describe "passing" do
+          it "should match the same hash" do
+            hash_including(:a => 1).should == {:a => 1}
+          end
+
+          it "should match a hash with extra stuff" do
+            hash_including(:a => 1).should == {:a => 1, :b => 2}
+          end
+          
+          describe "when matching against other constraints" do
+            it "should match an int against anything()" do
+              hash_including(:a => anything, :b => 2).should == {:a => 1, :b => 2}
+            end
+
+            it "should match a string against anything()" do
+              hash_including(:a => anything, :b => 2).should == {:a => "1", :b => 2}
+            end
+          end
+        end
+        
+        describe "failing" do
+          it "should not match a non-hash" do
+            hash_including(:a => 1).should_not == 1
+          end
+
+
+          it "should not match a hash with a missing key" do
+            hash_including(:a => 1).should_not == {:b => 2}
+          end
+
+          it "should not match a hash with an incorrect value" do
+            hash_including(:a => 1, :b => 2).should_not == {:a => 1, :b => 3}
+          end
+
+          it "should not match when values are nil but keys are different" do
+            hash_including(:a => nil).should_not == {:b => nil}
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/spec/spec/mocks/mock_spec.rb

@@ -23,6 +23,18 @@ module Spec
         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)
+        begin
+          @mock.rspec_verify
+          violated
+        rescue MockExpectationError => e
+          # NOTE - this regexp ended w/ $, but jruby adds extra info at the end of the line
+          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
@@ -37,18 +49,16 @@ module Spec
       
       it "should fail when receiving message specified as not to be received" do
         @mock.should_not_receive(:not_expected)
-        @mock.not_expected
         lambda {
-          @mock.rspec_verify
+          @mock.not_expected
           violated
-        }.should raise_error(MockExpectationError, "Mock 'test mock' expected :not_expected with (any args) 0 times, but received it once")
+        }.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")
-        @mock.not_expected("unexpected text")
         lambda {
-          @mock.rspec_verify
+          @mock.not_expected("unexpected text")
           violated
         }.should raise_error(MockExpectationError, "Mock 'test mock' expected :not_expected with (\"unexpected text\") 0 times, but received it once")
       end
@@ -77,7 +87,7 @@ module Spec
         @mock.rspec_verify
       end
       
-      it "should raise exception if args dont match when method called" do
+      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 {
           @mock.something("a","d","c")
@@ -85,6 +95,24 @@ module Spec
         }.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")
+        lambda {
+          @mock.something("a","d","c")
+          @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")
+        lambda {
+          @mock.something("a","d","c")
+          @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")
@@ -110,23 +138,19 @@ module Spec
       end
         
       it "should fail right away when method defined as never is received" do
-        pending "Used to pass (false positive). Which one is wrong, the spec or the actual behavior?"
-
         @mock.should_receive(:not_expected).never
         lambda {
           @mock.not_expected
-        }.should raise_error(MockExpectationError, "Mock 'test mock' expected :not_expected 0 times, but received it 1 times")
+        }.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
-        @mock.not_expected
-          
         lambda {
-          @mock.rspec_verify
-        }.should raise_error(MockExpectationError, "Mock 'test mock' expected :not_expected with (any args) 0 times, but received it once")
+          @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
@@ -186,14 +210,20 @@ module Spec
           @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
@@ -238,7 +268,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).
@@ -347,7 +377,7 @@ module Spec
         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.
         #
@@ -376,7 +406,7 @@ module Spec
         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)
@@ -386,6 +416,21 @@ module Spec
         @mock.rspec_verify
       end
 
+      it "should not require a different signature to replace a method stub" do
+        @mock.stub!(:msg).and_return(:stub_value)
+        @mock.should_receive(:msg).and_return(:mock_value)
+        @mock.msg(:arg).should equal(:mock_value)
+        @mock.msg.should equal(:stub_value)
+        @mock.msg.should equal(:stub_value)
+        @mock.rspec_verify
+      end
+
+      it "should raise an error when a previously stubbed method has a negative expectation" do
+        @mock.stub!(:msg).and_return(:stub_value)
+        @mock.should_not_receive(:msg).and_return(:mock_value)
+        lambda {@mock.msg(:arg)}.should raise_error(MockExpectationError)
+      end
+
       it "should temporarily replace a method stub on a non-mock" do
         non_mock = Object.new
         non_mock.stub!(:msg).and_return(:stub_value)
@@ -395,13 +440,39 @@ module Spec
         non_mock.msg.should equal(:stub_value)
         non_mock.rspec_verify
       end
-      
+
+      it "should return the stubbed value when no new value specified" do
+        @mock.stub!(:msg).and_return(:stub_value)
+        @mock.should_receive(:msg)
+        @mock.msg.should equal(:stub_value)
+        @mock.rspec_verify
+      end
+
+      it "should 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.rspec_verify
+      end
+
+      it "should yield multiple values after a similar stub" do
+        File.stub!(:open).and_yield(:stub_value)
+        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 }
+        File.rspec_verify
+      end
+
       it "should assign stub return values" do
         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")
@@ -414,62 +485,71 @@ module Spec
       
       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 #with" do
-        @mock.should_receive(:foo).with(:arg) { add_call }
-        
-        @mock.foo(:arg)
-
-        @calls.should == 1
-      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")
+        valid_html_str = "#{mock}"
+        valid_html_str.should_not include('<')
+      end
+    end
   end
 end

data/vendor/plugins/rspec/spec/spec/mocks/nil_expectation_warning_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+
+    describe "an expectation set on nil" do
+      
+      it "should issue a warning with file and line number information" do
+        expected_warning = "An expectation of :foo was set on nil. Called from #{__FILE__}:#{__LINE__+3}. Use allow_message_expectations_on_nil to disable warnings."
+        Kernel.should_receive(:warn).with(expected_warning)
+
+        nil.should_receive(:foo)
+        nil.foo
+      end
+      
+      it "should issue a warning when the expectation is negative" do
+        Kernel.should_receive(:warn)
+
+        nil.should_not_receive(:foo)
+      end
+      
+      it "should not issue a warning when expectations are set to be allowed" do
+        allow_message_expectations_on_nil
+        Kernel.should_not_receive(:warn)
+        
+        nil.should_receive(:foo)
+        nil.should_not_receive(:bar)
+        nil.foo
+      end
+
+    end
+    
+    describe "#allow_message_expectations_on_nil" do
+      
+      it "should not effect subsequent examples" do
+        example_group = Class.new(ExampleGroup)
+        example_group.it("when called in one example that doesn't end up setting an expectation on nil") do
+                        allow_message_expectations_on_nil
+                      end
+        example_group.it("should not effect the next exapmle ran") do
+                        Kernel.should_receive(:warn)
+                        nil.should_receive(:foo)
+                        nil.foo
+                      end
+                              
+        example_group.run.should be_true
+                  
+      end
+
+    end
+    
+  end
+end

data/vendor/plugins/rspec/spec/spec/mocks/null_object_mock_spec.rb

@@ -36,5 +36,19 @@ module Spec
         @mock.message(:unexpected_arg)
       end
     end
+
+    describe "#null_object?" do
+      it "should default to false" do
+        obj = mock('anything')
+        obj.should_not be_null_object
+      end
+    end
+    
+    describe "#as_null_object" do
+      it "should set the object to null_object" do
+        obj = mock('anything').as_null_object
+        obj.should be_null_object
+      end
+    end
   end
 end