baretest 0.2.4 → 0.4.0.pre1

data/lib/baretest/run.rb

@@ -6,15 +6,24 @@
 
 
 
+require 'baretest/persistence'
+
+
+
 module BareTest
 
-  # Run is the environment in which the suites and asserts are executed.
+  # Run is the environment in which the suites and assertions are executed.
   # Prior to the execution, the Run instance extends itself with the
-  # formatter given.
+  # formatter that should be used and other runner related toolsets.
   # Your formatter can override:
-  # :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.
+  # :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_variants::  Invoked per assertion. Takes the assertion to execute
+  #                       as argument.
+  # :run_test::           Invoked per setup variation of each assertion. Takes
+  #                       the assertion to execute and the setup blocks to use
+  #                       as arguments.
   #
   # Don't forget to call super within your overrides, or the tests won't be
   # executed.
@@ -26,13 +35,10 @@ module BareTest
     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
+    # :test::    the number of tests executed until now
+    # :suite::   the number of suites executed until now
+    # <status>:: the number of tests with that status (see
+    #            BareTest::StatusOrder for a list of states)
     attr_reader :count
 
     # Run the passed suite.
@@ -53,19 +59,42 @@ module BareTest
     # * :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)
+      @suite           = suite
+      @inits           = []
+      @options         = opts || {}
+      @count           = @options[:count] || Hash.new(0)
+      @provided        = [] # Array's set operations are the fastest
+      @include_tags    = @options[:include_tags]   # nil is ok here
+      @exclude_tags    = @options[:exclude_tags]   # nil is ok here
+      include_states   = @options[:include_states] # nil is ok here
+      exclude_states   = @options[:exclude_states] # nil is ok here
+      @states          = [nil, :success, :failure, :skipped, :pending, :error]
+      @skipped         = {}
+      @last_run_states = {}
+
+      @persistence    = @options[:persistence]
+
+      if (include_states || exclude_states) && !((include_states && include_states.empty?) && (exclude_states && exclude_states.empty?)) then
+        [include_states, exclude_states].compact.each do |states|
+          states << nil if states.include?(:new)
+          states << :pending if states.include?(:skipped)
+          states.concat([:error, :skipped, :pending]) if states.include?(:failure)
+          states.delete(:new)
+        end
+        @states = (include_states || @states) - (exclude_states || [])
+      end
 
       (BareTest.extender+Array(@options[:extender])).each do |extender|
         extend(extender)
       end
 
       # Extend with the output formatter
-      if format = @options[:format] then
-        require "baretest/run/#{format}" if String === format
-        extend(String === format ? BareTest.format["baretest/run/#{format}"] : format)
+      format = @options[:format]
+      if format.is_a?(String) then
+        require "baretest/run/#{format}"
+        extend(BareTest.format["baretest/run/#{format}"])
+      elsif format.is_a?(Module) then
+        extend(format)
       end
 
       # Extend with irb dropout code
@@ -93,7 +122,10 @@ module BareTest
     # Invoked once at the beginning.
     # Gets the toplevel suite as single argument.
     def run_all
+      @last_run_states = @persistence ? @persistence.read('final_states', {}) : {}
+      @skipped         = {}
       run_suite(@suite)
+      @persistence.store('final_states', @last_run_states) if @persistence
     end
 
     # Formatter callback.
@@ -101,35 +133,97 @@ module BareTest
     # Gets the suite to run as single argument.
     # Runs all assertions and nested suites.
     def run_suite(suite)
-      suite.assertions.each do |test|
-        run_test_variants(test)
+      missing_tags     = @include_tags && @include_tags - suite.tags
+      superfluous_tags = @exclude_tags && suite.tags & @exclude_tags
+      ignored          = (missing_tags && !missing_tags.empty?) || (superfluous_tags && !superfluous_tags.empty?)
+
+      unless ignored then
+        unmet_dependencies  = (suite.depends_on-@provided)
+        manually_skipped    = suite.skipped?
+        recursively_skipped = !unmet_dependencies.empty? || manually_skipped
+        skipped             = @skipped[suite] || recursively_skipped
+
+        if recursively_skipped then
+          skip_recursively(suite, "Skipped")
+        elsif skipped then
+          skip_suite(suite, "Skipped")
+        end
       end
-      suite.suites.each do |(description, suite)|
-        run_suite(suite)
+
+      if ignored then
+        states = []
+      else
+        states = suite.assertions.map do |test|
+          run_test_variants(test)
+        end
       end
+      states.concat(suite.suites.map { |(description, subsuite)|
+        run_suite(subsuite)
+      })
       @count[:suite] += 1
+
+      # || in case the suite contains no tests or suites
+      final_status = BareTest.most_important_status(states) || :pending
+
+      @provided |= suite.provides if final_status == :success
+
+      Status.new(suite, final_status)
     end
 
     # 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)
