openlogic-turn 0.8.2

data/lib/turn/runners/crossrunner.rb

@@ -0,0 +1,42 @@
+module Turn
+  require 'turn/runners/isorunner'
+
+  # = Cross Runner
+  #
+  # Cross Runner runs test in pairs.
+  #
+  # TODO: This needs work in the test_loop_runner.
+  #       It needs to show the files being cross tested.
+  #
+  # TODO: Cross runner output needs to be fixed
+  class CrossRunner < IsoRunner
+
+    #
+    def start
+      suite = TestSuite.new
+
+      files = @controller.files
+      viles = @controller.files # TODO: make selectable ?
+
+      #files = files.select{ |f| File.extname(f) == '.rb' and File.file?(f) }
+      #viles = viles.select{ |f| File.extname(f) == '.rb' and File.file?(f) }
+
+      pairs = files.inject([]){ |m, f| viles.collect{ |v| m << [f,v] }; m }
+      pairs = pairs.reject{ |f,v| f == v }
+
+      max = files.collect{ |f| f.sub(Dir.pwd+'/','').size }.max
+
+      testruns = pairs.collect do |file1, file2|
+        name1 = file1.sub(Dir.pwd+'/','')
+        name2 = file2.sub(Dir.pwd+'/','')
+        name = "%-#{max}s %-#{max}s" % [name1, name2]
+        suite.new_case(name, file1, file2)
+      end
+
+      test_loop_runner(suite)
+    end
+
+  end
+
+end
+

data/lib/turn/runners/isorunner.rb

@@ -0,0 +1,167 @@
+module Turn
+  require 'turn/colorize'
+  require 'yaml'
+  require 'open3'
+
+  # = IsoRunner
+  #
+  # Iso Runner provides means from running unit test
+  # in isolated processes. It can do this either by running
+  # each test in isolation (solo testing) or in pairs (cross testing).
+  #
+  # The IsoRunner proiveds some variery in ouput formats and can also
+  # log results to a file.
+  #
+  class IsoRunner
+    include Turn::Colorize
+
+    attr :reporter
+
+  private
+
+    def initialize(controller)
+      @controller = controller
+      @reporter   = controller.reporter
+      #yield(self) if block_given?
+      @loadpath = controller.loadpath
+      @requires = controller.requires
+      @live     = controller.live?
+      @minitest = controller.framework == :minitest
+    end
+
+  public
+
+    # Runs the list of test calls passed to it.
+    # This is used by #test_solo and #test_cross.
+    #
+    def start
+      suite = TestSuite.new
+      testruns = @controller.files.collect do |file|
+        name = file.sub(Dir.pwd+'/','')
+        suite.new_case(name, file)
+      end
+      test_loop_runner(suite)
+    end
+
+  private
+
+    # The IsoRunner actually shells out to turn in
+    # manifest mode, to gather results from isolated
+    # runs.
+    def test_loop_runner(suite)
+      reporter.start_suite(suite)
+
+      recase = []
+
+      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 << "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(' ')
+
+        #out = `#{cmd}`
+        #err = ''
+
+        out, err = nil, nil
+        Open3.popen3(cmd) do |stdin, stdout, stderr|
+          stdin.close
+          out = stdout.read.chomp
+          err = stderr.read.chomp
+        end
+
+        # TODO: how to report? will need to add something to reporter
+        # b/c it may have redirected stdout. Or use STDOUT?
+        #if !err.empty?
+        #  puts err
+        #  raise
+        #end
+
+        files = kase.files
+
+        # remove any unexpected output injected at the beginning
+        yaml = out[out.index(/^---/)..-1]
+        sub_suite = YAML.load(yaml)
+
+        # TODO: How to handle pairs?
+        #name  = kase.name
+        kases = sub_suite.cases
+        suite.cases[index] = kases
+
+        kases.each do |kase|
+          kase.files = files
+          #reporter.start_case(kase)
+          kase.tests.each do |test|
+            reporter.start_test(test)
+            if test.error?
+              #reporter.error(test.message)
+              reporter.error(test.raised)
+            elsif test.fail?
+              #reporter.fail(test.message)
+              reporter.error(test.raised)
+            else
+              reporter.pass
+            end
+            reporter.finish_test(test)
+          end
+          reporter.finish_case(kase)
+        end
+      end
+
+      suite.cases.flatten!
+
+      reporter.finish_suite(suite)
+
+      # shutdown auto runner
+      if @minitest
+
+      else
+        ::Test::Unit.run=true rescue nil
+      end
+
+      suite
+    end
+
+    #
+    #def test_parse_result(result)
+    #  if md = /(\d+) tests, (\d+) assertions, (\d+) failures, (\d+) errors/.match(result)
+    #    count = md[1..4].collect{|q| q.to_i}
+    #  else
+    #    count = [1, 0, 0, 1]  # SHOULD NEVER HAPPEN
+    #  end
+    #  return count
+    #end
+
+    # NOT USED YET.
+    def log_report(report)
+      if log #&& !dryrun?
+        #logfile = File.join('log', apply_naming_policy('testlog', 'txt'))
+        FileUtils.mkdir_p('log')
+        logfile = File.join('log', 'testlog.txt')
+        File.open(logfile, 'a') do |f|
+          f << "= #{self.class} Test @ #{Time.now}\n"
+          f << report
+          f << "\n"
+        end
+      end
+    end
+
+  end#class IsoRunner
+
+end#module Turn
+

data/lib/turn/runners/loadrunner.rb

@@ -0,0 +1,48 @@
+# TODO
+
+    # Load each test independently to ensure there are no
+    # require dependency issues. This is actually a bit redundant
+    # as test-solo will also cover these results. So we may deprecate
+    # this in the future. This does not generate a test log entry.
+
+    def test_load(options={})
+      options = test_configuration(options)
+
+      tests    = options['tests']
+      loadpath = options['loadpath']
+      requires = options['requires']
+      live     = options['live']
+      exclude  = options['exclude']
+
+      files = Dir.multiglob_r(*tests) - Dir.multiglob_r(*exclude)
+
+      return puts("No tests.") if files.empty?
+
+      max   = files.collect{ |f| f.size }.max
+      list  = []
+
+      files.each do |f|
+        next unless File.file?(f)
+        if r = system("ruby -I#{loadpath.join(':')} #{f} > /dev/null 2>&1")
+          puts "%-#{max}s  [PASS]" % [f]  #if verbose?
+        else
+          puts "%-#{max}s  [FAIL]" % [f]  #if verbose?
+          list << f
+        end
+      end
+
+      puts "  #{list.size} Load Failures"
+
+      if verbose?
+        unless list.empty?
+          puts "\n-- Load Failures --\n"
+          list.each do |f|
+            print "* "
+            system "ruby -I#{loadpath} #{f} 2>&1"
+            #puts
+          end
+          puts
+        end
+      end
+    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
+