baretest 0.1.0 → 0.2.3

data/examples/tests/variations/variations_01.rb

@@ -0,0 +1,14 @@
+require 'pp'
+
+BareTest.suite "Variations 01" do
+  setup do puts "n1" end
+  setup do puts "n2" end
+  setup :a, "a1" do puts "a1" end
+  setup :a, "a2" do puts "a2" end
+  setup :b, "b1" do puts "b1" end
+  setup :b, "b2" do puts "b2" end
+
+  assert "variants, a: :a, b: :b" do
+    true
+  end
+end

data/examples/tests/variations/variations_02.rb

@@ -0,0 +1,19 @@
+require 'pp'
+
+class String
+  def numeric?
+    self =~ /[+-]?(?:[1-9]\d*|0)(?:\.\d+)?(?:[eE][+-]?\d+)?/
+  end
+end
+
+BareTest.suite do
+  suite "Variations 02" do
+    setup :number, %w[123 -123 1.23 -1.23 1e3 -1e3 1e-3 -1e-3] do |number|
+      @number = number
+    end
+
+    assert ":number should be a numeric" do
+      @number.numeric?
+    end
+  end
+end

data/examples/tests/variations/variations_03.rb

@@ -0,0 +1,19 @@
+require 'pp'
+
+class String
+  def numeric?
+    self =~ /[+-]?(?:[1-9]\d*|0)(?:\.\d+)?(?:[eE][+-]?\d+)?/
+  end
+end
+
+BareTest.suite do
+  suite "Variations 02" do
+    setup :number, {'"123"' => "123", '"1.23"' => "1.23", '"1e3"' => "1e3"} do |number|
+      @number = number
+    end
+
+    assert ":number should be a numeric" do
+      @number.numeric?
+    end
+  end
+end

data/lib/baretest/assertion/context.rb

@@ -0,0 +1,20 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module BareTest
+  class Assertion
+    class Context
+      attr_reader :__assertion__
+      alias assertion __assertion__
+
+      def initialize(assertion)
+        @__assertion__ = assertion
+      end
+    end
+  end
+end

data/lib/baretest/assertion/failure.rb

@@ -0,0 +1,22 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module BareTest
+  class Assertion
+
+    # BareTest::Assertion::Failure can be raised within an assertion to indicate that the
+    # assertion failed. Unlike all other exceptions, this one will not set the Assertion's
+    # status to :error but to :failure. The exception's #message is used as
+    # Assertion#reason.
+    # Take a look at the implementation of some methods of BareTest::Assertion::Support for
+    # examples on how to use it.
+    #
+    class Failure < StandardError
+    end
+  end
+end

data/lib/baretest/assertion/skip.rb

@@ -0,0 +1,21 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module BareTest
+  class Assertion
+
+    # BareTest::Assertion::Skip can be raised within an assertion to indicate that the
+    # assertion is to be skipped. Unlike all other exceptions, this one will not set the Assertion's
+    # status to :error but to :failure. The exception's #message is used as
+    # Assertion#reason.
+    # Also see BareTest::Assertion::Support#skip
+    #
+    class Skip < StandardError
+    end
+  end
+end

data/lib/{test → baretest}/assertion/support.rb

@@ -6,51 +6,103 @@
 
 
 
-require 'test/assertion/failure'
+require 'baretest/assertion/failure'
+require 'baretest/assertion/skip'
 begin
   require 'thread'
 rescue LoadError; end # no thread support in this ruby
 
 
 
-module Test
+module BareTest
   @touch = {}
+
   # We don't want to litter in Assertion
-  # Touches are associated with 
-  def self.touch(assertion, thing=nil)
+  # Touches are associated withx
+  # Used by BareTest::Assertion::Support#touch
+  def self.touch(assertion, thing=nil) # :nodoc:
     @touch[assertion] ||= Hash.new(0)
     @touch[assertion][thing] += 1
   end
 
-  def self.touched(assertion, thing=nil)
+  # Used by BareTest::Assertion::Support#touched
+  def self.touched(assertion, thing=nil) # :nodoc:
     @touch[assertion] ||= Hash.new(0)
     @touch[assertion][thing]
   end
 
-  def self.clean_touches(assertion)
+  # Used by BareTest::Assertion::Support
+  def self.clean_touches(assertion) # :nodoc:
     @touch.delete(assertion)
   end
