rspec-expectations 2.6.0 → 2.7.0.rc1

data/lib/rspec/matchers/has.rb

@@ -10,15 +10,15 @@ module RSpec
       end
 
       def failure_message_for_should
-        "expected ##{predicate(@expected)}(#{@args[0].inspect}) to return true, got false"
+        "expected ##{predicate(@expected)}#{failure_message_args_description} to return true, got false"
       end
 
       def failure_message_for_should_not
-        "expected ##{predicate(@expected)}(#{@args[0].inspect}) to return false, got true"
+        "expected ##{predicate(@expected)}#{failure_message_args_description} to return false, got true"
       end
 
       def description
-        [method_description(@expected), args_description(@args)].compact.join(' ')
+        [method_description(@expected), args_description].compact.join(' ')
       end
 
     private
@@ -30,9 +30,14 @@ module RSpec
         method.to_s.gsub('_', ' ')
       end
 
-      def args_description(args)
-        return nil if args.empty?
-        args.map { |arg| arg.inspect }.join(', ')
+      def args_description
+        return nil if @args.empty?
+        @args.map { |arg| arg.inspect }.join(', ')
+      end
+
+      def failure_message_args_description
+        desc = args_description
+        "(#{desc})" if desc
       end
     end
   end

data/lib/rspec/matchers/have.rb

@@ -2,7 +2,11 @@ module RSpec
   module Matchers
     class Have #:nodoc:
       def initialize(expected, relativity=:exactly)
-        @expected = (expected == :no ? 0 : expected)
+        @expected = case expected
+                    when :no then 0
+                    when String then expected.to_i
+                    else expected
+                    end
         @relativity = relativity
         @actual = @collection_name = @plural_collection_name = nil
       end
@@ -15,26 +19,36 @@ module RSpec
         }
       end
     
-      def matches?(collection_owner)
-        if collection_owner.respond_to?(@collection_name)
-          collection = collection_owner.__send__(@collection_name, *@args, &@block)
-        elsif (@plural_collection_name && collection_owner.respond_to?(@plural_collection_name))
-          collection = collection_owner.__send__(@plural_collection_name, *@args, &@block)
-        elsif (collection_owner.respond_to?(:length) || collection_owner.respond_to?(:size))
-          collection = collection_owner
+      def matches?(collection_or_owner)
+        collection = determine_collection(collection_or_owner)
+        query_method = determine_query_method(collection)
+        raise not_a_collection unless query_method
+        @actual = collection.send(query_method)
+        case @relativity
+        when :at_least then @actual >= @expected
+        when :at_most  then @actual <= @expected
+        else                @actual == @expected
+        end
+      end
+
+      def determine_collection(collection_or_owner)
+        if collection_or_owner.respond_to?(@collection_name)
+          collection_or_owner.send(@collection_name, *@args, &@block)
+        elsif (@plural_collection_name && collection_or_owner.respond_to?(@plural_collection_name))
+          collection_or_owner.send(@plural_collection_name, *@args, &@block)
+        elsif determine_query_method(collection_or_owner)
+          collection_or_owner
         else
-          collection_owner.__send__(@collection_name, *@args, &@block)
+          collection_or_owner.send(@collection_name, *@args, &@block)
         end
-        @actual = collection.size if collection.respond_to?(:size)
-        @actual = collection.length if collection.respond_to?(:length)
-        raise not_a_collection if @actual.nil?
-        return @actual >= @expected if @relativity == :at_least
-        return @actual <= @expected if @relativity == :at_most
-        return @actual == @expected
       end
-      
+
+      def determine_query_method(collection)
+        [:size, :length, :count].detect {|m| collection.respond_to?(m)}
+      end
+
       def not_a_collection
-        "expected #{@collection_name} to be a collection but it does not respond to #length or #size"
+        "expected #{@collection_name} to be a collection but it does not respond to #length, #size or #count"
       end
     
       def failure_message_for_should
@@ -67,8 +81,8 @@ EOF
         "have #{relative_expectation} #{@collection_name}"
       end
       
-      def respond_to?(sym)
-        @expected.respond_to?(sym) || super
+      def respond_to?(m)
+        @expected.respond_to?(m) || super
       end
     
       private
@@ -117,6 +131,9 @@ EOF
     #   # Passes if [1,2,3].length == 3
     #   [1,2,3].should have(3).items #"items" is pure sugar
     #
