rspec 1.0.0 → 1.3.1

data/spec/spec/matchers/eql_spec.rb

@@ -1,27 +1,32 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 module Spec
   module Matchers
-    describe Eql do
+    describe "eql" do
       it "should match when actual.eql?(expected)" do
-        Eql.new(1).matches?(1).should be_true
+        1.should eql(1)
       end
+      
       it "should not match when !actual.eql?(expected)" do
-        Eql.new(1).matches?(2).should be_false
+        1.should_not eql(2)
       end
+      
       it "should describe itself" do
-        matcher = Eql.new(1)
+        matcher = eql(1)
+        matcher.matches?(1)
         matcher.description.should == "eql 1"
       end
+      
       it "should provide message, expected and actual on #failure_message" do
-        matcher = Eql.new("1")
+        matcher = eql("1")
         matcher.matches?(1)
-        matcher.failure_message.should == ["expected \"1\", got 1 (using .eql?)", "1", 1]
+        matcher.failure_message_for_should.should == "\nexpected \"1\"\n     got 1\n\n(compared using eql?)\n"
       end
+      
       it "should provide message, expected and actual on #negative_failure_message" do
-        matcher = Eql.new(1)
+        matcher = eql(1)
         matcher.matches?(1)
-        matcher.negative_failure_message.should == ["expected 1 not to equal 1 (using .eql?)", 1, 1]
+        matcher.failure_message_for_should_not.should == "\nexpected 1 not to equal 1\n\n(compared using eql?)\n"
       end
     end
   end

data/spec/spec/matchers/equal_spec.rb

@@ -1,27 +1,56 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
+require 'spec_helper'
 module Spec
   module Matchers
-    describe Equal do
+    describe "equal" do
+      
+      def inspect_object(o)
+        "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
+      end
+      
       it "should match when actual.equal?(expected)" do
-        Equal.new(1).matches?(1).should be_true
+        1.should equal(1)
       end
+
       it "should not match when !actual.equal?(expected)" do
-        Equal.new("1").matches?("1").should be_false
+        1.should_not equal("1")
       end
+      
       it "should describe itself" do
-        matcher = Equal.new(1)
+        matcher = equal(1)
+        matcher.matches?(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]
+      
+      it "should provide message on #failure_message" do
+        expected, actual = "1", "1"
+        matcher = equal(expected)
+        matcher.matches?(actual)
+        
+        matcher.failure_message_for_should.should == <<-MESSAGE
+
+expected #{inspect_object(expected)}
+     got #{inspect_object(actual)}
+
+Compared using equal?, which compares object identity,
+but expected and actual are not the same object. Use
+'actual.should == expected' if you don't care about
+object identity in this example.
+
+MESSAGE
       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]
+      
+      it "should provide message on #negative_failure_message" do
+        expected = actual = "1"
+        matcher = equal(expected)
+        matcher.matches?(actual)
+        matcher.failure_message_for_should_not.should == <<-MESSAGE
+
+expected not #{inspect_object(expected)}
+         got #{inspect_object(actual)}
+
+Compared using equal?, which compares object identity.
+
+MESSAGE
       end
     end
   end

data/spec/spec/matchers/exist_spec.rb

@@ -1,14 +1,11 @@
-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.
+require 'spec_helper'
 
 class Substance
   def initialize exists, description
     @exists = exists
     @description = description
   end
-  def exist?
+  def exist?(arg=nil)
     @exists
   end
   def inspect
@@ -16,33 +13,53 @@ class Substance
   end
 end
   
-describe "should exist" do
-  before(:each) do
-    @real = Substance.new true, 'something real'
-    @imaginary = Substance.new false, 'something imaginary'
+class SubstanceTester
+  include Spec::Matchers
+  def initialize substance
+    @substance = substance
   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
+  def should_exist
+    @substance.should exist
   end
 end
 
-describe "should_not exist" do  
+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 doesn't exist" do
-    @imaginary.should_not exist
+
+  describe "within an example group" do
+  
+    it "passes if target exists" do
+      @real.should exist
+    end
+  
+    it "passes if target exists with args" do
+      @real.should exist('this arg')
+    end
+  
+    it "fails if target does not exist" do
+      lambda { @imaginary.should exist }.should fail
+    end
+    
+    it "describes itself" do
+      exist.description.should == "exist"
+    end
+    
+    it "passes should_not exist if target doesn't exist" do
+      lambda { @real.should_not exist }.should fail
+    end
   end
-  it "should fail if target does exist" do
-    lambda { @real.should_not exist }.
-      should fail
+
+  describe "outside of an example group" do
+
+    it "should pass if target exists" do
+      real_tester = SubstanceTester.new @real
+      real_tester.should_exist
+    end
+
   end
+
 end
-    

data/spec/spec/matchers/has_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 describe "should have_sym(*args)" do
   it "should pass if #has_sym?(*args) returns true" do
@@ -11,11 +11,29 @@ describe "should have_sym(*args)" do
     }.should fail_with("expected #has_key?(:a) to return true, got false")
   end
 
