rspec 0.3.2 → 0.4.0

data/lib/spec/mock.rb

@@ -48,7 +48,6 @@ private
 
   def find_matching_expectation(sym, *args)
     expectation = @expectations.find {|expectation| expectation.matches(sym, args)}
-    expectation
   end
 
 end

data/lib/spec/respond_helper.rb

@@ -0,0 +1,15 @@
+module Spec
+
+	class RespondHelper < ShouldBase
+	
+		def initialize(target)
+			@target = target
+		end
+		
+		def to(expected)
+			fail_with_message(default_message("should respond to", expected)) unless @target.respond_to? expected
+		end
+		
+	end
+
+end

data/lib/spec/respond_negator.rb

@@ -0,0 +1,15 @@
+module Spec
+
+	class RespondNegator < ShouldBase
+	
+		def initialize(target)
+			@target = target
+		end
+		
+		def to(expected)
+			fail_with_message(default_message("should not respond to", expected)) if @target.respond_to? expected
+		end
+		
+	end
+
+end

data/lib/spec/should_base.rb

@@ -0,0 +1,36 @@
+module Spec
+  
+  class ShouldBase
+
+		def default_message(expectation, expected=:no_expectation_specified)
+      message = wrap(@target)
+      message += " #{expectation}"
+      if (expected != :no_expectation_specified)
+        message += " " + wrap(expected)
+      end
+      message
+   	end
+   	
+   	def wrap(obj)
+		  if obj == true
+		   "<true>"
+		  elsif obj == false
+		   "<false>"
+		  elsif obj.nil?
+		    "nil"
+		  elsif obj.kind_of? Proc
+		    "<Proc>"
+	    elsif (obj.kind_of? Array) || (obj.kind_of? String)
+	      "<#{obj.inspect}>"
+	    else
+        "<#{obj.inspect}:#{obj.class}>"
+      end
+ 	  end
+
+		def fail_with_message(message)
+			Kernel::raise(Spec::Exceptions::ExpectationNotMetError.new(message))
+		end
+
+  end
+  
+end

data/lib/spec/should_helper.rb

@@ -0,0 +1,74 @@
+module Spec
+
+  class ShouldHelper < ShouldBase
+
+	  def initialize(target)
+	  	@target = target
+		end
+		
+		def not
+		  ShouldNegator.new(@target)
+		end
+    
+    def have(expected_number=nil)
+      HaveHelper.new(@target, expected_number)
+    end
+	
+		def satisfy
+      fail_with_message "Supplied expectation was not satisfied" if (!yield @target)
+    end
+				
+	  def equal(expected)
+    	fail_with_message(default_message("should equal", expected)) unless (@target == expected)
+    end
+
+    def be(expected = :no_arg)
+      return self if (expected == :no_arg)
+      return if (expected == false and @target.nil?)
+    	fail_with_message(default_message("should be", expected)) unless (@target.equal?(expected))
+    end
+
+		def a
+			self
+		end
+		
+		alias an a
+		
+		def instance
+			InstanceHelper.new(@target)
+		end
+		
+		def kind
+			KindHelper.new(@target)
+		end
+		
+		def respond
+			RespondHelper.new(@target)
+		end
+		
+    def method_missing(sym, *args)
+      return if @target.send("#{sym}?", *args)
+      fail_with_message(default_message("should be #{sym}" + (args.empty? ? '' : (' ' + args.join(', ')))))
+    end
+
+    def match(expected)
+     	fail_with_message(default_message("should match", expected)) unless (@target =~ expected)
+    end
+
+    def include(sub)
+	    fail_with_message(default_message("should include", sub)) unless (@target.include? sub)
+    end
+    
+    def raise(exception=Exception)
+      begin
+        @target.call
+        fail_with_message(default_message("should raise", exception.inspect))
+      rescue exception
+      rescue
+        fail_with_message(default_message("should raise", exception.inspect))
+      end
+    end
+
+  end
+
+end

data/lib/spec/should_negator.rb

