baretest 0.1.0

data/lib/test/run/minimal.rb

@@ -0,0 +1,31 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module Test
+  class Run
+    module Minimal
+      def run_all(*args)
+        start  = Time.now
+        super              # run all suites
+        stop   = Time.now
+        values = @count.values_at(:test, :success, :pending, :failure, :error)
+        values.push(stop-start, global_status)
+        printf "Tests:    %d\n" \
+               "Success:  %d\n" \
+               "Pending:  %d\n" \
+               "Failures: %d\n" \
+               "Errors:   %d\n" \
+               "Time:     %f\n" \
+               "Status:   %s\n",
+               *values
+      end
+    end
+  end
+
+  @format["test/run/minimal"] = Run::Minimal # register the extender
+end

data/lib/test/run/spec.rb

@@ -0,0 +1,32 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module Test
+  class Run
+    module Spec
+      def run_all
+        @depth = 0
+        super
+      end
+
+      def run_suite(suite)
+        return super unless suite.description
+        puts("\n"+'  '*@depth+suite.description)
+        @depth += 1
+        super
+        @depth -= 1
+      end
+
+      def run_test(assertion)
+        puts('  '*@depth+assertion.description)
+      end
+    end
+  end
+
+  @format["test/run/spec"] = Run::Spec
+end

data/lib/test/run/tap.rb

@@ -0,0 +1,32 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module Test
+  class Run
+    module TAP
+      def run_all
+        puts "TAP version 13"
+        count = proc { |acc,csuite| acc+csuite.tests.size+csuite.suites.inject(0, &count) }
+        puts "1..#{count[0, suite]}"
+        @current = 0
+        super
+      end
+
+      def run_test(assertion)
+        rv = super
+        printf "%sok %d - %s%s\n",
+          rv.status == :success ? '' : 'not ',
+          @current+=1,
+          rv.description,
+          rv.status == :success ? '' : " # #{rv.status}"
+      end
+    end
+  end
+
+  @format["test/run/tap"] = Run::TAP
+end

data/lib/test/run/xml.rb

