turn 0.8.3 → 0.9.0

data/lib/turn/reporters/outline_reporter.rb

@@ -3,7 +3,7 @@ require 'stringio'
 
 module Turn
 
-  # = Outline Reporter (Turn's Original)
+  # Outline Reporter is Turn's Original.
   #
   #--
   # TODO: Should we fit reporter output to width of console?
@@ -11,15 +11,23 @@ module Turn
   #++
   class OutlineReporter < Reporter
 
+    #
+    TAB_SIZE = 8
+
     #
     def start_suite(suite)
-      @suite = suite
-      @time  = Time.now
+      @suite  = suite
+      @time   = Time.now
       @stdout = StringIO.new
       @stderr = StringIO.new
-      #files = suite.collect{ |s| s.file }.join(' ')
-      io.puts "LOADED SUITE #{suite.name}"
-      #io.puts "Started"
+      #files  = suite.collect{ |s| s.file }.join(' ')
+      puts '=' * 78
+      if suite.seed
+        io.puts "SUITE #{suite.name} (SEED #{suite.seed})"
+      else
+        io.puts "SUITE #{suite.name}"
+      end
+      puts '=' * 78
     end
 
     #
@@ -34,13 +42,9 @@ module Turn
       #  io.puts(test.file)
       #end
 
-      name = if @natural
-               " #{test.name.gsub("test_", "").gsub(/_/, " ")}" 
-             else
-               " #{test.name}"
-             end
+      name = naturalized_name(test)
 
-      io.print "    %-69s" % name
+      io.print "    %-57s" % name
 
       @stdout.rewind
       @stderr.rewind
@@ -51,43 +55,60 @@ module Turn
 
     #
     def pass(message=nil)
-      io.puts " #{PASS}"
+      io.puts " %s %s" % [ticktock, PASS]
+
       if message
         message = Colorize.magenta(message)
-        message = message.to_s.tabto(8)
+        message = message.to_s.tabto(TAB_SIZE)
         io.puts(message)
       end
     end
 
     #
     def fail(assertion)
-      message   = assertion.message.to_s
-      backtrace = filter_backtrace(assertion.backtrace)
-
-      io.puts(" #{FAIL}")
-      io.puts Colorize.bold(message).tabto(8)
-
-      unless backtrace.empty?
-        label = "Assertion at "
-        tabsize = 8
-        backtrace1 = label + backtrace.shift
-        io.puts(backtrace1.tabto(tabsize))
-        if @trace
-          io.puts backtrace.map{|l| l.tabto(label.length + tabsize) }.join("\n")
-        end
-      end
+      io.puts " %s %s" % [ticktock, FAIL]
+
+      message = []
+      message << Colorize.bold(assertion.message.to_s)
+      message << "Assertion at:"
+      message << clean_backtrace(assertion.backtrace).join("\n")
+      message = message.join("\n")
+
+      io.puts(message.tabto(TAB_SIZE))
+
+      #unless backtrace.empty?
+      #  io.puts "Assertion at".tabto(TAB_SIZE)
+      #  io.puts backtrace.map{|l| l.tabto(TAB_SIZE)}.join("\n")
+      #end
+
+      #io.puts "STDERR:".tabto(TAB_SIZE)
       show_captured_output
     end
 
     #
     def error(exception)
-      message   = exception.message
-      backtrace = "Exception `#{exception.class}' at " + filter_backtrace(exception.backtrace).join("\n")
-      message = Colorize.bold(message)
-      io.puts("#{ERROR}")
+      io.puts " %s %s" % [ticktock, ERROR]
+
+      message = []
+      message << Colorize.bold(exception.message)
+      message << "Exception `#{exception.class}' at:"
+      message << clean_backtrace(exception.backtrace).join("\n")
+      message = message.join("\n")
+
+      io.puts(message.tabto(TAB_SIZE))
+
+      #io.puts "STDERR:".tabto(TAB_SIZE)
+      show_captured_output
+    end
+
+    #
+    def skip(exception)
+      io.puts " %s %s" % [ticktock, SKIP]
+
+      message = exception.message
+
       io.puts(message.tabto(8))
-      io.puts "STDERR:".tabto(8)
-      io.puts(backtrace.tabto(8))
+
       show_captured_output
     end
 
@@ -129,7 +150,7 @@ module Turn
     #def finish_case(kase)
     #end
 
-    #
+    # TODO: pending (skip) counts
     def finish_suite(suite)
       total   = suite.count_tests
       failure = suite.count_failures

data/lib/turn/reporters/pretty_reporter.rb

@@ -8,6 +8,9 @@ module Turn
     #
     PADDING_SIZE = 4
 
+    #
+    TAB_SIZE = 10
+
     #
     def start_suite(suite)
       #old_sync, @@out.sync = @@out.sync, true if io.respond_to? :sync=
@@ -18,7 +21,7 @@ module Turn
       #files = suite.collect{ |s| s.file }.join(' ')
       io.puts "Loaded suite #{suite.name}"
       #io.puts "Loaded suite #{$0.sub(/\.rb$/, '')}\nStarted"
