turn 0.7.0 → 0.8.0

data/lib/turn/runners/isorunner.rb

@@ -1,5 +1,7 @@
 module Turn
   require 'turn/colorize'
+  require 'yaml'
+  require 'open3'
 
   # = IsoRunner
   #
@@ -24,6 +26,7 @@ module Turn
       @loadpath = controller.loadpath
       @requires = controller.requires
       @live     = controller.live?
+      @minitest = controller.framework == :minitest
     end
 
   public
@@ -34,7 +37,8 @@ module Turn
     def start
       suite = TestSuite.new
       testruns = @controller.files.collect do |file|
-        suite.new_case(file)
+        name = file.sub(Dir.pwd+'/','')
+        suite.new_case(name, file)
       end
       test_loop_runner(suite)
     end
@@ -52,20 +56,37 @@ module Turn
       suite.each_with_index do |kase, index|
         reporter.start_case(kase)
 
+        turn_path = File.expand_path(File.dirname(__FILE__) + '/../bin.rb')
+
+        files = kase.files.map{ |f| f.sub(Dir.pwd+'/', '') }
+
         # 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 << "ruby"
+        cmd << "-I#{@loadpath.join(':')}" unless @loadpath.empty?
+        cmd << "-r#{@requires.join(':')}" unless @requires.empty?
+        cmd << "--"
+        cmd << turn_path
+        cmd << "--marshal"
+        cmd << %[--loadpath="#{@loadpath.join(':')}"] unless @loadpath.empty?
+        cmd << %[--requires="#{@requires.join(':')}"] unless @requires.empty?
+        cmd << "--live" if @live
+        cmd << "--minitest" if @minitest
+        cmd << files.join(' ')
         cmd = cmd.join(' ')
-        result = `#{cmd}`
+
+        #out = `#{cmd}`
+
+        out, err = nil, nil
+        Open3.popen3(cmd) do |stdin, stdout, stderr|
+          stdin.close
+          out = stdout.read.chomp
+          err = stderr.read.chomp
+        end
 
         files = kase.files
 
-        head, yaml = *result.split('---')
+        head, yaml = *out.split('---')
         sub_suite = YAML.load(yaml)
 
         # TODO: How to handle pairs?
@@ -95,8 +116,14 @@ module Turn
 
       reporter.finish_suite(suite)
 
-      # shutdown test/unit auto runner if test/unit is loaded.
-      ::Test::Unit.run=true rescue nil
+      # shutdown auto runner
+      if @minitest
+
+      else
+        ::Test::Unit.run=true rescue nil
+      end
+
+      suite
     end
 
     #

data/lib/turn/runners/minirunner.rb