@@ -0,0 +1,64 @@
+module Spec
+  
+  class ShouldNegator < ShouldBase
+    
+    def initialize(target)
+      @target = target
+    end
+  
+    def satisfy
+	    fail_with_message "Supplied expectation was satisfied, but should not have been" if (yield @target)
+    end
+        
+    def equal(expected)
+	    fail_with_message(default_message("should not equal", expected)) if (@target == expected)
+    end
+    
+    def be(expected = :no_arg)
+	    return self if (expected == :no_arg)
+	    fail_with_message(default_message("should not be", expected)) if (@target.equal?(expected))
+    end
+
+		def a
+			self
+		end
+		
+		alias an a
+		
+		def instance
+			InstanceNegator.new(@target)
+		end
+		
+		def kind
+			KindNegator.new(@target)
+		end
+
+			def respond
+				RespondNegator.new(@target)
+			end
+    
+    def match(expected)
+        fail_with_message(default_message("should not match", expected)) if (@target =~ expected)
+    end
+    
+    def include(sub)
+        fail_with_message(default_message("should not include", sub)) if (@target.include? sub)
+    end
+   
+    def raise(exception=Exception)
+      begin
+        @target.call
+      rescue exception
+        fail_with_message(default_message("should not raise", exception.inspect))
+      rescue
+      end
+    end
+    
+    def method_missing(sym, *args)
+      return unless @target.send("#{sym}?", *args)
+      fail_with_message(default_message("should not be #{sym}" + (args.empty? ? '' : (' ' + args.join(', ')))))
+    end
+
+  end
+
+end

data/test/collection_owner.rb

@@ -0,0 +1,48 @@
+class CollectionWithSizeMethod
+
+  def initialize
+    @list = []
+  end
+  
+  def size
+    @list.size
+  end
+  
+  def push(item)
+    @list.push(item)
+  end
+
+end
+
+class CollectionWithLengthMethod
+
+  def initialize
+    @list = []
+  end
+  
+  def length
+    @list.length
+  end
+
+  def push(item)
+    @list.push(item)
+  end
+
+end
+
+class CollectionOwner
+  attr_reader :items_in_collection_with_size_method, :items_in_collection_with_length_method
+  
+  def initialize
+    @items_in_collection_with_size_method = CollectionWithSizeMethod.new
+    @items_in_collection_with_length_method = CollectionWithLengthMethod.new
+  end
+  
+  def add_to_collection_with_size_method(item)
+    @items_in_collection_with_size_method.push(item)
+  end
+  
+  def add_to_collection_with_length_method(item)
+    @items_in_collection_with_length_method.push(item)
+  end
+end

data/test/context_run_test.rb

@@ -9,32 +9,32 @@ class TestCon < Spec::Context
   end
 
   def passing_once_specification
-    true.should_equal(true)
+    true.should.equal(true)
   end
   
   def failing_once_specification
-    false.should_equal(true)
+    false.should.equal(true)
   end
   
   def erroring_once_specification
-    undefined_method.should_equal(true)
+    undefined_method.should.equal(true)
   end
   
   def passing_multi_specification
-    true.should_equal(true)
-    false.should_equal(false)
-    Object.should_equal(Object)
+    true.should.equal(true)
+    false.should.equal(false)
+    Object.should.equal(Object)
   end
 
   def failing_multi_specification
-    false.should_equal(true)
-    true.should_equal(false)
-    false.should_equal(nil)
+    false.should.equal(true)
+    true.should.equal(false)
+    false.should.equal(nil)
   end
 
   def erroring_multi_specification
-    undefined_method.should_equal(false)
-    undefined_method.should_not_equal(true)
+    undefined_method.should.equal(false)
+    undefined_method.should.not.equal(true)
   end
 
 end

data/test/error_reporting_test.rb

@@ -1,123 +1,103 @@
 require 'test/unit'
 
+require 'collection_owner'
 require 'spec'
 
-
 class ErrorReportingContext < Spec::Context
 
