baretest 0.1.0

data/lib/test/assertion/support.rb

@@ -0,0 +1,268 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'test/assertion/failure'
+begin
+  require 'thread'
+rescue LoadError; end # no thread support in this ruby
+
+
+
+module Test
+  @touch = {}
+  # We don't want to litter in Assertion
+  # Touches are associated with 
+  def self.touch(assertion, thing=nil)
+    @touch[assertion] ||= Hash.new(0)
+    @touch[assertion][thing] += 1
+  end
+
+  def self.touched(assertion, thing=nil)
+    @touch[assertion] ||= Hash.new(0)
+    @touch[assertion][thing]
+  end
+
+  def self.clean_touches(assertion)
+    @touch.delete(assertion)
+  end
+end
+
+module Test
+  class Assertion
+    module Support
+      module SetupAndTeardown
+        def self.extended(run_obj)
+          run_obj.init do
+            suite.teardown do
+              Test.clean_touches(self) # instance evaled, self is the assertion
+            end
+          end
+        end
+
+        Test.extender << self
+      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
+      #   raises :with_message => "bar" do raise "bar" end # => true
+      #   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}."
+        else
+          failure "Expected block to raise #{exception_class}, but nothing was raised."
+        end
+      end
+
+      # Will raise a Failure if the given block raises.
+      def raises_nothing
+        yield
+      rescue => exception
+        failure "Expected block to raise nothing, but it raised #{exception.class}."
+      else
+        true
+      end
+
+      # For comparisons of Floats you shouldn't use == but
+      # for example a delta comparison instead, to take care
+      # of the possible rounding differences.
+      def within_delta(a, b, delta)
+        (a-b).abs < delta
+      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 }
+      #     a_proc.call
+      #     touched(:executed)
+      #   end
+      def touch(thing=nil)
+        ::Test.touch(self, thing)
+      end
+
+      # See #touch
+      def touched(thing=nil, times=nil)
+        touched_times = ::Test.touched(self, thing)
+        if times then
+          unless touched_times == times then
+            if thing then
+              failure "Expected the code to touch %p %s times, but did %s times.", thing, times, touched_times
+            else
+              failure "Expected the code to touch %s times, but did %s times.", times, touched_times
+            end
+          end
+        elsif touched_times < 1 then
+          if thing then
+            failure "Expected the code to touch %p, but it was not touched.", thing
+          else
+            failure "Expected the code to touch, but no touch happened."
+          end
+        end
+        true
+      end
+
+      # 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
+      def same(*args)
+        expected, actual, message = extract_args(args, :expected, :actual, :message)
+
+        unless expected.equal?(actual) then
+          if message then
+            failure "Expected %s to be the same (equal?) as %p but was %p.", message, expected, actual
+          else
+            failure "Expected %p but got %p.", expected, actual
+          end
+        end
+        true
+      end
+
+      # Uses eql? to test whether the objects are equal
+      # equal expected, actual
+      # equal :expected => expected, :actual => actual
+      def hash_key_equal(*args)
+        expected, actual, message = extract_args(args, :expected, :actual, :message)
+
+        unless expected.eql?(actual) then
+          if message then
+            failure "Expected %s to be hash-key equal (eql?) to %p but was %p.", message, expected, actual
+          else
+            failure "Expected %p but got %p.", expected, actual
+          end
+        end
+        true
+      end
+
+      # Uses == to test whether the objects are equal
+      # equal expected, actual
+      # equal :expected => expected, :actual => actual
+      def order_equal(*args)
+        expected, actual, message = extract_args(args, :expected, :actual, :message)
+
+        unless expected == actual then
+          if message then
+            failure "Expected %s to be order equal (==) to %p but was %p.", message, expected, actual
+          else
+            failure "Expected %p but got %p.", expected, actual
+          end
+        end
+        true
+      end
+      alias equal order_equal
+
+      # Uses === to test whether the objects are equal
+      # equal expected, actual
+      # equal :expected => expected, :actual => actual
+      def case_equal(*args)
+        expected, actual, message = extract_args(args, :expected, :actual, :message)
+
+        unless expected === actual then
+          failure_with_optional_message \
+            "Expected %s to be case equal (===) to %p but was %p.",
+            "Expected %p but got %p.",
+            message, expected, actual
+        end
+        true
+      end
+
+      # To compare two collections (which must implement #each)
+      # without considering order. E.g. two sets, or the keys of
+      # two hashes.
+      def equal_unordered(*args)
+        expected, actual, message = extract_args(args, :expected, :actual, :message)
+
+        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 }
+          if message then
+            failure "Expected %s to have the same items the same number of times, " \
+                    "but %p are only in expected, and %p only in actual.",
+                    message, only_in_expected, only_in_actual
+          else
+            failure "Expected %p and %p to have the same items the same number of times, " \
+                    "but %p are only in expected, and %p only in actual.",
+                    expected, actual, only_in_expected, only_in_actual
+          end
+        end
+        true
+      end
+
+      # Raises a Failure if the given object is not an instance of the given class
+      # or a descendant thereof
+      def kind_of(*args)
+        expected, actual, message = extract_args(args, :expected, :actual, :message)
+        unless actual.kind_of?(expected) then
+          failure_with_optional_message \
+            "Expected %1$s to be a kind of %3$p, but was a %4$p",
+            "Expected %2$p to be a kind of %1$p, but was a %3$p",
+            message, expected, actual, actual.class
+        end
+        true
+      end
+
+      def failure_with_optional_message(with_message, without_message, message, *args)
+        if message then
+          failure(with_message, message, *args)
+        else
+          failure(without_message, *args)
+        end
+      end
+
+      # Raises Test::Assertion::Failure and runs sprintf over message with *args
+      # Particularly useful with %p and %s.
+      def failure(message, *args)
+        raise Test::Assertion::Failure, sprintf(message, *args)
+      end
+
+    private
+      def extract_args(args, *named)
+        if args.size == 1 && Hash === args.first then
+          args.first.values_at(*named)
+        else
+          args.first(named.size)
+        end
+      end
+    end # Support
+
+    include Support
+  end # Assertion
+end # Test
+
+module Enumerable
+  def equal_unordered?(other)
+    count = Hash.new(0)
+    other.each { |element| count[element] += 1 }
+    each { |element| count[element] -= 1 }
+    count.all? { |key, value| value.zero? }
+  end
+end

