openlogic-turn 0.8.2

data/lib/turn/runners/solorunner.rb

@@ -0,0 +1,8 @@
+module Turn
+  require 'turn/runners/isorunner'
+
+  class SoloRunner < IsoRunner
+  end
+
+end
+

data/lib/turn/runners/testrunner.rb

@@ -0,0 +1,166 @@
+#require 'test/unit'; Test::Unit.run = false
+require 'test/unit/ui/console/testrunner'
+
+#require 'turn/colorize'
+#require 'turn/components/suite.rb'
+#require 'turn/components/case.rb'
+#require 'turn/components/method.rb'
+#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
+  #
+  class TestRunner < ::Test::Unit::UI::Console::TestRunner
+
+    def initialize(controller)
+      output_level = 2 # 2-NORMAL 3-VERBOSE
+
+      controller.loadpath.each{ |path| $: << path } unless controller.live?
+      controller.requires.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|
+        if(Test::Unit::TestCase > klass)
+          sub_suites << klass.suite
+        end
+      end
+      suite = Test::Unit::TestSuite.new(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
+
+      @t_reporter = controller.reporter
+
+      super(suite, output_level, $stdout)
+    end
+
+    # Is this needed?
+    alias :t_attach_to_mediator :attach_to_mediator
+
+    def attach_to_mediator
+      @mediator.add_listener(::Test::Unit::UI::TestRunnerMediator::STARTED, &method(:t_started))
+      @mediator.add_listener(::Test::Unit::UI::TestRunnerMediator::FINISHED, &method(:t_finished))
+      @mediator.add_listener(::Test::Unit::TestSuite::STARTED, &method(:t_case_started))
+      @mediator.add_listener(::Test::Unit::TestSuite::FINISHED, &method(:t_case_finished))
+      @mediator.add_listener(::Test::Unit::TestCase::STARTED, &method(:t_test_started))
+      @mediator.add_listener(::Test::Unit::TestCase::FINISHED, &method(:t_test_finished))
+      @mediator.add_listener(::Test::Unit::TestResult::FAULT, &method(:t_fault))
+
+      @io.sync    = true
+
+      @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
+      @t_previous_assertion_count = 0
+    end
+
+    def t_started(result)
+      @t_suite = Turn::TestSuite.new(@suite.name)
+      @t_suite.size = @suite.size
+      @t_result = result
+      @t_reporter.start_suite(@t_suite)
+    end
+
+    def t_case_started(name)
+      # Err.. why is testunit running this on the suite?
+      (@not_first_case = true; return) unless @not_first_case
+      @t_case = @t_suite.new_case(name)
+      @t_reporter.start_case(@t_case)
+    end
+
+    def t_test_started(name)
+      methname, tcase = name.scan(%r/^([^\(]+)\(([^\)]+)\)/o).flatten!
+      @t_test = @t_case.new_test(methname)
+      #@t_test.file = tcase
+      #@t_test.name = method
+      @t_reporter.start_test(@t_test)
+    end
+
+    def t_fault(fault)
+      case fault
+      when ::Test::Unit::Error
+        #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!(fault)
+        @t_reporter.fail(fault)
+      end
+    end
+
+    def t_test_finished(name)
+      @t_reporter.pass if @t_test.pass?
+      @t_reporter.finish_test(@t_test)
+    end
+
+      def t_case_finished(name)
+      # Err.. why is testunit running this on the suite?
+      return if name=='' # FIXME skip suite call
+
+      #t = @t_result.run_count       - @t_previous_run_count
+      #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
+
+      #@t_previous_run_count       = @t_result.run_count.to_i
+      #@t_previous_failure_count   = @t_result.failure_count.to_i
+      #@t_previous_error_count     = @t_result.error_count.to_i
+      @t_previous_assertion_count = @t_result.assertion_count.to_i
+
+      @t_reporter.finish_case(@t_case)
+    end
+
+    def t_finished(elapsed_time)
+      #@t_suite.count_tests      = @t_result.run_count
+      #@t_suite.count_failures   = @t_result.failure_count
+      #@t_suite.count_errors     = @t_result.error_count
+      #@t_suite.count_passes     = @t_result.run_count - @t_result.failure_count - @t_result.error_count
+      @t_suite.count_assertions = @t_result.assertion_count
+
+      @t_reporter.finish_suite(@t_suite)
+    end
+
+    # This is copied verbatim from test/unit/ui/console/testrunner.rb.
+    # It is here for one simple reason: to supress testunits output of
+    # "Loaded Suite".
+    def setup_mediator
+      @mediator = create_mediator(@suite)
+      suite_name = @suite.to_s
+      if ( @suite.kind_of?(Module) )
+        suite_name = @suite.name
+      end
+      #output("Loaded suite #{suite_name}")
+    end
+
+  end#class TestRunner
+
+end#module Turn
+

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

data/test/test_framework.rb

@@ -0,0 +1,131 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+# Test on Ruby 1.9+
+if RUBY_VERSION >= '1.9'
+
+  class TestRuby19Framework < MiniTest::Unit::TestCase
+
+    def test_ruby19_minitest
+      setup_test('MiniTest')
+      result = turn 'tmp/test.rb'
+      assert result.index('PASS')
+    end
+
+    def test_ruby19_minitest_force
+      setup_test('MiniTest')
+      result = turn '--minitest tmp/test.rb'
+      assert result.index('PASS')
+    end
+
+    def test_ruby19_minitest_required
+      setup_test('MiniTest', 'minitest/unit')
+      result = turn 'tmp/test.rb'
+      assert result.index('PASS')
+    end
+
+    def test_ruby19_minitest_required_force
+      setup_test('MiniTest', 'minitest/unit')
+      result = turn '--minitest tmp/test.rb'
+      assert result.index('PASS')
+    end
+
+    def test_ruby19_minitest_mocking
+      setup_test('Test')
+      result = turn 'tmp/test.rb'
+      assert result.index('PASS')
+    end
+
+    def test_ruby19_minitest_mocking_force
+      setup_test('Test')
+      result = turn '--minitest tmp/test.rb'
+      assert result.index('PASS')
+    end
+
+    def test_ruby19_minitest_mocking_required
+      setup_test('Test', 'minitest/unit')
+      result = turn 'tmp/test.rb'
+      assert result.index('PASS')
+    end
+
+    def test_ruby19_minitest_mocking_required_force
+      setup_test('Test', 'minitest/unit')
+      result = turn '--minitest tmp/test.rb'
+      assert result.index('PASS')
+    end
+
+    # Ruby 1.9 users must remove ++require 'test/unit'++ from their tests.
+    #def test_ruby19_testunit_required
+    #  setup_test('Test', 'test/unit')
+    #  result = turn 'turn tmp/test.rb'
+    #  assert result.index('PASS')
+    #end
+
+    # Turn does not support Test::Unit 2.0+.
+    #def test_ruby19_testunit_force
+    #  setup_test('Test')
+    #  result = turn '--testunit tmp/test.rb'
+    #  assert result.index('PASS')
+    #end
+
+    # Turn does not support Test::Unit 2.0+.
+    #def test_ruby19_testunit_required_force
+    #  setup_test('Test', 'test/unit')
+    #  result = turn '--testunit tmp/test.rb'
+    #  assert result.index('PASS')
+    #end
+
+  end
+
+else
+
+  class TestRuby18Framework < Test::Unit::TestCase
+
+    def test_ruby18_testunit
+      setup_test('Test')
+      result = turn 'tmp/test.rb'
+      assert result.index('PASS')
+    end
+
+    def test_ruby18_testunit_required
+      setup_test('Test', 'test/unit')
+      result = turn 'tmp/test.rb'
+      assert result.index('PASS')
+    end
+
+    def test_ruby18_minitest
+      setup_test('MiniTest')
+      result = turn '--minitest tmp/test.rb'
+      assert result.index('PASS')
+    end
+
+    def test_ruby18_minitest_mocking_testunit
+      setup_test('Test')
+      result = turn '--minitest tmp/test.rb'
+      assert result.index('PASS')
+    end
+
+    # You can't use minitest and have ++require 'test/unit'++ in your tests.
+    #def test_ruby18_minitest_mocking_testunit_required
+    #  setup_test('Test', 'test/unit')
+    #  result = turn '--minitest tmp/test.rb'
+    #  assert result.index('PASS')
+    #end
+
+    # If you want to use minitest with Ruby 1.8 you have to use force option.
+    # TODO: add turn configuration to automatically do this.
+    #def test_ruby18_minitest_required
+    #  setup_test('MiniTest', 'minitest/unit')
+    #  result = turn 'tmp/test.rb'
+    #  assert result.index('PASS')
+    #end
+
+    def test_ruby18_minitest_required_force
+      setup_test('MiniTest', 'minitest/unit')
+      result = turn '--minitest tmp/test.rb'
+      assert result.index('PASS')
+    end
+
+  end
+
+end
+

data/test/test_reporters.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestReporters < Test::Unit::TestCase
+
+  begin
+    require 'ansi'
+    def test_progress
+      file = setup_test('Test')
+      result = turn '--progress', file
+      assert(result.index('PASS'), result)
+    end
+  rescue LoadError
+  end
+
+  def test_dotted
+    file = setup_test('Test')
+    result = turn '--dotted', file
+    assert result.index('0 failures')
+    assert result.index('0 errors')
+  end
+
+  def test_marshal
+    file = setup_test('Test')
+    result = turn '--marshal', file
+    assert !result.index('error: true')
+    assert !result.index('fail: true')
+  end
+
+  def test_outline
+    file = setup_outline_test
+    result = turn '--outline', file
+    assert result.index('You should see me')
+    assert !result.index('You should not see me')
+  end
+
+  def test_pretty
+    file = setup_test('Test')
+    result = turn '--pretty', file
+    assert result.index('0 errors')
+    assert result.index('0 failures')
+  end
+
+end
+