-  # should
-
-  def use_the_standard_message_for_should
-    Object.should { false == true }
+  def should_satisfy
+    5.should.satisfy { |x| x == 3 }
   end
 
-  def use_the_provided_message_for_should
-    Object.should("provided message") { false == true }
+  def should_not_satisfy
+    3.should.not.satisfy { |x| x == 3 }
   end
-  
-  # should_equal
 
-  def use_the_standard_message_for_should_equal
-    Object.should_equal Class
+  def should_equal
+    Object.should.equal Class
   end
 
-  def use_the_provided_message_for_should_equal
-    Object.should_equal(Class, "provided for should_equal")
+  def should_not_equal
+    Object.should.not.equal Object
   end
 
-  # should_not_equal
-
-  def use_the_standard_message_for_should_not_equal
-    Object.should_not_equal Object
+  def should_be_nil
+    Object.should.be nil
   end
 
-  def use_the_provided_message_for_should_not_equal
-    Object.should_not_equal(Object, "provided for should_not_equal")
+  def should_not_be_nil
+    nil.should.not.be nil
   end
 
-  # should_be_nil
+  def should_be_empty
+    ['foo', 'bar'].should.be.empty
+  end
   
-  def use_the_standard_message_for_should_be_nil
-    Object.should_be_nil
+  def should_not_be_empty
+    [].should.not.be.empty
   end
 
-  def use_the_provided_message_for_should_be_nil
-    Object.should_be_nil("provided for should_be_nil")
+  def should_include
+    ['foo'].should.include('bar')
   end
 
-  # should_not_be_nil
-  
-  def use_the_standard_message_for_should_not_be_nil
-    nil.should_not_be_nil
+  def should_not_include
+    ['foo'].should.not.include('foo')
   end
 
-  def use_the_provided_message_for_should_not_be_nil
-    nil.should_not_be_nil("provided for should_not_be_nil")
+  def should_be_true
+    false.should.be true
   end
 
-  # should_be_empty
-  
-  def use_the_standard_message_for_should_be_empty
-    ['foo', 'bar'].should_be_empty
+  def should_be_false
+    true.should.be false
   end
   
-  def use_the_provided_message_for_should_be_empty
-    ['foo', 'bar'].should_be_empty("provided for should_be_empty")
+  def should_raise_with_no_error
+    proc { ''.to_s }.should.raise NoMethodError
   end
-
-  # should_not_be_empty
   
-  def use_the_standard_message_for_should_not_be_empty
-    [].should_not_be_empty
-  end
-
-  def use_the_provided_message_for_should_not_be_empty
-    [].should_not_be_empty("provided for should_not_be_empty")
+  def should_raise_with_wrong_error
+    proc { ''.no_method }.should.raise SyntaxError
   end
-
-  # should_include
   
-  def use_the_standard_message_for_should_include
-    ['foo'].should_include('bar')
-  end
+  def should_not_raise
+    proc { ''.no_method }.should.not.raise NoMethodError
+  end  
 
-  def use_the_provided_message_for_should_include
-    ['foo'].should_include('bar', "provided for should_include")
+  def should_have_with_length
+    owner = CollectionOwner.new
+    owner.should.have(3).items_in_collection_with_length_method
   end
 
-  # should_not_include
-  
-  def use_the_standard_message_for_should_not_include
-    ['foo'].should_not_include('foo')
+  def should_have_at_least_with_length
+    owner = CollectionOwner.new
+    owner.should.have.at.least(3).items_in_collection_with_length_method
   end
 
-  def use_the_provided_message_for_should_not_include
-    ['foo'].should_not_include('foo', "provided for should_not_include")
+  def should_have_at_most_with_length
+    owner = CollectionOwner.new
+    (1..4).each { |n| owner.add_to_collection_with_length_method n }
+    owner.should.have.at.most(3).items_in_collection_with_length_method
   end
-
-  # should_be_true
   