@@ -0,0 +1,189 @@
+#
+
+# Becuase of some wierdness in MiniTest
+debug, $DEBUG = $DEBUG, false
+require 'minitest/unit'
+$DEBUG = debug
+
+Test = MiniTest
+
+module Turn
+
+  # = MiniTest TestRunner
+  #
+  class MiniRunner < ::MiniTest::Unit
+
+    #
+    def initialize(controller)
+
+      controller.loadpath.each{ |path| $: << path } unless controller.live?
+      controller.requires.each{ |path| require(path) }
+
+      [controller.files].flatten.each{ |path| require(path) }
+
+      files = [controller.files].flatten
+      files.each{ |path| require(path) }   
+
+      # TODO: Better name ?
+      @turn_suite_name = files.map{ |path| File.dirname(path).sub(Dir.pwd+'/','') }.uniq.join(',')
+
+      #sub_suites = []
+      #ObjectSpace.each_object(Class) do |klass|
+      #  if(Test::Unit::TestCase > klass)
+      #    sub_suites << klass.suite
+      #  end
+      #end
+      #suite = Test::Unit::TestSuite.new('')  # FIXME: Name?
+      #sub_suites.sort_by{|s|s.name}.each{|s| suite << s}
+
+      #suite.tests.each do |c|
+      #  pattern = controller.pattern
+      #  c.tests.reject! { |t| pattern !~ t.method_name }
+      #end
+
+      @turn_logger = controller.reporter
+
+      super()
+    end
+
+    #
+    def start(args=[])
+      run(args)
+      return @turn_suite
+    end
+
+    #
+    def run(args = [])
+      @verbose = true
+
+      filter = if args.first =~ /^(-n|--name)$/ then
+                 args.shift
+                 arg = args.shift
+                 arg =~ /\/(.*)\// ? Regexp.new($1) : arg
+               else
+                 /./ # anything - ^test_ already filtered by #tests
+               end
+
+      #@@out.puts "Loaded suite #{$0.sub(/\.rb$/, '')}\nStarted"
+
+      start = Time.now
+
+      run_test_suites(filter)
+
+      return failures + errors if @test_count > 0 # or return nil...
+    end
+
+    #
+    def run_test_suites(filter = /./)
+      @test_count, @assertion_count = 0, 0
+      old_sync, @@out.sync = @@out.sync, true if @@out.respond_to? :sync=
+
+      @turn_suite = Turn::TestSuite.new(@turn_suite_name)
+      @turn_suite.size = ::MiniTest::Unit::TestCase.test_suites.size
+      @turn_logger.start_suite(@turn_suite)
+
+      ::MiniTest::Unit::TestCase.test_suites.each do |kase|
+
+        test_cases = kase.test_methods.grep(filter)
+
+        @turn_case = @turn_suite.new_case(kase.name)
+
+        turn_cases = test_cases.map do |test|
+          @turn_case.new_test(test)
+        end
+
+        @turn_logger.start_case(@turn_case)
+
+        turn_cases.each do |test|
+          #methname, tcase = name.scan(%r/^([^\(]+)\(([^\)]+)\)/o).flatten!
+          @turn_test = test #@turn_case.new_test(test)
+          @turn_logger.start_test(@turn_test)
+
+          inst = kase.new(test.name)
+          inst._assertions = 0
+
+          result = inst.run(self)
+          report = @report.last
+
+          case result
+          when :pass
+            @turn_logger.pass
+          when :error
+            #trace = ::MiniTest::filter_backtrace(report[:exception].backtrace).first
+            @turn_test.error!(report)
+            @turn_logger.error(report)
+          when :fail
+            #trace = ::MiniTest::filter_backtrace(report[:exception].backtrace).first
+            @turn_test.fail!(report)
+            @turn_logger.fail(report)
+          when :skip
+            @turn_test.skip! #(report)
+            @turn_logger.skip #(report)
+          end
+
+          @turn_logger.finish_test(@turn_test)
+
+          @test_count += 1
+          @assertion_count += inst._assertions
+        end
+        @turn_case.count_assertions = @assertion_count  # for lack of a better appraoch
+        @turn_logger.finish_case(@turn_case)
+      end
+      @turn_logger.finish_suite(@turn_suite)
+      @@out.sync = old_sync if @@out.respond_to? :sync=
+      [@test_count, @assertion_count]
+    end
+
+    # Overwrite #puke method so that is stores a hash
+    # with :message and :exception keys.
+    def puke(klass, meth, e)
+      result = nil
+      msg = case e
+          when ::MiniTest::Skip
+            @skips += 1
+            result = :skip
+            e.message
+          when ::MiniTest::Assertion
+            @failures += 1
+            result = :fail
+            e.message
+          else
+            @errors += 1
+            result = :error
+            "#{e.class}: #{e.message}\n"
+          end
+
+      @report << e #{:message => msg, :exception => e}
+      result
+    end
+
+  end
+
+end
+
+class ::MiniTest::Unit::TestCase
+  old_verbose, $VERBOSE = $VERBOSE, false
+  # Overwrite #run method so that is uses symbols
+  # as return values rather than characters.
+  def run(runner)
+    result = :pass
+    begin
+      @passed = nil
+      self.setup
+      self.__send__(self.__name__.to_s)
+      @passed = true
+    rescue Exception => e
+      @passed = false
+      result = runner.puke(self.class, self.__name__.to_s, e)
+    ensure
+      begin
+        self.teardown
+      rescue Exception => e
+        result = runner.puke(self.class, self.__name__.to_s, e)
+      end
+    end
+    result
+  end
+  $VERBOSE = old_verbose
+end
+

data/lib/turn/runners/testrunner.rb

@@ -8,13 +8,14 @@ require 'test/unit/ui/console/testrunner'
 #require 'turn/reporters/outline_reporter.rb'
 #require 'turn/reporters/progress_reporter.rb'
 
+class Test::Unit::Failure
+  alias_method :backtrace, :location
+end
+
 module Turn
 
   # = TestUnit TestRunner
   #
-  #--
-  # TODO: Add minitest runner.
-  #++
   class TestRunner < ::Test::Unit::UI::Console::TestRunner
 
     def initialize(controller)
