turn 0.8.2 → 0.8.3

data/lib/turn/autorun/minitest0.rb

@@ -0,0 +1,163 @@
+require 'minitest/unit'
+require 'minitest/spec'
+#require 'rubygems'
+require 'turn/colorize'
+
+class MiniTest::Unit
+  PADDING_SIZE = 4
+  
+  @@use_natural_language_case_names = false
+  def self.use_natural_language_case_names=(boolean)
+    @use_natural_language_case_names = boolean
+  end
+  
+  def self.use_natural_language_case_names?
+    @use_natural_language_case_names
+  end
+  
+
+  def run(args = [])
+    @verbose = true
+    options = args.getopts("n:t", "name:", "trace")
+    filter = if name = options["n"] || options["name"]
+               if name =~ /\/(.*)\//
+                 Regexp.new($1)
+               elsif MiniTest::Unit.use_natural_language_case_names?
+                 # Turn 'sample error1' into 'test_sample_error1'
+                 name[0..4] == "test_" ? name.gsub(" ", "_") : "test_" + name.gsub(" ", "_")
+               else
+                 name
+               end
+             else
+               /./ # anything - ^test_ already filtered by #tests
+             end
+
+    @trace = options['t'] || options['trace']
+
+    @@out.puts "Loaded suite #{$0.sub(/\.rb$/, '')}\nStarted"
+
+    start = Time.now
+    run_test_suites filter
+
+    @@out.puts
+    @@out.puts "Finished in #{'%.6f' % (Time.now - start)} seconds."
+
+    @@out.puts
+
+    @@out.print "%d tests, " % test_count
+    @@out.print "%d assertions, " % assertion_count
+    @@out.print Turn::Colorize.fail("%d failures, " % failures)
+    @@out.print Turn::Colorize.error("%d errors, " % errors)
+    @@out.puts Turn::Colorize.skip("%d skips" % skips)
+
+    return failures + errors if @test_count > 0 # or return nil...
+  end
+
+  # Overwrite #run_test_suites so that it prints out reports
+  # as errors are generated.
+  def run_test_suites(filter = /./)
+    @test_count, @assertion_count = 0, 0
+    old_sync, @@out.sync = @@out.sync, true if @@out.respond_to? :sync=
+    TestCase.test_suites.each do |suite|
+      test_cases = suite.test_methods.grep(filter)
+      if test_cases.size > 0
+        @@out.print "\n#{suite}:\n"
+      end
+
+      test_cases.each do |test|
+        inst = suite.new test
+        inst._assertions = 0
+
+        t = Time.now
+
+        @broken = nil
+
+        @@out.print(case run_testcase(inst, self)
+                    when :pass
+                      @broken = false
+                      Turn::Colorize.pass(pad_with_size "PASS")
+                    when :error
+                      @broken = true
+                      Turn::Colorize.error(pad_with_size "ERROR")
+                    when :fail
+                      @broken = true
+                      Turn::Colorize.fail(pad_with_size "FAIL")
+                    when :skip
+                      @broken = false
+                      Turn::Colorize.skip(pad_with_size "SKIP")
+                    end)
+
+
+        @@out.print MiniTest::Unit.use_natural_language_case_names? ? 
+          " #{test.gsub("test_", "").gsub(/_/, " ")}" : " #{test}"
+        @@out.print " (%.2fs) " % (Time.now - t)
+
+        if @broken
+          @@out.puts
+
+          report = @report.last
+          @@out.puts pad(report[:message], 10)
+
+          trace = MiniTest::filter_backtrace(report[:exception].backtrace)
+          if @trace
+            @@out.print trace.map{|t| pad(t, 10) }.join("\n")
+          else
+            @@out.print pad(trace.first, 10)
+          end
+
+          @@out.puts
+        end
+
+        @@out.puts
+        @test_count += 1
+        @assertion_count += inst._assertions
+      end
+    end
+    @@out.sync = old_sync if @@out.respond_to? :sync=
+    [@test_count, @assertion_count]
+  end
+
+  def pad(str, size=PADDING_SIZE)
+    " " * size + str
+  end
+
+  def pad_with_size(str)
+    pad("%5s" % str)
+  end
+
+  # Overwrite #puke method so that is stores a hash
+  # with :message and :exception keys.
+  def puke(klass, meth, e)
+    result = nil
+    msg = case e
+        when MiniTest::Skip
+          @skips += 1
+          result = :skip
+          e.message
+        when MiniTest::Assertion
+          @failures += 1
+          result = :fail
+          e.message
+        else
+          @errors += 1
+          result = :error
+          "#{e.class}: #{e.message}\n"
+        end
+
+    @report << {:message => msg, :exception => e}
+    result
+  end
+
+private
+  # A wrapper over MiniTest::Unit::TestCase.run() that returns
+  # :pass whenever the test succeeds (i.e. run() returns "" or ".")
+  def run_testcase(testcase, runner)
+    original_result = testcase.run(runner)
+    if original_result == "" || original_result == "."
+        :pass
+    else
+        original_result
+    end
+  end
+end
+