-end
 
-module Test
   class Assertion
+
+    # BareTest::Assertion::Support is per default included into BareTest::Assertion.
+    # It provides several methods to make it easier to write assertions.
+    #
     module Support
+
+      # Creates global setup and teardown callbacks that are needed by some of
+      # BareTest::Assertion::Support's methods.
+      #
       module SetupAndTeardown
-        def self.extended(run_obj)
+
+        # Install the setup and teardown callbacks.
+        def self.extended(run_obj) # :nodoc:
           run_obj.init do
             suite.teardown do
-              Test.clean_touches(self) # instance evaled, self is the assertion
+              ::BareTest.clean_touches(self) # instance evaled, self is the assertion
             end
           end
         end
 
-        Test.extender << self
+        ::BareTest.extender << self
+      end
+
+      # FIXME: undocumented and untested
+      # It's really ugly. You should use a mock instead.
+      def yields(subject, meth, args, *expected)
+        subject.__send__(meth, *args) do |*actual|
+          current = expected.shift
+          return false unless actual == current
+        end
+        return expected.empty?
+      end
+
+      # FIXME: incomplete and untested
+      def throws(symbol) # :nodoc:
+        begin
+          passed = false
+          catch(sym) {
+            yield
+            passed = true
+            return false
+          }
+          passed = true
+          return true
+        rescue NameError => e
+          return false if e.message =~ 'uncaught throw'
+          raise
+        rescue Exception
+          passed = true
+          raise
+        ensure
+          raise ThrewSomethingElse unless passed
+        end
+      rescue ThrewSomethingElse => e
+        return false
+      end
+
+      # FIXME: incomplete and untested
+      def throws_nothing # :nodoc:
       end
 
       # Will raise a Failure if the given block doesn't raise or raises a different
       # exception than the one provided
       # You can optionally give an options :with_message, which is tested with === against
       # the exception message.
+      #
       # Examples:
       #   raises do raise "will work" end # => true
       #   raises SomeException do raise SomeException end # => true
@@ -58,26 +110,28 @@ module Test
       #   raises SomeException, :with_message => "bar"; raise SomeException, "bar" end # => true
       #   raises :with_message => /\Aknown \w+\z/; raise "known unknown" end # => true
       def raises(exception_class=StandardError, opts={})
-        begin
-          yield
-        rescue exception_class => exception
-          if opts[:with_message] && !(opts[:with_message] === exception.message) then
-            failure "Expected block to raise with the message %p, but the message was %p",
-                    exception.message, opts[:with_message]
-          else
-            true
-          end
-        rescue => exception
-          failure "Expected block to raise #{exception_class}, but it raised #{exception.class}."
+        yield
+      rescue exception_class => exception
+        if opts[:with_message] && !(opts[:with_message] === exception.message) then
+          failure "Expected block to raise with the message %p, but the message was %p",
+                  exception.message, opts[:with_message]
         else
-          failure "Expected block to raise #{exception_class}, but nothing was raised."
+          true
         end
+      rescue *::BareTest::Assertion::PassthroughExceptions
+        ::Kernel.raise
+      rescue => exception
+        failure "Expected block to raise #{exception_class}, but it raised #{exception.class}."
+      else
+        failure "Expected block to raise #{exception_class}, but nothing was raised."
       end
 
       # Will raise a Failure if the given block raises.
       def raises_nothing
         yield
-      rescue => exception
+      rescue *::BareTest::Assertion::PassthroughExceptions
+        ::Kernel.raise
+      rescue Exception => exception
         failure "Expected block to raise nothing, but it raised #{exception.class}."
       else
         true
@@ -88,10 +142,15 @@ module Test
       # of the possible rounding differences.
       def within_delta(a, b, delta)
         (a-b).abs < delta
+      rescue *::BareTest::Assertion::PassthroughExceptions
+        ::Kernel.raise
+      rescue Exception => e
+        failure "Could not compare %p with %p due to %s", a, b, e
       end
 
       # Use this method to test whether certain code (e.g. a callback) was reached.
       # touch marks that it was reached, #touched tests for whether it was reached.
+      #
       # Example:
       #   assert "Code in a Proc object is executed when invoking #call on it." do
       #     a_proc = proc { touch :executed }
