rspec-expectations 2.11.3 → 2.12.0

data/spec/rspec/matchers/dsl_spec.rb

@@ -22,13 +22,13 @@ describe "a matcher defined using the matcher DSL" do
   end
 
   it "has access to methods available in the scope of the example" do
-    RSpec::Matchers::define(:ignore) {}
-    ignore.question?.should eq(:answer)
+    RSpec::Matchers::define(:matcher_a) {}
+    matcher_a.question?.should eq(:answer)
   end
 
   it "raises when method is missing from local scope as well as matcher" do
-    RSpec::Matchers::define(:ignore) {}
-    expect { ignore.i_dont_exist }.to raise_error(NameError)
+    RSpec::Matchers::define(:matcher_b) {}
+    expect { matcher_b.i_dont_exist }.to raise_error(NameError)
   end
 
   it "clears user instance variables between invocations" do
@@ -45,13 +45,13 @@ describe "a matcher defined using the matcher DSL" do
 
   describe "#respond_to?" do
     it "returns true for methods in example scope" do
-      RSpec::Matchers::define(:ignore) {}
-      ignore.should respond_to(:question?)
+      RSpec::Matchers::define(:matcher_c) {}
+      matcher_c.should respond_to(:question?)
     end
 
     it "returns false for methods not defined in matcher or example scope" do
-      RSpec::Matchers::define(:ignore) {}
-      ignore.should_not respond_to(:i_dont_exist)
+      RSpec::Matchers::define(:matcher_d) {}
+      matcher_d.should_not respond_to(:i_dont_exist)
     end
   end
 end

data/spec/rspec/matchers/have_spec.rb

@@ -2,22 +2,16 @@ require 'spec_helper'
 require 'stringio'
 
 describe "have matcher" do
-
-  before(:each) do
-    if defined?(::ActiveSupport::Inflector) && ::ActiveSupport::Inflector.respond_to?(:pluralize)
-      @active_support_was_defined = true
-    else
-      @active_support_was_defined = false
-      module ::ActiveSupport
-        class Inflector
-          def self.pluralize(string)
-            string.to_s + 's'
-          end
-        end
+  let(:inflector) do
+    Class.new do
+      def self.pluralize(string)
+        string.to_s + 's'
       end
     end
   end
 
+  before(:each) { stub_const("ActiveSupport::Inflector", inflector) }
+
   def create_collection_owner_with(n)
     owner = RSpec::Expectations::Helper::CollectionOwner.new
     (1..n).each do |number|
@@ -91,45 +85,21 @@ describe "have matcher" do
     context "when ActiveSupport::Inflector is partially loaded without its inflectors" do
 
       it "does not pluralize the collection name" do
-        (class << ::ActiveSupport::Inflector; self; end).send :undef_method, :pluralize
+        stub_const("ActiveSupport::Inflector", Module.new)
         owner = create_collection_owner_with(1)
         expect { owner.should have(1).item }.to raise_error(NoMethodError)
       end
 
     end
-
-    after(:each) do
-      unless @active_support_was_defined
-        Object.__send__ :remove_const, :ActiveSupport
-      end
-    end
   end
 
   describe 'should have(1).item when Inflector is defined' do
-
-    before(:each) do
-      if defined?(Inflector)
-        @inflector_was_defined = true
-      else
-        @inflector_was_defined = false
-        class ::Inflector
-          def self.pluralize(string)
-            string.to_s + 's'
-          end
-        end
-      end
-    end
+    before { stub_const("Inflector", inflector) }
 
     it 'pluralizes the collection name' do
       owner = create_collection_owner_with(1)
       owner.should have(1).item
     end
-
-    after(:each) do
-      unless @inflector_was_defined
-        Object.__send__ :remove_const, :Inflector
-      end
-    end
   end
 
   describe "should have(n).items where result responds to items but returns something other than a collection" do

data/spec/rspec/matchers/include_spec.rb

@@ -56,6 +56,12 @@ describe "#include matcher" do
           {:key => 'value'}.should include(:other)
         }.should fail_matching(%Q|expected {:key=>"value"} to include :other|)
       end