data/lib/turn/autorun/testunit.rb

@@ -1,116 +1,9 @@
-require 'test/unit/ui/console/testrunner'
+#require 'test/unit/ui/console/testrunner'
+require 'turn/autoload'
 require 'turn/colorize'
+require 'turn/controller'
+require 'turn/runners/testrunner'
 
-module ::Test::Unit
-module UI
-module Console
-  class TestRunner
-    include Turn::Colorize
-
-    # 1.x of test/unut used @io, where as 2.x uses @output.
-    def turn_out
-      @turn_out ||= (@io || @output)
-    end
-
-    alias :t_attach_to_mediator :attach_to_mediator
-    def attach_to_mediator
-      @mediator.add_listener(TestRunnerMediator::STARTED, &method(:t_started))
-      @mediator.add_listener(TestRunnerMediator::FINISHED, &method(:t_finished))
-      @mediator.add_listener(TestCase::STARTED, &method(:t_test_started))
-      @mediator.add_listener(TestCase::FINISHED, &method(:t_test_finished))
-      @mediator.add_listener(TestResult::FAULT, &method(:t_fault))
-      turn_out.sync = true
-      @t_cur_file, @t_fault = nil
-    end
-
-    def t_started( result )
-      @t_result = result
-    end
-
-    def t_finished( elapsed_time )
-      failure = @t_result.failure_count
-      error   = @t_result.error_count
-      total   = @t_result.run_count
-      pass = total - failure - error
-
-      bar = '=' * 78
-      if COLORIZE
-        bar = if pass == total then ::ANSI::Code.green{bar}
-              else ::ANSI::Code.red{bar} end
-      end
-
-      turn_out.puts bar
-      turn_out.puts "  pass: %d,  fail: %d,  error: %d" % [pass, failure, error]
-      turn_out.puts "  total: %d tests with %d assertions in #{elapsed_time} seconds" % [total, @t_result.assertion_count]
-      turn_out.puts bar
-    end
-
-    def t_test_started( name )
-      method, file = name.scan(%r/^([^\(]+)\(([^\)]+)\)/o).flatten!
-      if @t_cur_file != file
-        @t_cur_file = file
-        file = COLORIZE ? ::ANSI::Code.yellow{file} : file
-        turn_out.puts file
-      end
-      turn_out.print "    %-69s" % method
-    end
-
-    def t_test_finished( name )
-      turn_out.puts " #{PASS}" unless @t_fault
-      @t_fault = false
-    end
-
-    def t_fault( fault )
-      @t_fault = true
-      msg = "\t"
-
-      case fault
-      when ::Test::Unit::Error
-        turn_out.puts ERROR
-        msg << fault.to_s.split("\n")[2..-1].join("\n\t")
-      when ::Test::Unit::Failure
-        test_name =  underscore(fault.test_name.match(/\((.*)\)/)[1])
-        better_location = fault.location.detect{|line|line.include?(test_name)} || fault.location[0]
-        turn_out.puts " #{FAIL}"
-        msg << better_location.to_s << "\n\t"
-        msg << fault.message.gsub("\n","\n\t")
-      end
-
-      msg = ::ANSI::Code.magenta{msg} if COLORIZE
-      turn_out.puts msg
-    end
-
-    private
-
-    # Taken from ActiveSupport::Inflector
-    def underscore(camel_cased_word)
-      word = camel_cased_word.to_s.dup
-      word.gsub!(/::/, '/')
-      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
-      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-      word.tr!("-", "_")
-      word.downcase!
-      word
-    end
-
-    def setup_mediator
-       @mediator = create_mediator(@suite)
-       suite_name = @suite.to_s
-       if ( @suite.kind_of?(Module) )
-         suite_name = @suite.name
-       end
-       msg = rails? ? "\n" : "Loaded suite #{suite_name}" #always same in rails so scrap it
-       output(msg)
-    end
-
-    def rails?
-      $:.to_s.include? "rails"
-    end
-
-
-  end
-end
+Test::Unit::AutoRunner::RUNNERS[:console] = proc do |r|
+  Turn::TestRunner
 end
-end
-
-# EOF

data/lib/turn/autorun/testunit0.rb

