baretest 0.1.0 → 0.2.3

data/lib/baretest/run/xml.rb

@@ -0,0 +1,80 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module BareTest
+  class Run
+
+    # XML runner is invoked with `-f xml` or `--format xml`.
+    # This runner provides xml output as a simple machine readable format.
+    # The schema is relatively simple:
+    #   <tests>
+    #     <suite description="the suites description">
+    #       <test>
+    #         <file>the file the test was defined in</file>
+    #         <line>the line the assertion starts on</line>
+    #         <status>one of: success, pending, skipped, failure, error</status>
+    #         <description>the description of the test</test>
+    #       </test>
+    #       ...many tests and/or suites
+    #     </suite>
+    #   </tests>
+    #   <report>
+    #     <duration>the duration in seconds as a float</duration>
+    #     <count type="the counters name, see BareTest::Run#count">integer</count>
+    #     ...many counts
+    #   </report>
+    #   <status>The final status, one of: success, incomplete, failure, error</status>
+    #
+    module XML # :nodoc:
+      def run_all
+        @depth = 1
+
+        puts '<?xml version="1.0" encoding="utf-8"?>',
+             '<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>},
+             %{<report>},
+             %{\t<duration>#{stop-start}</duration>}
+        @count.each { |key, value|
+          puts %{\t<count type="#{key}">#{value}</count>}
+        }
+        puts %{</report>},
+             %{<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, setup)
+        rv = super
+        puts %{#{"\t"*@depth}<test>},
+             %{#{"\t"*@depth}\t<file>#{rv.file}</file>},
+             %{#{"\t"*@depth}\t<line>#{rv.line}</line>},
+             %{#{"\t"*@depth}\t<status>#{rv.status}</status>},
+             %{#{"\t"*@depth}\t<description>#{rv.description}</description>},
+             %{#{"\t"*@depth}</test>}
+      end
+    end
+  end
+
+  @format["baretest/run/xml"] = Run::XML
+end

data/lib/{test → baretest}/run.rb

@@ -6,15 +6,18 @@
 
 
 
-module Test
+module BareTest
 
-  # Run is the envorionment in which the suites and asserts are executed.
+  # Run is the environment 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
+  # :run_all::   Invoked once, before the first run_suite is ran. No arguments.
+  # :run_suite:: Invoked per suite. Takes the suite to run as argument.
+  # :run_test::  Invoked per assertion. Takes the assertion to execute as argument.
+  #
+  # Don't forget to call super within your overrides, or the tests won't be
+  # executed.
   class Run
     # The toplevel suite.
     attr_reader :suite
@@ -38,12 +41,12 @@ module Test
     # suite).
     # Options accepted:
     # * :extenders:   An Array of Modules, will be used as argument to self.extend, useful e.g. for
-    #                 mock integration
+    #   mock integration
     # * :format:      A string with the basename (without suffix) of the formatter to use - or a
-    #                 Module
+    #   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
+    #   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
@@ -55,18 +58,18 @@ module Test
       @options     = opts || {}
       @count       = @options[:count] || Hash.new(0)
 
-      (Test.extender+Array(@options[:extender])).each do |extender|
+      (BareTest.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)
+        require "baretest/run/#{format}" if String === format
+        extend(String === format ? BareTest.format["baretest/run/#{format}"] : format)
       end
 
       # Extend with irb dropout code
-      extend(Test::IRBMode) if @options[:interactive]
+      extend(BareTest::IRBMode) if @options[:interactive]
 
       # Initialize extenders
       @inits.each { |init| instance_eval(&init) }
@@ -98,19 +101,29 @@ module Test
     # 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)
+      suite.assertions.each do |test|
+        run_test_variants(test)
       end
-      suite.suites.each do |suite|
+      suite.suites.each do |(description, suite)|
         run_suite(suite)
       end
       @count[:suite] += 1
     end
 
-    # Formatter callback.
     # Invoked once for every assertion.
+    # Iterates over all variants of an assertion and invokes run_test
+    # for each.
+    def run_test_variants(test)
+      test.suite.each_component_variant do |setups|
+        run_test(test, setups)
+      end
+    end
+
+    # Formatter callback.
+    # Invoked once for every variation of an assertion.
     # Gets the assertion to run as single argument.
-    def run_test(assertion)
+    def run_test(assertion, setup)
+      assertion.setups = setup
       rv = assertion.execute
       @count[:test]            += 1
       @count[assertion.status] += 1

data/lib/baretest/setup.rb

@@ -0,0 +1,15 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module BareTest
+  Setup = Struct.new(:component, :substitute, :value, :block) do
+    def inspect
+      sprintf "#<Setup component=%s substitute=%p value=%p>", component, substitute, value
+    end
+  end
+end

data/lib/baretest/skipped/assertion.rb

@@ -0,0 +1,20 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module BareTest
+  module Skipped
+
+    # Like Test::Assertion, but fakes execution and sets status always to
+    # skipped.
+    class Assertion < ::BareTest::Assertion
+      def execute(setup=nil) # :nodoc:
+        @status = :skipped and self
+      end
+    end
+  end
+end

data/lib/baretest/skipped/suite.rb

@@ -0,0 +1,49 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'baretest/skipped/assertion'
+
+
+
+module BareTest
+
+  module Skipped
+
+    # Like Test::Suite, but all Assertions are defined as Skipped::Assertion
+    class Suite < ::BareTest::Suite
+      def self.create(description=nil, parent=nil, opts={}, &block) # :nodoc:
+        new(description, parent, &block) # Skipped::Suite always
+      end
+
+      # All Assertions use Skipped::Assertion instead of Test::Assertion.
+      def assert(description=nil, &block) # :nodoc:
+        @skipped << Skipped::Assertion.new(self, description, &block)
+      end
+
+      # All setup blocks are disabled
+      def ancestry_setup # :nodoc:
+        []
+      end
+
+      # All teardown blocks are disabled
+      def ancestry_teardown # :nodoc:
+        []
+      end
+
+      # All setup blocks are disabled
+      def setup(&block) # :nodoc:
+        []
+      end
+
+      # All teardown blocks are disabled
+      def teardown(&block) # :nodoc:
+        []
+      end
+    end
+  end
+end

data/lib/baretest/skipped.rb

@@ -0,0 +1,15 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module BareTest
+
+  # Skipped contains variants of Suite and Assertion.
+  # See Skipped::Suite and Skipped::Assertion
+  module Skipped
+  end
+end

data/lib/baretest/suite.rb

@@ -0,0 +1,234 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'baretest/setup'
+
+
+
+module BareTest
+
+  # 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, in the order of definition
+    attr_reader :suites
+
+    # All assertions in this suite
+    attr_reader :assertions
+
+    # All skipped assertions in this suite
+    attr_reader :skipped
+
+    # 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
+
+    # Create a new suite.
+    #
+    # The arguments 'description', 'parent' and '&block' are the same as on Suite::new,
+    # 'opts' is an additional options hash.
+    #
+    # Keys the options hash accepts:
+    # :requires:: A string or array of strings with requires that have to be done in order to run
+    #             this suite. If a require fails, the suite is created as a Skipped::Suite instead.
+    #
+    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
+
+    # Create a new suite.
+    #
+    # Arguments:
+    # description:: A string with a human readable description of this suite, preferably
+    #               less than 60 characters and without newlines
+    # parent::      The suite that nests this suite. Ancestry plays a role in execution of setup
+    #               and teardown blocks (all ancestors setups and teardowns are executed too).
+    # &block::      The given block is instance evaled.
+    def initialize(description=nil, parent=nil, &block)
+      @description = description
+      @parent      = parent
+      @suites      = [] # [["description", subsuite, skipped], ["description2", ...], ...] - see Array#assoc
+      @assertions  = []
+      @skipped     = []
+      @setup       = {nil => []}
+      @components  = []
+      @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)
+      suite = self.class.create(description, self, opts, &block)
+      if append_to = @suites.assoc(description) then
+        append_to.last.update(suite)
+      else
+        @suites << [description, suite]
+      end
+      suite
+    end
+
+    # Performs a recursive merge with the given suite.
+    #
+    # Used to merge suites with the same description.
+    def update(with_suite)
+      if ::BareTest::Skipped::Suite === with_suite then
+        @skipped.concat(with_suite.skipped)
+      else
+        @assertions.concat(with_suite.assertions)
+        @setup.update(with_suite.setup) do |k,v1,v2| v1+v2 end
+        @teardown.concat(with_suite.teardown)
+        with_suite.suites.each { |description, suite|
+          if append_to = @suites.assoc(description) then
+            append_to.last.update(suite)
+          else
+            @suites << [description, suite]
+          end
+        }
+      end
+      self
+    end
+
+    # All setups in the order of their definition and nesting (outermost first,
+    # innermost last)
+    def ancestry_setup
+      @parent ? @parent.ancestry_setup.merge(@setup) { |k,v1,v2|
+        v1+v2
+      } : @setup
+    end
+
+    # All setup-components in the order of their definition and nesting
+    # (outermost first, innermost last)
+    def ancestry_components
+      @parent ? @parent.ancestry_components|@components : @components
+    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(component=nil, multiplexed=nil, &block)
+      if component.nil? && block then
+        @setup[nil] << ::BareTest::Setup.new(nil, nil, nil, block)
+      elsif block then
+        @components << component unless @setup.has_key?(component)
+        @setup[component] ||= []
+
+        case multiplexed
+          when String
+            @setup[component] << ::BareTest::Setup.new(component, multiplexed, nil, block)
+          when Array
+            multiplexed.each do |substitute|
+              @setup[component] << BareTest::Setup.new(component, substitute.to_s, substitute, block)
+            end
+          when Hash
+            multiplexed.each do |substitute, value|
+              @setup[component] << BareTest::Setup.new(component, substitute, value, block)
+            end
+        end
+      elsif component || multiplexed
+        raise ArgumentError, "With component or multiplexed given, a block must be provided too."
+      end
+
+      @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
+
+    def each_component_variant
+      setups     = ancestry_setup
+      components = ancestry_components
+      base       = setups[nil]
+
+      if components.empty?
+        yield(base)
+      else
+        setup_in_order = setups.values_at(*components)
+        maximums       = setup_in_order.map { |i| i.size }
+        iterations     = maximums.inject { |r,f| r*f } || 0
+
+        iterations.times do |i|
+          process = maximums.map { |e| i,e=i.divmod(e); e }
+          yield base+setup_in_order.zip(process).map { |variants, current|
+            variants[current]
+          }
+        end
+      end
+
+      self
+    end
+
+    def first_component_variant
+      setups, *comps = ancestry_setup.values_at(nil, *ancestry_components)
+      setups = setups+comps.map { |comp| comp.first }
+      yield(setups) if block_given?
+
+      setups
+    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)
+      assertion = Assertion.new(self, description, &block)
+      if match = caller.first.match(/^(.*):(\d+)(?::.+)?$/) then
+        file, line = match.captures
+        file = File.expand_path(file)
+        if File.exist?(file) then
+          assertion.file = file
+          assertion.line = line.to_i
+        end
+      end
+      @assertions << assertion
+    end
+
+    def to_s #:nodoc:
+      sprintf "%s %s", self.class, @description
+    end
+
+    def inspect #:nodoc:
+      sprintf "#<%s:%08x %p>", self.class, object_id>>1, @description
+    end
+  end
+end
+
+
+
+require 'baretest/skipped/suite' # TODO: determine why this require is on the bottom and document it.

data/lib/baretest/utilities.rb

@@ -0,0 +1,43 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module Kernel
+  # All extensions Kernel#require_path and Kernel#expanded_require_path will try
+  # for a given filename
+  RequireExtensions = %w[.rb .so .dll .bundle .dylib]
+
+  # Returns the path to the file require would load, also see Kernel#expanded_require_path
+  def require_path(name, extensions=nil)
+    extensions = (extensions || ::Kernel::RequireExtensions).join(',')
+    Dir.glob("{#{$LOAD_PATH.join(',')}}/#{name}{#{extensions}}") { |path|
+      return path
+    }
+    nil
+  end
+
+  # Returns the absolute path to the file require would load, also see Kernel#require_path
+  def expanded_require_path(name, extensions=nil)
+    path = require_path(name, extensions)
+    path && File.expand_path(path)
+  end
+
+  # Will load the given file like load (but accepts files without .rb in the end, like require),
+  # but evaluate it into the module given with the second arg (defaulting to Module.new).
+  # It uses Kernel#expanded_require_path with '' and '.rb' as extensions to determine the file to
+  # load uses the returned path for error messages (second argument to Module#modul_eval).
+  def load_into(name, mod=nil)
+    mod ||= Module.new
+    path  = expanded_require_path(name, ['', '.rb'])
+    raise LoadError, "No such file to load -- #{name}" unless path
+    mod.module_eval(File.read(path), path)
+
+    mod
+  end
+
+  module_function :require_path, :expanded_require_path, :load_into
+end

data/lib/{test → baretest}/version.rb

@@ -6,12 +6,21 @@
 
 
 
-module Test
+module BareTest
+
+  # The version of the baretest library
   module VERSION
+
+    # The major version number
     MAJOR = 0
-    MINOR = 1
-    TINY  = 0
 
+    # The minor version number
+    MINOR = 2
+
+    # The tiny version number
+    TINY  = 3
+
+    # The version as a string
     def self.to_s
       "#{MAJOR}.#{MINOR||0}.#{TINY||0}"
     end

data/lib/baretest.rb

@@ -0,0 +1,112 @@
+#--
+# Copyright 2009 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'baretest/assertion'
+require 'baretest/irb_mode'
+require 'baretest/run'
+require 'baretest/suite'
+require 'baretest/utilities'
+require 'baretest/version'
+# See bottom for more requires
+
+
+
+module BareTest
+  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
+    # Needed to test baretest itself using baretest
+    attr_reader :required_file # :nodoc:
+  end
+
+  # Loads all files in a test directory in order to load the suites and
+  # assertions. Used by the 'baretest' executable and the standard rake task.
+  #
+  # Options:
+  # :verbose::    Will print information about the load process (default: false)
+  # :setup_path:: The path to the setup file, the first loaded file (default: 'test/setup.rb')
+  # :chdir::      The directory this routine chdirs before loading, will jump back to the original
+  #               directory after loading (default: '.')
+  def self.load_standard_test_files(opts={})
+    verbose    = opts.delete(:verbose)
+    setup_path = opts.delete(:setup_path) || 'test/setup.rb'
+    chdir      = opts.delete(:chdir) || '.'
+    Dir.chdir(chdir) do
+      load(setup_path) if File.exist?(setup_path)
+      Dir.glob('test/{suite,unit,integration,system}/**/*.rb') { |path|
+        helper_path = path.sub(%r{^test/(suite|unit|integration|system)/}, 'test/helper/\1/')
+        puts(File.exist?(helper_path) ? "Loading helper file #{helper_path}" : "No helper file #{helper_path} to load") if verbose
+        load(helper_path) if File.exist?(helper_path)
+        puts "Loading test file #{path}" if verbose
+        load(path)
+      }
+    end
+  end
+
+  # Initializes BareTest, is automatically called
+  #
+  # Needed for bootstrapped selftest
+  def self.init # :nodoc:
+    @format         = {}
+    @extender       = []
+    @toplevel_suite = BareTest::Suite.new
+    @required_file  = ["", *$LOAD_PATH].map { |path|
+      File.expand_path(File.join(path, __FILE__))
+    }.find { |full| File.exist?(full) }
+  end
+  init
+
+  # If no description was given, it adds the contained assertions and suites to the toplevel suite,
+  # if a description was given, a suite with the given description is created, added to the toplevel
+  # suite, and all the contained assertions and suites are added to the created suite.
+  def self.suite(description=nil, opts={}, &block)
+    if description then
+      @toplevel_suite.suite(description, 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(description=nil, opts={}, &block)
+    suite(description, opts, &block)
+    if caller.first[/^[^:]*/] == $0 then # if is mainfile
+      run(:format => ENV['FORMAT'], :interactive => ENV['INTERACTIVE'])
+    end
+  end
+
+  # Runs the toplevel suite (which usually contains all suites and assertions
+  # defined in all loaded test files).
+  #
+  # Returns the Run instance.
+  def self.run(opts=nil)
+    runner = BareTest::Run.new(@toplevel_suite, opts)
+    runner.run_all
+    runner
+  end
+end
+
+
+
+# At bottom due to dependencies
+require 'baretest/assertion/support' # Needs Test.extender to be defined