@@ -23,7 +24,11 @@ module Turn
       controller.loadpath.each{ |path| $: << path } unless controller.live?
       controller.requires.each{ |path| require(path) }
 
-      [controller.files].flatten.each{ |path| require(path) }
+      files = [controller.files].flatten
+      files.each{ |path| require(path) }   
+
+      # TODO: Better name ?
+      name = files.map{ |path| File.dirname(path).sub(Dir.pwd+'/','') }.uniq.join(',')
 
       sub_suites = []
       ObjectSpace.each_object(Class) do |klass|
@@ -31,7 +36,8 @@ module Turn
           sub_suites << klass.suite
         end
       end
-      suite = Test::Unit::TestSuite.new('')  # FIXME: Name?
+      suite = Test::Unit::TestSuite.new(name)
+
       sub_suites.sort_by{|s|s.name}.each{|s| suite << s}
 
       suite.tests.each do |c|
@@ -61,6 +67,8 @@ module Turn
       @t_result   = nil
       @t_fault    = nil
 
+      @not_first_case = nil
+
       @t_previous_run_count       = 0
       @t_previous_error_count     = 0
       @t_previous_failure_count   = 0
@@ -68,7 +76,7 @@ module Turn
     end
 
     def t_started(result)
-      @t_suite = Turn::TestSuite.new #@suite
+      @t_suite = Turn::TestSuite.new(@suite.name)
       @t_suite.size = @suite.size
       @t_result = result
       @t_reporter.start_suite(@t_suite)
@@ -92,16 +100,16 @@ module Turn
     def t_fault(fault)
       case fault
       when ::Test::Unit::Error
-        msg = ""
-        msg << fault.to_s.split("\n")[2..-1].join("\n")
-        @t_test.error!(msg)
-        @t_reporter.error(msg)
+        #msg = ""
+        #msg << fault.to_s.split("\n")[2..-1].join("\n")
+        @t_test.error!(fault.exception)
+        @t_reporter.error(fault.exception)
       when ::Test::Unit::Failure
-        msg = ""
-        msg << fault.location[0] << "\n"
-        msg << fault.message #.gsub("\n","\n")
-        @t_test.fail!(msg)
-        @t_reporter.fail(msg)
+        #msg = ""
+        #msg << fault.location[0] << "\n"
+        #msg << fault.message #.gsub("\n","\n")
+        @t_test.fail!(fault)
+        @t_reporter.fail(fault)
       end
     end
 
@@ -118,7 +126,6 @@ module Turn
       #f = @t_result.failure_count   - @t_previous_failure_count
       #e = @t_result.error_count     - @t_previous_error_count
       a = @t_result.assertion_count - @t_previous_assertion_count
-
       #@t_case.counts(t,a,f,e)
 
       @t_case.count_assertions = a

data/lib/turn.rb