+    #   # Passes if ['a', 'b', 'c'].count == 3
+    #   [1,2,3].should have(3).items #"items" is pure sugar
+    #
     #   # Passes if "this string".length == 11
     #   "this string".should have(11).characters #"characters" is pure sugar
     def have(n)

data/lib/rspec/matchers/match_array.rb

@@ -34,7 +34,7 @@ module RSpec
       private
 
         def safe_sort(array)
-          array.all?{|item| item.respond_to?(:<=>)} ? array.sort : array
+          array.sort rescue array
         end
 
         def difference_between_arrays(array_1, array_2)

data/lib/rspec/matchers/matcher.rb

@@ -1,7 +1,7 @@
 module RSpec
   module Matchers
     class Matcher
-      include RSpec::Matchers::InstanceExec
+      include RSpec::Matchers::Extensions::InstanceEvalWithArgs
       include RSpec::Matchers::Pretty
       include RSpec::Matchers
 
@@ -20,7 +20,7 @@ module RSpec
           :failure_message_for_should_not => lambda {|actual| "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"}
         }
         making_declared_methods_public do
-          instance_exec(*@expected, &declarations)
+          instance_eval_with_args(*@expected, &declarations)
         end
       end
       
@@ -29,14 +29,14 @@ module RSpec
         @actual = actual
         if @expected_exception
           begin
-            instance_exec(actual, &@match_block)
+            instance_eval_with_args(actual, &@match_block)
             true
           rescue @expected_exception => @rescued_exception
             false
           end
         else
           begin
-            instance_exec(actual, &@match_block)
+            instance_eval_with_args(actual, &@match_block)
           rescue RSpec::Expectations::ExpectationNotMetError
             false
           end
@@ -47,7 +47,7 @@ module RSpec
       def does_not_match?(actual)
         @actual = actual
         @match_for_should_not_block ?
-          instance_exec(actual, &@match_for_should_not_block) :
+          instance_eval_with_args(actual, &@match_for_should_not_block) :
           !matches?(actual)
       end
 

data/spec/rspec/matchers/change_spec.rb

@@ -95,6 +95,44 @@ describe "should change(actual, message)" do
       end.to fail
     end
   end
+
+  context "with an arbitrary enumerable" do
+    before(:each) do
+      @instance = SomethingExpected.new
+      @instance.some_value = Class.new do
+        include Enumerable
+
+        attr_reader :elements
+
+        def initialize(*elements)
+          @elements = elements.dup
+        end
+
+        def <<(element)
+          elements << element
+        end
+
+        def dup
+          self.class.new *elements
+        end
+
+        def ==(other)
+          elements == other.elements
+        end
+      end.new
+    end
+
+    it "passes when actual is modified by the block" do
+      expect {@instance.some_value << 1}.to change(@instance, :some_value)
+    end
+
+    it "fails when actual is not modified by the block" do
+      expect do
+        expect {}.to change(@instance, :some_value)
+      end.to fail_with(/^some_value should have changed, but is still/)
+    end
+
+  end
 end
 
 describe "should_not change(actual, message)" do

data/spec/rspec/matchers/description_generation_spec.rb

@@ -5,75 +5,75 @@ describe "Matchers should be able to generate their own descriptions" do
     RSpec::Matchers.clear_generated_description
   end
 
-  it "should == expected" do
-    "this".should == "this"
-    RSpec::Matchers.generated_description.should == "should == \"this\""
+  it "should eq expected" do
+    "this".should eq "this"
+    RSpec::Matchers.generated_description.should eq "should eq this"
   end
 
-  it "should not == expected" do
-    "this".should_not == "that"
-    RSpec::Matchers.generated_description.should == "should not == \"that\""
+  it "should not eq expected" do
+    "this".should_not eq "that"
+    RSpec::Matchers.generated_description.should eq "should not eq that"
   end
 
   it "should be empty (arbitrary predicate)" do
     [].should be_empty
-    RSpec::Matchers.generated_description.should == "should be empty"
+    RSpec::Matchers.generated_description.should eq "should be empty"
   end
 
   it "should not be empty (arbitrary predicate)" do
     [1].should_not be_empty
-    RSpec::Matchers.generated_description.should == "should not be empty"
+    RSpec::Matchers.generated_description.should eq "should not be empty"
   end
 
   it "should be true" do
     true.should be_true
