test-queue-split 0.3.0

data/lib/test_queue/runner/minitest4.rb

@@ -0,0 +1,65 @@
+require 'test_queue/runner'
+require 'stringio'
+
+class MiniTestQueueRunner < MiniTest::Unit
+  def _run_suites(suites, type)
+    self.class.output = $stdout
+
+    if defined?(ParallelEach)
+      # Ignore its _run_suites implementation since we don't handle it gracefully.
+      # If we don't do this #partition is called on the iterator and all suites
+      # distributed immediately, instead of picked up as workers are available.
+      suites.map { |suite| _run_suite suite, type }
+    else
+      super
+    end
+  end
+
+  def _run_anything(*)
+    ret = super
+    output.puts
+    ret
+  end
+
+  def _run_suite(suite, type)
+    output.print '    '
+    output.print suite
+    output.print ': '
+
+    start = Time.now
+    ret = super
+    diff = Time.now - start
+
+    output.puts("  <%.3f>" % diff)
+    ret
+  end
+
+  self.runner = self.new
+  self.output = StringIO.new
+end
+
+class MiniTest::Unit::TestCase
+  class << self
+    attr_accessor :test_suites
+
+    def original_test_suites
+      @@test_suites.keys.reject{ |s| s.test_methods.empty? }
+    end
+  end
+end
+
+module TestQueue
+  class Runner
+    class MiniTest < Runner
+      def initialize
+        tests = ::MiniTest::Unit::TestCase.original_test_suites.sort_by{ |s| -(stats[s.to_s] || 0) }
+        super(tests)
+      end
+
+      def run_worker(iterator)
+        ::MiniTest::Unit::TestCase.test_suites = iterator
+        ::MiniTest::Unit.new.run
+      end
+    end
+  end
+end

data/lib/test_queue/runner/minitest5.rb

@@ -0,0 +1,62 @@
+require 'test_queue/runner'
+
+module MiniTest
+  def self.__run reporter, options
+    suites = Runnable.runnables
+
+    # Run the serial tests first after they complete, run the parallels tests
+    # We already sort suites based on its test_order at TestQueue::Runner::Minitest#initialize.
+    suites.map { |suite| suite.run reporter, options }
+  end
+
+  class Test
+    def self.runnables= runnables
+      @@runnables = runnables
+    end
+  end
+
+  class ProgressReporter
+    # Override original method to make test-queue specific output
+    def record result
+      io.print '    '
+      io.print result.class
+      io.print ': '
+      io.print result.result_code
+      io.puts("  <%.3f>" % result.time)
+    end
+  end
+
+  begin
+    require 'minitest/minitest_reporter_plugin'
+
+    class << self
+      private
+      def total_count(options)
+        0
+      end
+    end
+  rescue LoadError
+  end
+end
+
+module TestQueue
+  class Runner
+    class MiniTest < Runner
+      def initialize
+        tests = ::MiniTest::Test.runnables.reject { |s|
+          s.runnable_methods.empty?
+        }.sort_by { |s|
+          -(stats[s.to_s] || 0)
+        }.partition { |s|
+          s.test_order == :parallel
+        }.reverse.flatten
+        super(tests)
+      end
+
+      def run_worker(iterator)
+        ::MiniTest::Test.runnables = iterator
+        ::MiniTest.run ? 0 : 1
+      end
+    end
+  end
+end

data/lib/test_queue/runner/puppet_lint.rb

@@ -0,0 +1,31 @@
+require 'test_queue'
+require 'puppet-lint'
+
+module TestQueue
+  class Runner
+    class PuppetLint < Runner
+      def run_worker(iterator)
+        errors = 0
+        linter =  PuppetLint.new
+        iterator.each do |file|
+          puts "Evaluating #{file}"
+          linter.file = file
+          linter.run
+          errors += 1 if linter.errors?
+        end
+        errors
+      end
+
+      def summarize_worker(worker)
+        lines = worker.lines
+
+        files    = lines.select{ |line| line =~ /^Evaluating/ }
+        errors   = lines.select{ |line| line =~ /^ERROR/ }
+        warnings = lines.select{ |line| line =~ /^WARNING/ }
+
+        worker.summary = "#{files.size} files, #{warnings.size} warnings, #{errors.size} errors"
+        worker.failure_output = errors.join("\n")
+      end
+    end
+  end
+end

data/lib/test_queue/runner/rspec.rb

@@ -0,0 +1,35 @@
+require 'test_queue/runner'
+require 'rspec/core'
+
+case ::RSpec::Core::Version::STRING.to_i
+when 2
+  require_relative 'rspec2'
+when 3
+  require_relative 'rspec3'
+else
+  fail 'requires rspec version 2 or 3'
+end
+
+module TestQueue
+  class Runner
+    class RSpec < Runner
+      def initialize
+        @rspec = ::RSpec::Core::QueueRunner.new
+        super(@rspec.example_groups.sort_by{ |s| -(stats[s.to_s] || 0) })
+      end
+
+      def run_worker(iterator)
+        @rspec.run_each(iterator).to_i
+      end
+
+      def summarize_worker(worker)
+        worker.stats.each do |s, val|
+          stats[s] = val
+        end
+
+        worker.summary  = worker.lines.grep(/ examples?, /).first
+        worker.failure_output = worker.output[/^Failures:\n\n(.*)\n^Finished/m, 1]
+      end
+    end
+  end
+end

data/lib/test_queue/runner/rspec2.rb

