turn 0.8.2 → 0.9.7

data/lib/turn/reporters/outline_reporter.rb

@@ -3,28 +3,40 @@ 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?
+  #       y8: Yes. we should, but it's a kinda tricky, if you want to make it
+  #           cross-platform. (See https://github.com/cldwalker/hirb/blob/master/lib/hirb/util.rb#L61)
   # TODO: Running percentages?
+  # TODO: Cleanup me!
   #++
   class OutlineReporter < Reporter
 
+    #
+    TAB_SIZE = 8
+
     #
     def start_suite(suite)
-      @suite = suite
-      @time  = Time.now
+      @suite  = suite
+      @time   = Time.now
+      # @FIXME (y8): Why we need to capture stdout and stderr?
       @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
 
     #
     def start_case(kase)
-      io.puts(Colorize.bold("#{kase.name}"))
+      io.puts(Colorize.bold("#{kase.name}")) if kase.size > 0
     end
 
     #
@@ -33,7 +45,11 @@ module Turn
       #  @file = test.file
       #  io.puts(test.file)
       #end
-      io.print "    %-69s" % test.name
+
+      # @FIXME: Should we move naturalized_name to test itself?
+      name = naturalized_name(test)
+
+      io.print "     %-57s" % name
 
       @stdout.rewind
       @stderr.rewind
@@ -44,38 +60,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?
-        backtrace = "Assertion at " + filter_backtrace(assertion.backtrace).first
-        io.puts "STDERR:".tabto(8)
-        io.puts(backtrace.tabto(8))
-      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
 
@@ -117,28 +155,27 @@ module Turn
     #def finish_case(kase)
     #end
 
-    #
+    # TODO: pending (skip) counts
     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
-        bar = if pass == total then Colorize.green(bar)
-              else Colorize.red(bar) end
-      end
+      bar = passes == total ? Colorize.green(bar) : Colorize.red(bar)
 
-      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
 
   end
 
 end
-

data/lib/turn/reporters/pretty_reporter.rb

@@ -1,184 +1,165 @@
 require 'turn/reporter'
 
 module Turn
-
   # = Pretty Reporter (by Paydro)
   #
+  # Example output:
+  #    TestCaseName:
+  #         PASS test: Succesful test case.  (0:00:02:059)
+  #        ERROR test: Bogus test case.  (0:00:02:059)
+  #         FAIL test: Failed test case.  (0:00:02:059)
+  #
   class PrettyReporter < Reporter
-    #
-    PADDING_SIZE = 4
+    # Second column left padding in chars.
+    TAB_SIZE = 10
 
-    #
+    # Character to put in front of backtrace.
+    TRACE_MARK = '@ '
+
+    # TODO: solo and cross runners do not have name or seed, need to fix.
+
+    # At the very start, before any testcases are run, this is called.
     def start_suite(suite)
-      #old_sync, @@out.sync = @@out.sync, true if io.respond_to? :sync=
       @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 "Loaded suite #{$0.sub(/\.rb$/, '')}\nStarted"
-      io.puts "Started"
+
+      io.puts Colorize.bold("Loaded Suite #{suite.name}")
+      io.puts
+      if suite.seed
+        io.puts "Started at #{Time.now} w/ seed #{suite.seed}."
+      else
+        io.puts "Started at #{Time.now}."
+      end
+      io.puts
     end
 
-    #
+    # Invoked before a testcase is run.
     def start_case(kase)
-      #if kase.size > 0  # TODO: Don't have size yet?
-        io.print "\n#{kase.name}:\n"
-      #end
+      # Print case name if there any tests in suite
+      # TODO: Add option which will show all test cases, even without tests?
+      io.puts kase.name if kase.size > 0
     end
 
-    #
+    # Invoked before a test is run.
     def start_test(test)
       @test_time = Time.now
       @test = test
-      #if @file != test.file
-      #  @file = test.file
-      #  io.puts(test.file)
-      #end
-      #io.print "    %-69s" % test.name
-      #$stdout = @stdout
-      #$stderr = @stderr
-      #$stdout.rewind
-      #$stderr.rewind
     end
 
-    #
+    # Invoked when a test passes.
     def pass(message=nil)
-      io.print pad_with_size("#{PASS}")
-      io.print " #{@test}"
-      io.print " (%.2fs) " % (Time.now - @test_time)
+      banner PASS
+
       if message
         message = Colorize.magenta(message)
-        message = message.to_s.tabto(10)
+        message = message.to_s.tabto(TAB_SIZE)
+
         io.puts(message)
       end
     end
 
