rspec 1.1.11 → 1.1.12

data/spec/spec/matchers/include_spec.rb

@@ -5,6 +5,10 @@ describe "should include(expected)" do
     [1,2,3].should include(3)
     "abc".should include("a")
   end
+  
+  it 'should pass if target is a Hash and has the expected as a key' do
+    {:key => 'value'}.should include(:key)
+  end
 
   it "should fail if target does not include expected" do
     lambda {
@@ -13,6 +17,9 @@ describe "should include(expected)" do
     lambda {
       "abc".should include("d")
     }.should fail_with("expected \"abc\" to include \"d\"")
+    lambda {
+      {:key => 'value'}.should include(:other)
+    }.should fail_with(%Q|expected {:key=>"value"} to include :other|)
   end
 end
 
@@ -20,12 +27,22 @@ describe "should include(with, multiple, args)" do
   it "should pass if target includes all items" do
     [1,2,3].should include(1,2,3)
   end
+  
+  it 'should pass if target is a Hash including all items as keys' do
+    {:key => 'value', :other => 'value'}.should include(:key, :other)
+  end
 
   it "should fail if target does not include any one of the items" do
     lambda {
       [1,2,3].should include(1,2,4)
     }.should fail_with("expected [1, 2, 3] to include 1, 2 and 4")
   end
+  
+  it 'should pass if target is a Hash missing any item as a key' do
+    lambda {
+      {:key => 'value'}.should include(:key, :other)
+    }.should fail_with(%Q|expected {:key=>"value"} to include :key and :other|)
+  end
 end
 
 describe "should_not include(expected)" do
@@ -33,6 +50,10 @@ describe "should_not include(expected)" do
     [1,2,3].should_not include(4)
     "abc".should_not include("d")
   end
+  
+  it 'should pass if target is a Hash and does not have the expected as a key' do
+    {:other => 'value'}.should_not include(:key)
+  end
 
   it "should fail if target includes expected" do
     lambda {
@@ -41,6 +62,9 @@ describe "should_not include(expected)" do
     lambda {
       "abc".should_not include("c")
     }.should fail_with("expected \"abc\" not to include \"c\"")
+    lambda {
+      {:key => 'value'}.should_not include(:key)
+    }.should fail_with(%Q|expected {:key=>"value"} not to include :key|)
   end
 end
 

data/spec/spec/matchers/match_array_spec.rb

@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe "array.should =~ other_array" do
+  it "should pass if target contains all items" do
+    [1,2,3].should =~ [1,2,3]
+  end
+
+  it "should pass if target contains all items out of order" do
+    [1,3,2].should =~ [1,2,3]
+  end
+
+  it "should fail if target includes extra items" do
+    lambda {
+      [1,2,3,4].should =~ [1,2,3]
+    }.should fail_with(<<-MESSAGE)
+expected collection contained:  [1, 2, 3]
+actual collection contained:    [1, 2, 3, 4]
+the extra elements were:        [4]
+MESSAGE
+  end
+
+  it "should fail if target is missing items" do
+    lambda {
+      [1,2].should =~ [1,2,3]
+    }.should fail_with(<<-MESSAGE)
+expected collection contained:  [1, 2, 3]
+actual collection contained:    [1, 2]
+the missing elements were:      [3]
+MESSAGE
+  end
+
+  it "should fail if target is missing items and has extra items" do
+
+    lambda {
+      [1,2,4].should =~ [1,2,3]
+    }.should fail_with(<<-MESSAGE)
+expected collection contained:  [1, 2, 3]
+actual collection contained:    [1, 2, 4]
+the missing elements were:      [3]
+the extra elements were:        [4]
+MESSAGE
+  end
+
+  it "should sort items in the error message" do
+    lambda {
+      [6,2,1,5].should =~ [4,1,2,3]
+    }.should fail_with(<<-MESSAGE)
+expected collection contained:  [1, 2, 3, 4]
+actual collection contained:    [1, 2, 5, 6]
+the missing elements were:      [3, 4]
+the extra elements were:        [5, 6]
+MESSAGE
+  end
+
+  it "should accurately report extra elements when there are duplicates" do
+    lambda {
+      [1,1,1,5].should =~ [1,5]
+    }.should fail_with(<<-MESSAGE)
+expected collection contained:  [1, 5]
+actual collection contained:    [1, 1, 1, 5]
+the extra elements were:        [1, 1]
+MESSAGE
+  end
+
+  it "should accurately report missing elements when there are duplicates" do
+    lambda {
+      [1,5].should =~ [1,1,5]
+    }.should fail_with(<<-MESSAGE)
+expected collection contained:  [1, 1, 5]
+actual collection contained:    [1, 5]
+the missing elements were:      [1]
+MESSAGE
+  end
+
+end
+
+describe "should_not =~ [:with, :multiple, :args]" do
+  it "should not be supported" do
+    lambda {
+      [1,2,3].should_not =~ [1,2,3]
+    }.should fail_with(/Matcher does not support should_not/)
+  end
+end

data/spec/spec/matchers/matcher_methods_spec.rb

@@ -16,18 +16,9 @@ This module should provide the following methods, each of which returns a Matche
       it "be_arbitrary_predicate" do
         be_arbitrary_predicate.should be_an_instance_of(Be)
       end
-      it "be_close" do
-        be_close(1,2).should be_an_instance_of(BeClose)
-      end
       it "change" do
         change("target", :message).should be_an_instance_of(Change)
       end
-      it "eql" do
-        eql(:expected).should be_an_instance_of(Eql)
-      end
-      it "equal" do
-        equal(:expected).should be_an_instance_of(Equal)
-      end
       it "have" do
         have(0).should be_an_instance_of(Have)
       end
@@ -43,9 +34,6 @@ This module should provide the following methods, each of which returns a Matche
       it "include" do
         include(:value).should be_an_instance_of(Include)
       end
-      it "match" do
-        match(:value).should be_an_instance_of(Match)
-      end
       it "raise_error" do
         raise_error.should be_an_instance_of(RaiseError)
         raise_error(NoMethodError).should be_an_instance_of(RaiseError)
@@ -70,7 +58,7 @@ This module should provide the following methods, each of which returns a Matche
       end
 
       it "should convert have_xyz to Has(:have_xyz)" do
-        Has.should_receive(:new).with(:have_whatever)
+        self.should_receive(:has).with(:have_whatever)
         have_whatever
       end
     end

data/spec/spec/matchers/raise_error_spec.rb

@@ -12,6 +12,24 @@ describe "should raise_error" do
   end
 end
 
+describe "should raise_error {|err| ... }" do
+  it "passes if there is an error" do
+    ran = false
+    lambda { non_existent_method }.should raise_error {|e|
+      ran = true
+    }
+    ran.should be_true
+  end
+
+  it "passes the error to the block" do
+    error = nil
+    lambda { non_existent_method }.should raise_error {|e|
+      error = e
+    }
+    error.should be_an_instance_of(NameError)
+  end
+end
+
 describe "should_not raise_error" do
   it "should pass if nothing is raised" do
     lambda {}.should_not raise_error

data/spec/spec/matchers/respond_to_spec.rb

@@ -2,50 +2,112 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 describe "should respond_to(:sym)" do
   
-  it "should pass if target responds to :sym" do
+  it "passes if target responds to :sym" do
     Object.new.should respond_to(:methods)
   end
   
-  it "should fail target does not respond to :sym" do
+  it "fails if target does not respond to :sym" do
     lambda {
       "this string".should respond_to(:some_method)
-    }.should fail_with("expected \"this string\" to respond to :some_method")
+    }.should fail_with(%q|expected "this string" to respond to :some_method|)
   end
   
 end
 
+describe "should respond_to(:sym).with(1).argument" do
+  it "passes if target responds to :sym with 1 arg" do
+    obj = Object.new
+    def obj.foo(arg); end
+    obj.should respond_to(:foo).with(1).argument
+  end
+  
+  it "fails if target does not respond to :sym" do
+    obj = Object.new
+    lambda {
+      obj.should respond_to(:some_method).with(1).argument
+    }.should fail_with(/expected .* to respond to :some_method/)
+  end
+  
+  it "fails if :sym expects 0 args" do
+    obj = Object.new
+    def obj.foo; end
+    lambda {
+      obj.should respond_to(:foo).with(1).argument
+    }.should fail_with(/expected #<Object.*> to respond to :foo with 1 argument/)
+  end
+  
+  it "fails if :sym expects 2 args" do
+    obj = Object.new
+    def obj.foo(arg, arg2); end
+    lambda {
+      obj.should respond_to(:foo).with(1).argument
+    }.should fail_with(/expected #<Object.*> to respond to :foo with 1 argument/)
+  end
+end
+
 describe "should respond_to(message1, message2)" do
   
-  it "should pass if target responds to both messages" do
+  it "passes if target responds to both messages" do
     Object.new.should respond_to('methods', 'inspect')
   end
   
-  it "should fail target does not respond to first message" do
+  it "fails if target does not respond to first message" do
     lambda {
       Object.new.should respond_to('method_one', 'inspect')
     }.should fail_with(/expected #<Object:.*> to respond to "method_one"/)
   end
   
-  it "should fail target does not respond to second message" do
+  it "fails if target does not respond to second message" do
     lambda {
       Object.new.should respond_to('inspect', 'method_one')
     }.should fail_with(/expected #<Object:.*> to respond to "method_one"/)
   end
   
-  it "should fail target does not respond to either message" do
+  it "fails if target does not respond to either message" do
     lambda {
       Object.new.should respond_to('method_one', 'method_two')
     }.should fail_with(/expected #<Object:.*> to respond to "method_one", "method_two"/)
   end
 end
 
+describe "should respond_to(:sym).with(2).arguments" do
+  it "passes if target responds to :sym with 2 args" do
+    obj = Object.new
+    def obj.foo(a1, a2); end
+    obj.should respond_to(:foo).with(2).arguments
+  end
+  
+  it "fails if target does not respond to :sym" do
+    obj = Object.new
+    lambda {
+      obj.should respond_to(:some_method).with(2).arguments
+    }.should fail_with(/expected .* to respond to :some_method/)
+  end
+  
+  it "fails if :sym expects 0 args" do
+    obj = Object.new
+    def obj.foo; end
+    lambda {
+      obj.should respond_to(:foo).with(2).arguments
+    }.should fail_with(/expected #<Object.*> to respond to :foo with 2 arguments/)
+  end
+  
+  it "fails if :sym expects 2 args" do
+    obj = Object.new
+    def obj.foo(arg); end
+    lambda {
+      obj.should respond_to(:foo).with(2).arguments
+    }.should fail_with(/expected #<Object.*> to respond to :foo with 2 arguments/)
+  end
+end
+
 describe "should_not respond_to(:sym)" do
   
-  it "should pass if target does not respond to :sym" do
+  it "passes if target does not respond to :sym" do
     Object.new.should_not respond_to(:some_method)
   end
   
-  it "should fail target responds to :sym" do
+  it "fails if target responds to :sym" do
     lambda {
       Object.new.should_not respond_to(:methods)
     }.should fail_with(/expected #<Object:.*> not to respond to :methods/)

data/spec/spec/matchers/throw_symbol_spec.rb

@@ -2,52 +2,94 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
   module Matchers
-    describe ThrowSymbol, "(constructed with no Symbol)" do
-      before(:each) { @matcher = ThrowSymbol.new }
-
-      it "should match if any Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :sym }).should be_true
-      end
-      it "should not match if no Symbol is thrown" do
-        @matcher.matches?(lambda{ }).should be_false
-      end
-      it "should provide a failure message" do
-        @matcher.matches?(lambda{})
-        @matcher.failure_message.should == "expected a Symbol but nothing was thrown"
-      end
-      it "should provide a negative failure message" do
-        @matcher.matches?(lambda{ throw :sym})
-        @matcher.negative_failure_message.should == "expected no Symbol, got :sym"
-      end
-    end
-    
-    describe ThrowSymbol, "(constructed with a Symbol)" do
-      before(:each) { @matcher = ThrowSymbol.new(:sym) }
+    describe ThrowSymbol do
+      describe "with no args" do
+        before(:each) { @matcher = ThrowSymbol.new }
       
-      it "should match if correct Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :sym }).should be_true
+        it "should match if any Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :sym }).should be_true
+        end
+        it "should match if any Symbol is thrown with an arg" do
+          @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+        end
+        it "should not match if no Symbol is thrown" do
+          @matcher.matches?(lambda{ }).should be_false
+        end
+        it "should provide a failure message" do
+          @matcher.matches?(lambda{})
+          @matcher.failure_message.should == "expected a Symbol but nothing was thrown"
+        end
+        it "should provide a negative failure message" do
+          @matcher.matches?(lambda{ throw :sym})
+          @matcher.negative_failure_message.should == "expected no Symbol, got :sym"
+        end
       end
-      it "should not match if no Symbol is thrown" do
-        @matcher.matches?(lambda{ }).should be_false
-      end
-      it "should not match if correct Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :other_sym }).should be_false
-        @matcher.failure_message.should == "expected :sym, got :other_sym"
-      end
-      it "should provide a failure message when no Symbol is thrown" do
-        @matcher.matches?(lambda{})
-        @matcher.failure_message.should == "expected :sym but nothing was thrown"
-      end
-      it "should provide a failure message when wrong Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :other_sym })
-        @matcher.failure_message.should == "expected :sym, got :other_sym"
-      end
-      it "should provide a negative failure message" do
-        @matcher.matches?(lambda{ throw :sym })
-        @matcher.negative_failure_message.should == "expected :sym not to be thrown"
+          
+      describe "with a symbol" do
+        before(:each) { @matcher = ThrowSymbol.new(:sym) }
+      
+        it "should match if correct Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :sym }).should be_true
+        end
+        it "should match if correct Symbol is thrown with an arg" do
+          @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+        end
+        it "should not match if no Symbol is thrown" do
+          @matcher.matches?(lambda{ }).should be_false
+        end
+        it "should not match if correct Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :other_sym }).should be_false
+        end
+        it "should provide a failure message when no Symbol is thrown" do
+          @matcher.matches?(lambda{})
+          @matcher.failure_message.should == "expected :sym but nothing was thrown"
+        end
+        it "should provide a failure message when wrong Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :other_sym })
+          @matcher.failure_message.should == "expected :sym, got :other_sym"
+        end
+        it "should provide a negative failure message" do
+          @matcher.matches?(lambda{ throw :sym })
+          @matcher.negative_failure_message.should == "expected :sym not to be thrown"
+        end
+        it "should only match NameErrors raised by uncaught throws" do
+          @matcher.matches?(lambda{ sym }).should be_false
+        end
       end
-      it "should only match NameErrors raised by uncaught throws" do
-        @matcher.matches?(lambda{ sym }).should be_false
+
+      describe "with a symbol and an arg" do
+        before(:each) { @matcher = ThrowSymbol.new(:sym, "a") }
+    
+        it "should match if correct Symbol and args are thrown" do
+          @matcher.matches?(lambda{ throw :sym, "a" }).should be_true
+        end
+        it "should not match if nothing is thrown" do
+          @matcher.matches?(lambda{ }).should be_false
+        end
+        it "should not match if other Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :other_sym, "a" }).should be_false
+        end
+        it "should not match if no arg is thrown" do
+          @matcher.matches?(lambda{ throw :sym }).should be_false
+        end
+        it "should not match if wrong arg is thrown" do
+          @matcher.matches?(lambda{ throw :sym, "b" }).should be_false
+        end
+        it "should provide a failure message when no Symbol is thrown" do
+          @matcher.matches?(lambda{})
+          @matcher.failure_message.should == %q[expected :sym with "a" but nothing was thrown]
+        end
+        it "should provide a failure message when wrong Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :other_sym })
+          @matcher.failure_message.should == %q[expected :sym with "a", got :other_sym]
+        end
+        it "should provide a negative failure message" do
+          @matcher.matches?(lambda{ throw :sym })
+          @matcher.negative_failure_message.should == %q[expected :sym with "a" not to be thrown]
+        end
+        it "should only match NameErrors raised by uncaught throws" do
+          @matcher.matches?(lambda{ sym }).should be_false
+        end
       end
     end
   end