-  def use_the_standard_message_for_should_be_true
-    false.should_be_true
+  def should_have_with_size
+    owner = CollectionOwner.new
+    owner.should.have(3).items_in_collection_with_size_method
   end
 
-  def use_the_provided_message_for_should_be_true
-    false.should_be_true("provided for should_be_true")
+  def should_have_at_least_with_size
+    owner = CollectionOwner.new
+    owner.should.have.at.least(3).items_in_collection_with_size_method
   end
 
-  # should_be_false
-  
-  def use_the_standard_message_for_should_be_false
-    true.should_be_false
+  def should_have_at_most_with_size
+    owner = CollectionOwner.new
+    (1..4).each { |n| owner.add_to_collection_with_size_method n }
+    owner.should.have.at.most(3).items_in_collection_with_size_method
   end
-  
-  def use_the_provided_message_for_should_be_false
-    true.should_be_false("provided for should_be_false")
-  end
-
 end
 
-
 class ErrorReportingRunner
 
   def initialize
@@ -158,114 +138,88 @@ class ErrorReportingTest < Test::Unit::TestCase
     @runner.run(ErrorReportingContext)
   end
 
-  # should
-
-  def test_should_report_standard_message_for_should
-    assert @runner.dump_failures.include?("Expectation not met.")
+  def test_should_report_message_for_should_satisfy
+    assert @runner.dump_failures.include?("Supplied expectation was not satisfied")
   end
 
-  def test_should_report_provided_message_for_should
-    assert @runner.dump_failures.include?("provided message")
-  end  
+  def test_should_report_message_for_should_equal
+    assert @runner.dump_failures.include?("<Object:Class> should equal <Class:Class>"), @runner.dump_failures
+  end
 
-  # should_equal
+  def test_should_report_message_for_should_not_equal
+    assert @runner.dump_failures.include?("<Object:Class> should not equal <Object:Class>"), @runner.dump_failures
+  end
   
-  def test_should_report_standard_message_for_should_equal
-    assert @runner.dump_failures.include?("<Object:Class>\nshould be equal to:\n<Class:Class>"), @runner.dump_failures
+  def test_should_report_message_for_should_be_nil
+    assert @runner.dump_failures.include?("<Object:Class> should be nil")
   end
 
-  def test_should_report_provided_message_for_should_equal
-    assert @runner.dump_failures.include?("provided for should_equal"), @runner.dump_failures
+  def test_should_report_message_for_should_not_be_nil
+    assert @runner.dump_failures.include?("nil should not be nil")
   end
-
-  # should_not_equal
   
-  def test_should_report_standard_message_for_should_not_equal
-    assert @runner.dump_failures.include?("<Object:Class>\nshould not be equal to:\n<Object:Class>"), @runner.dump_failures
+  def test_should_report_message_for_should_be_empty
+    assert @runner.dump_failures.include?('<["foo", "bar"]> should be empty')
   end
-  
-  def test_should_report_provided_message_for_should_not_equal
-    assert @runner.dump_failures.include?("provided for should_not_equal"), @runner.dump_failures
+
+  def test_should_report_message_for_should_not_be_empty
+    assert @runner.dump_failures.include?("<[]> should not be empty")
   end
-  
-  # should_be_nil
-  
-  def test_should_report_standard_message_for_should_be_nil
-    assert @runner.dump_failures.include?("<Object> should be nil")
+    
+  def test_should_report_message_for_should_include
+    assert @runner.dump_failures.include?('<["foo"]> should include <"bar">')
   end
   
-  def test_should_report_provided_message_fro_should_be_nil
-    assert @runner.dump_failures.include?("provided for should_be_nil")
+  def test_should_report_message_for_should_not_include
+    assert @runner.dump_failures.include?('<["foo"]> should not include <"foo">')
   end
   
-  # should_not_be_nil
+  def test_should_report_message_for_should_be_true
+    assert @runner.dump_failures.include?("<false> should be <true>")
+  end
 
