turn 0.8.2 → 0.9.7

data/lib/turn/controller.rb

@@ -1,198 +1,45 @@
-require 'fileutils'
-
 module Turn
-  require 'turn/version'
-  require 'turn/components/suite.rb'
-  require 'turn/components/case.rb'
-  require 'turn/components/method.rb'
 
-  # = Controller
+  # Controls execution of test run.
   #
-  #--
-  # TODO: Add support to test run loggging.
-  #++
   class Controller
 
-    # List of if file names or glob pattern of tests to run.
-    attr_accessor :tests
-
-    # List of file names or globs to exclude from +tests+ list.
-    attr_accessor :exclude
-
-    # Regexp pattern that all test name's must
-    # match to be eligible to run.
-    attr_accessor :pattern
-
-    # Regexp pattern that all test cases must
-    # match to be eligible to run.
-    attr_accessor :matchcase
-
-    # Add these folders to the $LOAD_PATH.
-    attr_accessor :loadpath
-
-    # Libs to require when running tests.
-    attr_accessor :requires
-
-    # Reporter type.
-    attr_accessor :format
-
-    # Run mode.
-    attr_accessor :runmode
-
-    # Test against live install (i.e. Don't use loadpath option)
-    attr_accessor :live
-
-    # Log results? May be true/false or log file name. (TODO)
-    attr_accessor :log
-
-    # Verbose output?
-    attr_accessor :verbose
-
-    # Test framework, either :minitest or :testunit
-    attr_accessor :framework
-
-    def verbose? ; @verbose ; end
-    def live?    ; @live    ; end
-
-  private
-
-    def initialize
-      yield(self) if block_given?
-      initialize_defaults
-    end
-
     #
-    def initialize_defaults
-      @loadpath ||= ['lib']
-      @tests    ||= ["test/**/{test,}*{,test}.rb"]
-      @exclude  ||= []
-      @requires ||= []
-      @live     ||= false
-      @log      ||= true
-      #@format  ||= nil
-      #@runner   ||= RUBY_VERSION >= "1.9" ? MiniRunner : TestRunner
-      @pattern  ||= /.*/
+    def initialize(config=Turn.config)
+      @config = config
     end
 
-    # Collect test configuation.
-    #def test_configuration(options={})
-    #  #options = configure_options(options, 'test')
-    #  #options['loadpath'] ||= metadata.loadpath
-    #  options['tests']    ||= self.tests
-    #  options['loadpath'] ||= self.loadpath
-    #  options['requires'] ||= self.requires
-    #  options['live']     ||= self.live
-    #  options['exclude']  ||= self.exclude
-    #  #options['tests']    = list_option(options['tests'])
-    #  options['loadpath'] = list_option(options['loadpath'])
-    #  options['exclude']  = list_option(options['exclude'])
-    #  options['require']  = list_option(options['require'])
-    #  return options
-    #end
-
     #
-    def list_option(list)
-      case list
-      when nil
-        []
-      when Array
-        list
-      else
-        list.split(/[:;]/)
-      end
-    end
-
-  public
-
-    def tests=(paths)
-      @tests = list_option(paths)
-    end
-
-    def loadpath=(paths)
-      @loadpath = list_option(paths)
-    end
-
-    def exclude=(paths)
-      @exclude = list_option(paths)
-    end
-
-    def requires=(paths)
-      @requires = list_option(paths)
-    end
-
-    # Test files.
-    def files
-      @files ||= (
-        fs = tests.map do |t|
-          File.directory?(t) ? Dir[File.join(t, '**', '*')] : Dir[t]
-        end
-        fs = fs.flatten.reject{ |f| File.directory?(f) }
-
-        ex = exclude.map do |x|
-          File.directory?(x) ? Dir[File.join(x, '**', '*')] : Dir[x]
-        end
-        ex = ex.flatten.reject{ |f| File.directory?(f) }
-
-        (fs - ex).uniq.map{ |f| File.expand_path(f) }
-      )
-    end
+    attr :config
 
+    #
     def start
-      @files = nil  # reset files just in case
-
-      if files.empty?
+      if config.files.empty?
         $stderr.puts "No tests."
         return
       end
 
-      testrun = runner.new(self)
+      setup
 
+      testrun = runner.new
       testrun.start
     end
 
