turn 0.3.0 → 0.4.0

data/lib/turn/reporters/marshal_reporter.rb

@@ -0,0 +1,64 @@
+require 'yaml'
+
+module Turn
+  require 'turn/reporter'
+
+  # = Marshal Reporter
+  #
+  class MarshalReporter < Reporter
+
+    #def start_suite(suite)
+    #  #@suite = suite
+    #  #@time  = Time.now
+    #  #files = suite.collect{ |s| s.file }.join(' ')
+    #  #io.puts "Loaded suite #{suite.name}"
+    #  #io.puts "Started"
+    #end
+
+    #def start_test(test)
+    #  #if @file != test.file
+    #  #  @file = test.file
+    #  #  io.puts(test.file)
+    #  #end
+    #  io.print "    %-69s" % test.name
+    #end
+
+    #def start_case(kase)
+    #  io.puts(kase.name)
+    #end
+
+    #def pass(message=nil)
+    #  io.puts " #{PASS}"
+    #  if message
+    #    message = ::ANSICode.magenta(message) if COLORIZE
+    #    io.puts(message.to_s)
+    #  end
+    #end
+
+    #def fail(message=nil)
+    #  io.puts(" #{FAIL}")
+    #  if message
+    #    message = ::ANSICode.magenta(message) if COLORIZE
+    #    io.puts(message.to_s)
+    #  end
+    #end
+
+    #def error(message=nil)
+    #  io.puts("#{ERROR}")
+    #  io.puts(message.to_s) if message
+    #end
+
+    #def finish_test(test)
+    #end
+
+    #def finish_case(kase)
+    #end
+
+    def finish_suite(suite)    
+      $stdout << suite.to_yaml
+    end
+
+  end
+
+end
+

data/lib/turn/reporters/outline_reporter.rb

@@ -0,0 +1,85 @@
+require 'turn/reporter'
+
+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
+      #files = suite.collect{ |s| s.file }.join(' ')
+      io.puts "Loaded suite #{suite.name}"
+      #io.puts "Started"
+    end
+
+    def start_case(kase)
+      io.puts(kase.name)
+    end
+
+    def start_test(test)
+      #if @file != test.file
+      #  @file = test.file
+      #  io.puts(test.file)
+      #end
+      io.print "    %-69s" % test.name
+    end
+
+    def pass(message=nil)
+      io.puts " #{PASS}"
+      if message
+        message = ::ANSICode.magenta(message) if COLORIZE
+        message = message.to_s.tabto(8)
+        io.puts(message)
+      end
+    end
+
+    def fail(message=nil)
+      io.puts(" #{FAIL}")
+      if message
+        message = ::ANSICode.magenta(message) if COLORIZE
+        message = message.to_s.tabto(8)
+        io.puts(message)
+      end
+    end
+
+    def error(message=nil)
+      io.puts("#{ERROR}")
+      io.puts(message.to_s) if message
+    end
+
+    def finish_test(test)
+    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 ::ANSICode.green bar
+              else ::ANSICode.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/progress_reporter.rb

@@ -0,0 +1,117 @@
+require 'turn/reporter'
+require 'facets/progressbar'
+require 'facets/string/tab'
+
+module Turn
+
+  #
+  class ProgressReporter < Reporter
+
+    def start_suite(suite)
+      @pbar = ::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 = ::ANSICode.magenta(label) if COLORIZE
+          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 = ::ANSICode.red(message) if COLORIZE
+            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
+

data/lib/turn/runners/crossrunner.rb

@@ -0,0 +1,40 @@
+module Turn
+  require 'turn/runners/isorunner'
+
+  # = Cross Runner
+  #
+  # Cross Runner runs test in pairs.
+  #
+  # TODO: This needs work in the test_loop_runner.
+  #       It needs to show the files being cross tested.
+  #
+  # TODO: Cross runner output needs to be fixed
+  class CrossRunner < IsoRunner
+
+    #
+    def start
+      suite = TestSuite.new
+
+      files = @controller.files
+      viles = @controller.files # TODO: viles this 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) }
+
+      max = (files+viles).collect{ |f| f.size }.max
+
+      pairs = files.inject([]){ |m, f| viles.collect{ |v| m << [f,v] }; m }
+      pairs = pairs.reject{ |f,v| f == v }
+
+      testruns = pairs.collect do |file, versus|
+        name = "%-#{max}s %-#{max}s" % [file, versus]
+        suite.new_case(name, file, versus)
+      end
+
+      test_loop_runner(suite)
+    end
+
+  end
+
+end
+

data/lib/turn/runners/isorunner.rb