data/lib/test/assertion.rb

@@ -0,0 +1,117 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'test/assertion/failure'
+
+
+
+module Test
+
+  # Defines an assertion
+  # An assertion belongs to a suite and consists of a description and a block.
+  # The 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 lib/test/support.rb 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
+
+    # 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 reason.
+    attr_reader :failure_reason
+
+    # The suite this assertion belongs to
+    attr_reader :suite
+
+    # The block specifying the assertion
+    attr_reader :block
+
+    # 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
+      @status         = nil
+      @failure_reason = nil
+      @exception      = nil
+      @description    = description || "No description given"
+      @block          = block
+    end
+
+    # Run all setups in the order of their nesting (outermost first, innermost last)
+    def setup
+      @suite.ancestry_setup.each { |setup| instance_eval(&setup) } if @suite
+    end
+
+    # Run all teardowns in the order of their nesting (innermost first, outermost last)
+    def teardown
+      @suite.ancestry_teardown.each { |setup| instance_eval(&setup) } if @suite
+    end
+
+    # Runs the assertion and sets the status and exception
+    def execute
+      @exception = nil
+      if @block then
+        setup
+        # run the assertion
+        begin
+          @status = instance_eval(&@block) ? :success : :failure
+        rescue ::Test::Assertion::Failure => failure
+          @status         = :failure
+          @failure_reason = failure
+        rescue => exception
+          @failure_reason = "An error occurred"
+          @exception      = exception
+          @status         = :error
+        end
+        teardown
+      else
+        @status = :pending
+      end
+      self
+    end
+
+    def clean_copy(use_class=nil)
+      (use_class || self.class).new(@suite, @description, &@block)
+    end
+  end
+end

data/lib/test/debug.rb