@@ -1,102 +1,19 @@
-require 'test/unit/ui/console/testrunner'
-require 'turn/colorize'
-
-module ::Test::Unit
-module UI
-module Console
-  class TestRunner
-    include Turn::Colorize
-
-    # 1.x of test/unut used @io, where as 2.x uses @output.
-    def turn_out
-      @turn_out ||= (@io || @output)
-    end
-
-    alias :t_attach_to_mediator :attach_to_mediator
-    def attach_to_mediator
-      @mediator.add_listener(TestRunnerMediator::STARTED, &method(:t_started))
-      @mediator.add_listener(TestRunnerMediator::FINISHED, &method(:t_finished))
-      @mediator.add_listener(TestCase::STARTED, &method(:t_test_started))
-      @mediator.add_listener(TestCase::FINISHED, &method(:t_test_finished))
-      @mediator.add_listener(TestResult::FAULT, &method(:t_fault))
-      turn_out.sync = true
-      @t_cur_file, @t_fault = nil
-    end
-
-    def t_started( result )
-      @t_result = result
-    end
-
-    def t_finished( elapsed_time )
-      failure = @t_result.failure_count
-      error   = @t_result.error_count
-      total   = @t_result.run_count
-      pass = total - failure - error
-
-      bar = '=' * 78
-      if COLORIZE
-        bar = if pass == total then ::ANSI::Code.green bar
-              else ::ANSI::Code.red bar end
-      end
-
-      turn_out.puts bar
-      turn_out.puts "  pass: %d,  fail: %d,  error: %d" % [pass, failure, error]
-      turn_out.puts "  total: %d tests with %d assertions in #{elapsed_time} seconds" % [total, @t_result.assertion_count]
-      turn_out.puts bar
-    end
-
-    def t_test_started( name )
-      method, file = name.scan(%r/^([^\(]+)\(([^\)]+)\)/o).flatten!
-      if @t_cur_file != file
-        @t_cur_file = file
-        file = COLORIZE ? ::ANSI::Code.yellow(file) : file
-        turn_out.puts file
-      end
-      turn_out.print "    %-69s" % method
-    end
-
-    def t_test_finished( name )
-      turn_out.puts " #{PASS}" unless @t_fault
-      @t_fault = false
-    end
-
-    def t_fault( fault )
-      @t_fault = true
-      msg = "\t"
-
-      case fault
-      when ::Test::Unit::Error
-        turn_out.puts ERROR
-        msg << fault.to_s.split("\n")[2..-1].join("\n\t")
-      when ::Test::Unit::Failure
-        turn_out.puts " #{FAIL}"
-        msg << fault.location[0].to_s << "\n\t"
-        msg << fault.message.gsub("\n","\n\t")
-      end
-
-      msg = ::ANSI::Code.magenta msg if COLORIZE
-      turn_out.puts msg
-    end
-
-    private
-    def setup_mediator
-       @mediator = create_mediator(@suite)
-       suite_name = @suite.to_s
-       if ( @suite.kind_of?(Module) )
-         suite_name = @suite.name
-       end
-       msg = rails? ? "\n" : "Loaded suite #{suite_name}" #always same in rails so scrap it
-       output(msg)
-    end
-
-    def rails?
-      $:.to_s.include? "rails"
-    end
-
-
+module Turn
+  # Returns +true+ if the ruby version supports minitest.
+  # Otherwise, +false+ is returned.
+  def self.minitest?
+    RUBY_VERSION >= '1.9'
   end
 end
-end
+
+unless defined?(Turn::Command)
+  if Turn.minitest?
+    require 'turn/autorun/minitest'
+    MiniTest::Unit.autorun
+  else
+    require 'turn/autorun/testunit'
+  end
+  #autoload :Test,     'turn/autorun/testunit'
+  #autoload :MiniTest, 'turn/autorun/minitest'
 end
 
-# EOF

data/test/helper.rb

@@ -0,0 +1,97 @@
+require 'fileutils'
+
+if RUBY_VERSION < "1.9"
+  require 'test/unit'
+else
+  require 'minitest/unit'
+end
+
+#
+def turn(*args)
+  `ruby -Ilib bin/turn -Ilib #{args.join(' ')} 2>&1`
+end
+
+#
+def turn2(*args)
+  `ruby -Ilib bin/turn -Ilib #{args.join(' ')}`
+end
+
+#
+def setup_test(framework, required=false, name=nil)
+  text = ''
+  text << "require '#{required}'\n" if required
+  text << <<-HERE
+class TestTest < #{framework}::Unit::TestCase
+#{standard_test_body}
+end
+  HERE
+  #name = framwwork.downcase
+  #name = name + '_required' if requires
+  save_test(text, name)
+end
+
+#
+def save_test(text, name=nil)
+  file = File.join('tmp', name || 'test.rb')
+  FileUtils.mkdir_p('tmp')
+  File.open(file, 'w'){ |f| f << text }
+  return file
+end
+
+#
+def standard_test_body
+<<-HERE
+  def test_pass
+    assert_equal(1,1)
+  end
+HERE
+end
+
+#
+def guanlent_test_body
+<<-HERE
+  def test_pass
+    assert_equal(1,1)
+  end
+
+  def test_fail
+    assert_equal(1,2)
+  end
+
+  def test_error
+    raise
+  end
+HERE
+end
+
+#
+def setup_outline_test
+  text = <<-HERE
+class OutlineTest < Test::Unit::TestCase
+  def test_sample_pass
+    puts "You should not see me"
+    assert_equal(1,1)
+  end
+  def test_sample_fail
+    puts "You should see me"
+    assert_equal(1,2)
+  end
+end
+  HERE
+  save_test(text, 'outline_test.rb')
+end
+
+#
+def setup_minitest_autorun
+  text = <<-HERE
+require 'minitest/unit'
+MiniTest::Unit.autorun
+class TestTest < MiniTest::Unit::TestCase
+  def test_sample_pass
+    assert_equal(1,1)
+  end
+end
+  HERE
+  save_test(text, 'minitest_autorun_test.rb')
+end
+

data/test/runner

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+ruby -Ilib bin/turn -Ilib test/*.rb