rspec 0.8.2 → 0.9.0

data/spec/spec/matchers/have_spec.rb

@@ -11,22 +11,22 @@ module HaveSpecHelper
   end
 end
 
-context "should have(n).items" do
+describe "should have(n).items" do
   include HaveSpecHelper
 
-  specify "should pass if target has a collection of items with n members" do
+  it "should pass 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
 
-  specify "should convert :no to 0" do
+  it "should convert :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
 
-  specify "should fail if target has a collection of items with < n members" do
+  it "should fail 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
@@ -36,7 +36,7 @@ context "should have(n).items" do
     }.should fail_with("expected 4 items_in_collection_with_size_method, got 3")
   end
   
-  specify "should fail if target has a collection of items with > n members" do
+  it "should fail 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
@@ -47,22 +47,22 @@ context "should have(n).items" do
   end
 end
 
-context "should_not have(n).items" do
+describe "should_not have(n).items" do
   include HaveSpecHelper
 
-  specify "should pass if target has a collection of items with < n members" do
+  it "should pass 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
   
-  specify "should pass if target has a collection of items with > n members" do
+  it "should pass 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
 
-  specify "should fail if target has a collection of items with n members" do
+  it "should fail 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
@@ -73,22 +73,22 @@ context "should_not have(n).items" do
   end
 end
 
-context "should have_exactly(n).items" do
+describe "should have_exactly(n).items" do
   include HaveSpecHelper
 
-  specify "should pass if target has a collection of items with n members" do
+  it "should pass 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
 
-  specify "should convert :no to 0" do
+  it "should convert :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
 
-  specify "should fail if target has a collection of items with < n members" do
+  it "should fail 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
@@ -98,7 +98,7 @@ context "should have_exactly(n).items" do
     }.should fail_with("expected 4 items_in_collection_with_size_method, got 3")
   end
   
-  specify "should fail if target has a collection of items with > n members" do
+  it "should fail 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
@@ -109,22 +109,22 @@ context "should have_exactly(n).items" do
   end
 end
 
-context "should have_at_least(n).items" do
+describe "should have_at_least(n).items" do
   include HaveSpecHelper
 
-  specify "should pass if target has a collection of items with n members" do
+  it "should pass 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
   
-  specify "should pass if target has a collection of items with > n members" do
+  it "should pass 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
 
-  specify "should fail if target has a collection of items with < n members" do
+  it "should fail 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
@@ -134,7 +134,7 @@ context "should have_at_least(n).items" do
     }.should fail_with("expected at least 4 items_in_collection_with_size_method, got 3")
   end
   
-  specify "should provide educational negative failure messages" do
+  it "should provide educational negative failure messages" do
     #given
     owner = create_collection_owner_with(3)
     length_matcher = have_at_least(3).items_in_collection_with_length_method
@@ -163,16 +163,16 @@ EOF
   end
 end
 
-context "should have_at_most(n).items" do
+describe "should have_at_most(n).items" do
   include HaveSpecHelper
 
-  specify "should pass if target has a collection of items with n members" do
+  it "should pass 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
 
-  specify "should fail if target has a collection of items with > n members" do
+  it "should fail 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
@@ -182,13 +182,13 @@ context "should have_at_most(n).items" do
     }.should fail_with("expected at most 2 items_in_collection_with_size_method, got 3")
   end
   
-  specify "should pass if target has a collection of items with < n members" do
+  it "should pass 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
 
-  specify "should provide educational negative failure messages" do
+  it "should provide educational negative failure messages" do
     #given
     owner = create_collection_owner_with(3)
     length_matcher = have_at_most(3).items_in_collection_with_length_method
@@ -217,14 +217,14 @@ EOF
   end
 end
 
-context "have(n).items(args, block)" do
-  specify "should pass args to target" do
+describe "have(n).items(args, block)" do
+  it "should pass 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
 
-  specify "should pass block to target" do
+  it "should pass block to target" do
     target = mock("target")
     block = lambda { 5 }
     target.should_receive(:items).with("arg1","arg2", block).and_return([1,2,3])
@@ -232,28 +232,28 @@ context "have(n).items(args, block)" do
   end
 end
 
-context "have(n).items where target IS a collection" do
-  specify "should reference the number of items IN the collection" do
+describe "have(n).items where target IS a collection" do
+  it "should reference the number of items IN the collection" do
     [1,2,3].should have(3).items
   end
 