-    # Select reporter based on output mode.
-    def reporter
-      @reporter ||= (
-        case format
-        when :marshal
-          require 'turn/reporters/marshal_reporter'
-          Turn::MarshalReporter.new($stdout)
-        when :progress
-          require 'turn/reporters/progress_reporter'
-          Turn::ProgressReporter.new($stdout)
-        when :dotted
-          require 'turn/reporters/dot_reporter'
-          Turn::DotReporter.new($stdout)
-        when :pretty
-          require 'turn/reporters/pretty_reporter'
-          Turn::PrettyReporter.new($stdout)
-        when :cue
-          require 'turn/reporters/cue_reporter'
-          Turn::CueReporter.new($stdout)
-        else
-          require 'turn/reporters/outline_reporter'
-          Turn::OutlineReporter.new($stdout)
-        end
-      )
+    #
+    def setup
+      config.loadpath.each{ |path| $: << path } unless config.live?
+      config.requires.each{ |path| require(path) }
+      config.files.each{ |path| require(path) }
     end
 
-    # # Insatance of Runner, selected based on format and runmode.
+    # Insatance of Runner, selected based on format and runmode.
     def runner
       @runner ||= (
-        case framework
-        when :minitest
-          require 'turn/runners/minirunner'
-        else
-          require 'turn/runners/testrunner'
-        end
+        require 'turn/runners/minirunner'
 
-        case runmode
+        case config.runmode
         when :marshal
-          if framework == :minitest
-            Turn::MiniRunner
-          else
-            Turn::TestRunner
-          end
+          Turn::MiniRunner
         when :solo
           require 'turn/runners/solorunner'
           Turn::SoloRunner
@@ -200,11 +47,7 @@ module Turn
           require 'turn/runners/crossrunner'
           Turn::CrossRunner
         else
-          if framework == :minitest
-            Turn::MiniRunner
-          else
-            Turn::TestRunner
-          end
+          Turn::MiniRunner
         end
       )
     end
@@ -212,4 +55,3 @@ module Turn
   end
 
 end
-

data/lib/turn/decorators/topten_decorator.rb

@@ -0,0 +1,67 @@
+module Turn
+
+  class ToptenDecorator
+
+    def initialize(reporter)
+      @reporter = reporter
+    end
+
+    def method_missing(m,*args,&block)
+      @reporter.send(m,*args,&block)
+    end
+
+    def start_case(kase)
+      @reporter.start_case(kase)
+      @top_ten_current_case = kase
+    end
+
+    def start_test(test)
+      @reporter.start_test(test)
+      test_time_data[test_key(test)] = {:start => Time.now}
+    end
+
+    def finish_test(test)
+      @reporter.finish_test(test)
+      test_time_data[test_key(test)][:end] = Time.now
+    end
+
+    def finish_suite(suite)
+      @reporter.finish_suite(suite)
+      io.puts
+      io.puts Colorize.bold("Top 10 Longest Running Tests")
+      top_ten_times.each do |(test_name, time)|
+        io.print format_time(time)
+        io.puts format_test_name(test_name, time)
+      end
+      io.puts
+    end
+
+    private
+
+    def test_key(test)
+      "#{@top_ten_current_case.name} #{test}"
+    end
+
+    def top_ten_times
+      test_times.sort_by {|(_, time)| -time}.take(10)
+    end
+
+    def test_times
+      test_time_data.map {|(test, times)| [test, times[:end] - times[:start]]}
+    end
+
+    def test_time_data
+      @test_time_data ||= {}
+    end
+
+    def format_time(time)
+      Colorize.blue(time)
+    end
+
+    def format_test_name(test_name, time)
+      test_name.tabto(11-time.to_s.length)
+    end
+
+  end
+
+end

data/lib/turn/minitest.rb

@@ -0,0 +1,25 @@
+# make sure latest verison is used, rather than ruby's built-in
+begin
+  gem 'minitest', '< 5.0.0'
+rescue Gem::LoadError
+  warn "gem install minitest"
+end
+
+# we save the developer the trouble of having to load these (TODO: should we?)
+require 'minitest/unit'
+require 'minitest/spec'
+
+# compatability with old Test::Unit
+#Test = MiniTest unless defined?(Test)
+
+# load Turn's minitest runner
+require 'turn/runners/minirunner'
+
+# set MiniTest's runner to Turn::MiniRunner instance
+if MiniTest::Unit.respond_to?(:runner=)
+  MiniTest::Unit.runner = Turn::MiniRunner.new
+else
+  raise "MiniTest v#{MiniTest::Unit::VERSION} is out of date.\n" \
+        "Please update to a newer version, but version 5.0.0 or above will not work. ."
+  #MiniTest::Unit = Turn::MiniRunner
+end

data/lib/turn/reporter.rb

@@ -2,8 +2,6 @@ module Turn
   require 'turn/colorize'
   require 'turn/core_ext'
 
-  # = Reporter
-  #
   # There are two distinct way in which a report may be utilized
   # by a Runner: per-call or per-file. The method #pass, #fail
   # and #error are generic, and will be used in either case.