@@ -99,12 +158,15 @@ module Test
       #     touched(:executed)
       #   end
       def touch(thing=nil)
-        ::Test.touch(self, thing)
+        ::BareTest.touch(self, thing)
       end
 
+      # Used to verify that something was touched. You can also verify that something was touched
+      # a specific amount of times.
+      #
       # See #touch
       def touched(thing=nil, times=nil)
-        touched_times = ::Test.touched(self, thing)
+        touched_times = ::BareTest.touched(self, thing)
         if times then
           unless touched_times == times then
             if thing then
@@ -123,14 +185,18 @@ module Test
         true
       end
 
+      # Used to verify that something was not touched.
+      #
       # See #touch
       def not_touched(thing=nil)
         touched(thing, 0)
       end
 
       # Uses equal? to test whether the objects are the same
-      # same expected, actual
-      # same :expected => expected, :actual => actual
+      #
+      # Can be used in either of the following ways:
+      #   same expected, actual
+      #   same :expected => expected, :actual => actual
       def same(*args)
         expected, actual, message = extract_args(args, :expected, :actual, :message)
 
@@ -142,11 +208,18 @@ module Test
           end
         end
         true
+
+      rescue *::BareTest::Assertion::PassthroughExceptions
+        ::Kernel.raise
+      rescue Exception => e
+        failure "Could not compare %p with %p due to %s", expected, actual, e
       end
 
       # Uses eql? to test whether the objects are equal
-      # equal expected, actual
-      # equal :expected => expected, :actual => actual
+      #
+      # Can be used in either of the following ways:
+      #   equal expected, actual
+      #   equal :expected => expected, :actual => actual
       def hash_key_equal(*args)
         expected, actual, message = extract_args(args, :expected, :actual, :message)
 
@@ -158,11 +231,18 @@ module Test
           end
         end
         true
+
+      rescue *::BareTest::Assertion::PassthroughExceptions
+        ::Kernel.raise
+      rescue Exception => e
+        failure "Could not compare %p with %p due to %s", expected, actual, e
       end
 
       # Uses == to test whether the objects are equal
-      # equal expected, actual
-      # equal :expected => expected, :actual => actual
+      #
+      # Can be used in either of the following ways:
+      #   equal expected, actual
+      #   equal :expected => expected, :actual => actual
       def order_equal(*args)
         expected, actual, message = extract_args(args, :expected, :actual, :message)
 
@@ -174,12 +254,19 @@ module Test
           end
         end
         true
+
+      rescue *::BareTest::Assertion::PassthroughExceptions
+        ::Kernel.raise
+      rescue Exception => e
+        failure "Could not compare %p with %p due to %s", expected, actual, e
       end
       alias equal order_equal
 
       # Uses === to test whether the objects are equal
-      # equal expected, actual
-      # equal :expected => expected, :actual => actual
+      #
+      # Can be used in either of the following ways:
+      #   equal expected, actual
+      #   equal :expected => expected, :actual => actual
       def case_equal(*args)
         expected, actual, message = extract_args(args, :expected, :actual, :message)
 
@@ -190,6 +277,11 @@ module Test
             message, expected, actual
         end
         true
+
+      rescue *::BareTest::Assertion::PassthroughExceptions
+        ::Kernel.raise
+      rescue Exception => e
+        failure "Could not compare %p with %p due to %s", expected, actual, e
       end
 
       # To compare two collections (which must implement #each)
@@ -201,6 +293,7 @@ module Test
         count = Hash.new(0)
         expected.each { |element| count[element] += 1 }
         actual.each   { |element| count[element] -= 1 }
+
         unless count.all? { |key, value| value.zero? } then
           only_in_expected = count.select { |ele, n| n > 0 }.map { |ele, n| ele }
           only_in_actual   = count.select { |ele, n| n < 0 }.map { |ele, n| ele }
@@ -215,6 +308,11 @@ module Test
           end
         end
         true
+
+      rescue *::BareTest::Assertion::PassthroughExceptions
+        ::Kernel.raise
+      rescue Exception => e
+        failure "Could not compare %p with %p due to %s", expected, actual, e
       end
 
       # Raises a Failure if the given object is not an instance of the given class
