turn 0.7.0 → 0.8.0

data/History.txt

@@ -1,3 +1,11 @@
+== 0.8.0 / 2010-06-02
+  * Mintest support
+  * Two new reporters
+
+== 0.7.1 / 2009-12-25
+  * Copied String#tab from Facets.
+  * Facets is no longer needed as direct dependency.
+
 == 0.7.0 / 2009-10-13
   * Fix typo and potential bug.
   * Running ruby with /usr/bin/env for portability

data/README.txt

@@ -10,7 +10,7 @@ all the tests finish before you can see what the exact failure was. TURN
 displays each test on a separate line with failures being displayed
 immediately instead of at the end of the tests.
   
-If you have the 'facets' gem installed, then TURN output will be displayed in
+If you have the 'ansi' gem installed, then TURN output will be displayed in
 wonderful technicolor (but only if your terminal supports ANSI color codes).
 Well, the only colors are green and red, but that is still color.
 
@@ -40,12 +40,8 @@ application.
 
 == SYNOPSIS:
 
-If you have the 'facets' gem installed, then TURN output will be displayed in
-wonderful technicolor (but only if your terminal supports ANSI color codes).
-Well, the only colors are green and red, but that is still color.
-
-Note that the 'facets' gem is also required if you wish to use the
-progressbar output mode.
+Turn can be using from the command-line or via require. The command-line tool
+offers additional options for how one runs tests.
 
 === Command Line
 
@@ -87,7 +83,7 @@ scipt. Now your Rails tests will use TURN formatting.
 
 == REQUIREMENTS:
 
-* facets 2.0+ (for colorized output and progressbar output mode)
+* ansi 1.1+ (for colorized output and progressbar output mode)
 
 == INSTALL:
 

data/Rakefile

@@ -1,4 +1,3 @@
-
 begin
   require 'bones'
 rescue LoadError
