openlogic-turn 0.8.2

data/lib/turn/components/method.rb

@@ -0,0 +1,42 @@
+module Turn
+
+  #
+  class TestMethod
+    attr_accessor :name
+    attr_accessor :file
+    attr_accessor :raised
+    attr_accessor :message
+    attr_accessor :backtrace
+
+    def initialize(name)
+      @name      = name
+      @fail      = false
+      @error     = false
+      @raised    = nil
+      @message   = nil
+      @backtrace = []
+    end
+
+    def fail!(assertion)
+      @fail, @error = true, false
+      @raised    = assertion
+      @message   = assertion.message
+      @backtrace = assertion.backtrace
+    end
+
+    def error!(exception)
+      @fail, @error = false, true
+      @raised    = exception
+      @message   = exception.message
+      @backtrace = exception.backtrace
+    end
+
+    def fail?  ; @fail  ; end
+    def error? ; @error ; end
+    def pass?  ; !(@fail or @error) ; end
+
+    def to_s ; name ; end
+  end
+
+end
+

data/lib/turn/components/suite.rb

@@ -0,0 +1,85 @@
+module Turn
+
+  #
+  class TestSuite
+
+    include Enumerable
+
+    attr_accessor :name
+    attr_accessor :size
+    attr_accessor :cases
+
+    # This one can be set manually since it
+    # is not calculatable (beyond the case level).
+    attr_accessor :count_assertions
+
+    #
+    def initialize(name=nil)
+      @name  = name
+      @size  = nil
+      @cases = []
+
+      #@count_tests      = nil
+      #@count_assertions = nil
+      #@count_failures   = nil
+      #@count_errors     = nil
+      #@count_passes     = nil
+    end
+
+    #
+    def new_case(name, *files)
+      c = TestCase.new(name, *files)
+      @cases << c
+      c
+    end
+
+    def count_tests
+      #@count_tests ||= (
+        sum = 0; each{ |c| sum += c.count_tests }; sum
+      #)
+    end
+
+    def count_assertions
+      #@count_assertions ||= (
+        sum = 0; each{ |c| sum += c.count_assertions }; sum
+      #)
+    end
+
+    def count_failures
+      #@count_failures ||= (
+        sum = 0; each{ |c| sum += c.count_failures }; sum
+      #)
+    end
+
+    def count_errors
+      #@count_errors ||= (
+        sum = 0; each{ |c| sum += c.count_errors }; sum
+      #)
+    end
+
+    def count_passes
+      #@count_passes ||= (
+        sum = 0; each{ |c| sum += c.count_passes }; sum
+      #)
+    end
+
+    # Convenience methods --this is what is typcially wanted.
+    def counts
+      return count_tests, count_assertions, count_failures, count_errors #,count_skips
+    end
+
+    def each(&block)
+      @cases.each(&block)
+    end
+
+    def size
+      @size ||= @cases.size
+    end
+
+    def passed?
+      (count_failures == 0 && count_errors == 0)
+    end
+  end
+
+end
+

data/lib/turn/controller.rb