+    def run_test_variants(assertion)
+      ignored = !@states.include?(@last_run_states[assertion.id])
+      skipped = @skipped[assertion] || assertion.skipped?
+
+      if ignored then
+        overall_status = nil
+      elsif skipped then
+        Array.new(assertion.suite.component_variant_count) { run_test(assertion, []) }
+        @last_run_states[assertion.id] = :manually_skipped
+        overall_status                 = :manually_skipped
+      else
+        states = []
+        assertion.suite.each_component_variant do |setups|
+          rv = run_test(assertion, setups)
+          states << rv.status
+        end
+        overall_status                 = BareTest.most_important_status(states)
       end
+      @last_run_states[assertion.id] = overall_status if overall_status
+
+      overall_status
     end
 
     # Formatter callback.
     # Invoked once for every variation of an assertion.
     # Gets the assertion to run as single argument.
     def run_test(assertion, setup)
-      assertion.setups = setup
-      rv = assertion.execute
-      @count[:test]            += 1
-      @count[assertion.status] += 1
+      rv = assertion.execute(setup.map { |s| s.block }, assertion.suite.ancestry_teardown)
+      @count[:test]     += 1
+      @count[rv.status] += 1
+
       rv
     end
 
+    # Marks all assertion within this suite as skipped and the suite itself too.
+    def skip_suite(suite, reason) # :nodoc:
+      suite.skip(reason)
+      reason = suite.reason
+      suite.assertions.each do |test|
+        test.skip(reason)
+      end
+    end
+
+    # Marks all tests, suites and their subsuites within this suite as skipped.
+    def skip_recursively(suite, reason) # :nodoc:
+      skip_suite(suite, reason)
+      suite.suites.each do |description, subsuite|
+        skip_recursively(subsuite, reason)
+      end
+    end
+
     # Status over all tests ran up to now
     # Can be :error, :failure, :incomplete or :success
     # The algorithm is a simple fall through:
@@ -138,13 +232,20 @@ module BareTest
     # 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
+      status_counts         = @count.values_at(*BareTest::StatusOrder)
+      most_important_status = BareTest::StatusOrder.zip(status_counts) { |status, count|
+        break status if count > 0
+      } || :success
+    end
+
+    # Get an assertions' interpolated description for a given Array of Setup
+    # instances.
+    # See Assertion#interpolated_description
+    def interpolated_description(assertion, setup)
+      setups = setups ? setups.select { |s| s.component } : []
+      substitutes = {}
+      setups.each do |setup| substitutes[setup.component] = setup.substitute end
+      assertion.interpolated_description(substitutes)
     end
   end
 end

data/lib/baretest/run/cli.rb

@@ -15,14 +15,57 @@ module BareTest
     # It prints colored output (requires ANSI colors compatible terminal).
     #
     module CLI # :nodoc:
+      extend Formatter
+
+      option_defaults :color   => true,
+                      :profile => false
+
+      text "Options for 'CLI' formatter:\n"
+
+      option          :color,   '-c', '--[no-]color',   :Boolean, 'Enable/disable output coloring'
+      option          :profile, '-p', '--[no-]profile', :Boolean, 'Enable/disable profiling assertions'
+
+      text "\nEnvironment variables for 'CLI' formatter:\n"
+
+      env_option      :color,   'COLOR'
+      env_option      :profile, 'PROFILE'
+
       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...
+        :pending            => "\e[43m%9s\e[0m  %s%s\n",
+        :manually_skipped   => "\e[43m%9s\e[0m  %s%s\n",
+        :dependency_missing => "\e[43m%9s\e[0m  %s%s\n",
+        :library_missing    => "\e[43m%9s\e[0m  %s%s\n",
+        :component_missing  => "\e[43m%9s\e[0m  %s%s\n",
+        :ignored            => "\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...
+      }
+      StatusLabel = {
+        :pending            => " Pending ",
+        :manually_skipped   => " Skipped ",
+        :dependency_missing => " Skipped ",
+        :library_missing    => " Skipped ",
+        :component_missing  => " Skipped ",
+        :ignored            => " Skipped ",
+        :skipped            => " Skipped ",
+        :success            => " Success ",
+        :failure            => " Failure ",
+        :error              => "  Error  ",
+      }
+      Map = {
+        :pending            => :incomplete,
+        :manually_skipped   => :incomplete,
+        :dependency_missing => :incomplete,
+        :library_missing    => :incomplete,
+        :component_missing  => :incomplete,
+        :ignored            => :incomplete,
+        :skipped            => :incomplete,
+        :success            => :success,
+        :failure            => :failure,
+        :error              => :error,
       }
-
       FooterFormats = {
         :incomplete => "\e[43m%9s\e[0m\n",
         :success    => "\e[42m%9s\e[0m\n",
@@ -31,61 +74,63 @@ module BareTest
       }
 
       def run_all(*args)
