rspec 0.8.2 → 0.9.0

data/spec/spec/matchers/description_generation_spec.rb

@@ -1,134 +1,146 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-context "Matchers should be able to generate a description" do
-  setup do
+describe "Matchers should be able to generate their own descriptions" do
+  before(:each) do
     @desc = nil
     @callback = lambda { |desc| @desc = desc }
     Spec::Matchers.description_generated(&@callback)
   end
   
-  specify "should == expected" do
+  it "should == expected" do
     "this".should == "this"
     @desc.should == "should == \"this\""
   end
   
-  specify "should_not == expected" do
+  it "should not == expected" do
     "this".should_not == "that"
     @desc.should == "should not == \"that\""
   end
   
-  specify "should be empty (arbitrary predicate)" do
+  it "should be empty (arbitrary predicate)" do
     [].should be_empty
     @desc.should == "should be empty"
   end
   
-  specify "should not be empty (arbitrary predicate)" do
+  it "should not be empty (arbitrary predicate)" do
     [1].should_not be_empty
     @desc.should == "should not be empty"
   end
   
-  specify "should be true" do
+  it "should be true" do
     true.should be_true
     @desc.should == "should be true"
   end
   
-  specify "should be false" do
+  it "should be false" do
     false.should be_false
     @desc.should == "should be false"
   end
   
-  specify "should be nil" do
+  it "should be nil" do
     nil.should be_nil
     @desc.should == "should be nil"
   end
   
-  specify "should be > n" do
+  it "should be > n" do
     5.should be > 3
     @desc.should == "should be > 3"
   end
   
-  specify "should be close" do
-    5.0.should be_close(5.0, 0.5)
-    @desc.should == "should be close to 5.0 (+- 0.5)"
+  it "should be predicate arg1, arg2 and arg3" do
+    5.0.should be_between(0,10)
+    @desc.should == "should be between 0 and 10"
+  end
+
+  it "should be_few_words predicate should be transformed to 'be few words'" do
+    5.should be_kind_of(Fixnum)
+    @desc.should == "should be kind of Fixnum"
+  end
+
+  it "should preserve a proper prefix for be predicate" do
+    5.should be_a_kind_of(Fixnum)
+    @desc.should == "should be a kind of Fixnum"
+    5.should be_an_instance_of(Fixnum)
+    @desc.should == "should be an instance of Fixnum"
   end
   
-  specify "should equal" do
+  it "should equal" do
     expected = "expected"
     expected.should equal(expected)
     @desc.should == "should equal \"expected\""
   end
   
-  specify "should_not equal" do
+  it "should_not equal" do
     5.should_not equal(37)
     @desc.should == "should not equal 37"
   end
   
-  specify "should eql" do
+  it "should eql" do
     "string".should eql("string")
     @desc.should == "should eql \"string\""
   end
   
-  specify "should not eql" do
+  it "should not eql" do
     "a".should_not eql(:a)
     @desc.should == "should not eql :a"
   end
   
-  specify "should have_key" do
+  it "should have_key" do
     {:a => "a"}.should have_key(:a)
     @desc.should == "should have key :a"
   end
   
-  specify "should have n items" do
+  it "should have n items" do
     team.should have(3).players
     @desc.should == "should have 3 players"
   end
   
-  specify "should have at least n items" do
+  it "should have at least n items" do
     team.should have_at_least(2).players
     @desc.should == "should have at least 2 players"
   end
   
-  specify "should have at most n items" do
+  it "should have at most n items" do
     team.should have_at_most(4).players
     @desc.should == "should have at most 4 players"
   end
   
-  specify "should include" do
+  it "should include" do
     [1,2,3].should include(3)
     @desc.should == "should include 3"
   end
   
-  specify "should match" do
+  it "should match" do
     "this string".should match(/this string/)
     @desc.should == "should match /this string/"
   end
   
-  specify "should raise_error" do
+  it "should raise_error" do
     lambda { raise }.should raise_error
     @desc.should == "should raise Exception"
   end
   
-  specify "should raise_error with type" do
+  it "should raise_error with type" do
     lambda { raise }.should raise_error(RuntimeError)
     @desc.should == "should raise RuntimeError"
   end
   
-  specify "should raise_error with type and message" do
+  it "should raise_error with type and message" do
     lambda { raise "there was an error" }.should raise_error(RuntimeError, "there was an error")
     @desc.should == "should raise RuntimeError with \"there was an error\""
   end
   
-  specify "should respond_to" do
+  it "should respond_to" do
     [].should respond_to(:insert)
     @desc.should == "should respond to #insert"
   end
   
-  specify "should throw symbol" do
+  it "should throw symbol" do
     lambda { throw :what_a_mess }.should throw_symbol
     @desc.should == "should throw a Symbol"
   end
   
-  specify "should throw symbol (with named symbol)" do
+  it "should throw symbol (with named symbol)" do
     lambda { throw :what_a_mess }.should throw_symbol(:what_a_mess)
     @desc.should == "should throw :what_a_mess"
   end
@@ -141,7 +153,7 @@ context "Matchers should be able to generate a description" do
     end.new
   end
   
