test-queue-patched 0.4.3

data/lib/test_queue/runner/cucumber.rb

@@ -0,0 +1,115 @@
+require 'cucumber'
+require 'cucumber/rspec/disable_option_parser'
+require 'cucumber/cli/main'
+
+module Cucumber
+  module Ast
+    class Features
+      attr_accessor :features
+    end
+
+    class Feature
+      def to_s
+        title
+      end
+    end
+  end
+
+  class Runtime
+    if defined?(::Cucumber::Runtime::FeaturesLoader)
+      # Without this module, Runtime#features would load all features specified
+      # on the command line. We want to avoid that and load only the features
+      # each worker needs ourselves, so we override the default behavior to let
+      # us put our iterator in place without loading any features directly.
+      module InjectableFeatures
+        def features
+          return @features if defined?(@features)
+          super
+        end
+
+        def features=(iterator)
+          @features = ::Cucumber::Ast::Features.new
+          @features.features = iterator
+        end
+      end
+
+      prepend InjectableFeatures
+    else
+      attr_writer :features
+    end
+  end
+end
+
+module TestQueue
+  class Runner
+    class Cucumber < Runner
+      def initialize
+        super(TestFramework::Cucumber.new)
+      end
+
+      def run_worker(iterator)
+        runtime = @test_framework.runtime
+        runtime.features = iterator
+
+        @test_framework.cli.execute!(runtime)
+
+        if runtime.respond_to?(:summary_report, true)
+          runtime.send(:summary_report).test_cases.total_failed
+        else
+          runtime.results.scenarios(:failed).size
+        end
+      end
+
+      def summarize_worker(worker)
+        output                = worker.output.gsub(/\e\[\d+./, '')
+        worker.summary        = output.split("\n").grep(/^\d+ (scenarios?|steps?)/).first
+        worker.failure_output = output.scan(/^Failing Scenarios:\n(.*)\n\d+ scenarios?/m).join("\n")
+      end
+    end
+  end
+
+  class TestFramework
+    class Cucumber < TestFramework
+      class FakeKernel
+        def exit(n)
+          if $!
+            # Let Cucumber exit for raised exceptions.
+            Kernel.exit(n)
+          end
+          # Don't let Cucumber exit to indicate test failures. We want to
+          # return the number of failures from #run_worker instead.
+        end
+      end
+
+      def cli
+        @cli ||= ::Cucumber::Cli::Main.new(ARGV.dup, $stdin, $stdout, $stderr, FakeKernel.new)
+      end
+
+      def runtime
+        @runtime ||= ::Cucumber::Runtime.new(cli.configuration)
+      end
+
+      def all_suite_files
+        if runtime.respond_to?(:feature_files, true)
+          runtime.send(:feature_files)
+        else
+          cli.configuration.feature_files
+        end
+      end
+
+      def suites_from_file(path)
+        if defined?(::Cucumber::Core::Gherkin::Document)
+          source = ::Cucumber::Runtime::NormalisedEncodingFile.read(path)
+          doc = ::Cucumber::Core::Gherkin::Document.new(path, source)
+          [[File.basename(doc.uri), doc]]
+        else
+          loader =
+            ::Cucumber::Runtime::FeaturesLoader.new([path],
+                                                    cli.configuration.filters,
+                                                    cli.configuration.tag_expression)
+          loader.features.map { |feature| [feature.title, feature] }
+        end
+      end
+    end
+  end
+end

data/lib/test_queue/runner/minitest.rb

@@ -0,0 +1,21 @@
+begin
+  require 'minitest'
+  require 'test_queue/runner/minitest5'
+rescue LoadError => e
+  require 'minitest/unit'
+  require 'test_queue/runner/minitest4'
+end
+
+module TestQueue
+  class Runner
+    class MiniTest < Runner
+      def summarize_worker(worker)
+        worker.summary = worker.lines.grep(/, \d+ errors?, /).first
+        failures  = worker.lines.select{ |line|
+          line if (line =~ /^Finished/) ... (line =~ /, \d+ errors?, /)
+        }[1..-2]
+        worker.failure_output = failures.join("\n") if failures
+      end
+    end
+  end
+end

data/lib/test_queue/runner/minitest4.rb

@@ -0,0 +1,88 @@
+require 'test_queue/runner'
+require 'set'
+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
+
+  def failure_count
+    failures.length
+  end
+end
+
+module TestQueue
+  class Runner
+    class MiniTest < Runner
+      def initialize
+        if ::MiniTest::Unit::TestCase.original_test_suites.any?
+          fail "Do not `require` test files. Pass them via ARGV instead and they will be required as needed."
+        end
+        super(TestFramework::MiniTest.new)
+      end
+
+      def run_worker(iterator)
+        ::MiniTest::Unit::TestCase.test_suites = iterator
+        ::MiniTest::Unit.new.run
+      end
+    end
+  end
+
+  class TestFramework
+    class MiniTest < TestFramework
+      def all_suite_files
+        ARGV
+      end
+
+      def suites_from_file(path)
+        ::MiniTest::Unit::TestCase.reset
+        require File.absolute_path(path)
+        ::MiniTest::Unit::TestCase.original_test_suites.map { |suite|
+          [suite.name, suite]
+        }
+      end
+    end
+  end
+end

data/lib/test_queue/runner/minitest5.rb

@@ -0,0 +1,87 @@
+require 'test_queue/runner'
+
+module MiniTest
+  def self.__run reporter, options
+    suites = Runnable.runnables
+    suites.map { |suite| suite.run reporter, options }
+  end
+
+  class Runnable
+    def failure_count
+      failures.length
+    end
+  end
+
+  class Test
+    def self.runnables= runnables
+      @@runnables = runnables
+    end
+
+    # Synchronize all tests, even serial ones.
+    #
+    # Minitest runs serial tests before parallel ones to ensure the
+    # unsynchronized serial tests don't overlap the parallel tests. But since
+    # the test-queue master hands out tests without actually loading their
+    # code, there's no way to know which are parallel and which are serial.
+    # Synchronizing serial tests does add some overhead, but hopefully this is
+    # outweighed by the speed benefits of using test-queue.
+    def _synchronize; Test.io_lock.synchronize { yield }; 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
+        if ::MiniTest::Test.runnables.any? { |r| r.runnable_methods.any? }
+          fail "Do not `require` test files. Pass them via ARGV instead and they will be required as needed."
+        end
+        super(TestFramework::MiniTest.new)
+      end
+
+      def run_worker(iterator)
+        ::MiniTest::Test.runnables = iterator
+        ::MiniTest.run ? 0 : 1
+      end
+    end
+  end
+
+  class TestFramework
+    class MiniTest < TestFramework
+      def all_suite_files
+        ARGV
+      end
+
+      def suites_from_file(path)
+        ::MiniTest::Test.reset
+        require File.absolute_path(path)
+        ::MiniTest::Test.runnables
+          .reject { |s| s.runnable_methods.empty? }
+          .map { |s| [s.name, s] }
+      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,79 @@
+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
+        super(TestFramework::RSpec.new)
+      end
+
+      def run_worker(iterator)
+        rspec = ::RSpec::Core::QueueRunner.new
+        rspec.run_each(iterator).to_i
+      end
+
+      def summarize_worker(worker)
+        worker.summary  = worker.lines.grep(/ examples?, /).first
+        worker.failure_output = worker.output[/^Failures:\n\n(.*)\n^Finished/m, 1]
+      end
+    end
+  end
+
+  class TestFramework
+    class RSpec < TestFramework
+      def all_suite_files
+        options = ::RSpec::Core::ConfigurationOptions.new(ARGV)
+        options.parse_options if options.respond_to?(:parse_options)
+        options.configure(::RSpec.configuration)
+
+        ::RSpec.configuration.files_to_run.uniq
+      end
+
+      def suites_from_file(path)
+        ::RSpec.world.example_groups.clear
+        load path
+        split_groups(::RSpec.world.example_groups).map { |example_or_group|
+          name = if example_or_group.respond_to?(:id)
+                   example_or_group.id
+                 elsif example_or_group.respond_to?(:full_description)
+                   example_or_group.full_description
+                 elsif example_or_group.metadata.key?(:full_description)
+                   example_or_group.metadata[:full_description]
+                 else
+                   example_or_group.metadata[:example_group][:full_description]
+                 end
+          [name, example_or_group]
+        }
+      end
+
+      private
+
+      def split_groups(groups)
+        return groups unless split_groups?
+
+        groups_to_split, groups_to_keep = [], []
+        groups.each do |group|
+          (group.metadata[:no_split] ? groups_to_keep : groups_to_split) << group
+        end
+        queue = groups_to_split.flat_map(&:descendant_filtered_examples)
+        queue.concat groups_to_keep
+        queue
+      end
+
+      def split_groups?
+        return @split_groups if defined?(@split_groups)
+        @split_groups = ENV['TEST_QUEUE_SPLIT_GROUPS'] && ENV['TEST_QUEUE_SPLIT_GROUPS'].strip.downcase == 'true'
+      end
+    end
+  end
+end

data/lib/test_queue/runner/rspec2.rb

@@ -0,0 +1,44 @@
+class ::RSpec::Core::ExampleGroup
+  def self.failure_count
+    examples.map {|e| e.execution_result[:status] == "failed"}.length
+  end
+end
+
+module RSpec::Core
+  class QueueRunner < CommandLine
+    def initialize
+      super(ARGV)
+      @configuration.output_stream = $stdout
+      @configuration.error_stream  = $stderr
+    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|
+            if g.is_a? ::RSpec::Core::Example
+              print "    #{g.full_description}: "
+              example = g
+              g = example.example_group
+              ::RSpec.world.filtered_examples.clear
+              examples = [example]
+              examples.extend(::RSpec::Core::Extensions::Ordered::Examples)
+              ::RSpec.world.filtered_examples[g] = examples
+            else
+              print "    #{g.description}: "
+            end
+            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,54 @@
+class ::RSpec::Core::ExampleGroup
+  def self.failure_count
+    examples.map {|e| e.execution_result.status == "failed"}.length
+  end
+end
+
+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 run_specs(iterator)
+      @configuration.reporter.report(0) do |reporter|
+        @configuration.with_suite_hooks do
+          iterator.map { |g|
+            start = Time.now
+            if g.is_a? ::RSpec::Core::Example
+              print "    #{g.full_description}: "
+              example = g
+              g = example.example_group
+              ::RSpec.world.filtered_examples.clear
+              ::RSpec.world.filtered_examples[g] = [example]
+            else
+              print "    #{g.description}: "
+            end
+            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,74 @@
+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)
+        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,74 @@
+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
+
+  def failure_count
+    (@iterator || @tests).map {|t| t.instance_variable_get(:@_result).failure_count}.inject(0, :+)
+  end
+end
+
+module TestQueue
+  class Runner
+    class TestUnit < Runner
+      def initialize
+        if Test::Unit::Collector::Descendant.new.collect.tests.any?
+          fail "Do not `require` test files. Pass them via ARGV instead and they will be required as needed."
+        end
+        super(TestFramework::TestUnit.new)
+      end
+
+      def run_worker(iterator)
+        @suite = Test::Unit::TestSuite.new("specified by test-queue master")
+        @suite.iterator = iterator
+        res = Test::Unit::UI::Console::TestRunner.new(@suite).start
+        res.run_count - res.pass_count
+      end
+
+      def summarize_worker(worker)
+        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
+
+  class TestFramework
+    class TestUnit < TestFramework
+      def all_suite_files
+        ARGV
+      end
+
+      def suites_from_file(path)
+        Test::Unit::TestCase::DESCENDANTS.clear
+        require File.absolute_path(path)
+        Test::Unit::Collector::Descendant.new.collect.tests.map { |suite|
+          [suite.name, suite]
+        }
+      end
+    end
+  end
+end