-    #
-    def fail(assertion)
-      io.print pad_with_size("#{FAIL}")
-      io.print " #{@test}"
-      io.print " (%.2fs) " % (Time.now - @test_time)
-
-      #message = assertion.location[0] + "\n" + assertion.message #.gsub("\n","\n")
-      #trace   = MiniTest::filter_backtrace(report[:exception].backtrace).first
+    # Invoked when a test raises an assertion.
+    def fail(assertion, message=nil)
+      banner FAIL
 
-      message = assertion.message
+      prettify(assertion, message)
+    end
 
-      if assertion.respond_to?(:backtrace)
-        trace = filter_backtrace(assertion.backtrace).first
-      else
-        trace = filter_backtrace(assertion.location).first
-      end
+    # Invoked when a test raises an exception.
+    def error(exception, message=nil)
+      banner ERROR
 
-      io.puts
-      #io.puts pad(message, 10)
-      io.puts message.tabto(10)
-      io.puts trace.tabto(10)
-      #show_captured_output
+      prettify(exception, message)
     end
 
-    #
-    def error(exception)
-      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")
+    # Invoked when a test is skipped.
+    def skip(exception, message=nil)
+      banner SKIP
 
-      message = exception.message
+      prettify(exception, message)
+    end
 
-      if exception.respond_to?(:backtrace)
-        trace = filter_backtrace(exception.backtrace).first
-      else
-        trace = filter_backtrace(exception.location).first
-      end
+    # Invoked after all tests in a testcase have ben run.
+    def finish_case(kase)
+      # Print newline is there any tests in suite
+      io.puts if kase.size > 0
+    end
 
+    # After all tests are run, this is the last observable action.
+    def finish_suite(suite)
+      total      = colorize_count("%d tests", suite.count_tests, :bold)
+      passes     = colorize_count("%d passed", suite.count_passes, :pass)
+      assertions = colorize_count("%d assertions", suite.count_assertions, nil)
+      failures   = colorize_count("%d failures", suite.count_failures, :fail)
+      errors     = colorize_count("%d errors", suite.count_errors, :error)
+      skips      = colorize_count("%d skips", suite.count_skips, :skip)
+
+      io.puts "Finished in %.6f seconds." % (Time.now - @time)
       io.puts
-      io.puts message.tabto(10)
-      io.puts trace.tabto(10)
-    end
 
-    # TODO: skip support
-    #def skip
-    #  io.puts(pad_with_size("#{SKIP}"))
-    #end
+      io.puts [ total, passes, failures, errors, skips, assertions ].join(", ")
 
-    #
-    def finish_test(test)
+      # Please keep this newline, since it will be useful when after test case
+      # there will be other lines. For example "rake aborted!" or kind of.
       io.puts
-      #@test_count += 1
-      #@assertion_count += inst._assertions
-      #$stdout = STDOUT
-      #$stderr = STDERR
     end
 
-=begin
-    def show_captured_output
-      show_captured_stdout
-      show_captured_stderr
-    end
-
-    def show_captured_stdout
-      @stdout.rewind
-      return if @stdout.eof?
-      STDOUT.puts(<<-output.tabto(8))
-\nSTDOUT:
-#{@stdout.read}
-      output
+  private
+    # Creates an optionally-colorized string describing the number of occurances an event occurred.
+    #
+    # @param [String] str A printf-style string that expects an integer argument (i.e. the count)
+    # @param [Integer] count The number of occurances of the event being described.
+    # @param [nil, Symbol] colorize_method The method on Colorize to call in order to apply color to the result, or nil
+    #   to not apply any coloring at all.
+    def colorize_count(str, count, colorize_method)
+      str= str % [count]
+      str= Colorize.send(colorize_method, str) if colorize_method and count != 0
+      str
     end
 
-    def show_captured_stderr
-      @stderr.rewind
-      return if @stderr.eof?
-      STDOUT.puts(<<-output.tabto(8))
-\nSTDERR:
-#{@stderr.read}
-      output
-    end
-=end
+    # TODO: Could also provide % done with time info. But it's already taking up
+    #       a lot of screen realestate. Maybe use --verbose flag to offer two forms.
 
