test-spec 0.2 → 0.3.0

data/examples/stack.rb

@@ -0,0 +1,38 @@
+# Copied without code changes from RSpec.
+
+class StackUnderflowError < RuntimeError
+end
+
+class StackOverflowError < RuntimeError
+end
+
+class Stack
+  
+  def initialize
+    @items = []
+  end
+  
+  def push object
+    raise StackOverflowError if @items.length == 10
+    @items.push object
+  end
+  
+  def pop
+    raise StackUnderflowError if @items.empty?
+    @items.delete @items.last
+  end
+  
+  def peek
+    raise StackUnderflowError if @items.empty?
+    @items.last
+  end
+  
+  def empty?
+    @items.empty?
+  end
+
+  def full?
+    @items.length == 10
+  end
+  
+end

data/examples/stack_spec.rb

@@ -0,0 +1,119 @@
+# Copied with minor code changes (should_xxx -> should.xxx) from RSpec.
+
+require File.dirname(__FILE__) + '/../lib/test/spec'
+require File.dirname(__FILE__) + "/stack"
+
+context "A stack (in general)" do
+  setup do
+    @stack = Stack.new
+    ["a","b","c"].each { |x| @stack.push x }
+  end
+  
+  specify "should add to the top when sent 'push'" do
+    @stack.push "d"
+    @stack.peek.should.equal "d"
+  end
+  
+  specify "should return the top item when sent 'peek'" do
+    @stack.peek.should.equal "c"
+  end
+  
+  specify "should NOT remove the top item when sent 'peek'" do
+    @stack.peek.should.equal "c"
+    @stack.peek.should.equal "c"
+  end
+  
+  specify "should return the top item when sent 'pop'" do
+    @stack.pop.should.equal "c"
+  end
+  
+  specify "should remove the top item when sent 'pop'" do
+    @stack.pop.should.equal "c"
+    @stack.pop.should.equal "b"
+  end
+end
+
+context "An empty stack" do
+  setup do
+    @stack = Stack.new
+  end
+  
+  specify "should be empty" do
+    @stack.should.be.empty
+  end
+  
+  specify "should no longer be empty after 'push'" do
+    @stack.push "anything"
+    @stack.should.not.be.empty
+  end
+  
+  specify "should complain when sent 'peek'" do
+    lambda { @stack.peek }.should.raise StackUnderflowError
+  end
+  
+  specify "should complain when sent 'pop'" do
+    lambda { @stack.pop }.should.raise StackUnderflowError
+  end
+end
+
+context "An almost empty stack (with one item)" do
+  setup do
+    @stack = Stack.new
+    @stack.push 3
+  end
+  
+  specify "should not be empty" do
+    @stack.should.not.be.empty
+  end
+  
+  specify "should remain not empty after 'peek'" do
+    @stack.peek
+    @stack.should.not.be.empty
+  end
+  
+  specify "should become empty after 'pop'" do
+    @stack.pop
+    @stack.should.be.empty
+  end
+end
+
+context "An almost full stack (with one item less than capacity)" do
+  setup do
+    @stack = Stack.new
+    (1..9).each { |i| @stack.push i }
+  end
+  
+  specify "should not be full" do
+    @stack.should.not.be.full
+  end
+  
+  specify "should become full when sent 'push'" do
+    @stack.push Object.new
+    @stack.should.be.full
+  end
+end
+
+context "A full stack" do
+  setup do
+    @stack = Stack.new
+    (1..10).each { |i| @stack.push i }
+  end
+  
+  specify "should be full" do
+    @stack.should.be.full
+  end
+  
+  specify "should remain full after 'peek'" do
+    @stack.peek
+    @stack.should.be.full
+  end
+  
+  specify "should no longer be full after 'pop'" do
+    @stack.pop
+    @stack.should.not.be.full
+  end
+
+  specify "should complain on 'push'" do
+    lambda { @stack.push Object.new }.should.raise StackOverflowError
+  end
+end

data/lib/{test-spec/test → test}/spec.rb

@@ -1,7 +1,7 @@
 #
 # test/spec -- a BDD interface for Test::Unit
 #
-# Copyright (C) 2006  Christian Neukirchen <mailto:chneukirchen@gmail.com>
+# Copyright (C) 2006, 2007  Christian Neukirchen <mailto:chneukirchen@gmail.com>
 #
 # This work is licensed under the same terms as Ruby itself.
 #
@@ -24,9 +24,9 @@ module Test                     # :nodoc:
 end
 
 module Test::Spec
-  VERSION = "0.1"
+  VERSION = "0.3"
   
-  CONTEXTS = {}
+  CONTEXTS = {}                 # :nodoc:
 
   class DefinitionError < StandardError
   end