-  def test_should_report_standard_message_for_should_not_be_nil
-    assert @runner.dump_failures.include?("<> should not be nil")
+  def test_should_report_message_for_should_be_false
+    assert @runner.dump_failures.include?("<true> should be <false>")
   end
   
-  def test_should_report_provided_message_for_should_not_be_nil
-    assert @runner.dump_failures.include?("provided for should_not_be_nil")
+  def test_should_report_message_for_should_raise_with_no_error
+    assert @runner.dump_failures.include?("<Proc> should raise <\"NoMethodError\">")
   end
-
-  # should_be_empty
   
-  def test_should_report_standard_message_for_should_be_empty
-    assert @runner.dump_failures.include?('<["foo", "bar"]> should be empty')
+  def test_should_report_message_for_should_raise_with_wrong_error
+    assert @runner.dump_failures.include?("<Proc> should raise <\"SyntaxError\">")
   end
   
-  def test_should_report_provided_message_for_should_be_empty
-    assert @runner.dump_failures.include?("provided for should_be_empty")
+  def test_should_report_message_for_should_not_raise
+    assert @runner.dump_failures.include?("<Proc> should not raise <\"NoMethodError\">")
   end
   
-  # should_not_be_empty
-
-  def test_should_report_standard_message_for_should_not_be_empty
-    assert @runner.dump_failures.include?("<[]> should not be empty")
+  def test_should_report_message_for_should_not_raise
+    assert @runner.dump_failures.include?("<Proc> should not raise <\"NoMethodError\">")
   end
   
-  def test_should_report_provided_message_for_should_not_be_empty
-    assert @runner.dump_failures.include?("provided for should_not_be_empty")
+  def test_should_report_message_for_should_have_with_length
+    assert @runner.dump_failures.include?('<CollectionOwner> should have 3 items_in_collection_with_length_method (has 0)')
   end
-
-  # should_include
   
-  def test_should_report_standard_message_for_should_include
-    assert @runner.dump_failures.include?('<["foo"]> should include <"bar">')
+  def test_should_report_message_for_should_have_at_least_with_length
+    assert @runner.dump_failures.include?('<CollectionOwner> should have at least 3 items_in_collection_with_length_method (has 0)')
   end
   
-  def test_should_report_provided_message_for_should_include
-    assert @runner.dump_failures.include?("provided for should_include")
+  def test_should_report_message_for_should_have_at_most_with_length
+    assert @runner.dump_failures.include?('<CollectionOwner> should have at most 3 items_in_collection_with_length_method (has 4)')
   end
   
-  # should_not_include
-
-  def test_should_report_standard_message_for_should_not_include
-    assert @runner.dump_failures.include?('<["foo"]> should not include <"foo">')
-  end
-
-  def test_should_report_provided_message_for_should_not_include
-    assert @runner.dump_failures.include?("provided for should_not_include")
+  def test_should_report_message_for_should_have_with_size
+    assert @runner.dump_failures.include?('<CollectionOwner> should have 3 items_in_collection_with_size_method (has 0)')
   end
   
-  # should_be_true
-
-  def test_should_report_standard_message_for_should_be_true
-    assert @runner.dump_failures.include?("<false> should be true")
-  end
-
-  def test_should_report_provided_message_for_should_be_true
-    assert @runner.dump_failures.include?("provided for should_be_true")
+  def test_should_report_message_for_should_have_at_least_with_size
+    assert @runner.dump_failures.include?('<CollectionOwner> should have at least 3 items_in_collection_with_size_method (has 0)')
   end
   
-  # should_be_false
-
-  def test_should_report_standard_message_for_should_be_false
-    assert @runner.dump_failures.include?("<true> should be false")
-  end
-
-  def test_should_report_provided_message_for_should_be_false
-    assert @runner.dump_failures.include?("provided for should_be_false")
+  def test_should_report_message_for_should_have_at_most_with_size
+    assert @runner.dump_failures.include?('<CollectionOwner> should have at most 3 items_in_collection_with_size_method (has 4)')
   end
-
+  
 end