-      io.puts "Started"
+      io.puts "Started (#{suite.seed})"
     end
 
     #
@@ -56,7 +59,7 @@ module Turn
     end
 
     #
-    def fail(assertion)
+    def fail(assertion, message=nil)
       io.print pad_with_size("#{FAIL}")
       io.print " #{@test}"
       io.print " (%.2fs) " % (Time.now - @test_time)
@@ -64,53 +67,63 @@ module Turn
       #message = assertion.location[0] + "\n" + assertion.message #.gsub("\n","\n")
       #trace   = MiniTest::filter_backtrace(report[:exception].backtrace).first
 
-      message = assertion.message
+      message ||= assertion.message
 
       _trace = if assertion.respond_to?(:backtrace)
                  filter_backtrace(assertion.backtrace)
                else
                  filter_backtrace(assertion.location).first
                end
+
       io.puts
-      tabsize = 10
       #io.puts pad(message, tabsize)
-      io.puts message.tabto(tabsize)
-      io.puts _trace.shift.tabto(tabsize)
-      if @trace
-        io.puts _trace.map{|l| l.tabto(tabsize) }.join("\n")
-      end
+      io.puts message.tabto(TAB_SIZE)
+
+      cnt = @trace ? @trace.to_i : _trace.size
+      io.puts _trace[0, cnt].map{|l| l.tabto(TAB_SIZE) }.join("\n")
+
       #show_captured_output
     end
 
     #
-    def error(exception)
+    def error(exception, message=nil)
       io.print pad_with_size("#{ERROR}")
       io.print " #{@test}"
       io.print " (%.2fs) " % (Time.now - @test_time)
 
       #message = exception.to_s.split("\n")[2..-1].join("\n")
 
-      message = exception.message
+      message ||= exception.message
 
       _trace = if exception.respond_to?(:backtrace)
-                 filter_backtrace(exception.backtrace)
+                 clean_backtrace(exception.backtrace)
                else
-                 filter_backtrace(exception.location)
+                 clean_backtrace(exception.location)
                end
-      trace = _trace.shift
+
       io.puts
-      tabsize = 10
-      io.puts message.tabto(tabsize)
-      io.puts trace.tabto(tabsize)
-      if @trace
-        io.puts _trace.map{|l| l.tabto(tabsize) }.join("\n")
-      end
+      io.puts message.tabto(TAB_SIZE)
+      io.puts _trace.map{|l| l.tabto(TAB_SIZE) }.join("\n")
     end
 
-    # TODO: skip support
-    #def skip
-    #  io.puts(pad_with_size("#{SKIP}"))
-    #end
+    #
+    def skip(exception, message=nil)
+      io.print pad_with_size("#{SKIP}")
+      io.print " #{@test}"
+      io.print " (%.2fs) " % (Time.now - @test_time)
+
+      message ||= exception.message
+
+      _trace = if exception.respond_to?(:backtrace)
+                 clean_backtrace(exception.backtrace)
+               else
+                 clean_backtrace(exception.location)
+               end
+
+      io.puts
+      io.puts message.tabto(TAB_SIZE)
+      io.puts _trace.map{|l| l.tabto(TAB_SIZE) }.join("\n")
+    end
 
     #
     def finish_test(test)

data/lib/turn/reporters/progress_reporter.rb

@@ -6,28 +6,39 @@ module Turn
   #
   class ProgressReporter < Reporter
 
+    def initialize(io, opts={})
+      super(io, opts)
+      @fails  = Hash.new{|h,k|h[k]=[]}
+      @errors = Hash.new{|h,k|h[k]=[]}
+      @skips  = Hash.new{|h,k|h[k]=[]}
+    end
+
     def start_suite(suite)
       @pbar = ::ANSI::Progressbar.new('Testing', suite.size)
       @pbar.inc
     end
 
-    #def start_case(kase)
-    #end
+    def start_case(testcase)
+      @_current_case = testcase
+    end
 
     #def start_test(test)
     #end
 
     #def pass(message=nil)
-    #  #@pbar.inc
     #end
 
-    #def fail(message=nil)
-    #  #@pbar.inc
-    #end
+    def fail(assertion, message=nil)
+      @fails[@_current_case] << assertion
+    end
 
-    #def error(message=nil)
-    #  #@pbar.inc
-    #end
+    def error(exception, message=nil)
+      @errors[@_current_case] << exception
+    end
+
+    def skip(exception, message=nil)
+      @skips[@_current_case] << exception
+    end
 
     def finish_case(kase)
       @pbar.inc
@@ -42,13 +53,14 @@ module Turn
     def post_report(suite)
       tally = test_tally(suite)
 
-      width = suite.collect{ |tr| tr.name.size }.max
+      width = suite.collect{ |tr| tr.name.to_s.size }.max
 
       headers = [ 'TESTCASE  ', '  TESTS   ', 'ASSERTIONS', ' FAILURES ', '  ERRORS   ' ]
