class Turn::IsoRunner

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.

Attributes

reporter[R]

Public Class Methods

new() click to toggle source
# File lib/turn/runners/isorunner.rb, line 22
def initialize
  @config = Turn.config

  @reporter = @config.reporter
  #yield(self) if block_given?
  @loadpath = @config.loadpath
  @requires = @config.requires
  @live     = @config.live?
  @minitest = @config.framework == :minitest
end

Public Instance Methods

start() click to toggle source

Runs the list of test calls passed to it. This is used by test_solo and test_cross.

# File lib/turn/runners/isorunner.rb, line 38
def start
  suite = TestSuite.new
  testruns = @config.files.collect do |file|
    name = file.sub(Dir.pwd+'/','')
    suite.new_case(name, file)
  end
  test_loop_runner(suite)
end

Private Instance Methods

log_report(report) click to toggle source

NOT USED YET.

# File lib/turn/runners/isorunner.rb, line 154
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
test_loop_runner(suite) click to toggle source

The IsoRunner actually shells out to turn in manifest mode, to gather results from isolated runs.

# File lib/turn/runners/isorunner.rb, line 52
    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 << %Q[--loadpath="#{@loadpath.join(':')}"] unless @loadpath.empty?
        cmd << %Q[--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
#p cmd
        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
        b = out.index(/^---/)
        yaml = out[b..-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