-        @depth = 0
         puts "Running all tests#{' verbosly' if $VERBOSE}"
-        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)
+
+        @depth    = 0
+        @deferred = []
+        start     = Time.now
+        rv        = super # run all suites
+        duration  = Time.now-start
+        status    = global_status
+        test, success, pending, manually_skipped, dependency_missing,
+          library_missing, component_missing, ignored, skipped, failure, error =
+          *@count.values_at(:test, :success, :pending, :manually_skipped,
+                            :dependency_missing, :library_missing,
+                            :component_missing, :ignored, :skipped, :failure,
+                            :error)
+
+        printf "\n%2$d tests run in %1$.1fs\n%3$d successful, %4$d pending, %5$d skipped, %6$d failures, %7$d errors\n",
+          duration, test, success, pending, (skipped+manually_skipped+
+          dependency_missing+library_missing+component_missing), failure, error
         print "Final status: "
-        printf FooterFormats[status], status_label(status)
+        printf FooterFormats[Map[status]], StatusLabel[status]
+
+        rv
       end
 
       def run_suite(suite)
         return super unless suite.description
-        skipped = suite.skipped.size
         case size = suite.assertions.size
           when 0
-            if skipped.zero? then
-              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m"
-            else
-              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (#{skipped} skipped)"
-            end
+            defer "\n           \e[1m#{'  '*@depth+suite.description}\e[0m"
           when 1
-            if skipped.zero? then
-              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (1 test)"
-            else
-              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (1 test/#{skipped} skipped)"
-            end
+            defer "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (1 test)"
           else
-            if skipped.zero? then
-              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (#{size} tests)"
-            else
-              puts "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (#{size} tests/#{skipped} skipped)"
-            end
+            defer "\n           \e[1m#{'  '*@depth+suite.description}\e[0m (#{size} tests)"
         end
         @depth += 1
-        super(suite) # run the suite
+        rv = super(suite) # run the suite
+        pop_deferred
         @depth -= 1
+
+        rv
       end
 
       def run_test(assertion, setup)
-        rv               = super # run the assertion
-        indent           = '           '+'  '*@depth
-        message          = []
-        deeper           = []
+        clear_deferred
+        rv        = super # run the assertion
+        indent    = '           '+'  '*@depth
+        backtrace = []
+        reason    = rv.reason(:indent => indent)
 
-        printf(Formats[rv.status], status_label(rv.status), '  '*@depth, rv.interpolated_description)
+        printf(Formats[rv.status], StatusLabel[rv.status], '  '*@depth, interpolated_description(assertion, setup))
         if rv.status == :error then
-          message = (rv.exception.message || "no error message given").split("\n")
-          deeper  = $VERBOSE ? rv.exception.backtrace : rv.exception.backtrace.first(1)
+          backtrace = $VERBOSE ? rv.exception.backtrace : rv.exception.backtrace.first(1)
         elsif rv.status == :failure
-          message = (rv.reason || "no failure reason given").split("\n")
-          deeper  = ["#{rv.file}:#{rv.line}"]
+          backtrace = ["#{assertion.file}:#{assertion.line}"]
         end
-        message.each do |line| print(indent, line, "\n") end
-        deeper.each do |line| print(indent, '  ', line, "\n") end
+        puts reason if reason
+        backtrace.each do |line| print(indent, '  ', line, "\n") end
 
         rv
       end
@@ -94,8 +139,17 @@ module BareTest
         str.scan(/[^ ]+ /)
       end
 
-      def status_label(status)
-        status.to_s.capitalize.center(9)
+      def defer(output)
+        @deferred << output
+      end
+
+      def pop_deferred
+        @deferred.pop
+      end
+
+      def clear_deferred
+        puts *@deferred unless @deferred.empty?
+        @deferred.clear
       end
     end
   end

data/lib/baretest/run/minimal.rb

@@ -18,11 +18,12 @@ module BareTest
         start  = Time.now
         super              # run all suites
         stop   = Time.now
-        values = @count.values_at(:test, :success, :pending, :failure, :error)
+        values = @count.values_at(:test, :success, :pending, :skipped, :failure, :error)
         values.push(stop-start, global_status)
         printf "Tests:    %d\n" \
                "Success:  %d\n" \
                "Pending:  %d\n" \
+               "Skipped:  %d\n" \
                "Failures: %d\n" \
                "Errors:   %d\n" \
                "Time:     %f\n" \

data/lib/baretest/run/none.rb

@@ -0,0 +1,21 @@
+#--
+# Copyright 2009-2010 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module BareTest
+  class Run
+
+    # None runner is invoked with `-f none` or `--format none`.
+    # This runner produces NO output at all. You can use it if you're only
+    # interested in baretests exit status.
+    #
+    module None # :nodoc:
+    end
+  end
+
+  @format["baretest/run/none"] = Run::None # register the extender
+end