-    RSpec::Matchers.generated_description.should == "should be true"
+    RSpec::Matchers.generated_description.should eq "should be true"
   end
 
   it "should be false" do
     false.should be_false
-    RSpec::Matchers.generated_description.should == "should be false"
+    RSpec::Matchers.generated_description.should eq "should be false"
   end
 
   it "should be nil" do
     nil.should be_nil
-    RSpec::Matchers.generated_description.should == "should be nil"
+    RSpec::Matchers.generated_description.should eq "should be nil"
   end
 
   it "should be > n" do
     5.should be > 3
-    RSpec::Matchers.generated_description.should == "should be > 3"
+    RSpec::Matchers.generated_description.should eq "should be > 3"
   end
 
   it "should be predicate arg1, arg2 and arg3" do
     5.0.should be_between(0,10)
-    RSpec::Matchers.generated_description.should == "should be between 0 and 10"
+    RSpec::Matchers.generated_description.should eq "should be between 0 and 10"
   end
 
   it "should equal" do
     expected = "expected"
     expected.should equal(expected)
-    RSpec::Matchers.generated_description.should == "should equal \"expected\""
+    RSpec::Matchers.generated_description.should eq "should equal \"expected\""
   end
 
   it "should_not equal" do
     5.should_not equal(37)
-    RSpec::Matchers.generated_description.should == "should not equal 37"
+    RSpec::Matchers.generated_description.should eq "should not equal 37"
   end
 
   it "should eql" do
     "string".should eql("string")
-    RSpec::Matchers.generated_description.should == "should eql \"string\""
+    RSpec::Matchers.generated_description.should eq "should eql \"string\""
   end
 
   it "should not eql" do
     "a".should_not eql(:a)
-    RSpec::Matchers.generated_description.should == "should not eql :a"
+    RSpec::Matchers.generated_description.should eq "should not eql :a"
   end
 
   it "should have_key" do
     {:a => "a"}.should have_key(:a)
-    RSpec::Matchers.generated_description.should == "should have key :a"
+    RSpec::Matchers.generated_description.should eq "should have key :a"
   end
 
   it "should have_some_method" do
@@ -81,7 +81,7 @@ describe "Matchers should be able to generate their own descriptions" do
     def object.has_eyes_closed?; true; end
 
     object.should have_eyes_closed
-    RSpec::Matchers.generated_description.should == 'should have eyes closed'
+    RSpec::Matchers.generated_description.should eq 'should have eyes closed'
   end
 
   it "should have_some_method(args*)" do
@@ -89,67 +89,67 @@ describe "Matchers should be able to generate their own descriptions" do
     def object.has_taste_for?(*args); true; end
 
     object.should have_taste_for("wine", "cheese")
-    RSpec::Matchers.generated_description.should == 'should have taste for "wine", "cheese"'
+    RSpec::Matchers.generated_description.should eq 'should have taste for "wine", "cheese"'
   end
 
   it "should have n items" do
     team.should have(3).players
-    RSpec::Matchers.generated_description.should == "should have 3 players"
+    RSpec::Matchers.generated_description.should eq "should have 3 players"
   end
 
   it "should have at least n items" do
     team.should have_at_least(2).players
-    RSpec::Matchers.generated_description.should == "should have at least 2 players"
+    RSpec::Matchers.generated_description.should eq "should have at least 2 players"
   end
 
   it "should have at most n items" do
     team.should have_at_most(4).players
-    RSpec::Matchers.generated_description.should == "should have at most 4 players"
+    RSpec::Matchers.generated_description.should eq "should have at most 4 players"
   end
 
   it "should include" do
     [1,2,3].should include(3)
-    RSpec::Matchers.generated_description.should == "should include 3"
+    RSpec::Matchers.generated_description.should eq "should include 3"
   end
 
   it "array.should =~ [1,2,3]" do
     [1,2,3].should =~ [1,2,3]
-    RSpec::Matchers.generated_description.should == "should contain exactly 1, 2 and 3"
+    RSpec::Matchers.generated_description.should eq "should contain exactly 1, 2 and 3"
   end
 
   it "should match" do
     "this string".should match(/this string/)
-    RSpec::Matchers.generated_description.should == "should match /this string/"
+    RSpec::Matchers.generated_description.should eq "should match /this string/"
   end
 
   it "should raise_error" do
     lambda { raise }.should raise_error
