openlogic-turn 0.8.2

data/lib/turn/reporters/dot_reporter.rb

@@ -0,0 +1,93 @@
+require 'turn/reporter'
+
+module Turn
+
+  # = Traditional Dot Reporter
+  #
+  class DotReporter < Reporter
+
+    def start_suite(suite)
+      @time = Time.now
+      io.puts "Loaded suite #{suite.name}"
+      io.puts "Started"
+    end
+
+    def start_case(kase)
+    end
+
+    def start_test(test)
+    end
+
+    def pass(message=nil)
+      io.print Colorize.pass('.'); io.flush
+    end
+
+    def fail(message=nil)
+      io.print Colorize.fail('F'); io.flush
+    end
+
+    def error(message=nil)
+      io.print Colorize.error('E'); io.flush
+    end
+
+    def finish_test(test)
+    end
+
+    def finish_case(kase)
+    end
+
+    def finish_suite(suite)
+      io.puts("\nFinished in %.5f seconds." % [Time.now - @time])
+
+      report = ''
+
+      list = []
+      suite.each do |testcase|
+        testcase.each do |testunit|
+          if testunit.fail? || testunit.error?
+            list << testunit
+          end
+        end
+      end
+
+      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"
+        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
+
+  private
+
+    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
+    end
+
+  end
+
+end
+

data/lib/turn/reporters/marshal_reporter.rb

@@ -0,0 +1,17 @@
+require 'turn/reporter'
+require 'yaml'
+
+module Turn
+
+  # = Marshal Reporter
+  #
+  class MarshalReporter < Reporter
+
+    def finish_suite(suite)    
+      $stdout << suite.to_yaml
+    end
+
+  end
+
+end
+

data/lib/turn/reporters/outline_reporter.rb

@@ -0,0 +1,144 @@
+require 'turn/reporter'
+require 'stringio'
+
+module Turn
+
+  # = Outline Reporter (Turn's Original)
+  #
+  #--
+  # TODO: Should we fit reporter output to width of console?
+  # TODO: Running percentages?
+  #++
+  class OutlineReporter < Reporter
+
+    #
+    def start_suite(suite)
+      @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"
+    end
+
+    #
+    def start_case(kase)
+      io.puts(Colorize.bold("#{kase.name}"))
+    end
+
+    #
+    def start_test(test)
+      #if @file != test.file
+      #  @file = test.file
+      #  io.puts(test.file)
+      #end
+      io.print "    %-69s" % test.name
+
+      @stdout.rewind
+      @stderr.rewind
+
+      $stdout = @stdout
+      $stderr = @stderr unless $DEBUG
+    end
+
+    #
+    def pass(message=nil)
+      io.puts " #{PASS}"
+      if message
+        message = Colorize.magenta(message)
+        message = message.to_s.tabto(8)
+        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
+      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(message.tabto(8))
+      io.puts "STDERR:".tabto(8)
+      io.puts(backtrace.tabto(8))
+      show_captured_output
+    end
+
+    #
+    def finish_test(test)
+      $stdout = STDOUT
+      $stderr = STDERR
+    end
+
+    #
+    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
+    end
+
+# No longer used b/c of error messages are fairly extraneous.
+=begin
+    def show_captured_stderr
+      @stderr.rewind
+      return if @stderr.eof?
+      STDOUT.puts(<<-output.tabto(8))
+\nSTDERR:
+#{@stderr.read}
+      output
+    end
+=end
+
+    #
+    #def finish_case(kase)
+    #end
+
+    #
+    def finish_suite(suite)
+      total   = suite.count_tests
+      failure = suite.count_failures
+      error   = suite.count_errors
+      pass    = total - failure - error
+
+      bar = '=' * 78
+      if COLORIZE
+        bar = if pass == total then Colorize.green(bar)
+              else Colorize.red(bar) end
+      end
+
+      tally = [total, suite.count_assertions]
+
+      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 bar
+    end
+
+  end
+
+end
+

data/lib/turn/reporters/pretty_reporter.rb