@@ -0,0 +1,116 @@
+require 'test/unit/ui/console/testrunner'
+require 'turn/colorize'
+
+module ::Test::Unit
+module UI
+module Console
+  class TestRunner
+    include Turn::Colorize
+
+    # 1.x of test/unut used @io, where as 2.x uses @output.
+    def turn_out
+      @turn_out ||= (@io || @output)
+    end
+
+    alias :t_attach_to_mediator :attach_to_mediator
+    def attach_to_mediator
+      @mediator.add_listener(TestRunnerMediator::STARTED, &method(:t_started))
+      @mediator.add_listener(TestRunnerMediator::FINISHED, &method(:t_finished))
+      @mediator.add_listener(TestCase::STARTED, &method(:t_test_started))
+      @mediator.add_listener(TestCase::FINISHED, &method(:t_test_finished))
+      @mediator.add_listener(TestResult::FAULT, &method(:t_fault))
+      turn_out.sync = true
+      @t_cur_file, @t_fault = nil
+    end
+
+    def t_started( result )
+      @t_result = result
+    end
+
+    def t_finished( elapsed_time )
+      failure = @t_result.failure_count
+      error   = @t_result.error_count
+      total   = @t_result.run_count
+      pass = total - failure - error
+
+      bar = '=' * 78
+      if colorize?
+        bar = if pass == total then ::ANSI::Code.green{bar}
+              else ::ANSI::Code.red{bar} end
+      end
+
+      turn_out.puts bar
+      turn_out.puts "  pass: %d,  fail: %d,  error: %d" % [pass, failure, error]
+      turn_out.puts "  total: %d tests with %d assertions in #{elapsed_time} seconds" % [total, @t_result.assertion_count]
+      turn_out.puts bar
+    end
+
+    def t_test_started( name )
+      method, file = name.scan(%r/^([^\(]+)\(([^\)]+)\)/o).flatten!
+      if @t_cur_file != file
+        @t_cur_file = file
+        file = colorize? ? ::ANSI::Code.yellow{file} : file
+        turn_out.puts file
+      end
+      turn_out.print "    %-69s" % method
+    end
+
+    def t_test_finished( name )
+      turn_out.puts " #{PASS}" unless @t_fault
+      @t_fault = false
+    end
+
+    def t_fault( fault )
+      @t_fault = true
+      msg = "\t"
+
+      case fault
+      when ::Test::Unit::Error
+        turn_out.puts ERROR
+        msg << fault.to_s.split("\n")[2..-1].join("\n\t")
+      when ::Test::Unit::Failure
+        test_name =  underscore(fault.test_name.match(/\((.*)\)/)[1])
+        better_location = fault.location.detect{|line|line.include?(test_name)} || fault.location[0]
+        turn_out.puts " #{FAIL}"
+        msg << better_location.to_s << "\n\t"
+        msg << fault.message.gsub("\n","\n\t")
+      end
+
+      msg = ::ANSI::Code.magenta{msg} if colorize?
+      turn_out.puts msg
+    end
+
+    private
+
+    # Taken from ActiveSupport::Inflector
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+
+    def setup_mediator
+       @mediator = create_mediator(@suite)
+       suite_name = @suite.to_s
+       if ( @suite.kind_of?(Module) )
+         suite_name = @suite.name
+       end
+       msg = rails? ? "\n" : "Loaded suite #{suite_name}" #always same in rails so scrap it
+       output(msg)
+    end
+
+    def rails?
+      $:.to_s.include? "rails"
+    end
+
+
+  end
+end
+end
+end
+
+# EOF

data/lib/turn/colorize.rb

@@ -12,46 +12,54 @@ module Turn
 
   module Colorize
 
-    COLORIZE = defined?(::ANSI::Code) && ENV.has_key?('TERM')
+    COLORLESS_TERMINALS = ['dumb']
+
+    def colorize?
+      defined?(::ANSI::Code) &&
+        ENV.has_key?('TERM') &&
+        !COLORLESS_TERMINALS.include?(ENV['TERM']) &&
+        $stdout.tty?
+    end
+    module_function :colorize?
 
     def self.red(string)
-      COLORIZE ? ::ANSI::Code.red{ string } : string
+      colorize? ? ::ANSI::Code.red{ string } : string
     end
 
     def self.green(string)
-      COLORIZE ? ::ANSI::Code.green{ string } : string
+      colorize? ? ::ANSI::Code.green{ string } : string
     end
 
     def self.blue(string)
-      COLORIZE ? ::ANSI::Code.blue{ string } : string
+      colorize? ? ::ANSI::Code.blue{ string } : string
     end
 
     def self.magenta(string)
-      COLORIZE ? ::ANSI::Code.magenta{ string } : string
+      colorize? ? ::ANSI::Code.magenta{ string } : string
     end
 
     def self.bold(string)
-      COLORIZE ? ::ANSI::Code.bold{ string } : string
+      colorize? ? ::ANSI::Code.bold{ string } : string
     end
 
     def self.pass(string)
-      COLORIZE ? ::ANSI::Code.green{ string } : string
+      colorize? ? ::ANSI::Code.green{ string } : string
     end
 
     def self.fail(string)
-      COLORIZE ? ::ANSI::Code.red{ string } : string
+      colorize? ? ::ANSI::Code.red{ string } : string
     end
 
     #def self.error(string)
-    #  COLORIZE ? ::ANSI::Code.white{ ::ANSI::Code.on_red{ string } } : string
+    #  colorize? ? ::ANSI::Code.white{ ::ANSI::Code.on_red{ string } } : string
     #end
 
     def self.error(string)
-      COLORIZE ? ::ANSI::Code.yellow{ string } : string
+      colorize? ? ::ANSI::Code.yellow{ string } : string
     end
 
     def self.skip(string)
-      COLORIZE ? ::ANSI::Code.cyan{ string } : string
+      colorize? ? ::ANSI::Code.cyan{ string } : string
     end
 
     PASS  = pass('PASS')