@@ -228,8 +326,14 @@ module Test
             message, expected, actual, actual.class
         end
         true
+
+      rescue *::BareTest::Assertion::PassthroughExceptions
+        ::Kernel.raise
+      rescue Exception => e
+        failure "Could not test whether %p is a child of %p due to %s", actual, expected, e
       end
 
+      # A method to make raising failures that only optionally have a message easier.
       def failure_with_optional_message(with_message, without_message, message, *args)
         if message then
           failure(with_message, message, *args)
@@ -238,13 +342,34 @@ module Test
         end
       end
 
-      # Raises Test::Assertion::Failure and runs sprintf over message with *args
+      # Raises Test::Assertion::Failure, which causes the Assertion to get the
+      # status :failure. Runs sprintf over message with *args
+      # Particularly useful with %p and %s.
+      def failure(message="Assertion failed", *args)
+        raise ::BareTest::Assertion::Failure, sprintf(message, *args)
+      end
+
+      # Raises Test::Assertion::Skip, which causes the Assertion to get the
+      # status :skipped. Runs sprintf over message with *args
       # Particularly useful with %p and %s.
-      def failure(message, *args)
-        raise Test::Assertion::Failure, sprintf(message, *args)
+      def skip(message="Assertion was skipped", *args)
+        raise ::BareTest::Assertion::Skip, sprintf(message, *args)
       end
 
     private
+      # extract arg allows to use named or positional args
+      #
+      # Example:
+      #   extract_args([1,2,3], :foo, :bar, :baz) # => [1,2,3]
+      #   extract_args({:foo => 1,:bar => 2, :baz => 3}, :foo, :bar, :baz) # => [1,2,3]
+      #
+      # Usage:
+      #   def foo(*args)
+      #     x,y,z = extract_args(args, :x, :y, :z)
+      #   end
+      #   foo(1,2,3)
+      #   foo(:x => 1, :y => 2, :z => 3) # equivalent to the one above
+      #
       def extract_args(args, *named)
         if args.size == 1 && Hash === args.first then
           args.first.values_at(*named)
@@ -254,11 +379,21 @@ module Test
       end
     end # Support
 
-    include Support
+    class Context
+      include ::BareTest::Assertion::Support
+    end
   end # Assertion
-end # Test
+end # BareTest
 
 module Enumerable
+
+  # Part of BareTest - require 'baretest/assertion/support'
+  #
+  # Returns true if all elements of self occur the same amount of times in other, regardless
+  # of order. Uses +eql?+ to determine equality.
+  #
+  # Example:
+  #   [2,1,3,2].equal_unordered?([3,2,2,1]) # => true
   def equal_unordered?(other)
     count = Hash.new(0)
     other.each { |element| count[element] += 1 }

data/lib/baretest/assertion.rb