@@ -0,0 +1,204 @@
+require 'fileutils'
+
+module Turn
+  require 'turn/components/suite.rb'
+  require 'turn/components/case.rb'
+  require 'turn/components/method.rb'
+
+  # = Controller
+  #
+  #--
+  # TODO: Add support to test run loggging.
+  #++
+  class Controller
+
+    # File glob pattern of tests to run.
+    # Can be an array of files/globs.
+    attr_accessor :tests
+
+    # Files globs to specially exclude.
+    attr_accessor :exclude
+
+    # Regexp pattern that all test name's must
+    # match to be eligible to run.
+    attr_accessor :pattern
+
+    # Add these folders to the $LOAD_PATH.
+    attr_accessor :loadpath
+
+    # Libs to require when running tests.
+    attr_accessor :requires
+
+    # Reporter type.
+    attr_accessor :format
+
+    # Run mode.
+    attr_accessor :runmode
+
+    # Test against live install (i.e. Don't use loadpath option)
+    attr_accessor :live
+
+    # Log results? May be true/false or log file name. (TODO)
+    attr_accessor :log
+
+    # Verbose output?
+    attr_accessor :verbose
+
+    # Test framework, either :minitest or :testunit
+    attr_accessor :framework
+
+    def verbose? ; @verbose ; end
+    def live?    ; @live    ; end
+
+  private
+
+    def initialize
+      yield(self) if block_given?
+      initialize_defaults
+    end
+
+    #
+    def initialize_defaults
+      @loadpath ||= ['lib']
+      @tests    ||= "test/**/{test,}*{,test}"
+      @exclude  ||= []
+      @requires ||= []
+      @live     ||= false
+      @log      ||= true
+      #@reporter ||= OutlineReporter.new($stdout)
+      #@runner   ||= RUBY_VERSION >= "1.9" ? MiniRunner : TestRunner
+      @pattern  ||= /.*/
+    end
+
+    # Collect test configuation.
+    #def test_configuration(options={})
+    #  #options = configure_options(options, 'test')
+    #  #options['loadpath'] ||= metadata.loadpath
+    #  options['tests']    ||= self.tests
+    #  options['loadpath'] ||= self.loadpath
+    #  options['requires'] ||= self.requires
+    #  options['live']     ||= self.live
+    #  options['exclude']  ||= self.exclude
+    #  #options['tests']    = list_option(options['tests'])
+    #  options['loadpath'] = list_option(options['loadpath'])
+    #  options['exclude']  = list_option(options['exclude'])
+    #  options['require']  = list_option(options['require'])
+    #  return options
+    #end
+
+    #
+    def list_option(list)
+      case list
+      when nil
+        []
+      when Array
+        list
+      else
+        list.split(/[:;]/)
+      end
+    end
+
+  public
+
+    def loadpath=(paths)
+      @loadpath = list_option(paths)
+    end
+
+    def exclude=(paths)
+      @exclude = list_option(paths)
+    end
+
+    def requires=(paths)
+      @requires = list_option(paths)
+    end
+
+    def files
+      @files ||= (
+        fs = tests.map do |t|
+          File.directory?(t) ? Dir[File.join(t, '**', '*')] : Dir[t]
+        end
+        fs = fs.flatten.reject{ |f| File.directory?(f) }
+        ex = exclude.map do |x|
+          File.directory?(x) ? Dir[File.join(x, '**', '*')] : Dir[x]
+        end
+        ex = ex.flatten.reject{ |f| File.directory?(f) }
+        (fs - ex).uniq.map{ |f| File.expand_path(f) }
+      )
+    end
+
+    def start
+      @files = nil  # reset files just in case
+
+      if files.empty?
+        $stderr.puts "No tests."
+        return
+      end
+
+      testrun = runner.new(self)
+
+      testrun.start
+    end
+
+    # Select reporter based on output mode.
+    def reporter
+      @reporter ||= (
+        case format
+        when :marshal
+          require 'turn/reporters/marshal_reporter'
+          Turn::MarshalReporter.new($stdout)
+        when :progress
+          require 'turn/reporters/progress_reporter'
+          Turn::ProgressReporter.new($stdout)
+        when :dotted
+          require 'turn/reporters/dot_reporter'
+          Turn::DotReporter.new($stdout)
+        when :pretty
+          require 'turn/reporters/pretty_reporter'
+          Turn::PrettyReporter.new($stdout)
+        when :cue
+          require 'turn/reporters/cue_reporter'
+          Turn::CueReporter.new($stdout)
+        else
+          require 'turn/reporters/outline_reporter'
+          Turn::OutlineReporter.new($stdout)
+        end
+      )
+    end
+
+    # # Insatance of Runner, selected based on format and runmode.
+    def runner
+      @runner ||= (
+        case framework
+        when :minitest
+          require 'turn/runners/minirunner'
+        else
+          require 'turn/runners/testrunner'
+        end
+
+        case runmode
+        when :marshal
+          if framework == :minitest
+            Turn::MiniRunner
+          else
+            Turn::TestRunner
+          end
+        when :solo
+          require 'turn/runners/solorunner'
+          Turn::SoloRunner
+        when :cross
+          require 'turn/runners/crossrunner'
+          Turn::CrossRunner
+        else
+          if framework == :minitest
+            Turn::MiniRunner
+          else
+            Turn::TestRunner
+          end
+        end
+      )
+    end
+
+  end
+
+end
+

data/lib/turn/core_ext.rb