-    def finish_case(kase)
-      if kase.size == 0
-        io.puts pad("(No Tests)")
+    # Outputs test case header for given event (error, fail & etc)
+    #
+    # Example:
+    #    PASS test: Test decription.  (0.15s 0:00:02:059)
+    def banner(event)
+      name = naturalized_name(@test)
+      delta = Time.now - @test_time  # test runtime
+      if @verbose
+        out = "%18s (%0.5fs) (%s) %s" % [event, delta, ticktock, name]
+      else
+        out = "%18s (%s) %s" % [event, ticktock, name]
+      end
+      if @mark > 0 && delta > @mark
+        out[1] = Colorize.mark('*')
       end
+      io.puts out
     end
 
+    # Cleanups and prints test payload
     #
-    def finish_suite(suite)
-      #@@out.sync = old_sync if @@out.respond_to? :sync=
+    # Example:
+    #         fail is not 1
+    #       @ test/test_runners.rb:46:in `test_autorun_with_trace'
+    #         bin/turn:4:in `<main>'
+    def prettify(raised, message=nil)
+      # Get message from raised, if not given
+      message ||= raised.message
 
-      total   = suite.count_tests
-      failure = suite.count_failures
-      error   = suite.count_errors
-      #pass    = total - failure - error
+      backtrace = raised.respond_to?(:backtrace) ? raised.backtrace : raised.location
 
-      io.puts
-      io.puts "Finished in #{'%.6f' % (Time.now - @time)} seconds."
-      io.puts
-
-      io.print "%d tests, " % total
-      io.print "%d assertions, " % suite.count_assertions
-      io.print Colorize.fail( "%d failures" % failure) + ', '
-      io.print Colorize.error("%d errors" % error) #+ ', '
-      #io.puts  Colorize.cyan( "%d skips" % skips ) #TODO
-      io.puts
-    end
-
-  private
+      # Filter and clean backtrace
+      backtrace = clean_backtrace(backtrace)
 
-    #
-    def pad(str, size=PADDING_SIZE)
-      " " * size + str
-    end
+      # Add trace mark to first line.
+      backtrace.first.insert(0, TRACE_MARK)
 
-    #
-    def pad_with_size(str)
-      " " * (18 - str.size) + str
+      io.puts Colorize.bold(message.tabto(TAB_SIZE))
+      io.puts backtrace.shift.tabto(TAB_SIZE - TRACE_MARK.length)
+      io.puts backtrace.join("\n").tabto(TAB_SIZE)
+      io.puts
     end
-
   end
-
 end
-

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
+      headers = [ 'TESTCASE  ', '  TESTS   ', 'ASSERTIONS', ' FAILURES ', '  ERRORS   ', 'SKIPS    ' ]
+      io.puts "\n\n%-#{width}s       %10s %10s %10s %10s %10s\n" % headers
 
-      files = nil
+      io.puts ("-" * (width + 60))
 
+      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 << "%10s %10s %10s %10s" % tally
+      tally_line = ("-" * (width + 60))
+      tally_line << "\n%-#{width}s  " % "TOTAL"
+      tally_line << "%10s %10s %10s %10s %10s" % tally
+
+      io.puts(tally_line + "\n\n\n")
 
-      io.puts(tally_line + "\n")
+      io.puts "-- Failures --\n\n" unless @fails.empty?
 
-      fails = suite.select do |testrun|
-        testrun.fail? || testrun.error?
+      @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
@@ -89,7 +127,7 @@ module Turn
     def paint_line(testrun, width)
       line = ''
       line << "%-#{width}s  " % [testrun.name]
-      line << "%10s %10s %10s %10s" % testrun.counts
+      line << "%10s %10s %10s %10s %10s" % testrun.counts
       line << " " * 8
       if testrun.fail?
         line << "[#{FAIL}]"
@@ -103,14 +141,13 @@ module Turn
 
     def test_tally(suite)
       counts = suite.collect{ |tr| tr.counts }
-      tally  = [0,0,0,0]
+      tally  = [0,0,0,0,0]
       counts.each do |count|
-        4.times{ |i| tally[i] += count[i] }
+        5.times{ |i| tally[i] += count[i] }
       end
       return tally
     end
 
   end
 
-end
-
+end

data/lib/turn/runners/crossrunner.rb

@@ -15,8 +15,8 @@ module Turn
     def start
       suite = TestSuite.new
 
-      files = @controller.files
-      viles = @controller.files # TODO: make selectable ?
+      files = @config.files
+      viles = @config.files # TODO: make selectable ?
 
       #files = files.select{ |f| File.extname(f) == '.rb' and File.file?(f) }
       #viles = viles.select{ |f| File.extname(f) == '.rb' and File.file?(f) }