@@ -0,0 +1,35 @@
+module RSpec::Core
+  class QueueRunner < CommandLine
+    def initialize
+      super(ARGV)
+      @configuration.output_stream = $stdout
+      @configuration.error_stream  = $stderr
+    end
+
+    def example_groups
+      @options.configure(@configuration)
+      @configuration.load_spec_files
+      @world.announce_filters
+      @world.example_groups
+    end
+
+    def run_each(iterator)
+      @configuration.reporter.report(0, @configuration.randomize? ? @configuration.seed : nil) do |reporter|
+        begin
+          @configuration.run_hook(:before, :suite)
+          iterator.map {|g|
+            print "    #{g.description}: "
+            start = Time.now
+            ret = g.run(reporter)
+            diff = Time.now-start
+            puts("  <%.3f>" % diff)
+
+            ret
+          }.all? ? 0 : @configuration.failure_exit_code
+        ensure
+          @configuration.run_hook(:after, :suite)
+        end
+      end
+    end
+  end
+end

data/lib/test_queue/runner/rspec3.rb

@@ -0,0 +1,45 @@
+module RSpec::Core
+  # RSpec 3.2 introduced:
+  unless Configuration.method_defined?(:with_suite_hooks)
+    class Configuration
+      def with_suite_hooks
+        begin
+          hook_context = SuiteHookContext.new
+          hooks.run(:before, :suite, hook_context)
+          yield
+        ensure
+          hooks.run(:after, :suite, hook_context)
+        end
+      end
+    end
+  end
+
+  class QueueRunner < Runner
+    def initialize
+      options = ConfigurationOptions.new(ARGV)
+      super(options)
+    end
+
+    def example_groups
+      setup($stderr, $stdout)
+      @world.ordered_example_groups
+    end
+
+    def run_specs(iterator)
+      @configuration.reporter.report(@world.ordered_example_groups.count) do |reporter|
+        @configuration.with_suite_hooks do
+          iterator.map { |g|
+            print "    #{g.description}: "
+            start = Time.now
+            ret = g.run(reporter)
+            diff = Time.now-start
+            puts("  <%.3f>" % diff)
+
+            ret
+          }.all? ? 0 : @configuration.failure_exit_code
+        end
+      end
+    end
+    alias_method :run_each, :run_specs
+  end
+end

data/lib/test_queue/runner/sample.rb

@@ -0,0 +1,76 @@
+require 'test_queue'
+require 'test_queue/runner'
+
+module TestQueue
+  class Runner
+    class Sample < Runner
+      def spawn_workers
+        puts "Spawning #@concurrency workers"
+        super
+      end
+
+      def after_fork(num)
+        puts "  -- worker #{num} booted as pid #{$$}"
+        super
+      end
+
+      def run_worker(iterator)
+        sum = 0
+        iterator.each do |item|
+          puts "  #{item.inspect}"
+          sum += item
+        end
+        sum
+      end
+
+      def summarize_worker(worker)
+        stats.update(worker.stats)
+
+        worker.summary  = worker.output.scan(/^\s*(\d+)/).join(', ')
+        worker.failure_output = ''
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  TestQueue::Runner::Sample.new(Array(1..10)).execute
+end
+
+__END__
+
+Spawning 4 workers
+  -- worker 0 booted as pid 40406
+  -- worker 1 booted as pid 40407
+  -- worker 2 booted as pid 40408
+  -- worker 3 booted as pid 40409
+
+==> Starting ruby test-queue worker [1] (40407)
+
+  2
+  5
+  8
+
+==> Starting ruby test-queue worker [3] (40409)
+
+
+==> Starting ruby test-queue worker [2] (40408)
+
+  3
+  6
+  9
+
+==> Starting ruby test-queue worker [0] (40406)
+
+  1
+  4
+  7
+  10
+
+==> Summary
+
+    [1]                                                 2, 5, 8      in 0.0024s      (pid 40407 exit 15)
+    [3]                                                              in 0.0036s      (pid 40409 exit 0)
+    [2]                                                 3, 6, 9      in 0.0038s      (pid 40408 exit 18)
+    [0]                                             1, 4, 7, 10      in 0.0044s      (pid 40406 exit 22)
+

data/lib/test_queue/runner/testunit.rb

@@ -0,0 +1,56 @@
+require 'test_queue/runner'
+
+gem 'test-unit'
+require 'test/unit'
+require 'test/unit/collector/descendant'
+require 'test/unit/testresult'
+require 'test/unit/testsuite'
+require 'test/unit/ui/console/testrunner'
+
+class Test::Unit::TestSuite
+  attr_accessor :iterator
+
+  def run(result, &progress_block)
+    @start_time = Time.now
+    yield(STARTED, name)
+    yield(STARTED_OBJECT, self)
+    run_startup(result)
+    (@iterator || @tests).each do |test|
+      @n_tests += test.size
+      run_test(test, result, &progress_block)
+      @passed = false unless test.passed?
+    end
+    run_shutdown(result)
+  ensure
+    @elapsed_time = Time.now - @start_time
+    yield(FINISHED, name)
+    yield(FINISHED_OBJECT, self)
+  end
+end
+
+module TestQueue
+  class Runner
+    class TestUnit < Runner
+      def initialize
+        @suite = Test::Unit::Collector::Descendant.new.collect
+        tests = @suite.tests.sort_by{ |s| -(stats[s.to_s] || 0) }
+        super(tests)
+      end
+
+      def run_worker(iterator)
+        @suite.iterator = iterator
+        res = Test::Unit::UI::Console::TestRunner.new(@suite).start
+        res.run_count - res.pass_count
+      end
+
+      def summarize_worker(worker)
+        worker.stats.each do |s, val|
+          stats[s.to_s] = val
+        end
+
+        worker.summary = worker.output.split("\n").grep(/^\d+ tests?/).first
+        worker.failure_output = worker.output.scan(/^Failure:\n(.*)\n=======================*/m).join("\n")
+      end
+    end
+  end
+end