@@ -0,0 +1,56 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module Test
+  class Run
+    module XML
+      def run_all
+        @depth = 1
+
+        puts '<?xml version="1.0" encoding="utf-8"?>'
+        puts '<tests>'
+        start  = Time.now
+        super
+        stop   = Time.now
+        status = case
+          when @count[:error]   > 0 then 'error'
+          when @count[:failure] > 0 then 'failure'
+          when @count[:pending] > 0 then 'incomplete'
+          when @count[:skipped] > 0 then 'incomplete'
+          else 'success'
+        end
+        puts %{</tests>}
+        puts %{<report>}
+        puts %{\t<duration>#{stop-start}</duration>}
+        @count.each { |key, value|
+          puts %{\t<count type="#{key}">#{value}</count>}
+        }
+        puts %{</report>}
+        puts %{<status>#{status}</status>}
+      end
+
+      def run_suite(suite)
+        puts %{#{"\t"*@depth}<suite description="#{suite.description}">}
+        @depth += 1
+        super
+        @depth -= 1
+        puts %{#{"\t"*@depth}</suite>}
+      end
+
+      def run_test(assertion)
+        rv = super
+        puts %{#{"\t"*@depth}<test>}
+        puts %{#{"\t"*@depth}\t<status>#{rv.status}</status>}
+        puts %{#{"\t"*@depth}\t<description>#{rv.description}</description>}
+        puts %{#{"\t"*@depth}</test>}
+      end
+    end
+  end
+
+  @format["test/run/xml"] = Run::XML
+end

data/lib/test/run.rb

@@ -0,0 +1,137 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module Test
+
+  # Run is the envorionment in which the suites and asserts are executed.
+  # Prior to the execution, the Run instance extends itself with the
+  # formatter given.
+  # Your formatter can override:
+  # * run_all
+  # * run_suite
+  # * run_test
+  class Run
+    # The toplevel suite.
+    attr_reader :suite
+
+    # The initialisation blocks of extenders
+    attr_reader :inits
+
+    # Some statistics, standard count keys are:
+    # * :test - the number of tests executed until now
+    # * :suite - the number of suites executed until now
+    # * :success - the number of tests with status :success
+    # * :failure - the number of tests with status :failure
+    # * :pending - the number of tests with status :pending
+    # * :skipped - the number of tests with status :skipped
+    # * :error - the number of tests with status :error
+    attr_reader :count
+
+    # Run the passed suite.
+    # Calls run_all with the toplevel suite as argument and a block that
+    # calls run_suite with the yielded argument (which should be the toplevel
+    # suite).
+    # Options accepted:
+    # * :extenders:   An Array of Modules, will be used as argument to self.extend, useful e.g. for
+    #                 mock integration
+    # * :format:      A string with the basename (without suffix) of the formatter to use - or a
+    #                 Module
+    # * :interactive: true/false, will switch this Test::Run instance into IRB mode, where an error
+    #                 will cause an irb session to be started in the context of a clean copy of
+    #                 the assertion with all setup callbacks invoked
+    #
+    # The order of extensions is:
+    # * :extender
+    # * :format (extends with the formatter module)
+    # * :interactive (extends with IRBMode)
+    def initialize(suite, opts=nil)
+      @suite       = suite
+      @inits       = []
+      @options     = opts || {}
+      @count       = @options[:count] || Hash.new(0)
+
+      (Test.extender+Array(@options[:extender])).each do |extender|
+        extend(extender)
+      end
+
+      # Extend with the output formatter
+      if format = @options[:format] then
+        require "test/run/#{format}" if String === format
+        extend(String === format ? Test.format["test/run/#{format}"] : format)
+      end
+
+      # Extend with irb dropout code
+      extend(Test::IRBMode) if @options[:interactive]
+
+      # Initialize extenders
+      @inits.each { |init| instance_eval(&init) }
+    end
+
+    # Hook initializers for extenders.
+    # Blocks passed to init will be instance_eval'd at the end of initialize.
+    # Example usage:
+    #   module ExtenderForRun
+    #     def self.extended(run_obj)
+    #        run_obj.init do
+    #          # do some initialization stuff for this module
+    #        end
+    #     end
+    #   end
+    def init(&block)
+      @inits << block
+    end
+
+    # Formatter callback.
+    # Invoked once at the beginning.
+    # Gets the toplevel suite as single argument.
+    def run_all
+      run_suite(@suite)
+    end
+
+    # Formatter callback.
+    # Invoked once for every suite.
+    # Gets the suite to run as single argument.
+    # Runs all assertions and nested suites.
+    def run_suite(suite)
+      suite.tests.each do |test|
+        run_test(test)
+      end
+      suite.suites.each do |suite|
+        run_suite(suite)
+      end
+      @count[:suite] += 1
+    end
+
+    # Formatter callback.
+    # Invoked once for every assertion.
+    # Gets the assertion to run as single argument.
+    def run_test(assertion)
+      rv = assertion.execute
+      @count[:test]            += 1
+      @count[assertion.status] += 1
+      rv
+    end
+
+    # Status over all tests ran up to now
+    # Can be :error, :failure, :incomplete or :success
+    # The algorithm is a simple fall through:
+    # if any test errored, then global_status is :error,
+    # if not, then if any test failed, global_status is :failure,
+    # if not, then if any test was pending or skipped, global_status is :incomplete,
+    # if not, then global_status is success
+    def global_status
+      case
+        when @count[:error]   > 0 then :error
+        when @count[:failure] > 0 then :failure
+        when @count[:pending] > 0 then :incomplete
+        when @count[:skipped] > 0 then :incomplete
+        else :success
+      end
+    end
+  end
+end

data/lib/test/suite.rb

@@ -0,0 +1,95 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module Test
+
+  # A Suite is a container for multiple assertions.
+  # You can give a suite a description, also a suite can contain
+  # setup and teardown blocks that are executed before (setup) and after
+  # (teardown) every assertion.
+  # Suites can also be nested. Nested suites will inherit setup and teardown.
+  class Suite
+
+    # Nested suites
+    attr_reader :suites
+
+    # All assertions in this suite
+    attr_reader :tests
+
+    # This suites description. Toplevel suites usually don't have a description.
+    attr_reader :description
+
+    # This suites direct parent. Nil if toplevel suite.
+    attr_reader :parent
+
+    # An Array containing the suite itself (first element), then its direct
+    # parent suite, then that suite's parent and so on
+    attr_reader :ancestors
+
+    def self.create(description=nil, parent=nil, opts={}, &block)
+      Array(opts[:requires]).each { |file| require file } if opts[:requires]
+    rescue LoadError
+      # A suite is skipped if requirements are not met
+      Skipped::Suite.new(description, parent, &block)
+    else
+      # All suites within Skipped::Suite are Skipped::Suite
+      (block ? self : Skipped::Suite).new(description, parent, &block)
+    end
+
+    def initialize(description=nil, parent=nil, &block)
+      @description = description
+      @parent      = parent
+      @suites      = []
+      @tests       = []
+      @setup       = []
+      @teardown    = []
+      @ancestors   = [self] + (@parent ? @parent.ancestors : [])
+      instance_eval(&block) if block
+    end
+
+    # Define a nested suite.
+    # Nested suites inherit setup & teardown methods.
+    # Also if an outer suite is skipped, all inner suites are skipped too.
+    # Valid values for opts:
+    # requires
+    # :   A list of files to require, if one of the requires fails, the suite
+    #     will be skipped. Accepts a String or an Array
+    def suite(description=nil, opts={}, &block)
+      @suites << self.class.create(description, self, opts, &block)
+    end
+
+    # All setups in the order of their nesting (outermost first, innermost last)
+    def ancestry_setup
+      ancestors.map { |suite| suite.setup }.flatten.reverse
+    end
+
+    # All teardowns in the order of their nesting (innermost first, outermost last)
+    def ancestry_teardown
+      ancestors.map { |suite| suite.teardown }.flatten
+    end
+
+    # Define a setup block for this suite. The block will be ran before every
+    # assertion once, even for nested suites.
+    def setup(&block)
+      block ? @setup << block : @setup
+    end
+
+    # Define a teardown block for this suite. The block will be ran after every
+    # assertion once, even for nested suites.
+    def teardown(&block)
+      block ? @teardown << block : @teardown
+    end
+
+    # Define an assertion. The block is supposed to return a trueish value
+    # (anything but nil or false).
+    # See Assertion for more info.
+    def assert(description=nil, &block)
+      @tests << Assertion.new(self, description, &block)
+    end
+  end
+end

data/lib/test/version.rb

@@ -0,0 +1,19 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module Test
+  module VERSION
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+
+    def self.to_s
+      "#{MAJOR}.#{MINOR||0}.#{TINY||0}"
+    end
+  end
+end

data/lib/test.rb

@@ -0,0 +1,118 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'test/irb_mode'
+require 'test/run'
+require 'test/suite'
+require 'test/assertion'
+# See bottom for more requires
+
+
+
+module Test
+  class <<self
+    # A hash of formatters (require-string => module) to be used with Test::Run.
+    attr_reader :format
+
+    # For mock integration and others, append modules that should extend the Test::Run instance.
+    attr_reader :extender
+
+    # The toplevel suite. That's the one run_if_mainfile and define add suites
+    # and assertions to.
+    attr_reader :toplevel_suite
+
+    # The full path to this file
+    attr_reader :required_file
+  end
+
+  # For bootstrapped selftest
+  def self.init
+    @format         = {}
+    @extender       = []
+    @toplevel_suite = Suite.new
+    @required_file  = ["", *$LOAD_PATH].map { |path|
+      File.expand_path(File.join(path, __FILE__))
+    }.find { |full| File.exist?(full) }
+  end
+  init
+
+  # Adds the contained assertions and suites to the toplevel suite
+  def self.define(name=nil, opts={}, &block)
+    if name then
+      @toplevel_suite.suite(name, opts, &block)
+    elsif opts && !opts.empty?
+      raise ArgumentError, "Suites with options must have names"
+    else
+      @toplevel_suite.instance_eval(&block)
+    end
+  end
+
+  # Creates a Test::Run instance, adds the assertions and suites defined in its
+  # own block to that Test::Run instance's toplevel suite and if $PROGRAM_NAME
+  # (aka $0) is equal to __FILE__ (means the current file is the file directly
+  # executed by ruby, and not just required/loaded/evaled by another file),
+  # subsequently also runs that suite.
+  def self.run_if_mainfile(name=nil, opts={}, &block)
+    define(name, opts, &block)
+    if caller.first[/^[^:]*/] == $0 then # if is mainfile
+      run(:format => ENV['FORMAT'], :interactive => ENV['INTERACTIVE'])
+    end
+  end
+
+  def self.run(opts=nil)
+    Run.new(@toplevel_suite, opts).run_all
+  end
+
+  # Skipped contains variants of Suite and Assertion.
+  # See Skipped::Suite and Skipped::Assertion
+  module Skipped
+    # Like Test::Suite, but all Assertions are defined as Skipped::Assertion
+    class Suite < ::Test::Suite
+      # :nodoc:
+      # All Assertions use Skipped::Assertion instead of Test::Assertion.
+      def assert(description=nil, &block)
+        @tests << Skipped::Assertion.new(self, description, &block)
+      end
+
+      # :nodoc:
+      # All setup blocks are disabled
+      def ancestry_setup
+        []
+      end
+
+      # :nodoc:
+      # All teardown blocks are disabled
+      def ancestry_teardown
+        []
+      end
+
+      # :nodoc:
+      # All setup blocks are disabled
+      def setup(&block)
+        []
+      end
+
+      # :nodoc:
+      # All teardown blocks are disabled
+      def teardown(&block)
+        []
+      end
+    end
+
+    # Like Test::Assertion, but fakes execution and sets status always to
+    # skipped.
+    class Assertion < ::Test::Assertion
+      def execute() @status = :skipped and self end
+    end
+  end
+end
+
+
+
+# At bottom due to dependencies
+require 'test/assertion/support' # Needs Test.extender to be defined

data/test/external/bootstraptest.rb

@@ -0,0 +1,5 @@
+Test.run_if_mainfile do
+  assert "Sample assert" do
+    true
+  end
+end

data/test/external/bootstrapwrap.rb

@@ -0,0 +1,2 @@
+require File.expand_path("#{__FILE__}/../bootstraptest.rb")
+puts "Done"