@@ -16,54 +14,118 @@ module Turn
 
     include Colorize
 
+    # Where to send report, defaults to `$stdout`.
     attr :io
 
-    def initialize(io)
-      @io = io || $stdout
+    def initialize(io, opts={})
+      @io      = io || $stdout
+      @trace   = opts[:trace]
+      @natural = opts[:natural]
+      @verbose = opts[:verbose]
+      @mark    = opts[:mark].to_i
     end
 
     # These methods are called in the process of running the tests.
 
+    # At the very start, before any testcases are run, this is called.
     def start_suite(test_suite)
     end
 
+    # Invoked before a testcase is run.
     def start_case(test_case)
     end
 
+    # Invoked before a test is run.
     def start_test(test)
     end
 
+    # Invoked when a test passes.
     def pass(message=nil)
     end
 
+    # Invoked when a test raises an assertion.
     def fail(assertion, message=nil)
     end
 
+    # Invoked when a test raises an exception.
     def error(exception, message=nil)
     end
 
+    # Invoked when a test is skipped.
+    def skip(exception, message=nil)
+    end
+
+    # Invoked after a test has been run.
     def finish_test(test)
     end
 
+    # Invoked after all tests in a testcase have ben run.
     def finish_case(test_case)
     end
 
+    # After all tests are run, this is the last observable action.
     def finish_suite(test_suite)
     end
 
   private
 
-    # TODO: backtrace filter probably could use some refinement.
-    def filter_backtrace(bt)
-      return [] unless bt
-      bt.reject!{ |line| line.rindex('minitest') }
-      bt.reject!{ |line| line.rindex('test/unit') }
-      bt.reject!{ |line| line.rindex('lib/turn') }
-      bt.reject!{ |line| line.rindex('bin/turn') }
-      bt.map{ |line| line.sub(Dir.pwd+'/', '') }
+    # Apply filter_backtrace and limit_backtrace in one go.
+    def clean_backtrace(backtrace)
+      limit_backtrace(filter_backtrace(backtrace))
+    end
+
+    # TODO: Is the text/unit line needed any more now that Dir.pwd is excluded
+    #       from filtering?
+
+    $RUBY_IGNORE_CALLERS ||= []
+    $RUBY_IGNORE_CALLERS.concat([
+      /\/lib\/turn.*\.rb/,
+      /\/bin\/turn/,
+      /\/lib\/minitest.*\.rb/,
+      /\/test\/unit(?!(\/.*\_test.rb)|.*\/test_.*).*\.rb.*/
+    ])
+
+    # Filter backtrace of unimportant entries, and applies count limit if set in
+    # configuration. Setting $DEBUG to true will deactivate filter, or if the filter
+    # happens to remove all backtrace entries it will revert to the full backtrace,
+    # as that probably means there was an issue with the test harness itself.
+    def filter_backtrace(backtrace)
+      return [] unless backtrace
+      bt, pwd = backtrace.dup, Dir.pwd
+      unless $DEBUG
+        bt = bt.reject do |line|
+          $RUBY_IGNORE_CALLERS.any?{|re| re =~ line} unless line.start_with?(pwd)
+        end
+      end
+      bt = backtrace if bt.empty?  # if empty just dump the whole thing
+      bt.map{ |line| line.sub(pwd+'/', '') }
+    end
+
+    # Limit backtrace to number of lines if `trace` configuration option is set.
+    def limit_backtrace(backtrace)
+      return [] unless backtrace
+      @trace ? backtrace[0, @trace.to_i] : backtrace
+    end
+
+    # Returns a more readable test name with spaces instead of underscores
+    def naturalized_name(test)
+      if @natural
+        test.name.gsub("test_", "").gsub(/_/, " ")
+      else
+        test.name
+      end
     end
 
+    #
+    def ticktock
+      t = Time.now - @time
+      h, t = t.divmod(3600)
+      m, t = t.divmod(60)
+      s = t.truncate
+      f = ((t - s) * 1000).to_i
+
+      "%01d:%02d:%02d.%03d" % [h,m,s,f]
+    end
   end
 
 end
-

data/lib/turn/reporters/cue_reporter.rb

@@ -27,7 +27,8 @@ module Turn
       #  @file = test.file
       #  io.puts(test.file)
       #end
-      io.print Colorize.blue("    %-69s" % test.name)
+      name = naturalized_name(test)
+      io.print Colorize.blue("    %-69s" % name)
       $stdout = @stdout
       $stderr = @stderr
       $stdout.rewind
@@ -67,6 +68,15 @@ module Turn
       prompt
     end
 
+    def skip(exception, message=nil)
+      message = message || exception.to_s
+      io.puts("#{SKIP}")
+      io.puts(message) #if message
+
+      #prompt
+    end
+
+
     def finish_test(test)
       $stdout = STDOUT
       $stderr = STDERR
