turn 0.8.3 → 0.9.0

data/lib/turn/controller.rb

@@ -1,197 +1,6 @@
-require 'fileutils'
-
 module Turn
 
-  require 'turn/version'
-  require 'turn/autoload'
-  require 'turn/components/suite.rb'
-  require 'turn/components/case.rb'
-  require 'turn/components/method.rb'
-
-  # Configure Turn
-  def self.config(&block)
-    @config ||= Configuration.new
-    block.call(@config) if block
-    @config
-  end
-
-  #
-  #
-  #--
-  # TODO: Add support to test run loggging.
-  #++
-  class Configuration
-
-    # 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
-
-    # Enable full backtrace
-    attr_accessor :trace
-
-    # Use natural language case names.
-    attr_accessor :natural
-
-    def verbose? ; @verbose ; end
-    def live?    ; @live    ; end
-    def natural? ; @natural ; 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
-      @matchcase ||= nil
-      @pattern   ||= /.*/
-      @natural   ||= false
-
-      @files = nil  # reset files just in case
-    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) }
-      ).flatten
-    end
-
-    # TODO: Better name ?
-    def suite_name
-      files.map{ |path| File.dirname(path).sub(Dir.pwd+'/','') }.uniq.join(',')
-    end
-
-    # Select reporter based on output mode.
-    def reporter
-      @reporter ||= (
-        opts = { :trace=>trace, :natural=>natural? }
-        case format
-        when :marshal
-          require 'turn/reporters/marshal_reporter'
-          Turn::MarshalReporter.new($stdout, opts)
-        when :progress
-          require 'turn/reporters/progress_reporter'
-          Turn::ProgressReporter.new($stdout, opts)
-        when :dotted
-          require 'turn/reporters/dot_reporter'
-          Turn::DotReporter.new($stdout, opts)
-        when :pretty
-          require 'turn/reporters/pretty_reporter'
-          Turn::PrettyReporter.new($stdout, opts)
-        when :cue
-          require 'turn/reporters/cue_reporter'
-          Turn::CueReporter.new($stdout, opts)
-        else
-          require 'turn/reporters/outline_reporter'
-          Turn::OutlineReporter.new($stdout, opts)
-        end
-      )
-    end
-
-  end
-
-  # = Controller
+  # Controls execution of test run.
   #
   class Controller
 
@@ -223,23 +32,23 @@ module Turn
       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 config.framework
-        when :minitest
+        #case config.framework
+        #when :minitest
           require 'turn/runners/minirunner'
-        else
-          require 'turn/runners/testrunner'
-        end
+        #else
+        #  require 'turn/runners/testrunner'
+        #end
 
         case config.runmode
         when :marshal
-          if config.framework == :minitest
+          #if config.framework == :minitest
             Turn::MiniRunner
-          else
-            Turn::TestRunner
-          end
+          #else
+          #  Turn::TestRunner
+          #end
         when :solo
           require 'turn/runners/solorunner'
           Turn::SoloRunner
@@ -247,11 +56,11 @@ module Turn
           require 'turn/runners/crossrunner'
           Turn::CrossRunner
         else
-          if config.framework == :minitest
+          #if config.framework == :minitest
             Turn::MiniRunner
-          else
-            Turn::TestRunner
-          end
+          #else
+          #  Turn::TestRunner
+          #end
         end
       )
     end

data/lib/turn/{autorun/minitest.rb → minitest.rb}

@@ -1,12 +1,16 @@
-require 'turn/autoload'
+#require 'turn'
 
+# make sure latest verison is used, rather than ruby's built-in
+begin; gem 'minitest'; rescue Exception; end
+
+# we save the developer the trouble of having to load these (TODO: should we?)
 require 'minitest/unit'
 require 'minitest/spec'
 
-require 'turn/colorize'
-require 'turn/controller'
+# 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

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,6 +14,7 @@ module Turn
 
     include Colorize
 
+    # Where to send report, defaults to `$stdout`.
     attr :io
 
     def initialize(io, opts={})
@@ -26,46 +25,102 @@ module Turn
 
     # 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') }
+    # Apply filter_backtrace and limit_backtrace in one go.
+    def clean_backtrace(backtrace)
+      limit_backtrace(filter_backtrace(backtrace))
+    end
+
+    $RUBY_IGNORE_CALLERS ||= []
+    $RUBY_IGNORE_CALLERS.concat([
+      /\/turn.*\.rb/,
+      /\/bin\/turn/,
+      /\/minitest.*\.rb/,
+      /\/test\/unit.*\.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 = backtrace.dup
+      bt.reject!{ |line| $RUBY_IGNORE_CALLERS.any?{ |re| re =~ line } } unless $DEBUG
+      #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 = backtrace if bt.empty?  # if empty just dump the whole thing
       bt.map{ |line| line.sub(Dir.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
+
+    #
+    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(60)
+      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

@@ -67,6 +67,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
@@ -130,9 +139,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 +166,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

@@ -19,17 +19,21 @@ module Turn
     end
 
     def pass(message=nil)
-      io.print Colorize.pass('.'); io.flush
+      io.print Colorize.pass('S'); 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('-'); io.flush
+    end
+
     def finish_test(test)
     end
 
@@ -53,14 +57,11 @@ 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)
-          backtrace = filter_backtrace(testunit.backtrace)
-          message << "\n" + (backtrace.shift || '')
-          if @trace
-            message << "\n" + backtrace.join("\n")
-          end
-          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