@@ -0,0 +1,34 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'pp'
+require 'yaml'
+
+
+
+module Test
+  class Suite
+    def to_s
+      sprintf "%s %s", self.class, @description
+    end
+
+    def inspect
+      sprintf "#<%s:%08x %p>", self.class, object_id>>1, @description
+    end
+  end
+
+  class Assertion
+    def to_s
+      sprintf "%s %s", self.class, @description
+    end
+
+    def inspect
+      sprintf "#<%s:%08x @suite=%p %p>", self.class, object_id>>1, @suite, @description
+    end
+  end
+end

data/lib/test/irb_mode.rb

@@ -0,0 +1,104 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'test/debug'
+
+
+
+module Test
+  module IRBMode
+    module AssertionExtensions
+    end
+
+    class AssertionContext < ::Test::Assertion
+      attr_accessor :original_assertion
+
+      def to_s
+        "Assertion"
+      end
+
+      def e!
+        em!
+        bt!
+      end
+
+      def em!
+        puts @original_assertion.exception
+      end
+
+      def bt!
+        size = caller.size+3
+        puts @original_assertion.exception.backtrace[0..-size]
+      end
+    end
+
+    def self.extended(by)
+      by.init do
+        require 'irb'
+        require 'test/debug'
+        IRB.setup(nil) # must only be called once
+      end
+    end
+
+    # Formatter callback.
+    # Invoked once for every assertion.
+    # Gets the assertion to run as single argument.
+    def run_test(assertion)
+      rv = super
+      # drop into irb if assertion failed
+      if [:failure, :error].include?(rv.status) then
+        start_irb_mode(assertion)
+        irb_mode_for_assertion(assertion)
+        stop_irb_mode(assertion)
+      end
+
+      @count[:test]            += 1
+      @count[assertion.status] += 1
+      rv
+    end
+
+    def start_irb_mode(assertion)
+      ancestry = assertion.suite.ancestors.reverse.map { |suite| suite.name }
+
+      puts
+      puts "#{assertion.status.to_s.capitalize} in #{ancestry.join(' > ')}"
+      puts "  #{assertion.description}"
+      puts "#{assertion.exception} - #{assertion.exception.backtrace.first}"
+      super
+    rescue NoMethodError # HAX, not happy about that. necessary due to order of extend
+    end
+
+    # This method is highlevel hax, try to add necessary API to
+    # Test::Assertion
+    def irb_mode_for_assertion(assertion)
+      irb_context = assertion.clean_copy(AssertionContext)
+      irb_context.original_assertion = assertion
+      irb_context.setup
+      @irb = IRB::Irb.new(IRB::WorkSpace.new(irb_context.send(:binding)))
+      irb  = @irb # for closure
+
+      # HAX - cargo cult, taken from irb.rb, not yet really understood.
+      IRB.conf[:IRB_RC].call(irb.context) if IRB.conf[:IRB_RC] # loads the irbrc?
+      IRB.conf[:MAIN_CONTEXT] = irb.context # why would the main context be set here?
+      # /HAX
+
+      trap("SIGINT") do
+        irb.signal_handle
+      end
+      catch(:IRB_EXIT) do irb.eval_input end
+
+      irb_context.teardown
+    end
+
+    def stop_irb_mode(assertion)
+      puts
+      super
+    rescue NoMethodError # HAX, not happy about that. necessary due to order of extend
+    end
+  end
+end

data/lib/test/run/cli.rb