@@ -0,0 +1,184 @@
+require 'turn/reporter'
+
+module Turn
+
+  # = Pretty Reporter (by Paydro)
+  #
+  class PrettyReporter < Reporter
+    #
+    PADDING_SIZE = 4
+
+    #
+    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"
+    end
+
+    #
+    def start_case(kase)
+      #if kase.size > 0  # TODO: Don't have size yet?
+        io.print "\n#{kase.name}:\n"
+      #end
+    end
+
+    #
+    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
+
+    #
+    def pass(message=nil)
+      io.print pad_with_size("#{PASS}")
+      io.print " #{@test}"
+      io.print " (%.2fs) " % (Time.now - @test_time)
+      if message
+        message = Colorize.magenta(message)
+        message = message.to_s.tabto(10)
+        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
+
+      message = assertion.message
+
+      if assertion.respond_to?(:backtrace)
+        trace = filter_backtrace(assertion.backtrace).first
+      else
+        trace = filter_backtrace(assertion.location).first
+      end
+
+      io.puts
+      #io.puts pad(message, 10)
+      io.puts message.tabto(10)
+      io.puts trace.tabto(10)
+      #show_captured_output
+    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")
+
+      message = exception.message
+
+      if exception.respond_to?(:backtrace)
+        trace = filter_backtrace(exception.backtrace).first
+      else
+        trace = filter_backtrace(exception.location).first
+      end
+
+      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
+
+    #
+    def finish_test(test)
+      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
+    end
+
+    def show_captured_stderr
+      @stderr.rewind
+      return if @stderr.eof?
+      STDOUT.puts(<<-output.tabto(8))
+\nSTDERR:
+#{@stderr.read}
+      output
+    end
+=end
+
+    def finish_case(kase)
+      if kase.size == 0
+        io.puts pad("(No Tests)")
+      end
+    end
+
+    #
+    def finish_suite(suite)
+      #@@out.sync = old_sync if @@out.respond_to? :sync=
+
+      total   = suite.count_tests
+      failure = suite.count_failures
+      error   = suite.count_errors
+      #pass    = total - failure - error
+
+      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
+
+    #
+    def pad(str, size=PADDING_SIZE)
+      " " * size + str
+    end
+
+    #
+    def pad_with_size(str)
+      " " * (18 - str.size) + str
+    end
+
+  end
+
+end
+

data/lib/turn/reporters/progress_reporter.rb

@@ -0,0 +1,116 @@
+require 'turn/reporter'
+require 'ansi/progressbar'
+
+module Turn
+
+  #
+  class ProgressReporter < Reporter
+
+    def start_suite(suite)
+      @pbar = ::ANSI::Progressbar.new('Testing', suite.size)
+      @pbar.inc
+    end
+
+    #def start_case(kase)
+    #end
+
+    #def start_test(test)
+    #end
+
+    #def pass(message=nil)
+    #  #@pbar.inc
+    #end
+
+    #def fail(message=nil)
+    #  #@pbar.inc
+    #end
+
+    #def error(message=nil)
+    #  #@pbar.inc
+    #end
+
+    def finish_case(kase)
+      @pbar.inc
+    end
+
+    def finish_suite(suite)
+      @pbar.finish
+      post_report(suite)
+    end
+
+    #
+    def post_report(suite)
+      tally = test_tally(suite)
+
+      width = suite.collect{ |tr| tr.name.size }.max
+
+      headers = [ 'TESTCASE  ', '  TESTS   ', 'ASSERTIONS', ' FAILURES ', '  ERRORS   ' ]
+      io.puts "\n%-#{width}s       %10s %10s %10s %10s\n" % headers
+
+      files = nil
+
+      suite.each do |testrun|
+        if testrun.files != [testrun.name] && testrun.files != files
+          label = testrun.files.join(' ')
+          label = Colorize.magenta(label)
+          io.puts(label + "\n")
+          files = testrun.files
+        end
+        io.puts paint_line(testrun, width)
+      end
+
+      #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
+
+      io.puts(tally_line + "\n")
+
+      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)
+            io.puts(message+"\n\n")
+          end
+          io.puts
+        end
+      #end
+    end
+
+  private
+
+    def paint_line(testrun, width)
+      line = ''
+      line << "%-#{width}s  " % [testrun.name]
+      line << "%10s %10s %10s %10s" % testrun.counts
+      line << " " * 8
+      if testrun.fail?
+        line << "[#{FAIL}]"
+      elsif testrun.error?
+        line << "[#{FAIL}]"
+      else
+        line << "[#{PASS}]"
+      end
+      line
+    end
+
+    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
+    end
+
+  end
+
+end
+