+
+      it "fails if target doesn't have a key and we expect nil" do
+        lambda {
+          {}.should include(:something => nil)
+        }.should fail_matching(%Q|expected {} to include {:something=>nil}|)
+      end
     end
   end
 

data/spec/rspec/matchers/match_array_spec.rb

@@ -122,3 +122,17 @@ describe "should_not =~ [:with, :multiple, :args]" do
     }.should fail_with(/Matcher does not support should_not/)
   end
 end
+
+describe "matching against things that aren't arrays" do
+  it "fails with nil and the expected error message is given" do
+    expect { nil.should match_array([1,2,3]) }.to fail_with(/expected an array/)
+  end
+
+  it "fails with a float and the expected error message is given" do
+    expect { (3.7).should match_array([1,2,3]) }.to fail_with(/expected an array/)
+  end
+
+  it "fails with a string and the expected error message is given" do
+    expect { "I like turtles".should match_array([1,2,3]) }.to fail_with(/expected an array/)
+  end
+end

data/spec/rspec/matchers/raise_error_spec.rb

@@ -9,7 +9,7 @@ describe "should raise_error" do
   it "passes if anything is raised" do
     lambda {raise}.should raise_error
   end
-  
+
   it "fails if nothing is raised" do
     lambda {
       lambda {}.should raise_error
@@ -45,11 +45,32 @@ describe "should_not raise_error" do
   it "passes if nothing is raised" do
     lambda {}.should_not raise_error
   end
-  
+
   it "fails if anything is raised" do
     lambda {
       lambda { raise RuntimeError, "example message" }.should_not raise_error
-    }.should fail_with("expected no Exception, got #<RuntimeError: example message>")
+    }.should fail_with(/expected no Exception, got #<RuntimeError: example message>/)
+  end
+
+  it 'includes the backtrace of the error that was raised in the error message' do
+    expect {
+      expect { raise "boom" }.not_to raise_error
+    }.to raise_error { |e|
+      backtrace_line = "#{File.basename(__FILE__)}:#{__LINE__ - 2}"
+      e.message.should include("with backtrace", backtrace_line)
+    }
+  end
+
+  it 'formats the backtrace using the configured backtrace formatter' do
+    RSpec::Matchers.configuration.backtrace_formatter.
+                    stub(:format_backtrace).
+                    and_return("formatted-backtrace")
+
+    expect {
+      expect { raise "boom" }.not_to raise_error
+    }.to raise_error { |e|
+      e.message.should include("with backtrace", "formatted-backtrace")
+    }
   end
 end
 
@@ -57,21 +78,34 @@ describe "should raise_error(message)" do
   it "passes if RuntimeError is raised with the right message" do
     lambda {raise 'blah'}.should raise_error('blah')
   end
+
   it "passes if RuntimeError is raised with a matching message" do
     lambda {raise 'blah'}.should raise_error(/blah/)
   end
+
   it "passes if any other error is raised with the right message" do
     lambda {raise NameError.new('blah')}.should raise_error('blah')
   end
+
   it "fails if RuntimeError error is raised with the wrong message" do
     lambda do
       lambda {raise 'blarg'}.should raise_error('blah')
-    end.should fail_with("expected Exception with \"blah\", got #<RuntimeError: blarg>")
+    end.should fail_with(/expected Exception with \"blah\", got #<RuntimeError: blarg>/)
   end
+
   it "fails if any other error is raised with the wrong message" do
     lambda do
       lambda {raise NameError.new('blarg')}.should raise_error('blah')
-    end.should fail_with("expected Exception with \"blah\", got #<NameError: blarg>")
+    end.should fail_with(/expected Exception with \"blah\", got #<NameError: blarg>/)
+  end
+
+  it 'includes the backtrace of any other error in the failure message' do
+    expect {
+      expect { raise "boom" }.to raise_error(ArgumentError)
+    }.to raise_error { |e|
+      backtrace_line = "#{File.basename(__FILE__)}:#{__LINE__ - 2}"
+      e.message.should include("with backtrace", backtrace_line)
+    }
   end
 end
 
@@ -79,18 +113,21 @@ describe "should_not raise_error(message)" do
   it "passes if RuntimeError error is raised with the different message" do
     lambda {raise 'blarg'}.should_not raise_error('blah')
   end
+
   it "passes if any other error is raised with the wrong message" do
     lambda {raise NameError.new('blarg')}.should_not raise_error('blah')
   end
+
   it "fails if RuntimeError is raised with message" do
     lambda do
       lambda {raise 'blah'}.should_not raise_error('blah')
-    end.should fail_with(%Q|expected no Exception with "blah", got #<RuntimeError: blah>|)
+    end.should fail_with(/expected no Exception with "blah", got #<RuntimeError: blah>/)
   end
+
   it "fails if any other error is raised with message" do
     lambda do
       lambda {raise NameError.new('blah')}.should_not raise_error('blah')
-    end.should fail_with(%Q|expected no Exception with "blah", got #<NameError: blah>|)
+    end.should fail_with(/expected no Exception with "blah", got #<NameError: blah>/)
   end
 end
 
@@ -98,19 +135,19 @@ describe "should raise_error(NamedError)" do
   it "passes if named error is raised" do
     lambda { non_existent_method }.should raise_error(NameError)
   end
-  
+
   it "fails if nothing is raised" do
     lambda {
       lambda { }.should raise_error(NameError)
-    }.should fail_with("expected NameError but nothing was raised")
+    }.should fail_with(/expected NameError but nothing was raised/)
   end
-  
+
   it "fails if another error is raised (NameError)" do
     lambda {
       lambda { raise RuntimeError, "example message" }.should raise_error(NameError)
-    }.should fail_with("expected NameError, got #<RuntimeError: example message>")
+    }.should fail_with(/expected NameError, got #<RuntimeError: example message>/)
   end
-  
+
   it "fails if another error is raised (NameError)" do
     lambda {
       lambda { load "non/existent/file" }.should raise_error(NameError)
@@ -122,35 +159,35 @@ describe "should_not raise_error(NamedError)" do
   it "passes if nothing is raised" do
     lambda { }.should_not raise_error(NameError)
   end
-  
+
   it "passes if another error is raised" do
     lambda { raise }.should_not raise_error(NameError)
   end
-  
+
   it "fails if named error is raised" do
     lambda {
       lambda { 1 + 'b' }.should_not raise_error(TypeError)
     }.should fail_with(/expected no TypeError, got #<TypeError: String can't be/)
-  end  
+  end
 end
 
 describe "should raise_error(NamedError, error_message) with String" do
   it "passes if named error is raised with same message" do
     lambda { raise "example message" }.should raise_error(RuntimeError, "example message")
   end
-  
+
   it "fails if nothing is raised" do
     lambda {
       lambda {}.should raise_error(RuntimeError, "example message")
-    }.should fail_with("expected RuntimeError with \"example message\" but nothing was raised")
+    }.should fail_with(/expected RuntimeError with \"example message\" but nothing was raised/)
   end
-  
+
   it "fails if incorrect error is raised" do
     lambda {
       lambda { raise RuntimeError, "example message" }.should raise_error(NameError, "example message")
-    }.should fail_with("expected NameError with \"example message\", got #<RuntimeError: example message>")
+    }.should fail_with(/expected NameError with \"example message\", got #<RuntimeError: example message>/)
   end
-  
+
   it "fails if correct error is raised with incorrect message" do
     lambda {
       lambda { raise RuntimeError.new("not the example message") }.should raise_error(RuntimeError, "example message")
@@ -197,7 +234,7 @@ describe "should raise_error(NamedError, error_message) { |err| ... }" do
       lambda {}.should raise_error(RuntimeError, "example message") { |err|
         ran = true
       }
-    }.should fail_with("expected RuntimeError with \"example message\" but nothing was raised")
+    }.should fail_with(/expected RuntimeError with \"example message\" but nothing was raised/)
 
     ran.should == false
   end
@@ -211,7 +248,7 @@ describe "should raise_error(NamedError, error_message) { |err| ... }" do
       }.should raise_error(SyntaxError, "example message") { |err|
         ran = true
       }
-    }.should fail_with("expected SyntaxError with \"example message\", got #<RuntimeError: example message>")
+    }.should fail_with(/expected SyntaxError with \"example message\", got #<RuntimeError: example message>/)
 
     ran.should == false
   end
@@ -225,7 +262,7 @@ describe "should raise_error(NamedError, error_message) { |err| ... }" do
       }.should raise_error(RuntimeError, "different message") { |err|
         ran = true
       }
-    }.should fail_with("expected RuntimeError with \"different message\", got #<RuntimeError: example message>")
+    }.should fail_with(/expected RuntimeError with \"different message\", got #<RuntimeError: example message>/)
 
     ran.should == false
   end
@@ -273,7 +310,21 @@ describe "should_not raise_error(NamedError, error_message) { |err| ... }" do
       }.should_not raise_error(RuntimeError, "example message") { |err|
         ran = true
       }
-    }.should fail_with("expected no RuntimeError with \"example message\", got #<RuntimeError: example message>")
+    }.should fail_with(/expected no RuntimeError with \"example message\", got #<RuntimeError: example message>/)
+
+    ran.should == false
+  end
+
+  it 'skips the error verification block when using the expect {...}.to syntax' do
+    ran = false
+
+    expect {
+      expect {
+        raise "example message"
+      }.not_to raise_error(RuntimeError, "example message") { |err|
+        ran = true
+      }
+    }.to fail_with(/expected no RuntimeError with \"example message\", got #<RuntimeError: example message>/)
 
     ran.should == false
   end
@@ -283,19 +334,19 @@ describe "should_not raise_error(NamedError, error_message) with String" do
   it "passes if nothing is raised" do
     lambda {}.should_not raise_error(RuntimeError, "example message")
   end
-  
+
   it "passes if a different error is raised" do
     lambda { raise }.should_not raise_error(NameError, "example message")
   end
-  
+
   it "passes if same error is raised with different message" do
     lambda { raise RuntimeError.new("not the example message") }.should_not raise_error(RuntimeError, "example message")
   end
-  
+
   it "fails if named error is raised with same message" do
     lambda {
       lambda { raise "example message" }.should_not raise_error(RuntimeError, "example message")
-    }.should fail_with("expected no RuntimeError with \"example message\", got #<RuntimeError: example message>")
+    }.should fail_with(/expected no RuntimeError with \"example message\", got #<RuntimeError: example message>/)
   end
 end
 
@@ -303,23 +354,23 @@ describe "should raise_error(NamedError, error_message) with Regexp" do
   it "passes if named error is raised with matching message" do
     lambda { raise "example message" }.should raise_error(RuntimeError, /ample mess/)
   end
-  
+
   it "fails if nothing is raised" do
     lambda {
       lambda {}.should raise_error(RuntimeError, /ample mess/)
-    }.should fail_with("expected RuntimeError with message matching /ample mess/ but nothing was raised")
+    }.should fail_with(/expected RuntimeError with message matching \/ample mess\/ but nothing was raised/)
   end
-  
+
   it "fails if incorrect error is raised" do
     lambda {
       lambda { raise RuntimeError, "example message" }.should raise_error(NameError, /ample mess/)
-    }.should fail_with("expected NameError with message matching /ample mess/, got #<RuntimeError: example message>")
+    }.should fail_with(/expected NameError with message matching \/ample mess\/, got #<RuntimeError: example message>/)
   end
-  
+
   it "fails if correct error is raised with incorrect message" do
     lambda {
       lambda { raise RuntimeError.new("not the example message") }.should raise_error(RuntimeError, /less than ample mess/)
-    }.should fail_with("expected RuntimeError with message matching /less than ample mess/, got #<RuntimeError: not the example message>")
+    }.should fail_with(/expected RuntimeError with message matching \/less than ample mess\/, got #<RuntimeError: not the example message>/)
   end
 end
 
@@ -327,18 +378,18 @@ describe "should_not raise_error(NamedError, error_message) with Regexp" do
   it "passes if nothing is raised" do
     lambda {}.should_not raise_error(RuntimeError, /ample mess/)
   end
-  
+
   it "passes if a different error is raised" do
     lambda { raise }.should_not raise_error(NameError, /ample mess/)
   end
-  
+
   it "passes if same error is raised with non-matching message" do
     lambda { raise RuntimeError.new("non matching message") }.should_not raise_error(RuntimeError, /ample mess/)
   end
-  
+
   it "fails if named error is raised with matching message" do
     lambda {
       lambda { raise "example message" }.should_not raise_error(RuntimeError, /ample mess/)
-    }.should fail_with("expected no RuntimeError with message matching /ample mess/, got #<RuntimeError: example message>")
+    }.should fail_with(/expected no RuntimeError with message matching \/ample mess\/, got #<RuntimeError: example message>/)
   end
 end

data/spec/rspec/matchers/start_with_end_with_spec.rb

@@ -130,7 +130,7 @@ describe "should end_with" do
   end
 
   context "with an object that does not respond to :[]" do
-    it "should raise an error if expected value can't be indexed'" do
+    it "raises an error if expected value can't be indexed'" do
       expect { Object.new.should end_with 0 }.to raise_error(ArgumentError, /does not respond to :\[\]/)
     end
   end

data/spec/rspec/matchers/yield_spec.rb

@@ -130,6 +130,12 @@ describe "yield_with_no_args matcher" do
       }.to fail_with(/expected given block to yield with no arguments, but yielded with arguments/)
     end
 
+    it 'fails if the block yields with arg false' do
+      expect {
+        expect { |b| _yield_with_args(false, &b) }.to yield_with_no_args
+      }.to fail_with(/expected given block to yield with no arguments, but yielded with arguments/)
+    end
+
     it 'raises an error if it yields multiple times' do
       expect {
         expect { |b| [1, 2].each(&b) }.to yield_with_no_args
@@ -179,6 +185,7 @@ describe "yield_with_args matcher" do
   it 'has a description' do
     yield_with_args.description.should eq("yield with args")
     yield_with_args(1, 3).description.should eq("yield with args(1, 3)")
+    yield_with_args(false).description.should eq("yield with args(false)")
   end
 
   describe "expect {...}.to yield_with_args" do
@@ -273,6 +280,34 @@ describe "yield_with_args matcher" do
     end
   end
 
+  describe "expect {...}.to yield_with_args( false )" do
+    it 'passes if the block yields with the given arguments' do
+      expect { |b| _yield_with_args(false, &b) }.to yield_with_args(false)
+    end
+
+    it 'passes if the block yields with the given arguments using instance_eval' do
+      expect { |b| InstanceEvaler.new.yield_with_args(false, &b) }.to yield_with_args(false)
+    end
+
+    it 'fails if the block does not yield' do
+      expect {
+        expect { |b| _dont_yield(&b) }.to yield_with_args(false)
+      }.to fail_with(/expected given block to yield with arguments, but did not yield/)
+    end
+
+    it 'fails if the block yields with no arguments' do
+      expect {
+        expect { |b| _yield_with_no_args(&b) }.to yield_with_args(false)
+      }.to fail_with(/expected given block to yield with arguments, but yielded with unexpected arguments/)
+    end
+
+    it 'fails if the block yields with different arguments' do
+      expect {
+        expect { |b| _yield_with_args(false, &b) }.to yield_with_args(true)
+      }.to fail_with(/expected given block to yield with arguments, but yielded with unexpected arguments/)
+    end
+  end
+
   describe "expect {...}.to yield_with_args(/reg/, /ex/)" do
     it "passes if the block yields strings matching the regexes" do
       expect { |b| _yield_with_args("regular", "expression", &b) }.to yield_with_args(/reg/, /ex/)