@@ -0,0 +1,79 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module Test
+  class Run
+    module CLI
+      Formats = {
+        :pending => "\e[43m%9s\e[0m  %s%s\n",
+        :skipped => "\e[43m%9s\e[0m  %s%s\n",
+        :success => "\e[42m%9s\e[0m  %s%s\n",
+        :failure => "\e[41m%9s\e[0m  %s%s\n",
+        :error   => "\e[37;40;1m%9s\e[0m  %s%s\n"  # ]]]]]]]] - bbedit hates open brackets...
+      }
+
+      FooterFormats = {
+        :incomplete => "\e[43m%9s\e[0m\n",
+        :success    => "\e[42m%9s\e[0m\n",
+        :failure    => "\e[41m%9s\e[0m\n",
+        :error      => "\e[37;40;1m%9s\e[0m\n"  # ]]]]]]]] - bbedit hates open brackets...
+      }
+
+      def run_all(*args)
+        @depth = 0
+        puts "Running all tests\n"
+        start = Time.now
+        super # run all suites
+        status = global_status
+        printf "\n%2$d tests run in %1$.1fs\n%3$d successful, %4$d pending, %5$d failures, %6$d errors\n",
+          Time.now-start, *@count.values_at(:test, :success, :pending, :failure, :error)
+        print "Final status: "
+        printf FooterFormats[status], status_label(status)
+      end
+
+      def run_suite(suite)
+        return super unless suite.description
+        #label, size = '  '*@depth+suite.description, suite.tests.size.to_s
+        #printf "\n\e[1m%-*s\e[0m (%d tests)\n", 71-size.length, label, size
+        case size = suite.tests.size
+          when 0
+            puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m"
+          when 1
+            puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (1 test)"
+          else
+            puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (#{size} tests)"
+        end
+        @depth += 1
+        super # run the suite
+        @depth -= 1
+      end
+
+      def run_test(assertion)
+        rv = super # run the assertion
+        printf(Formats[rv.status], status_label(rv.status), '  '*@depth, rv.description)
+        if rv.status == :error then
+          indent = '           '+'  '*@depth
+          print(indent, rv.exception.message, "\n", indent, rv.exception.backtrace.first, "\n")
+        elsif rv.status == :failure && rv.failure_reason then
+          print('           ', '  '*@depth, rv.failure_reason, "\n")
+        end
+        rv
+      end
+
+      def word_wrap(string, cols)
+        str.scan(/[^ ]+ /)
+      end
+
+      def status_label(status)
+        status.to_s.capitalize.center(9)
+      end
+    end
+  end
+
+  @format["test/run/cli"] = Run::CLI # register the extender
+end

data/lib/test/run/errors.rb

@@ -0,0 +1,42 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module Test
+  class Run
+    module Errors
+      def run_all
+        @depth = 0
+        puts "Running all tests, reporting errors"
+        super
+        start = Time.now
+        puts "\nDone, #{@count[:error]} errors encountered."
+      end
+
+      def run_suite(suite)
+        return super unless suite.description
+        puts "#{'  '*@depth+suite.description} (#{suite.tests.size} tests)"
+        @depth += 1
+        super # run the suite
+        @depth -= 1
+      end
+
+      def run_test(assertion)
+        rv = super # run the assertion
+        puts('  '*@depth+rv.description)
+        if rv.exception then
+          size = caller.size+5
+          puts((['-'*80, rv.exception]+rv.exception.backtrace[0..-size]+['-'*80, '']).map { |l|
+          	('  '*(@depth+1))+l
+          })
+        end
+      end
+    end
+  end
+
+  @format["test/run/errors"] = Run::Errors # register the extender
+end

data/lib/test/run/interactive.rb

@@ -0,0 +1,60 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module Test
+  class Run
+    module Interactive
+      def self.extended(obj)
+        obj.init do
+          require "test/irb_mode"
+          extend(Test::IRBMode)
+        end
+      end
+
+      def run_all
+        count    = proc { |acc,csuite| acc+csuite.tests.size+csuite.suites.inject(0, &count) }
+        @counted = count[0, suite] # count the number of tests to run
+        @depth   = 0
+        @width   = (Math.log(@counted)/Math.log(10)).floor+1
+
+        puts "Running all tests in interactive mode\n"
+        $stdout.sync = true
+        print_count
+
+        super
+
+        puts "\n\nDone"
+        $stdout.sync = false
+        $stdout.flush
+      end
+
+      def run_suite(suite)
+        return super unless suite.description
+        @depth += 1
+        super
+        @depth -= 1
+      end
+
+      def run_test(assertion)
+        rv          = super
+        print_count
+        rv
+      end
+
+      def print_count
+        printf "\rRan %*d of %*d assertions", @width, @count[:test], @width, @counted
+      end
+
+      def stop_irb_mode(assertion)
+        puts "\n\n"
+      end
+    end
+  end
+
+  @format["test/run/interactive"] = Run::Interactive # register the extender
+end