-  teardown do
-    Spec::Matchers.unregister_callback(:description_generated, @callback)
+  after(:each) do
+    Spec::Matchers.unregister_description_generated(@callback)
   end
 end

data/spec/spec/matchers/eql_spec.rb

@@ -1,41 +1,28 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-context "should eql(expected)" do
-  
-  specify "should pass if target.eql?(expected)" do
-    1.should eql(1)
+module Spec
+  module Matchers
+    describe Eql do
+      it "should match when actual.eql?(expected)" do
+        Eql.new(1).matches?(1).should be_true
+      end
+      it "should not match when !actual.eql?(expected)" do
+        Eql.new(1).matches?(2).should be_false
+      end
+      it "should describe itself" do
+        matcher = Eql.new(1)
+        matcher.description.should == "eql 1"
+      end
+      it "should provide message, expected and actual on #failure_message" do
+        matcher = Eql.new("1")
+        matcher.matches?(1)
+        matcher.failure_message.should == ["expected \"1\", got 1 (using .eql?)", "1", 1]
+      end
+      it "should provide message, expected and actual on #negative_failure_message" do
+        matcher = Eql.new(1)
+        matcher.matches?(1)
+        matcher.negative_failure_message.should == ["expected 1 not to equal 1 (using .eql?)", 1, 1]
+      end
+    end
   end
-  
-  specify "should fail unless target.eql?(expected)" do
-    lambda {
-      1.should eql("1")
-    }.should fail
-  end
-  
-  specify "should provide message, expected and actual on failure" do
-    matcher = eql("1")
-    matcher.matches?(1)
-    matcher.failure_message.should == ["expected \"1\", got 1 (using .eql?)", "1", 1]
-  end
-  
-end
-
-context "should_not eql(expected)" do
-  
-  specify "should pass unless target.eql?(expected)" do
-    1.should_not eql("1")
-  end
-  
-  specify "should fail if target.eql?(expected)" do
-    lambda {
-      1.should_not eql(1)
-    }.should fail
-  end
-  
-  specify "should provide message, expected and actual on failure" do
-    matcher = eql(1)
-    matcher.matches?(1)
-    matcher.negative_failure_message.should == ["expected 1 not to equal 1 (using .eql?)", 1, 1]
-  end
-  
 end

data/spec/spec/matchers/equal_spec.rb

@@ -1,41 +1,28 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-context "should equal(expected)" do
-  
-  specify "should pass if target.equal?(expected)" do
-    1.should equal(1)
+module Spec
+  module Matchers
+    describe Equal do
+      it "should match when actual.equal?(expected)" do
+        Equal.new(1).matches?(1).should be_true
+      end
+      it "should not match when !actual.equal?(expected)" do
+        Equal.new("1").matches?("1").should be_false
+      end
+      it "should describe itself" do
+        matcher = Equal.new(1)
+        matcher.description.should == "equal 1"
+      end
+      it "should provide message, expected and actual on #failure_message" do
+        matcher = Equal.new("1")
+        matcher.matches?(1)
+        matcher.failure_message.should == ["expected \"1\", got 1 (using .equal?)", "1", 1]
+      end
+      it "should provide message, expected and actual on #negative_failure_message" do
+        matcher = Equal.new(1)
+        matcher.matches?(1)
+        matcher.negative_failure_message.should == ["expected 1 not to equal 1 (using .equal?)", 1, 1]
+      end
+    end
   end
-  
-  specify "should fail unless target.equal?(expected)" do
-    lambda {
-      "1".should equal("1")
-    }.should fail
-  end
-  
-  specify "should provide message, expected and actual on failure" do
-    matcher = equal("1")
-    matcher.matches?("1")
-    matcher.failure_message.should == ["expected \"1\", got \"1\" (using .equal?)", "1", "1"]
-  end
-  
-end
-
-context "should_not equal(expected)" do
-  
-  specify "should pass unless target.equal?(expected)" do
-    "1".should_not equal("1")
-  end
-  
-  specify "should fail if target.equal?(expected)" do
-    lambda {
-      1.should_not equal(1)
-    }.should fail
-  end
-  
-  specify "should provide message, expected and actual on failure" do
-    matcher = equal(1)
-    matcher.matches?(1)
-    matcher.negative_failure_message.should == ["expected 1 not to equal 1 (using .equal?)", 1, 1]
-  end
-  
 end

data/spec/spec/matchers/exist_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+# NOTE - this was initially handled by an explicit matcher, but is now
+# handled by a default set of predicate_matchers.
+
+class Substance
+  def initialize exists, description
+    @exists = exists
+    @description = description
+  end
+  def exist?
+    @exists
+  end
+  def inspect
+    @description
+  end
+end
+  
+describe "should exist" do
+  before(:each) do
+    @real = Substance.new true, 'something real'
+    @imaginary = Substance.new false, 'something imaginary'
+  end
+  
+  it "should pass if target exists" do
+    @real.should exist
+  end
+  
+  it "should fail if target does not exist" do
+    lambda { @imaginary.should exist }.
+      should fail
+  end
+end
+
+describe "should_not exist" do  
+  before(:each) do
+    @real = Substance.new true, 'something real'
+    @imaginary = Substance.new false, 'something imaginary'
+  end
+  it "should pass if target doesn't exist" do
+    @imaginary.should_not exist
+  end
+  it "should fail if target does exist" do
+    lambda { @real.should_not exist }.
+      should fail
+  end
+end
+    