@@ -0,0 +1,129 @@
+module Turn
+  require 'turn/colorize'
+
+  # = IsoRunner
+  #
+  # Iso Runner provides means from running unit test
+  # in isolated processes. It can do this either by running
+  # each test in isolation (solo testing) or in pairs (cross testing).
+  #
+  # The IsoRunner proiveds some variery in ouput formats and can also
+  # log results to a file.
+  #
+  class IsoRunner
+    include Turn::Colorize
+
+    attr :reporter
+
+  private
+
+    def initialize(controller)
+      @controller = controller
+      @reporter   = controller.reporter
+      #yield(self) if block_given?
+      @loadpath = controller.loadpath
+      @requires = controller.requires
+      @live     = controller.live?
+    end
+
+  public
+
+    # Runs the list of test calls passed to it.
+    # This is used by #test_solo and #test_cross.
+    #
+    def start
+      suite = TestSuite.new
+      testruns = @controller.files.collect do |file|
+        suite.new_case(file)
+      end
+      test_loop_runner(suite)
+    end
+
+  private
+
+    # The IsoRunner actually shells out to turn in
+    # manifest mode, to gather results from isolated
+    # runs.
+    def test_loop_runner(suite)
+      reporter.start_suite(suite)
+
+      recase = []
+
+      suite.each_with_index do |kase, index|
+        reporter.start_case(kase)
+
+        # FRACKING GENIUS RIGHT HERE !!!!!!!!!!!!
+        cmd = []
+        cmd << %[turn]
+        cmd << %[--marshal]
+        cmd << %[--loadpath="#{@loadpath.join(';')}"] unless @loadpath.empty?
+        cmd << %[--requires="#{@requires.join(';')}"] unless @requires.empty?
+        cmd << %[--live] if @live
+        cmd << %[#{kase.files.join(' ')}]
+        cmd = cmd.join(' ')
+        result = `#{cmd}`
+
+        files = kase.files
+
+        head, yaml = *result.split('---')
+        sub_suite = YAML.load(yaml)
+
+        # TODO: How to handle pairs?
+        #name  = kase.name
+        kases = sub_suite.cases
+        suite.cases[index] = kases
+
+        kases.each do |kase|
+          kase.files = files
+          #reporter.start_case(kase)
+          kase.tests.each do |test|
+            reporter.start_test(test)
+            if test.error?
+              reporter.error(test.message)
+            elsif test.fail?
+              reporter.fail(test.message)
+            else
+              reporter.pass
+            end
+            reporter.finish_test(test)
+          end
+          reporter.finish_case(kase)
+        end
+      end
+
+      suite.cases.flatten!
+
+      reporter.finish_suite(suite)
+
+      # shutdown test/unit auto runner if test/unit is loaded.
+      ::Test::Unit.run=true rescue nil
+    end
+
+    #
+    #def test_parse_result(result)
+    #  if md = /(\d+) tests, (\d+) assertions, (\d+) failures, (\d+) errors/.match(result)
+    #    count = md[1..4].collect{|q| q.to_i}
+    #  else
+    #    count = [1, 0, 0, 1]  # SHOULD NEVER HAPPEN
+    #  end
+    #  return count
+    #end
+
+    # NOT USED YET.
+    def log_report(report)
+      if log #&& !dryrun?
+        #logfile = File.join('log', apply_naming_policy('testlog', 'txt'))
+        FileUtils.mkdir_p('log')
+        logfile = File.join('log', 'testlog.txt')
+        File.open(logfile, 'a') do |f|
+          f << "= #{self.class} Test @ #{Time.now}\n"
+          f << report
+          f << "\n"
+        end
+      end
+    end
+
+  end#class IsoRunner
+
+end#module Turn
+

data/lib/turn/runners/loadrunner.rb

@@ -0,0 +1,48 @@
+# TODO
+
+    # Load each test independently to ensure there are no
+    # require dependency issues. This is actually a bit redundant
+    # as test-solo will also cover these results. So we may deprecate
+    # this in the future. This does not generate a test log entry.
+
+    def test_load(options={})
+      options = test_configuration(options)
+
+      tests    = options['tests']
+      loadpath = options['loadpath']
+      requires = options['requires']
+      live     = options['live']
+      exclude  = options['exclude']
+
+      files = Dir.multiglob_r(*tests) - Dir.multiglob_r(*exclude)
+
+      return puts("No tests.") if files.empty?
+
+      max   = files.collect{ |f| f.size }.max
+      list  = []
+
+      files.each do |f|
+        next unless File.file?(f)
+        if r = system("ruby -I#{loadpath.join(':')} #{f} > /dev/null 2>&1")
+          puts "%-#{max}s  [PASS]" % [f]  #if verbose?
+        else
+          puts "%-#{max}s  [FAIL]" % [f]  #if verbose?
+          list << f
+        end
+      end
+
+      puts "  #{list.size} Load Failures"
+
+      if verbose?
+        unless list.empty?
+          puts "\n-- Load Failures --\n"
+          list.each do |f|
+            print "* "
+            system "ruby -I#{loadpath} #{f} 2>&1"
+            #puts
+          end
+          puts
+        end
+      end
+    end
+