@@ -0,0 +1,31 @@
+# Borrowed methods from Ruby Facets.
+
+class String
+
+  # Aligns each line n spaces.
+  def tab(n)
+    gsub(/^ */, ' ' * n)
+  end
+
+  # Preserves relative tabbing.
+  # The first non-empty line ends up with n spaces before nonspace.
+  def tabto(n)
+    if self =~ /^( *)\S/
+      indent(n - $1.length)
+    else
+      self
+    end
+  end
+
+  # Indent left or right by n spaces.
+  # (This used to be called #tab and aliased as #indent.)
+  def indent(n, c=' ')
+    if n >= 0
+      gsub(/^/, c * n)
+    else
+      gsub(/^#{Regexp.escape(c)}{0,#{-n}}/, "")
+    end
+  end
+
+end
+

data/lib/turn/reporter.rb

@@ -0,0 +1,69 @@
+module Turn
+  require 'turn/colorize'
+  require 'turn/core_ext'
+
+  # = Reporter
+  #
+  # There are two distinct way in which a report may be utilized
+  # by a Runner: per-call or per-file. The method #pass, #fail
+  # and #error are generic, and will be used in either case.
+  # A per-call runner will use all the methods of a Reporter,
+  # while a per-file runner will use start_case per file,
+  # and will not use the start_test and finish_test methods,
+  # since those are beyond it's grainularity.
+  #
+  class Reporter
+
+    include Colorize
+
+    attr :io
+
+    def initialize(io)
+      @io = io || $stdout
+    end
+
+    # These methods are called in the process of running the tests.
+
+    def start_suite(test_suite)
+    end
+
+    def start_case(test_case)
+    end
+
+    def start_test(test)
+    end
+
+    def pass(message=nil)
+    end
+
+    def fail(assertion, message=nil)
+    end
+
+    def error(exception, message=nil)
+    end
+
+    def finish_test(test)
+    end
+
+    def finish_case(test_case)
+    end
+
+    def finish_suite(test_suite)
+    end
+
+  private
+
+    # TODO: backtrace filter probably could use some refinement.
+    def filter_backtrace(bt)
+      return [] unless bt
+      bt.reject!{ |line| line.rindex('minitest') }
+      bt.reject!{ |line| line.rindex('test/unit') }
+      bt.reject!{ |line| line.rindex('lib/turn') }
+      bt.reject!{ |line| line.rindex('bin/turn') }
+      bt.map{ |line| line.sub(Dir.pwd+'/', '') }
+    end
+
+  end
+
+end
+

data/lib/turn/reporters/cue_reporter.rb

@@ -0,0 +1,167 @@
+require 'turn/reporter'
+
+module Turn
+
+  # = Cue Reporter
+  #
+  # Inspired by Shindo.
+  #
+  class CueReporter < Reporter
+
+    def start_suite(suite)
+      @suite = suite
+      @time  = Time.now
+      @stdout = StringIO.new
+      @stderr = StringIO.new
+      #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 Colorize.blue("    %-69s" % test.name)
+      $stdout = @stdout
+      $stderr = @stderr
+      $stdout.rewind
+      $stderr.rewind
+    end
+
+    def pass(message=nil)
+      io.puts " #{PASS}"
+      if message
+        message = Colorize.green(message)
+        message = message.to_s.tabto(8)
+        io.puts(message)
+      end
+    end
+
+    def fail(assertion, message=nil)
+      io.puts(" #{FAIL}")
+      #message = assertion.location[0] + "\n" + assertion.message #.gsub("\n","\n")
+      message = message || assertion.to_s
+      #if message
+        message = Colorize.red(message)
+        message = message.to_s.tabto(8)
+        io.puts(message)
+      #end
+
+      show_captured_output
+
+      prompt
+    end
+
+    def error(exception, message=nil)
+      #message = exception.to_s.split("\n")[2..-1].join("\n")
+      message = message || exception.to_s
+      io.puts("#{ERROR}")
+      io.puts(message) #if message
+
+      prompt
+    end
+
+    def finish_test(test)
+      $stdout = STDOUT
+      $stderr = STDERR
+    end
+
+    def show_captured_output
+      show_captured_stdout
+      show_captured_stderr
+    end
+
+    def show_captured_stdout
+      @stdout.rewind
+      return if @stdout.eof?
+      STDOUT.puts(<<-output.tabto(8))
+\nSTDOUT:
+#{@stdout.read}
+      output
+    end
+
+    def show_captured_stderr
+      @stderr.rewind
+      return if @stderr.eof?
+      STDOUT.puts(<<-output.tabto(8))
+\nSTDERR:
+#{@stderr.read}
+      output
+    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 Colorize.green(bar)
+              else Colorize.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
+
+    private
+
+    def prompt
+      begin
+        io << "  [c,i,q,r,t,#,?] "
+        io.flush
+        until inp = $stdin.gets ; sleep 1 ; end
+        answer = inp.strip
+        case answer
+        when 'c', ''
+        when 'r'
+          # how to reload and start over?
+        when 'i'
+          # how to drop into an interactive console?
+        when 't'
+          io.puts $@
+          raise ArgumentError
+        when /^\d+$/
+          io.puts $@[0..answer.to_i]
+          raise ArgumentError
+        when 'q'
+          exit -1
+        when '?'
+          io.puts HELP
+          raise ArgumentError #prompt
+        else
+          raise ArgumentError
+        end
+      rescue ArgumentError
+        retry
+      end
+    end
+
+    HELP = %{
+      c continue
+      r restart
+      i irb
+      t backtrace
+      # backtrace lines
+      q quit
+      ? help
+    }
+
+  end
+
+end
+