openlogic-turn 0.8.2

data/lib/turn/autorun/testunit.rb

@@ -0,0 +1,116 @@
+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
+        test_name =  underscore(fault.test_name.match(/\((.*)\)/)[1])
+        better_location = fault.location.detect{|line|line.include?(test_name)} || fault.location[0]
+        turn_out.puts " #{FAIL}"
+        msg << better_location.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
+
+    # Taken from ActiveSupport::Inflector
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+
+    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

@@ -0,0 +1,65 @@
+begin
+  require 'ansi/code'
+rescue LoadError
+  begin
+    require 'rubygems'
+    require 'ansi/code'
+  rescue LoadError
+  end
+end
+
+module Turn
+
+  module Colorize
+
+    COLORIZE = defined?(::ANSI::Code) && ENV.has_key?('TERM')
+
+    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
+

data/lib/turn/command.rb

@@ -0,0 +1,210 @@
+require 'optparse'
+require 'turn/controller'
+
+module Turn
+
+  # Turn - Pretty Unit Test Runner for Ruby
+  #
+  # SYNOPSIS
+  #   turn [OPTIONS] [RUN MODE] [OUTPUT MODE] [test globs...]
+  #
+  # OPTIONS
+  #   -h --help             display this help information
+  #      --live             don't use loadpath
+  #      --log              log results to a file
+  #   -n --name=PATTERN     only run tests that match regexp PATTERN
+  #   -I --loadpath=PATHS   add given PATHS to the $LOAD_PATH
+  #   -r --requires=LIBS    require given LIBS before running tests
+  #   -m --minitest         Force use of MiniTest framework.
+  #
+  # RUN MODES
+  #      --normal      run all tests in a single process [default]
+  #      --solo        run each test in a separate process
+  #      --cross       run each pair of test files in a separate process
+  #
+  # OUTPUT MODES
+  #   -O --outline     turn's original case/test outline mode [default]
+  #   -P --progress    indicates progress with progress bar
+  #   -D --dotted      test/unit's traditonal dot-progress mode
+  #      --pretty      new pretty reporter
+  #   -M --marshal     dump output as YAML (normal run mode only)
+  #   -Q --queued      interactive testing
+  #
+  class Command
+
+    # Shortcut for new.main(*argv)
+    def self.main(*argv)
+      new.main(*argv)
+    end
+
+    # Log output.
+    attr :log
+
+    # Do not use local loadpath.
+    attr :live
+
+    # Only run tests matching this pattern.
+    attr :pattern
+
+    # List of paths to add to $LOAD_PATH
+    attr :loadpath
+
+    # Libraries to require before running tests.
+    attr :requires
+
+    # Framework to use, :minitest or :testunit.
+    attr :framework
+
+    # Run mode.
+    attr :runmode
+
+    # Output mode.
+    attr :outmode
+
+    #
+    def initialize
+      @live      = nil
+      @log       = nil
+      @pattern   = nil
+      @loadpath  = []
+      @requires  = []
+      @runmode   = nil
+      @outmode   = nil
+      @framework = RUBY_VERSION >= "1.9" ? :minitest : :testunit
+    end
+
+    #
+    def option_parser
+      OptionParser.new do |opts|
+
+        opts.banner = "Turn - Pretty Unit Test Runner for Ruby"
+
+        opts.separator " "
+        opts.separator "SYNOPSIS"
+        opts.separator "  turn [OPTIONS] [RUN MODE] [OUTPUT MODE] [TEST GLOBS ...]"
+
+        opts.separator " "
+        opts.separator "GENERAL OPTIONS"
+
+        opts.on('-I', '--loadpath=PATHS', "add paths to $LOAD_PATH") do |path|
+          @loadpath.concat(path.split(':'))
+        end
+
+        opts.on('-r', '--require=LIBS', "require libraries") do |lib|
+          @requires.concat(lib.split(':'))
+        end
+
+        opts.on('-n', '--name=PATTERN', "only run tests that match PATTERN") do |pattern|
+          @pattern = Regexp.new(pattern, Regexp::IGNORECASE)
+        end
+
+        opts.on('-m', '--minitest', "Force use of MiniTest framework") do
+          @framework = :minitest
+        end
+
+        # Turn does not support Test::Unit 2.0+
+        #opts.on('-u', '--testunit', "Force use of TestUnit framework") do
+        #  @framework = :testunit
+        #end
+
+        opts.on('--log', "log results to a file") do #|path|
+          @log = true # TODO: support path/file
+        end
+
+        opts.on('--live', "do not use local load path") do
+          @live = true
+        end
+
+        opts.separator " "
+        opts.separator "RUN MODES"
+
+        opts.on('--normal', "run all tests in a single process [default]") do
+          @runmode = nil
+        end
+
+        opts.on('--solo', "run each test in a separate process") do
+          @runmode = :solo
+        end
+
+        opts.on('--cross', "run each pair of test files in a separate process") do
+          @runmode = :cross
+        end
+
+        #opts.on('--load', "") do
+        #end
+
+        opts.separator " "
+        opts.separator "OUTPUT MODES"
+
+        opts.on('--outline', '-O', "turn's original case/test outline mode [default]") do
+          @outmode = :outline
+        end
+
+        opts.on('--progress', '-P', "indicates progress with progress bar") do
+          @outmode = :progress
+        end
+
+        opts.on('--dotted', '-D', "test-unit's traditonal dot-progress mode") do
+          @outmode = :dotted
+        end
+
+        opts.on('--pretty', '-T', "new pretty output mode") do
+          @outmode = :pretty
+        end
+
+        opts.on('--cue', '-C', "cue for action on each failure/error") do
+          @outmode = :cue
+        end
+
+        opts.on('--marshal', '-M', "dump output as YAML (normal run mode only)") do
+          @runmode = :marshal
+          @outmode = :marshal
+        end
+
+        opts.separator " "
+        opts.separator "COMMAND OPTIONS"
+
+        opts.on('--debug', "turn debug mode on") do
+          $VERBOSE = true
+          $DEBUG   = true
+        end
+
+        opts.on_tail('--help', '-h', "display this help information") do
+          puts opts
+          exit
+        end
+      end
+    end
+
+    # Run command.
+    def main(*argv)
+      option_parser.parse!(argv)
+
+      @loadpath = ['lib'] if loadpath.empty?
+
+      tests = ARGV.empty? ? nil : ARGV.dup
+
+      controller = Turn::Controller.new do |c|
+        c.live      = live
+        c.log       = log
+        c.loadpath  = loadpath
+        c.requires  = requires
+        c.tests     = tests
+        c.runmode   = runmode
+        c.format    = outmode
+        c.pattern   = pattern
+        c.framework = framework
+      end
+
+      result = controller.start
+
+      if result
+        exit result.passed?
+      else # no tests
+        exit
+      end
+    end
+
+  end
+
+end