-  specify "should reference the number of items IN the collection" do
-    lambda { [1,2,3].should have(7).items }.should_fail_with("expected 7 items, got 3")
+  it "should reference the number of items IN the collection" do
+    lambda { [1,2,3].should have(7).items }.should fail_with("expected 7 items, got 3")
   end
 end
 
-context "have(n).characters where target IS a String" do
-  specify "should pass if the length is correct" do
+describe "have(n).characters where target IS a String" do
+  it "should pass if the length is correct" do
     "this string".should have(11).characters
   end
 
-  specify "should fail if the length is incorrect" do
-    lambda { "this string".should have(12).characters }.should_fail_with("expected 12 characters, got 11")
+  it "should fail if the length is incorrect" do
+    lambda { "this string".should have(12).characters }.should fail_with("expected 12 characters, got 11")
   end
 end
 
-context "have(n).things on an object which is not a collection nor contains one" do
-  specify "should fail" do
-    lambda { Object.new.should have(2).things }.should_raise(NoMethodError, /undefined method `things' for #<Object:/)
+describe "have(n).things on an object which is not a collection nor contains one" do
+  it "should fail" do
+    lambda { Object.new.should have(2).things }.should raise_error(NoMethodError, /undefined method `things' for #<Object:/)
   end
 end

data/spec/spec/matchers/include_spec.rb

@@ -1,12 +1,12 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-context "should include(expected)" do
-  specify "should pass if target includes expected" do
+describe "should include(expected)" do
+  it "should pass if target includes expected" do
     [1,2,3].should include(3)
     "abc".should include("a")
   end
 
-  specify "should fail if target does not include expected" do
+  it "should fail if target does not include expected" do
     lambda {
       [1,2,3].should include(4)
     }.should fail_with("expected [1, 2, 3] to include 4")
@@ -16,13 +16,13 @@ context "should include(expected)" do
   end
 end
 
-context "should_not include(expected)" do
-  specify "should pass if target does not include expected" do
+describe "should_not include(expected)" do
+  it "should pass if target does not include expected" do
     [1,2,3].should_not include(4)
     "abc".should_not include("d")
   end
 
-  specify "should fail if target includes expected" do
+  it "should fail if target includes expected" do
     lambda {
       [1,2,3].should_not include(3)
     }.should fail_with("expected [1, 2, 3] not to include 3")

data/spec/spec/matchers/match_spec.rb

@@ -1,35 +1,35 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-context "should match(expected)" do
-  specify "should pass when target (String) matches expected (Regexp)" do
+describe "should match(expected)" do
+  it "should pass when target (String) matches expected (Regexp)" do
     "string".should match(/tri/)
   end
 
-  specify "should fail when target (String) matches expected (Regexp)" do
+  it "should fail when target (String) matches expected (Regexp)" do
     lambda {
       "string".should match(/rings/)
     }.should fail
   end
 
-  specify "should provide message, expected and actual on failure" do
+  it "should provide message, expected and actual on failure" do
     matcher = match(/rings/)
     matcher.matches?("string")
     matcher.failure_message.should == ["expected \"string\" to match /rings/", /rings/, "string"]
   end
 end
 
-context "should_not match(expected)" do
-  specify "should pass when target (String) matches expected (Regexp)" do
+describe "should_not match(expected)" do
+  it "should pass when target (String) matches expected (Regexp)" do
     "string".should_not match(/rings/)
   end
 
-  specify "should fail when target (String) matches expected (Regexp)" do
+  it "should fail when target (String) matches expected (Regexp)" do
     lambda {
       "string".should_not match(/tri/)
     }.should fail
   end
 
-  specify "should provide message, expected and actual on failure" do
+  it "should provide message, expected and actual on failure" do
     matcher = match(/tri/)
     matcher.matches?("string")
     matcher.negative_failure_message.should == ["expected \"string\" not to match /tri/", /tri/, "string"]

data/spec/spec/matchers/matcher_methods_spec.rb

@@ -2,84 +2,77 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
   module Matchers
-    
-    context "Spec::Matchers should support" do
-      specify "be_true" do
+    context %Q{The Spec::Matchers module gets included in the execution context of every spec.
+This module should provide the following methods, each of which returns a Matcher object.} do
+      it "be_true" do
         be_true.should be_an_instance_of(Be)
       end
-      specify "be_false" do
+      it "be_false" do
         be_false.should be_an_instance_of(Be)
       end
-      specify "be_nil" do
+      it "be_nil" do
         be_nil.should be_an_instance_of(Be)
       end
-      specify "be_arbitrary_predicate" do
+      it "be_arbitrary_predicate" do
         be_arbitrary_predicate.should be_an_instance_of(Be)
       end
-      specify "be_close" do
+      it "be_close" do
         be_close(1,2).should be_an_instance_of(BeClose)
       end
-      specify "change" do
+      it "change" do
         change("target", :message).should be_an_instance_of(Change)
       end
-      specify "eql" do
+      it "eql" do
         eql(:expected).should be_an_instance_of(Eql)
       end
-      specify "equal" do
+      it "equal" do
         equal(:expected).should be_an_instance_of(Equal)
       end
-      specify "have_x > has_x?" do
-        have_key(:key).should be_an_instance_of(Has)
-      end
-      specify "have" do
+      it "have" do
         have(0).should be_an_instance_of(Have)
       end
-      specify "have_exactly" do
+      it "have_exactly" do
         have_exactly(0).should be_an_instance_of(Have)
       end
-      specify "have_at_least" do
+      it "have_at_least" do
         have_at_least(0).should be_an_instance_of(Have)
       end
-      specify "have_at_most" do
+      it "have_at_most" do
         have_at_most(0).should be_an_instance_of(Have)
       end
-      specify "include" do
+      it "include" do
         include(:value).should be_an_instance_of(Include)
       end
-      specify "match" do
+      it "match" do
         match(:value).should be_an_instance_of(Match)
       end
-      specify "raise_error" do
+      it "raise_error" do
         raise_error.should be_an_instance_of(RaiseError)
         raise_error(NoMethodError).should be_an_instance_of(RaiseError)
         raise_error(NoMethodError, "message").should be_an_instance_of(RaiseError)
       end
-      specify "satisfy" do
+      it "satisfy" do
         satisfy{}.should be_an_instance_of(Satisfy)
       end
-      specify "throw_symbol" do
+      it "throw_symbol" do
         throw_symbol.should be_an_instance_of(ThrowSymbol)
         throw_symbol(:sym).should be_an_instance_of(ThrowSymbol)
       end
-      specify "respond_to" do
+      it "respond_to" do
         respond_to(:sym).should be_an_instance_of(RespondTo)
       end
-      
     end
     
-    context "Spec::Matchers should convert be_xyz to..." do
-      specify "sym passed to Be" do
+    describe "Spec::Matchers#method_missing" do
+      it "should convert be_xyz to Be(:be_xyz)" do
         Be.should_receive(:new).with(:be_whatever)
         be_whatever
       end
-    end
-    
-    context "Spec::Matchers should convert have_xyz to..." do
-      specify "string passed to Has" do
+
+      it "should convert have_xyz to Has(:have_xyz)" do
         Has.should_receive(:new).with(:have_whatever)
         have_whatever
       end
     end
-
   end
 end

data/spec/spec/matchers/raise_error_spec.rb

@@ -1,145 +1,145 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-context "should raise_error" do
-  specify "should pass if anything is raised" do
+describe "should raise_error" do
+  it "should pass if anything is raised" do
     lambda {raise}.should raise_error
   end
   
-  specify "should fail if nothing is raised" do
+  it "should fail if nothing is raised" do
     lambda {
       lambda {}.should raise_error
     }.should fail_with("expected Exception but nothing was raised")
   end
 end
 
-context "should_not raise_error" do
-  specify "should pass if nothing is raised" do
+describe "should_not raise_error" do
+  it "should pass if nothing is raised" do
     lambda {}.should_not raise_error
   end
   
-  specify "should fail if anything is raised" do
+  it "should fail if anything is raised" do
     lambda {
       lambda {raise}.should_not raise_error
     }.should fail_with("expected no Exception, got RuntimeError")
   end
 end
 
-context "should raise_error(NamedError)" do
-  specify "should pass if named error is raised" do
+describe "should raise_error(NamedError)" do
+  it "should pass if named error is raised" do
     lambda { non_existent_method }.should raise_error(NameError)
   end
   
-  specify "should fail if nothing is raised" do
+  it "should fail if nothing is raised" do
     lambda {
       lambda { }.should raise_error(NameError)
     }.should fail_with("expected NameError but nothing was raised")
   end
   
-  specify "should fail if another error is raised" do
+  it "should fail if another error is raised" do
     lambda {
       lambda { raise }.should raise_error(NameError)
     }.should fail_with("expected NameError, got RuntimeError")
   end
 end
 
-context "should_not raise_error(NamedError)" do
-  specify "should pass if nothing is raised" do
+describe "should_not raise_error(NamedError)" do
+  it "should pass if nothing is raised" do
     lambda { }.should_not raise_error(NameError)
   end
   
-  specify "should pass if another error is raised" do
+  it "should pass if another error is raised" do
     lambda { raise }.should_not raise_error(NameError)
   end
   
-  specify "should fail if named error is raised" do
+  it "should fail if named error is raised" do
     lambda {
       lambda { non_existent_method }.should_not raise_error(NameError)
     }.should fail_with(/expected no NameError, got #<NameError: undefined/)
   end  
 end
 
-context "should raise_error(NamedError, error_message) with String" do
-  specify "should pass if named error is raised with same message" do
+describe "should raise_error(NamedError, error_message) with String" do
+  it "should pass if named error is raised with same message" do
     lambda { raise "example message" }.should raise_error(RuntimeError, "example message")
   end
   
-  specify "should fail if nothing is raised" do
+  it "should fail 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")
   end
   
-  specify "should fail if incorrect error is raised" do
+  it "should fail if incorrect error is raised" do
     lambda {
       lambda { raise }.should raise_error(NameError, "example message")
     }.should fail_with("expected NameError with \"example message\", got RuntimeError")
   end
   
-  specify "should fail if correct error is raised with incorrect message" do
+  it "should fail if correct error is raised with incorrect message" do
     lambda {
       lambda { raise RuntimeError.new("not the example message") }.should raise_error(RuntimeError, "example message")
     }.should fail_with(/expected RuntimeError with \"example message\", got #<RuntimeError: not the example message/)
   end
 end
 
-context "should_not raise_error(NamedError, error_message) with String" do
-  specify "should pass if nothing is raised" do
+describe "should_not raise_error(NamedError, error_message) with String" do
+  it "should pass if nothing is raised" do
     lambda {}.should_not raise_error(RuntimeError, "example message")
   end
   
-  specify "should pass if a different error is raised" do
+  it "should pass if a different error is raised" do
     lambda { raise }.should_not raise_error(NameError, "example message")
   end
   
-  specify "should pass if same error is raised with different message" do
+  it "should pass 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
   
-  specify "should fail if named error is raised with same message" do
+  it "should fail 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>")
   end
 end
 
-context "should raise_error(NamedError, error_message) with Regexp" do
-  specify "should pass if named error is raised with matching message" do
+describe "should raise_error(NamedError, error_message) with Regexp" do
+  it "should pass if named error is raised with matching message" do
     lambda { raise "example message" }.should raise_error(RuntimeError, /ample mess/)
   end
   
-  specify "should fail if nothing is raised" do
+  it "should fail 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")
   end
   
-  specify "should fail if incorrect error is raised" do
+  it "should fail if incorrect error is raised" do
     lambda {
       lambda { raise }.should raise_error(NameError, /ample mess/)
     }.should fail_with("expected NameError with message matching /ample mess/, got RuntimeError")
   end
   
-  specify "should fail if correct error is raised with incorrect message" do
+  it "should fail 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>")
   end
 end
 
-context "should_not raise_error(NamedError, error_message) with Regexp" do
-  specify "should pass if nothing is raised" do
+describe "should_not raise_error(NamedError, error_message) with Regexp" do
+  it "should pass if nothing is raised" do
     lambda {}.should_not raise_error(RuntimeError, /ample mess/)
   end
   
-  specify "should pass if a different error is raised" do
+  it "should pass if a different error is raised" do
     lambda { raise }.should_not raise_error(NameError, /ample mess/)
   end
   
-  specify "should pass if same error is raised with non-matching message" do
+  it "should pass 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
   
-  specify "should fail if named error is raised with matching message" do
+  it "should fail 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>")