+  it "should fail if #has_sym?(*args) returns nil" do
+    klass = Class.new do
+      def has_foo?
+      end
+    end
+    lambda {
+      klass.new.should have_foo
+    }.should fail_with("expected #has_foo?(nil) to return true, got false")
+  end
+
   it "should fail if target does not respond to #has_sym?" do
     lambda {
       Object.new.should have_key(:a)
     }.should raise_error(NoMethodError)
   end
+  
+  it "should reraise an exception thrown in #has_sym?(*args)" do
+    o = Object.new
+    def o.has_sym?(*args)
+      raise "Funky exception"
+    end
+    lambda { o.should have_sym(:foo) }.should raise_error("Funky exception")
+  end
 end
 
 describe "should_not have_sym(*args)" do
@@ -23,6 +41,14 @@ describe "should_not have_sym(*args)" do
     {:a => "A"}.should_not have_key(:b)
   end
 
+  it "should pass if #has_sym?(*args) returns nil" do
+    klass = Class.new do
+      def has_foo?
+      end
+    end
+    klass.new.should_not have_foo
+  end
+
   it "should fail if #has_sym?(*args) returns true" do
     lambda {
       {:a => "A"}.should_not have_key(:a)
@@ -34,4 +60,131 @@ describe "should_not have_sym(*args)" do
       Object.new.should have_key(:a)
     }.should raise_error(NoMethodError)
   end
+  
+  it "should reraise an exception thrown in #has_sym?(*args)" do
+    o = Object.new
+    def o.has_sym?(*args)
+      raise "Funky exception"
+    end
+    lambda { o.should_not have_sym(:foo) }.should raise_error("Funky exception")
+  end
+end
+
+describe "should have_sym(&block)" do
+  it "should pass when actual returns true for :has_sym?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).and_yield
+    delegate.should_receive(:check_has_foo).and_return(true)
+    actual.should have_foo { delegate.check_has_foo }
+  end
+
+  it "should fail when actual returns false for :has_sym?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).and_yield
+    delegate.should_receive(:check_has_foo).and_return(false)
+    lambda {
+      actual.should have_foo { delegate.check_has_foo }
+    }.should fail_with("expected #has_foo?(nil) to return true, got false")
+  end
+
+  it "should fail when actual does not respond to :has_sym?" do
+    delegate = mock("delegate", :check_has_foo => true)
+    lambda {
+      Object.new.should have_foo { delegate.check_has_foo }
+    }.should raise_error(NameError)
+  end
+end
+
+describe "should_not have_sym(&block)" do
+  it "should pass when actual returns false for :has_sym?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).and_yield
+    delegate.should_receive(:check_has_foo).and_return(false)
+    actual.should_not have_foo { delegate.check_has_foo }
+  end
+
+  it "should fail when actual returns true for :has_sym?(&block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).and_yield
+    delegate.should_receive(:check_has_foo).and_return(true)
+    lambda {
+      actual.should_not have_foo { delegate.check_has_foo }
+    }.should fail_with("expected #has_foo?(nil) to return false, got true")
+  end
+
+  it "should fail when actual does not respond to :has_sym?" do
+    delegate = mock("delegate", :check_has_foo => true)
+    lambda {
+      Object.new.should_not have_foo { delegate.check_has_foo }
+    }.should raise_error(NameError)
+  end
+end
+
+describe "should have_sym(*args, &block)" do
+  it "should pass when actual returns true for :has_sym?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).with(:a).and_yield(:a)
+    delegate.should_receive(:check_has_foo).with(:a).and_return(true)
+    actual.should have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+  end
+
+  it "should fail when actual returns false for :has_sym?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).with(:a).and_yield(:a)
+    delegate.should_receive(:check_has_foo).with(:a).and_return(false)
+    lambda {
+      actual.should have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+    }.should fail_with("expected #has_foo?(:a) to return true, got false")
+  end
+
+  it "should fail when actual does not respond to :has_sym?" do
+    delegate = mock("delegate", :check_has_foo => true)
+    lambda {
+      Object.new.should have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+    }.should raise_error(NameError)
+  end
+end
+
+describe "should_not have_sym(*args, &block)" do
+  it "should pass when actual returns false for :has_sym?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).with(:a).and_yield(:a)
+    delegate.should_receive(:check_has_foo).with(:a).and_return(false)
+    actual.should_not have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+  end
+
+  it "should fail when actual returns true for :has_sym?(*args, &block)" do
+    actual = mock("actual")
+    delegate = mock("delegate")
+    actual.should_receive(:has_foo?).with(:a).and_yield(:a)
+    delegate.should_receive(:check_has_foo).with(:a).and_return(true)
+    lambda {
+      actual.should_not have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+    }.should fail_with("expected #has_foo?(:a) to return false, got true")
+  end
+
+  it "should fail when actual does not respond to :has_sym?" do
+    delegate = mock("delegate", :check_has_foo => true)
+    lambda {
+      Object.new.should_not have_foo(:a) { |foo| delegate.check_has_foo(foo) }
+    }.should raise_error(NameError)
+  end
+end
+
+
+describe "has" do
+  it "should work when the target implements #send" do
+    o = {:a => "A"}
+    def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end
+    lambda {
+      o.should have_key(:a)
+    }.should_not raise_error
+  end
 end