@@ -34,8 +34,16 @@ module Test::Spec
   class Should
     include Test::Unit::Assertions
 
-    def initialize(object)
+    def self.deprecated_alias(to, from)    # :nodoc:
+      define_method(to) { |*args|
+        warn "Test::Spec::Should##{to} is deprecated and will be removed in future versions."
+        __send__ from, *args
+      }
+    end
+
+    def initialize(object, message=nil)
       @object = object
+      @message = message
     end
 
     $TEST_SPEC_TESTCASE = nil
@@ -52,96 +60,121 @@ module Test::Spec
       self
     end
 
-    def not
-      ShouldNot.new(@object)
+    def not(*args)
+      case args.size
+      when 0
+        ShouldNot.new(@object, @message)
+      when 1
+        ShouldNot.new(@object, @message).pass(args.first)
+      else
+        raise ArgumentError, "#not takes zero or one argument(s)."
+      end
     end
 
+    def messaging(message)
+      @message = message.to_s
+      self
+    end
+    alias blaming messaging
 
     def satisfy(&block)
-      assert_block("satisfy block failed.") {
+      assert_block(@message || "satisfy block failed.") {
         yield @object
       }
     end
 
     def equal(value)
-      assert_equal value, @object
+      assert_equal value, @object, @message
     end
     alias == equal
 
     def close(value, delta)
-      assert_in_delta value, @object, delta
+      assert_in_delta value, @object, delta, @message
     end
-    alias be_close close
+    deprecated_alias :be_close, :close
 
     def be(*value)
       case value.size
       when 0
         self
       when 1
-        assert_same value.first, @object
+        if CustomShould === value.first 
+          pass value.first
+        else
+          assert_same value.first, @object, @message
+        end
       else
         raise ArgumentError, "should.be needs zero or one argument"
       end
     end
 
     def match(value)
-      assert_match value, @object
+      assert_match value, @object, @message
     end
     alias =~ match
 
     def instance_of(klass)
-      assert_instance_of klass, @object
+      assert_instance_of klass, @object, @message
     end
-    alias be_an_instance_of instance_of
+    deprecated_alias :be_an_instance_of, :instance_of
 
     def kind_of(klass)
-      assert_kind_of klass, @object
+      assert_kind_of klass, @object, @message
     end
-    alias be_a_kind_of kind_of
+    deprecated_alias :be_a_kind_of, :kind_of
 
     def respond_to(method)
-      assert_respond_to @object, method
+      assert_respond_to @object, method, @message
     end
 
     def _raise(*args)
       args = [RuntimeError]  if args.empty?
-      assert_raise(*args, &@object)
+      assert_raise(*(args + [@message]), &@object)
     end
 
     def throw(*args)
-      assert_throws(*args, &@object)
+      assert_throws(*(args + [@message]), &@object)
     end
 
     def nil
-      assert_nil @object
+      assert_nil @object, @message
     end
-    alias be_nil nil
+    deprecated_alias :be_nil, :nil
 
 
     def include(value)
-      msg = build_message(nil, "<?> expected to include ?, but it didn't.",
+      msg = build_message(@message, "<?> expected to include ?, but it didn't.",
                           @object, value)
       assert_block(msg) { @object.include?(value) }
     end
 
     def >(value)
-      assert_operator @object, :>, value
+      assert_operator @object, :>, value, @message
     end
 
     def >=(value)
-      assert_operator @object, :>=, value
+      assert_operator @object, :>=, value, @message
     end
 
     def <(value)
-      assert_operator @object, :<, value
+      assert_operator @object, :<, value, @message
     end
 
     def <=(value)
-      assert_operator @object, :<=, value
+      assert_operator @object, :<=, value, @message
     end
 
     def ===(value)
-      assert_operator @object, :===, value
+      assert_operator @object, :===, value, @message
+    end
+
+    def pass(custom)
+      _wrap_assertion {
+        assert_nothing_raised(Test::Unit::AssertionFailedError,
+                              @message || custom.failure_message) {
+          assert custom.matches?(@object), @message || custom.failure_message
+        }
+      }
     end
 
     def method_missing(name, *args)
@@ -150,7 +183,7 @@ module Test::Spec
       
       if @object.respond_to?("#{name}?")
         assert @object.__send__("#{name}?", *args),
-               "#{name}? expected to be true."
+          "#{name}? expected to be true. #{@message}"
       else
         super
       end
@@ -160,12 +193,19 @@ module Test::Spec
   class ShouldNot
     include Test::Unit::Assertions
 
-    def initialize(object)
+    def initialize(object, message=nil)
       @object = object
+      @message = message
+    end
+
+    def satisfy(&block)
+      assert_block(@message || "not.satisfy block succeded.") {
+        not yield @object
+      }
     end
     
     def equal(value)
-      assert_not_equal value, @object
+      assert_not_equal value, @object, @message
     end
     alias == equal
 
@@ -174,7 +214,11 @@ module Test::Spec
       when 0
         self
       when 1
-        assert_not_same value.first, @object
+        if CustomShould === value.first 
+          pass value.first
+        else
+          assert_not_same value.first, @object, @message
+        end
       else
         Kernel.raise ArgumentError, "should.be needs zero or one argument"
       end
@@ -182,42 +226,80 @@ module Test::Spec
 
     def match(value)
       # Icky Regexp check
-      assert_no_match value, @object
+      assert_no_match value, @object, @message
     end
     alias =~ match
 
     def _raise(*args)
-      assert_nothing_raised(*args, &@object)
+      assert_nothing_raised(*(args+[@message]), &@object)
     end
 
     def throw
-      assert_nothing_thrown(&@object)
+      assert_nothing_thrown(@message, &@object)
     end
 
     def nil
-      assert_not_nil @object
+      assert_not_nil @object, @message
     end
-    alias be_nil nil 
 
+    def be_nil
+      warn "Test::Spec::ShouldNot#be_nil is deprecated and will be removed in future versions."
+      self.nil
+    end
 
-    def not
-      Should.new(@object)
+    def not(*args)
+      case args.size
+      when 0
+        Should.new(@object, @message)
+      when 1
+        Should.new(@object, @message).pass(args.first)
+      else
+        raise ArgumentError, "#not takes zero or one argument(s)."
+      end
     end
 
+    def pass(custom)
+      _wrap_assertion {
+        begin
+          assert !custom.matches?(@object), @message || custom.failure_message
+        end
+      }
+    end
 
     def method_missing(name, *args)
       # This will make raise call Kernel.raise, and self.raise call _raise.
       return _raise(*args)  if name == :raise
 
       if @object.respond_to?("#{name}?")
-        assert_block("#{name}? expected to be false.") {
+        assert_block("#{name}? expected to be false. #{@message}") {
           not @object.__send__("#{name}?", *args)
         }
       else
         super
       end
     end
+    
+  end
 
+  class CustomShould
+    attr_accessor :object
+    
+    def initialize(obj)
+      self.object = obj
+    end
+
+    def failure_message
+      "#{self.class.name} failed"
+    end
+
+    def matches?(*args, &block)
+      assumptions(*args, &block)
+      true
+    end
+
+    def assumptions(*args, &block)
+      raise NotImplementedError, "you need to supply a #{self.class}#matches? method"
+    end
   end
 end
 
@@ -275,10 +357,16 @@ class Test::Spec::TestCase
       
       self.count += 1                 # Let them run in order of definition
       
-      # TODO Changed by Jean-Michel
-      # define_method("test_%03d: %s" % [count, specname], &block)
       define_method("test_spec {%s} %03d [%s]" % [name, count, specname], &block)
     end
+
+    def xspecify(specname, &block)
+      raise ArgumentError, "xspecify needs a block"  if block.nil?
+
+      specify specname do
+        @_result.add_disabled(specname)
+      end
+    end
     
     def setup(&block)
       setups << block
@@ -324,6 +412,24 @@ class Test::Spec::TestCase
   end
 end
 
+class Test::Spec::Disabled < Test::Unit::Failure    # :nodoc:
+  def initialize(name)
+    @name = name
+  end
+
+  def single_character_display
+    "D"
+  end
+
+  def short_display
+    @name
+  end
+
+  def long_display
+    @name + " is disabled"
+  end
+end
+
 
 # Monkey-patch test/unit to run tests in an optionally specified order.
 module Test::Unit               # :nodoc:
@@ -348,19 +454,35 @@ module Test::Unit               # :nodoc:
       @tests.first.respond_to?(:position) ? @tests.first.position : 0
     end
   end
+
+  class TestResult              # :nodoc:
+    # Records a disabled test.
+    def add_disabled(name)
+      notify_listeners(FAULT, Test::Spec::Disabled.new(name))
+      notify_listeners(CHANGED, self)
+    end  
+  end
 end
 
 
-# Global helpers
+
+#-- Global helpers
 
 class Object
-  def should
-    Test::Spec::Should.new(self)
+  def should(*args)
+    case args.size
+    when 0
+      Test::Spec::Should.new(self)
+    when 1
+      Test::Spec::Should.new(self).pass(args.first)
+    else
+      raise ArgumentError, "Object#should takes zero or one argument(s)."
+    end
   end
 end
 
 module Kernel
-  def context(name, &block)
+  def context(name, &block)     # :doc:
     (Test::Spec::CONTEXTS[name] ||= Test::Spec::TestCase.new(name)).add(&block)
   end