data/spec/spec/matchers/handler_spec.rb

@@ -46,30 +46,43 @@ module ExampleExpectations
   
 end
 
-context "ExpectationMatcherHandler" do
-  include ExampleExpectations
-  
-  specify "should handle submitted args" do
-    5.should arbitrary_matcher(:expected => 5)
-    5.should arbitrary_matcher(:expected => "wrong").with(5)
-    lambda { 5.should arbitrary_matcher(:expected => 4) }.should fail_with("expected 4, got 5")
-    lambda { 5.should arbitrary_matcher(:expected => 5).with(4) }.should fail_with("expected 4, got 5")
-    5.should_not arbitrary_matcher(:expected => 4)
-    5.should_not arbitrary_matcher(:expected => 5).with(4)
-    lambda { 5.should_not arbitrary_matcher(:expected => 5) }.should fail_with("expected not 5, got 5")
-    lambda { 5.should_not arbitrary_matcher(:expected => 4).with(5) }.should fail_with("expected not 5, got 5")
-  end
+module Spec
+  module Expectations
+    describe ExpectationMatcherHandler, ".handle_matcher" do
+      it "should ask the matcher if it matches" do
+        matcher = mock("matcher")
+        actual = Object.new
+        matcher.should_receive(:matches?).with(actual).and_return(true)
+        ExpectationMatcherHandler.handle_matcher(actual, matcher)
+      end
+    end
+    
+    describe ExpectationMatcherHandler do
+      include ExampleExpectations
+      
+      it "should handle submitted args" do
+        5.should arbitrary_matcher(:expected => 5)
+        5.should arbitrary_matcher(:expected => "wrong").with(5)
+        lambda { 5.should arbitrary_matcher(:expected => 4) }.should fail_with("expected 4, got 5")
+        lambda { 5.should arbitrary_matcher(:expected => 5).with(4) }.should fail_with("expected 4, got 5")
+        5.should_not arbitrary_matcher(:expected => 4)
+        5.should_not arbitrary_matcher(:expected => 5).with(4)
+        lambda { 5.should_not arbitrary_matcher(:expected => 5) }.should fail_with("expected not 5, got 5")
+        lambda { 5.should_not arbitrary_matcher(:expected => 4).with(5) }.should fail_with("expected not 5, got 5")
+      end
 
-  specify "should handle the submitted block" do
-    5.should arbitrary_matcher { 5 }
-    5.should arbitrary_matcher(:expected => 4) { 5 }
-    5.should arbitrary_matcher(:expected => 4).with(5) { 3 }
-  end
+      it "should handle the submitted block" do
+        5.should arbitrary_matcher { 5 }
+        5.should arbitrary_matcher(:expected => 4) { 5 }
+        5.should arbitrary_matcher(:expected => 4).with(5) { 3 }
+      end
   
-  specify "should explain when matcher does not support should_not" do
-    lambda {
-      5.should_not positive_only_matcher(:expected => 5)
-    }.should fail_with(/Matcher does not support should_not.\n/)
-  end
+      it "should explain when matcher does not support should_not" do
+        lambda {
+          5.should_not positive_only_matcher(:expected => 5)
+        }.should fail_with(/Matcher does not support should_not.\n/)
+      end
 
+    end
+  end
 end

data/spec/spec/matchers/has_spec.rb

@@ -1,35 +1,35 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-context "should have_sym(*args)" do
-  specify "should pass if #has_sym?(*args) returns true" do
+describe "should have_sym(*args)" do
+  it "should pass if #has_sym?(*args) returns true" do
     {:a => "A"}.should have_key(:a)
   end
 
-  specify "should fail if #has_sym?(*args) returns false" do
+  it "should fail if #has_sym?(*args) returns false" do
     lambda {
       {:b => "B"}.should have_key(:a)
     }.should fail_with("expected #has_key?(:a) to return true, got false")
   end
 
-  specify "should fail if target does not respond to #has_sym?" do
+  it "should fail if target does not respond to #has_sym?" do
     lambda {
       Object.new.should have_key(:a)
     }.should raise_error(NoMethodError)
   end
 end
 
-context "should_not have_sym(*args)" do
-  specify "should pass if #has_sym?(*args) returns false" do
+describe "should_not have_sym(*args)" do
+  it "should pass if #has_sym?(*args) returns false" do
     {:a => "A"}.should_not have_key(:b)
   end
 
-  specify "should fail if #has_sym?(*args) returns true" do
+  it "should fail if #has_sym?(*args) returns true" do
     lambda {
       {:a => "A"}.should_not have_key(:a)
     }.should fail_with("expected #has_key?(:a) to return false, got true")
   end
 
-  specify "should fail if target does not respond to #has_sym?" do
+  it "should fail if target does not respond to #has_sym?" do
     lambda {
       Object.new.should have_key(:a)
     }.should raise_error(NoMethodError)