@@ -99,22 +109,26 @@ module Turn
     #end
 
     def finish_suite(suite)
-      total   = suite.count_tests
-      failure = suite.count_failures
-      error   = suite.count_errors
-      pass    = total - failure - error
+      total      = suite.count_tests
+      passes     = suite.count_passes
+      assertions = suite.count_assertions
+      failures   = suite.count_failures
+      errors     = suite.count_errors
+      skips      = suite.count_skips
 
       bar = '=' * 78
-      if COLORIZE
+      # @FIXME: Remove this, since Colorize already take care of colorize?
+      if colorize?
         bar = if pass == total then Colorize.green(bar)
               else Colorize.red(bar) end
       end
 
-      tally = [total, suite.count_assertions]
+      # @FIXME: Should we add suite.runtime, instead if this lame time calculations?
+      tally = [total, assertions, (Time.new - @time)]
 
       io.puts bar
-      io.puts "  pass: %d,  fail: %d,  error: %d" % [pass, failure, error]
-      io.puts "  total: %d tests with %d assertions in #{Time.new - @time} seconds" % tally
+      io.puts "  pass: %d,  fail: %d,  error: %d, skip: %d" % [passes, failures, errors, skips]
+      io.puts "  total: %d tests with %d assertions in %f seconds" % tally
       io.puts bar
     end
 
@@ -130,9 +144,11 @@ module Turn
         when 'c', ''
         when 'r'
           # how to reload and start over?
+          io.puts "restart has not been implemented yet"
         when 'i'
           # how to drop into an interactive console?
-        when 't'
+          io.puts "irb support has not been implemented yet"
+        when 'b', 't'
           io.puts $@
           raise ArgumentError
         when /^\d+$/
@@ -155,7 +171,7 @@ module Turn
       c continue
       r restart
       i irb
-      t backtrace
+      b backtrace
       # backtrace lines
       q quit
       ? help

data/lib/turn/reporters/dot_reporter.rb

@@ -22,14 +22,18 @@ module Turn
       io.print Colorize.pass('.'); io.flush
     end
 
-    def fail(message=nil)
+    def fail(assertion, message=nil)
       io.print Colorize.fail('F'); io.flush
     end
 
-    def error(message=nil)
+    def error(exception, message=nil)
       io.print Colorize.error('E'); io.flush
     end
 
+    def skip(exception, message=nil)
+      io.print Colorize.skip('S'); io.flush
+    end
+
     def finish_test(test)
     end
 
@@ -53,41 +57,33 @@ module Turn
       unless list.empty? # or verbose?
         #report << "\n\n-- Failures and Errors --\n\n"
         list.uniq.each do |testunit|
-          message = testunit.fail? ? ' ' + FAIL : ERROR
-          message = message + ' ' + testunit.message.tabto(0)
-          message << "\n" + (filter_backtrace(testunit.backtrace).first || '')
-          report << "\n" << message << "\n"
+          message = []
+          message << (testunit.fail? ? FAIL : ERROR)
+          message << testunit.message.tabto(2)
+          message << clean_backtrace(testunit.backtrace).join("\n").tabto(2)
+          report << "\n" << message.join("\n") << "\n"
         end
         report << "\n"
       end
 
       io.puts report
 
-      count = test_tally(suite)
-
-      tally = "%s tests, %s assertions, %s failures, %s errors" % count
- 
-      if count[-1] > 0 or count[-2] > 0
-        tally = Colorize.red(tally)
-      else
-        tally = Colorize.green(tally)
-      end
-
-      io.puts tally
-    end
+      # @TODO: Add something like suite.count(:tests, :passes) or
+      #        suite.count(tests: "%d tests", passes: "%d passes")
+      #        to cleanup, which will return something handy
+      #        (suite.count(:test, :passes).test proxy maybe?)
+      total      = "%d tests" % suite.count_tests
+      passes     = "%d passed" % suite.count_passes
+      assertions = "%d assertions" % suite.count_assertions
+      failures   = "%s failures" % suite.count_failures
+      errors     = "%s errors" % suite.count_errors
+      skips      = "%s skips" % suite.count_skips
 
-  private
+      tally = [total, passes, assertions, failures, errors, skips].join(", ")
 
-    def test_tally(suite)
-      counts = suite.collect{ |tr| tr.counts }
-      tally  = [0,0,0,0]
-      counts.each do |count|
-        4.times{ |i| tally[i] += count[i] }
-      end
-      return tally
+      io.puts suite.passed? ? Colorize.green(tally) : Colorize.red(tally)
     end
 
   end
 
-end
-
+end