rspec-expectations 2.0.0.beta.19 → 2.0.0.beta.20

data/spec/rspec/matchers/have_spec.rb

@@ -29,19 +29,19 @@ end
 describe "should have(n).items" do
   include HaveSpecHelper
 
-  it "should pass if target has a collection of items with n members" do
+  it "passes if target has a collection of items with n members" do
     owner = create_collection_owner_with(3)
     owner.should have(3).items_in_collection_with_length_method
     owner.should have(3).items_in_collection_with_size_method
   end
 
-  it "should convert :no to 0" do
+  it "converts :no to 0" do
     owner = create_collection_owner_with(0)
     owner.should have(:no).items_in_collection_with_length_method
     owner.should have(:no).items_in_collection_with_size_method
   end
 
-  it "should fail if target has a collection of items with < n members" do
+  it "fails if target has a collection of items with < n members" do
     owner = create_collection_owner_with(3)
     lambda {
       owner.should have(4).items_in_collection_with_length_method
@@ -51,7 +51,7 @@ describe "should have(n).items" do
     }.should fail_with("expected 4 items_in_collection_with_size_method, got 3")
   end
   
-  it "should fail if target has a collection of items with > n members" do
+  it "fails if target has a collection of items with > n members" do
     owner = create_collection_owner_with(3)
     lambda {
       owner.should have(2).items_in_collection_with_length_method
@@ -65,7 +65,7 @@ end
 describe 'should have(1).item when ActiveSupport::Inflector is defined' do
   include HaveSpecHelper
   
-  it 'should pluralize the collection name' do
+  it 'pluralizes the collection name' do
     owner = create_collection_owner_with(1)
     owner.should have(1).item
   end
@@ -93,7 +93,7 @@ describe 'should have(1).item when Inflector is defined' do
     end
   end
   
-  it 'should pluralize the collection name' do
+  it 'pluralizes the collection name' do
     owner = create_collection_owner_with(1)
     owner.should have(1).item
   end
@@ -106,7 +106,7 @@ describe 'should have(1).item when Inflector is defined' do
 end
 
 describe "should have(n).items where result responds to items but returns something other than a collection" do
-  it "should provide a meaningful error" do
+  it "provides a meaningful error" do
     owner = Class.new do
       def items
         Object.new
@@ -121,19 +121,19 @@ end
 describe "should_not have(n).items" do
   include HaveSpecHelper
 
-  it "should pass if target has a collection of items with < n members" do
+  it "passes if target has a collection of items with < n members" do
     owner = create_collection_owner_with(3)
     owner.should_not have(4).items_in_collection_with_length_method
     owner.should_not have(4).items_in_collection_with_size_method
   end
   
-  it "should pass if target has a collection of items with > n members" do
+  it "passes if target has a collection of items with > n members" do
     owner = create_collection_owner_with(3)
     owner.should_not have(2).items_in_collection_with_length_method
     owner.should_not have(2).items_in_collection_with_size_method
   end
 
-  it "should fail if target has a collection of items with n members" do
+  it "fails if target has a collection of items with n members" do
     owner = create_collection_owner_with(3)
     lambda {
       owner.should_not have(3).items_in_collection_with_length_method
@@ -147,19 +147,19 @@ end
 describe "should have_exactly(n).items" do
   include HaveSpecHelper
 
-  it "should pass if target has a collection of items with n members" do
+  it "passes if target has a collection of items with n members" do
     owner = create_collection_owner_with(3)
     owner.should have_exactly(3).items_in_collection_with_length_method
     owner.should have_exactly(3).items_in_collection_with_size_method
   end
 
-  it "should convert :no to 0" do
+  it "converts :no to 0" do
     owner = create_collection_owner_with(0)
     owner.should have_exactly(:no).items_in_collection_with_length_method
     owner.should have_exactly(:no).items_in_collection_with_size_method
   end
 
-  it "should fail if target has a collection of items with < n members" do
+  it "fails if target has a collection of items with < n members" do
     owner = create_collection_owner_with(3)
     lambda {
       owner.should have_exactly(4).items_in_collection_with_length_method
@@ -169,7 +169,7 @@ describe "should have_exactly(n).items" do
     }.should fail_with("expected 4 items_in_collection_with_size_method, got 3")
   end
   
-  it "should fail if target has a collection of items with > n members" do
+  it "fails if target has a collection of items with > n members" do
     owner = create_collection_owner_with(3)
     lambda {
       owner.should have_exactly(2).items_in_collection_with_length_method
@@ -183,19 +183,19 @@ end
 describe "should have_at_least(n).items" do
   include HaveSpecHelper
 
-  it "should pass if target has a collection of items with n members" do
+  it "passes if target has a collection of items with n members" do
     owner = create_collection_owner_with(3)
     owner.should have_at_least(3).items_in_collection_with_length_method
     owner.should have_at_least(3).items_in_collection_with_size_method
   end
   
-  it "should pass if target has a collection of items with > n members" do
+  it "passes if target has a collection of items with > n members" do
     owner = create_collection_owner_with(3)
     owner.should have_at_least(2).items_in_collection_with_length_method
     owner.should have_at_least(2).items_in_collection_with_size_method
   end
 
-  it "should fail if target has a collection of items with < n members" do
+  it "fails if target has a collection of items with < n members" do
     owner = create_collection_owner_with(3)
     lambda {
       owner.should have_at_least(4).items_in_collection_with_length_method
@@ -205,7 +205,7 @@ describe "should have_at_least(n).items" do
     }.should fail_with("expected at least 4 items_in_collection_with_size_method, got 3")
   end
   
-  it "should provide educational negative failure messages" do
+  it "provides educational negative failure messages" do
     #given
     owner = create_collection_owner_with(3)
     length_matcher = have_at_least(3).items_in_collection_with_length_method
@@ -237,13 +237,13 @@ end
 describe "should have_at_most(n).items" do
   include HaveSpecHelper
 
-  it "should pass if target has a collection of items with n members" do
+  it "passes if target has a collection of items with n members" do
     owner = create_collection_owner_with(3)
     owner.should have_at_most(3).items_in_collection_with_length_method
     owner.should have_at_most(3).items_in_collection_with_size_method
   end
 
-  it "should fail if target has a collection of items with > n members" do
+  it "fails if target has a collection of items with > n members" do
     owner = create_collection_owner_with(3)
     lambda {
       owner.should have_at_most(2).items_in_collection_with_length_method
@@ -253,13 +253,13 @@ describe "should have_at_most(n).items" do
     }.should fail_with("expected at most 2 items_in_collection_with_size_method, got 3")
   end
   
-  it "should pass if target has a collection of items with < n members" do
+  it "passes if target has a collection of items with < n members" do
     owner = create_collection_owner_with(3)
     owner.should have_at_most(4).items_in_collection_with_length_method
     owner.should have_at_most(4).items_in_collection_with_size_method
   end
 
-  it "should provide educational negative failure messages" do
+  it "provides educational negative failure messages" do
     #given
     owner = create_collection_owner_with(3)
     length_matcher = have_at_most(3).items_in_collection_with_length_method
@@ -289,13 +289,13 @@ EOF
 end
 
 describe "have(n).items(args, block)" do
-  it "should pass args to target" do
+  it "passes args to target" do
     target = mock("target")
     target.should_receive(:items).with("arg1","arg2").and_return([1,2,3])
     target.should have(3).items("arg1","arg2")
   end
 
-  it "should pass block to target" do
+  it "passes block to target" do
     target = mock("target")
     block = lambda { 5 }
     target.should_receive(:items).with("arg1","arg2", block).and_return([1,2,3])
@@ -304,27 +304,27 @@ describe "have(n).items(args, block)" do
 end
 
 describe "have(n).items where target IS a collection" do
-  it "should reference the number of items IN the collection" do
+  it "references the number of items IN the collection" do
     [1,2,3].should have(3).items
   end
 
-  it "should fail when the number of items IN the collection is not as expected" do
+  it "fails when the number of items IN the collection is not as expected" do
     lambda { [1,2,3].should have(7).items }.should fail_with("expected 7 items, got 3")
   end
 end
 
 describe "have(n).characters where target IS a String" do
-  it "should pass if the length is correct" do
+  it "passes if the length is correct" do
     "this string".should have(11).characters
   end
 
-  it "should fail if the length is incorrect" do
+  it "fails if the length is incorrect" do
     lambda { "this string".should have(12).characters }.should fail_with("expected 12 characters, got 11")
   end
 end
 
 describe "have(n).things on an object which is not a collection nor contains one" do
-  it "should fail" do
+  it "fails" do
     lambda { Object.new.should have(2).things }.should raise_error(NoMethodError, /undefined method `things' for #<Object:/)
   end
 end
@@ -338,19 +338,19 @@ describe RSpec::Matchers::Have, "for a collection owner that implements #send" d
     def @collection.send(*args); raise "DOH! Library developers shouldn't use #send!" end
   end
   
-  it "should work in the straightforward case" do
+  it "works in the straightforward case" do
     lambda {
       @collection.should have(2).floozles
     }.should_not raise_error
   end
 
-  it "should work when doing automatic pluralization" do
+  it "works when doing automatic pluralization" do
     lambda {
       @collection.should have_at_least(1).floozle
     }.should_not raise_error
   end
 
-  it "should blow up when the owner doesn't respond to that method" do
+  it "blows up when the owner doesn't respond to that method" do
     lambda {
       @collection.should have(99).problems
     }.should raise_error(NoMethodError, /problems/)
@@ -360,7 +360,7 @@ end
 module RSpec
   module Matchers
     describe Have do
-      it "should have method_missing as private" do
+      it "has method_missing as private" do
         with_ruby 1.8 do
           described_class.private_instance_methods.should include("method_missing")
         end
@@ -369,7 +369,7 @@ module RSpec
         end
       end
 
-      it "should not respond_to? method_missing (because it's private)" do
+      it "does not respond_to? method_missing (because it's private)" do
         formatter = described_class.new({ }, StringIO.new)
         formatter.should_not respond_to(:method_missing)
       end
@@ -381,24 +381,24 @@ module RSpec
           @a_method_which_object_defines = Object.instance_methods.first
         end
         
-        it "should be true for a method which Have defines" do
+        it "is true for a method which Have defines" do
           @have.should respond_to(@a_method_which_have_defines)
         end
         
-        it "should be true for a method that it's superclass (Object) defines" do
+        it "is true for a method that it's superclass (Object) defines" do
           @have.should respond_to(@a_method_which_object_defines)
         end
         
-        it "should be false for a method which neither Object nor nor Have defines" do
+        it "is false for a method which neither Object nor nor Have defines" do
           @have.should_not respond_to(:foo_bar_baz)
         end
         
-        it "should be false if the owner doesn't respond to the method" do
+        it "is false if the owner doesn't respond to the method" do
           have = Have.new(99)
           have.should_not respond_to(:problems)
         end
         
-        it "should be true if the owner responds to the method" do
+        it "is true if the owner responds to the method" do
           have = Have.new(:a_symbol)
           have.should respond_to(:to_sym)
         end

data/spec/rspec/matchers/include_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
 describe "should include(expected)" do
-  it "should pass if target includes expected" do
+  it "passes if target includes 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
+  it 'passes 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
+  it "fails if target does not include expected" do
     lambda {
       [1,2,3].should include(4)
     }.should fail_with("expected [1, 2, 3] to include 4")
@@ -24,21 +24,21 @@ describe "should include(expected)" do
 end
 
 describe "should include(with, multiple, args)" do
-  it "should pass if target includes all items" do
+  it "passes 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
+  it 'passes 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
+  it "fails 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
+  it 'passes 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|)
@@ -46,16 +46,16 @@ describe "should include(with, multiple, args)" do
 end
 
 describe "should_not include(expected)" do
-  it "should pass if target does not include expected" do
+  it "passes if target does 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
+  it 'passes 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
+  it "fails if target includes expected" do
     lambda {
       [1,2,3].should_not include(3)
     }.should fail_with("expected [1, 2, 3] not to include 3")
@@ -69,18 +69,18 @@ describe "should_not include(expected)" do
 end
 
 describe "should include(:key => value)" do
-  it "should pass if target is a Hash and includes the key/value pair" do
+  it "passes if target is a Hash and includes the key/value pair" do
     {:key => 'value'}.should include(:key => 'value')
   end
-  it "should pass if target is a Hash and includes the key/value pair among others" do
+  it "passes if target is a Hash and includes the key/value pair among others" do
     {:key => 'value', :other => 'different'}.should include(:key => 'value')
   end
-  it "should fail if target is a Hash and has a different value for key" do
+  it "fails if target is a Hash and has a different value for key" do
     lambda {
       {:key => 'different'}.should include(:key => 'value')
     }.should fail_with(%Q|expected {:key=>"different"} to include {:key=>"value"}|)
   end
-  it "should fail if target is a Hash and has a different key" do
+  it "fails if target is a Hash and has a different key" do
     lambda {
       {:other => 'value'}.should include(:key => 'value')
     }.should fail_with(%Q|expected {:other=>"value"} to include {:key=>"value"}|)

data/spec/rspec/matchers/match_array_spec.rb

@@ -18,15 +18,15 @@ class UnsortableObject
 end
 
 describe "array.should =~ other_array" do
-  it "should pass if target contains all items" do
+  it "passes 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
+  it "passes 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
+  it "fails if target includes extra items" do
     lambda {
       [1,2,3,4].should =~ [1,2,3]
     }.should fail_with(<<-MESSAGE)
@@ -36,7 +36,7 @@ the extra elements were:        [4]
 MESSAGE
   end
 
-  it "should fail if target is missing items" do
+  it "fails if target is missing items" do
     lambda {
       [1,2].should =~ [1,2,3]
     }.should fail_with(<<-MESSAGE)
@@ -46,7 +46,7 @@ the missing elements were:      [3]
 MESSAGE
   end
 
-  it "should fail if target is missing items and has extra items" do
+  it "fails if target is missing items and has extra items" do
 
     lambda {
       [1,2,4].should =~ [1,2,3]
@@ -58,7 +58,7 @@ the extra elements were:        [4]
 MESSAGE
   end
 
-  it "should sort items in the error message if they all respond to <=>" do
+  it "sorts items in the error message if they all respond to <=>" do
     lambda {
       [6,2,1,5].should =~ [4,1,2,3]
     }.should fail_with(<<-MESSAGE)
@@ -69,7 +69,7 @@ the extra elements were:        [5, 6]
 MESSAGE
   end
 
-    it "should not sort items in the error message if they don't all respond to <=>" do
+    it "does not sort items in the error message if they don't all respond to <=>" do
       lambda {
         [UnsortableObject.new(2), UnsortableObject.new(1)].should =~ [UnsortableObject.new(4), UnsortableObject.new(3)]
       }.should fail_with(<<-MESSAGE)
@@ -80,7 +80,7 @@ the extra elements were:        [2, 1]
 MESSAGE
     end
 
-  it "should accurately report extra elements when there are duplicates" do
+  it "accurately reports extra elements when there are duplicates" do
     lambda {
       [1,1,1,5].should =~ [1,5]
     }.should fail_with(<<-MESSAGE)
@@ -90,7 +90,7 @@ the extra elements were:        [1, 1]
 MESSAGE
   end
 
-  it "should accurately report missing elements when there are duplicates" do
+  it "accurately reports missing elements when there are duplicates" do
     lambda {
       [1,5].should =~ [1,1,5]
     }.should fail_with(<<-MESSAGE)
@@ -103,7 +103,7 @@ MESSAGE
 end
 
 describe "should_not =~ [:with, :multiple, :args]" do
-  it "should not be supported" do
+  it "is not supported" do
     lambda {
       [1,2,3].should_not =~ [1,2,3]
     }.should fail_with(/Matcher does not support should_not/)