-      io.puts "\n%-#{width}s       %10s %10s %10s %10s\n" % headers
+      io.puts "\n\n%-#{width}s       %10s %10s %10s %10s\n" % headers
 
-      files = nil
+      io.puts ("-" * (width + 50))
 
+      files = nil
       suite.each do |testrun|
         if testrun.files != [testrun.name] && testrun.files != files
           label = testrun.files.join(' ')
@@ -61,27 +73,53 @@ module Turn
 
       #puts("\n%i tests, %i assertions, %i failures, %i errors\n\n" % tally)
 
-      tally_line = "-----\n"
-      tally_line << "%-#{width}s  " % "TOTAL"
+      tally_line = ("-" * (width + 50))
+      tally_line << "\n%-#{width}s  " % "TOTAL"
       tally_line << "%10s %10s %10s %10s" % tally
 
-      io.puts(tally_line + "\n")
+      io.puts(tally_line + "\n\n\n")
 
-      fails = suite.select do |testrun|
-        testrun.fail? || testrun.error?
+      io.puts "-- Failures --\n\n" unless @fails.empty?
+
+      @fails.each do |tc, cc|
+        cc.each do |e|
+          message = e.message.tabto(0).strip
+          message = Colorize.red(message)
+          message += "\n" + clean_backtrace(e.backtrace).join("\n")
+          io.puts(message+"\n\n")
+        end
+        io.puts
       end
 
-      #if tally[2] != 0 or tally[3] != 0
-        unless fails.empty? # or verbose?
-          io.puts "\n\n-- Failures and Errors --\n\n"
-          fails.uniq.each do |testrun|
-            message = testrun.message.tabto(0).strip
-            message = Colorize.red(message)
-            io.puts(message+"\n\n")
-          end
-          io.puts
+      io.puts "-- Errors --\n\n" unless @errors.empty?
+
+      @errors.each do |tc, cc|
+        cc.each do |e|
+          message = e.message.tabto(0).strip
+          message = Colorize.red(message)
+          message += "\n" + clean_backtrace(e.backtrace).join("\n")
+          io.puts(message+"\n\n")
         end
+        io.puts
+      end
+
+      #fails = suite.select do |testrun|
+      #  testrun.fail? || testrun.error?
       #end
+
+      ##if tally[2] != 0 or tally[3] != 0
+      #  unless fails.empty? # or verbose?
+      #    io.puts "\n\n-- Failures and Errors --\n\n"
+      #    fails.uniq.each do |testrun|
+      #      message = testrun.message.tabto(0).strip
+      #      message = Colorize.red(message)
+      #      # backtrace ?
+      #      #message += clean_backtrace(testrun.exception.backtrace).join("\n")
+      #      io.puts(message+"\n\n")
+      #    end
+      #    io.puts
+      #  end
+      ##end
     end
 
   private

data/lib/turn/runners/minirunner.rb

@@ -40,8 +40,12 @@ module Turn
 
     # Override #_run_suite to setup Turn.
     def _run_suites suites, type
+      # Someone want to explain to me why these are fucking here?
+      suites = suites - [MiniTest::Spec, Test::Unit::TestCase]
+
       @turn_suite = Turn::TestSuite.new(@turn_config.suite_name)
-      @turn_suite.size = ::MiniTest::Unit::TestCase.test_suites.size
+      @turn_suite.size = suites.size  #::MiniTest::Unit::TestCase.test_suites.size
+      @turn_suite.seed = ::MiniTest::Unit.runner.options[:seed]
 
       turn_reporter.start_suite(@turn_suite)
 
@@ -101,8 +105,8 @@ module Turn
     def puke(klass, meth, err)
       case err
       when MiniTest::Skip
-        @turn_test.skip!
-        turn_reporter.skip #(e)
+        @turn_test.skip!(err)
+        turn_reporter.skip(err)
       when MiniTest::Assertion
         @turn_test.fail!(err)
         turn_reporter.fail(err)
@@ -113,35 +117,6 @@ module Turn
       super(klass, meth, err)
     end
 
-    # To maintain compatibility with old versions of MiniTest.
-    #
-    # Hey, Ryan Davis wrote this code!
-    if ::MiniTest::Unit::VERSION < '2.0'    
-      #attr_accessor :options
-
-      #
-      def run(args=[])
-        suites = ::MiniTest::Unit::TestCase.test_suites
-        return if suites.empty?
-
-        @test_count, @assertion_count = 0, 0
-        sync = @@out.respond_to? :"sync=" # stupid emacs
-        old_sync, @@out.sync = @@out.sync, true if sync
-
-        results = _run_suites suites, :test #type
-
-        @test_count      = results.inject(0) { |sum, (tc, _)| sum + tc }
-        @assertion_count = results.inject(0) { |sum, (_, ac)| sum + ac }
-
-        @@out.sync = old_sync if sync
-
-        return failures + errors if @test_count > 0 # or return nil...
-      rescue Interrupt
-        abort 'Interrupted'
-      end
-
-    end
-
   end
 
 end