@@ -13,7 +12,7 @@ Bones {
   authors      'Tim Pease'
   email        'tim.pease@gmail.com'
   url          'http://gemcutter.org/gems/turn'
-  version      File.read('.meta/version').strip
+  version      File.read('Version.txt').strip
   ignore_file  '.gitignore'
   rubyforge.name 'codeforpeople'
 
@@ -21,11 +20,21 @@ Bones {
   rdoc.exclude << '^lib'
 
   use_gmail
-  enable_sudo
 
   depend_on 'ansi'
-  depend_on 'facets'
   depend_on 'bones-git', :development => true
 }
 
+# Might be useful one day, so we'll leave it here.
+#
+# Rake::TaskManager.class_eval do
+#   def remove_task(task_name)
+#     @tasks.delete(task_name.to_s)
+#   end
+# end
+#
+# def remove_task(task_name)
+#   Rake.application.remove_task(task_name)
+# end
+
 # EOF

data/Release.txt

@@ -1,50 +1,33 @@
-= Turn 0.6.1
-
-The facets/ansicode.rb library has been spun off as a separate
-project called 'ansi'. So this version swaps out its optional
-color support for the new project as well. You can install it via:
-
-  gem install ansi
-
-You might want to take at the library, it has a few other
-interesting ANSI-related classes as well.
-
-== As of 0.6.0
-
-Turn 0.6 is now compatible with Test/Unit 2.0. 
-
-A instance variable name change made between 1.x and 2.0 series
-of test/unit prevent the Turn modified Testrunner from working
-correctly.
-
-Other than that this release is the same as the 0.5.1 release.
-
-== As of 0.5.0
-
-As of 0.5.0, Turn has some signifficant new features:
-
-While Turn still provides the exact same functionality for running
-tests via ruby or testrb as previous versions. The turn commandline 
-utility has been completely rewritten with expanded capabilites. 
-
-The turn command now features three run modes:
-
-* Solo runner for running each test file in a separate process.
-* Cross runner for running test file pairs in separate processes.
-* Normal runner, which of course runs all test in a single process.
-
-It also support three report modes:
-
-* Progress reporter which uses a progress bar.
-* Minimal reporter which provides traditional "dot" progress.
-* Outline reporter populaized by turn.
-
-The is also a special Marshal Mode which dumps test results as YAML.
-And the underlying API makes it easy create new reporters.
-
-To get a quick rundown on how to use the new commandline:
-
-  $ turn --help
+= Turn 0.8.0
+
+Version 0.8.0 is a fairly significant release for Turn. This release
+adds support for Ruby 1.9's Minitest framework. You can even use
+minitest with Ruby 1.8 by supplying the --minitest option on the turn
+command line.
+
+In addition, two new reporters have been a added, a new "pretty" reporter
+which provides a more a modern "OSX" look (thanks Paydro) and a Cue
+reporter which seeks user input with each failure or error (thanks
+Shindo).
+
+With this release we are encouraging users to move away from using
+autorun modes. Autorunning is when your test script includes code
+that "automagically" sets up a test runner, e.g. require 'test/unit'
+and MiniTest::Unit.autorun, and by simply running the scripts
+through the ruby interpretor the tests get run. There are a number
+of problems with this approach. To begin with, running tests this way
+limits Turn of a single mode of operation (that's no fun!) More
+importantly it prevents interoperability between the old TestUnit
+and the new MiniTest systems. By leaving these out and using a 
+commandline runner you can use the same tests for each version of
+Ruby. This may require some adjutments to build tools, but hell,
+why not use Turn there too. The Turn::Controller class makes it
+damn easy.
+
+One last note. Turn is no longer compatible with TestUnit 2.0+.
+TestUnit and MiniTest are deverging and after some consideration
+it was decided that Turn's goal is to support Ruby's native test
+framework, whatever it may be.
 
 Enjoy!
 

data/Version.txt

@@ -0,0 +1 @@
+0.8.0

data/bin/turn

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
-
-load 'turn/command.rb'
+require 'turn/command'
+Turn::Command.main(*ARGV)
 

data/demo/test_autorun_minitest.rb

@@ -0,0 +1,26 @@
+require 'minitest/unit'
+require 'turn'
+
+class SampleCase1 < MiniTest::Unit::TestCase
+  def test_sample_pass1
+    assert_equal(1,1)
+  end
+  def test_sample_pass2
+    assert_equal(2,2)
+  end
+
+  def test_sample_fail1
+    assert_equal(1,2)
+  end
+  def test_sample_fail2
+    assert_include(1,[])
+  end
+
+  def test_sample_error1
+    raise StandardError, "Raised exception!"
+  end
+  def test_sample_error2
+    raise StandardError, "Raised another exception!"
+  end
+end
+

data/demo/test_autorun_testunit.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+require 'turn'
+
+class SampleCase1 < Test::Unit::TestCase
+  def test_sample_pass1
+    assert_equal(1,1)
+  end
+  def test_sample_pass2
+    assert_equal(2,2)
+  end
+
+  def test_sample_fail1
+    assert_equal(1,2)
+  end
+  def test_sample_fail2
+    assert_include(1,[])
+  end
+
+  def test_sample_error1
+    raise StandardError, "Raised exception!"
+  end
+  def test_sample_error2
+    raise StandardError, "Raised another exception!"
+  end
+end
+

data/demo/test_sample.rb

@@ -0,0 +1,35 @@
+class SampleCase1 < Test::Unit::TestCase
+  def test_sample_pass1
+    assert_equal(1,1)
+  end
+  def test_sample_pass2
+    assert_equal(2,2)
+  end
+
+  def test_sample_fail1
+    assert_equal(1,2)
+  end
+  def test_sample_fail2
+    assert_include(1,[])
+  end
+
+  def test_sample_error1
+    raise StandardError, "Raised exception!"
+  end
+  def test_sample_error2
+    raise StandardError, "Raised another exception!"
+  end
+end
+
+
+class SampleCase2 < Test::Unit::TestCase
+  def test_sample_pass1
+    assert_equal(1,1)
+  end
+  def test_sample_pass2
+    assert_equal(1,1)
+  end
+end
+
+class EmptyCase < Test::Unit::TestCase
+end

data/lib/turn/autorun/minitest.rb

@@ -0,0 +1,155 @@
+require 'minitest/unit'
+require 'minitest/spec'
+#require 'rubygems'
+require 'ansi'
+
+class MiniTest::Unit
+  include ANSI::Code
+
+  PADDING_SIZE = 4
+
+  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
+
+    @@out.puts
+    @@out.puts "Finished in #{'%.6f' % (Time.now - start)} seconds."
+
+    @@out.puts
+
+    @@out.print "%d tests, " % test_count
+    @@out.print "%d assertions, " % assertion_count
+    @@out.print red { "%d failures, " % failures }
+    @@out.print yellow { "%d errors, " % errors }
+    @@out.puts cyan { "%d skips" % skips}
+
+    return failures + errors if @test_count > 0 # or return nil...
+  end
+
+  # Overwrite #run_test_suites so that it prints out reports
+  # as errors are generated.
+  def run_test_suites(filter = /./)
+    @test_count, @assertion_count = 0, 0
+    old_sync, @@out.sync = @@out.sync, true if @@out.respond_to? :sync=
+    TestCase.test_suites.each do |suite|
+      test_cases = suite.test_methods.grep(filter)
+      if test_cases.size > 0
+        @@out.print "\n#{suite}:\n"
+      end
+
+      test_cases.each do |test|
+        inst = suite.new test
+        inst._assertions = 0
+
+        t = Time.now
+
+        @broken = nil
+
+        @@out.print(case inst.run(self)
+                    when :pass
+                      @broken = false
+                      green { pad_with_size "PASS" }
+                    when :error
+                      @broken = true
+                      yellow { pad_with_size "ERROR" }
+                    when :fail
+                      @broken = true
+                      red { pad_with_size "FAIL" }
+                    when :skip
+                      @broken = false
+                      cyan { pad_with_size "SKIP" }
+                    end)
+
+
+        @@out.print " #{test}"
+        @@out.print " (%.2fs) " % (Time.now - t)
+
+        if @broken
+          @@out.puts
+
+          report = @report.last
+          @@out.puts pad(report[:message], 10)
+          trace = MiniTest::filter_backtrace(report[:exception].backtrace).first
+          @@out.print pad(trace, 10)
+
+          @@out.puts
+        end
+
+        @@out.puts
+        @test_count += 1
+        @assertion_count += inst._assertions
+      end
+    end
+    @@out.sync = old_sync if @@out.respond_to? :sync=
+    [@test_count, @assertion_count]
+  end
+
+  def pad(str, size=PADDING_SIZE)
+    " " * size + str
+  end
+
+  def pad_with_size(str)
+    pad("%5s" % str)
+  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 << {:message => msg, :exception => e}
+    result
+  end
+
+
+  class TestCase
+    # 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__
+        @passed = true
+      rescue Exception => e
+        @passed = false
+        result = runner.puke(self.class, self.__name__, e)
+      ensure
+        begin
+          self.teardown
+        rescue Exception => e
+          result = runner.puke(self.class, self.__name__, e)
+        end
+      end
+      result
+    end
+  end
+end
+

data/lib/turn/autorun/testunit.rb

@@ -0,0 +1,102 @@
+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
+
+
+  end
+end
+end
+end
+
+# EOF

data/lib/turn/bin.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.dirname(File.dirname(__FILE__)))
+require 'turn/command'
+Turn::Command.main(*ARGV)
+

data/lib/turn/colorize.rb

@@ -14,16 +14,52 @@ module Turn
 
     COLORIZE = defined?(::ANSI::Code) && ENV.has_key?('TERM')
 
-    if COLORIZE
-      PASS  = ::ANSI::Code.green('PASS')
-      FAIL  = ::ANSI::Code.red('FAIL')
-      ERROR = ::ANSI::Code.white(::ANSI::Code.on_red('ERROR'))
-    else
-      PASS  = "PASS"
-      FAIL  = "FAIL"
-      ERROR = "ERROR"
+    def self.red(string)
+      COLORIZE ? ::ANSI::Code.red{ string } : string
     end
 
+    def self.green(string)
+      COLORIZE ? ::ANSI::Code.green{ string } : string
+    end
+
+    def self.blue(string)
+      COLORIZE ? ::ANSI::Code.blue{ string } : string
+    end
+
+    def self.magenta(string)
+      COLORIZE ? ::ANSI::Code.magenta{ string } : string
+    end
+
+    def self.bold(string)
+      COLORIZE ? ::ANSI::Code.bold{ string } : string
+    end
+
+    def self.pass(string)
+      COLORIZE ? ::ANSI::Code.green{ string } : string
+    end
+
+    def self.fail(string)
+      COLORIZE ? ::ANSI::Code.red{ string } : string
+    end
+
+    #def self.error(string)
+    #  COLORIZE ? ::ANSI::Code.white{ ::ANSI::Code.on_red{ string } } : string
+    #end
+
+    def self.error(string)
+      COLORIZE ? ::ANSI::Code.yellow{ string } : string
+    end
+
+    def self.skip(string)
+      COLORIZE ? ::ANSI::Code.cyan{ string } : string
+    end
+
+    PASS  = pass('PASS')
+    FAIL  = fail('FAIL')
+    ERROR = error('ERROR')
+    SKIP  = skip('SKIP')
+
   end
 
 end
+