-    RSpec::Matchers.generated_description.should == "should raise Exception"
+    RSpec::Matchers.generated_description.should eq "should raise Exception"
   end
 
   it "should raise_error with type" do
     lambda { raise }.should raise_error(RuntimeError)
-    RSpec::Matchers.generated_description.should == "should raise RuntimeError"
+    RSpec::Matchers.generated_description.should eq "should raise RuntimeError"
   end
 
   it "should raise_error with type and message" do
     lambda { raise "there was an error" }.should raise_error(RuntimeError, "there was an error")
-    RSpec::Matchers.generated_description.should == "should raise RuntimeError with \"there was an error\""
+    RSpec::Matchers.generated_description.should eq "should raise RuntimeError with \"there was an error\""
   end
 
   it "should respond_to" do
     [].should respond_to(:insert)
-    RSpec::Matchers.generated_description.should == "should respond to #insert"
+    RSpec::Matchers.generated_description.should eq "should respond to #insert"
   end
 
   it "should throw symbol" do
     lambda { throw :what_a_mess }.should throw_symbol
-    RSpec::Matchers.generated_description.should == "should throw a Symbol"
+    RSpec::Matchers.generated_description.should eq "should throw a Symbol"
   end
 
   it "should throw symbol (with named symbol)" do
     lambda { throw :what_a_mess }.should throw_symbol(:what_a_mess)
-    RSpec::Matchers.generated_description.should == "should throw :what_a_mess"
+    RSpec::Matchers.generated_description.should eq "should throw :what_a_mess"
   end
 
   def team

data/spec/rspec/matchers/eq_spec.rb

@@ -18,13 +18,13 @@ module RSpec
       it "describes itself" do
         matcher = eq(1)
         matcher.matches?(1)
-        matcher.description.should == "== 1"
+        matcher.description.should == "eq 1"
       end
       
       it "provides message, expected and actual on #failure_message" do
         matcher = eq("1")
         matcher.matches?(1)
-        matcher.failure_message_for_should.should == "\nexpected \"1\"\n     got 1\n\n(compared using ==)\n"
+        matcher.failure_message_for_should.should == "\nexpected: \"1\"\n     got: 1\n\n(compared using ==)\n"
       end
       
       it "provides message, expected and actual on #negative_failure_message" do

data/spec/rspec/matchers/has_spec.rb

@@ -11,6 +11,22 @@ describe "should have_sym(*args)" do
     }.should fail_with("expected #has_key?(:a) to return true, got false")
   end
 
+  it 'does not include any args in the failure message if no args were given to the matcher' do
+    o = Object.new
+    def o.has_some_stuff?; false; end
+    expect {
+      o.should have_some_stuff
+    }.to fail_with("expected #has_some_stuff? to return true, got false")
+  end
+
+  it 'includes multiple args in the failure message if multiple args were given to the matcher' do
+    o = Object.new
+    def o.has_some_stuff?(*_); false; end
+    expect {
+      o.should have_some_stuff(:a, 7, "foo")
+    }.to fail_with('expected #has_some_stuff?(:a, 7, "foo") to return true, got false')
+  end
+
   it "fails if #has_sym?(*args) returns nil" do
     klass = Class.new do
       def has_foo?
@@ -18,7 +34,7 @@ describe "should have_sym(*args)" do
     end
     lambda {
       klass.new.should have_foo
-    }.should fail_with("expected #has_foo?(nil) to return true, got false")
+    }.should fail_with(/expected #has_foo.* to return true, got false/)
   end
 
   it "fails if target does not respond to #has_sym?" do
@@ -68,6 +84,22 @@ describe "should_not have_sym(*args)" do
     end
     lambda { o.should_not have_sym(:foo) }.should raise_error("Funky exception")
   end
+
+  it 'does not include any args in the failure message if no args were given to the matcher' do
+    o = Object.new
+    def o.has_some_stuff?; true; end
+    expect {
+      o.should_not have_some_stuff
+    }.to fail_with("expected #has_some_stuff? to return false, got true")
+  end
+
+  it 'includes multiple args in the failure message if multiple args were given to the matcher' do
+    o = Object.new
+    def o.has_some_stuff?(*_); true; end
+    expect {
+      o.should_not have_some_stuff(:a, 7, "foo")
+    }.to fail_with('expected #has_some_stuff?(:a, 7, "foo") to return false, got true')
+  end
 end
 
 describe "has" do