data/lib/turn/components/case.rb

@@ -0,0 +1,104 @@
+module Turn
+
+  #
+  class TestCase
+    include Enumerable
+
+    # Name of test case.
+    attr_accessor :name
+
+    # Test methods.
+    attr_accessor :tests
+
+    # Some runners marshal tests per file.
+    attr_accessor :files
+
+    #attr_accessor :count_passes
+    #attr_accessor :count_failures
+    #attr_accessor :count_errors
+    #attr_accessor :count_tests
+
+    # This can't be calculated, so it must be
+    # assigned by the runner.
+    attr_accessor :count_assertions
+
+    # Holds dump of test output (optional depending on runner).
+    attr_accessor :message
+
+    # Command used to run test (optional depending on runner).
+    #attr_accessor :command
+
+    #
+    def initialize(name, *files)
+      @name  = name
+      @files = (files.empty? ? [name] : files)
+      @tests = []
+
+      @message = nil
+      @count_assertions = 0
+
+      #@count_tests      = 0
+      #@count_failures   = 0
+      #@count_errors     = 0
+
+      #@command = command
+    end
+
+    def new_test(name)
+      c = TestMethod.new(name)
+      @tests << c
+      c
+    end
+
+    # Whne used by a per-file runner.
+    #alias_method :file, :name
+
+    # Were there any errors?
+    def error?
+      count_errors != 0
+    end
+
+    # Were there any failures?
+    def fail?
+      count_failures != 0
+    end
+
+    # Did all tests/assertion pass?
+    def pass?
+      not(fail? or error?)
+    end
+
+    def count_tests
+      tests.size
+    end
+
+    alias_method :size, :count_tests
+
+    def count_failures
+      sum = 0; tests.each{ |t| sum += 1 if t.fail? }; sum
+    end
+
+    def count_errors
+      sum = 0; tests.each{ |t| sum += 1 if t.error? }; sum
+    end
+
+    def count_passes
+      sum = 0; tests.each{ |t| sum += 1 if t.pass? }; sum
+    end
+
+    #
+    def counts
+      return count_tests, count_assertions, count_failures, count_errors
+    end
+
+    def message
+      tests.collect{ |t| t.message }.join("\n")
+    end
+
+    def each(&block)
+      tests.each(&block)
+    end
+  end
+
+end
+