@@ -0,0 +1,182 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'baretest/assertion/context'
+require 'baretest/assertion/failure'
+require 'baretest/assertion/skip'
+
+
+
+module BareTest
+
+  # Defines an assertion
+  # An assertion belongs to a suite and consists of a description and a block.
+  # To verify the assertion, the suite's (and its ancestors) setup blocks are
+  # executed, then the assertions block is executed and after that, the suite's
+  # (and ancestors) teardown blocks are invoked.
+  #
+  # An assertion has 5 possible states, see Assertion#status for a list of them.
+  #
+  # There are various helper methods in BareTest::Assertion::Support which help you
+  # defining nicer diagnostics or just easier ways to test common scenarios.
+  # The following are test helpers:
+  # * Kernel#raises(exception_class=StandardError)
+  # * Kernel#within_delta(a, b, delta)
+  # * Kernel#equal_unordered(a,b)
+  # * Enumerable#equal_unordered(other)
+  class Assertion
+
+    # The exceptions baretest will not rescue (NoMemoryError, SignalException, Interrupt
+    # and SystemExit)
+    PassthroughExceptions = [NoMemoryError, SignalException, Interrupt, SystemExit]
+
+    # An assertion has 5 possible states:
+    # :success:: The assertion passed. This means the block returned a trueish value.
+    # :failure:: The assertion failed. This means the block returned a falsish value.
+    #            Alternatively it raised a Test::Failure (NOT YET IMPLEMENTED).
+    #            The latter has the advantage that it can provide nicer diagnostics.
+    # :pending:: No block given to the assertion to be run
+    # :skipped:: If one of the parent suites is missing a dependency, its assertions
+    #            will be skipped
+    # :error::   The assertion errored out. This means the block raised an exception
+    attr_reader :status
+
+    # If an exception occured in Assertion#execute, this will contain the
+    # Exception object raised.
+    attr_reader :exception
+
+    # The description of this assertion.
+    attr_reader :description
+
+    # The failure/error/skipping/pending reason.
+    attr_reader :reason
+
+    # The suite this assertion belongs to
+    attr_reader :suite
+
+    # The Context-instance the assertions setup, assert and teardown are run
+    attr_reader :context
+
+    # The Setup instances whose #block is to be executed before this assertion
+    # is ran
+    attr_accessor :setups
+
+    # The block specifying the assertion
+    attr_reader :block
+
+    # The file this assertion is specified in. Not contructed by Assertion itself.
+    attr_accessor :code
+
+    # The file this assertion is specified in. Not contructed by Assertion itself.
+    attr_accessor :file
+
+    # The line this assertion is specified on. Not contructed by Assertion itself.
+    attr_accessor :line
+
+    # The lines this assertion spans. Not contructed by Assertion itself.
+    attr_accessor :lines
+
+    # suite::       The suite the Assertion belongs to
+    # description:: A descriptive string about what this Assertion tests.
+    # &block::      The block definition. Without one, the Assertion will have a
+    #               :pending status.
+    def initialize(suite, description, &block)
+      @suite          = suite
+      @description    = (description || "No description given")
+      @setups         = nil
+      @block          = block
+      reset
+    end
+
+    def reset
+      @status    = nil
+      @reason    = nil
+      @exception = nil
+      @context   = ::BareTest::Assertion::Context.new(self)
+    end
+
+    def interpolated_description
+      setups = @setups ? @setups.select { |s| s.component } : []
+      if setups.empty? then
+        @description
+      else
+        substitutes = {}
+        setups.each do |setup| substitutes[setup.component] = setup.substitute end
+        @description.gsub(/:(?:#{substitutes.keys.join('|')})\b/) { |m|
+          substitutes[m[1..-1].to_sym]
+        }
+      end
+    end
+
+    # Run all setups in the order of their nesting (outermost first, innermost last)
+    def setup
+      @setups  ||= @suite ? @suite.first_component_variant : []
+      @setups.each do |setup| @context.instance_exec(setup.value, &setup.block) end
+      true
+    rescue *PassthroughExceptions
+      raise # pass through exceptions must be passed through
+    rescue Exception => exception
+      @reason    = "An error occurred during setup"
+      @exception = exception
+      @status    = :error
+      false
+    end
+
+    # Run all teardowns in the order of their nesting (innermost first, outermost last)
+    def teardown
+      @suite.ancestry_teardown.each do |teardown|
+        @context.instance_eval(&teardown)
+      end if @suite
+    rescue *PassthroughExceptions
+      raise # pass through exceptions must be passed through
+    rescue Exception => exception
+      @reason    = "An error occurred during setup"
+      @exception = exception
+      @status    = :error
+    end
+
+    # Runs the assertion and sets the status and exception
+    def execute(setups=nil)
+      @setups    = setups if setups
+      @exception = nil
+      if @block then
+        if setup() then
+          # run the assertion
+          begin
+            @status = @context.instance_eval(&@block) ? :success : :failure
+            @reason = "Assertion failed" if @status == :failure
+          rescue *PassthroughExceptions
+            raise # pass through exceptions must be passed through
+          rescue ::BareTest::Assertion::Failure => failure
+            @status = :failure
+            @reason = failure.message
+          rescue ::BareTest::Assertion::Skip => skip
+            @status = :skipped
+            @reason = skip.message
+          rescue Exception => exception
+            @reason    = "An error occurred during execution"
+            @exception = exception
+            @status    = :error
+          end
+        end
+        teardown
+      else
+        @status = :pending
+      end
+      self
+    end
+
+    def to_s # :nodoc:
+      sprintf "%s %s", self.class, @description
+    end
+
+    def inspect # :nodoc:
+      sprintf "#<%s:%08x suite=%p %p>", self.class, object_id>>1, @suite, @description
+    end
+  end
+end