parallel_tests 1.1.0 → 1.1.1

data/lib/parallel_tests/gherkin/runner.rb

@@ -0,0 +1,116 @@
+require "parallel_tests/test/runner"
+require 'shellwords'
+
+module ParallelTests
+  module Gherkin
+    class Runner < ParallelTests::Test::Runner
+
+      class << self
+        def run_tests(test_files, process_number, num_processes, options)
+          combined_scenarios = test_files
+
+          if options[:group_by] == :scenarios
+            grouped = test_files.map { |t| t.split(':') }.group_by(&:first)
+            combined_scenarios = grouped.map {|file,files_and_lines| "#{file}:#{files_and_lines.map(&:last).join(':')}" }
+          end
+
+          sanitized_test_files = combined_scenarios.map { |val| WINDOWS ? "\"#{val}\"" : Shellwords.escape(val) }
+
+          options[:env] ||= {}
+          options[:env] = options[:env].merge({'AUTOTEST' => '1'}) if $stdout.tty? # display color when we are in a terminal
+
+          cmd = [
+            executable,
+            (runtime_logging if File.directory?(File.dirname(runtime_log))),
+            cucumber_opts(options[:test_options]),
+            *sanitized_test_files
+          ].compact.join(' ')
+          execute_command(cmd, process_number, num_processes, options)
+        end
+
+        def test_file_name
+          @test_file_name || 'feature'
+        end
+
+        def test_suffix
+          /\.feature$/
+        end
+
+        def line_is_result?(line)
+          line =~ /^\d+ (steps?|scenarios?)/
+        end
+
+        # cucumber has 2 result lines per test run, that cannot be added
+        # 1 scenario (1 failed)
+        # 1 step (1 failed)
+        def summarize_results(results)
+          sort_order = %w[scenario step failed undefined skipped pending passed]
+
+          %w[scenario step].map do |group|
+            group_results = results.grep(/^\d+ #{group}/)
+            next if group_results.empty?
+
+            sums = sum_up_results(group_results)
+            sums = sums.sort_by { |word, _| sort_order.index(word) || 999 }
+            sums.map! do |word, number|
+              plural = "s" if word == group and number != 1
+              "#{number} #{word}#{plural}"
+            end
+            "#{sums[0]} (#{sums[1..-1].join(", ")})"
+          end.compact.join("\n")
+        end
+
+        def cucumber_opts(given)
+          if given =~ /--profile/ or given =~ /(^|\s)-p /
+            given
+          else
+            [given, profile_from_config].compact.join(" ")
+          end
+        end
+
+        def profile_from_config
+          # copied from https://github.com/cucumber/cucumber/blob/master/lib/cucumber/cli/profile_loader.rb#L85
+          config = Dir.glob("{,.config/,config/}#{name}{.yml,.yaml}").first
+          if config && File.read(config) =~ /^parallel:/
+            "--profile parallel"
+          end
+        end
+
+        def tests_in_groups(tests, num_groups, options={})
+          if options[:group_by] == :scenarios
+            @test_file_name = "scenario"
+          end
+          method = "by_#{options[:group_by]}"
+          if Grouper.respond_to?(method)
+            Grouper.send(method, find_tests(tests, options), num_groups, options)
+          else
+            super
+          end
+        end
+
+
+        def runtime_logging
+          " --format ParallelTests::Gherkin::RuntimeLogger --out #{runtime_log}"
+        end
+
+        def runtime_log
+          "tmp/parallel_runtime_#{name}.log"
+        end
+
+        def determine_executable
+          case
+          when File.exists?("bin/#{name}")
+            "bin/#{name}"
+          when ParallelTests.bundler_enabled?
+            "bundle exec #{name}"
+          when File.file?("script/#{name}")
+            "script/#{name}"
+          else
+            "#{name}"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/parallel_tests/gherkin/runtime_logger.rb

@@ -0,0 +1,28 @@
+require 'parallel_tests/gherkin/io'
+
+module ParallelTests
+  module Gherkin
+    class RuntimeLogger
+      include Io
+
+      def initialize(step_mother, path_or_io, options=nil)
+        @io = prepare_io(path_or_io)
+        @example_times = Hash.new(0)
+      end
+
+      def before_feature(_)
+        @start_at = ParallelTests.now.to_f
+      end
+
+      def after_feature(feature)
+        @example_times[feature.file] += ParallelTests.now.to_f - @start_at
+      end
+
+      def after_features(*args)
+        lock_output do
+          @io.puts @example_times.map { |file, time| "#{file}:#{time}" }
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/grouper.rb

@@ -0,0 +1,73 @@
+module ParallelTests
+  class Grouper
+    class << self
+      def by_steps(tests, num_groups, options)
+        features_with_steps = build_features_with_steps(tests, options)
+        in_even_groups_by_size(features_with_steps, num_groups)
+      end
+
+      def by_scenarios(tests, num_groups, options={})
+        scenarios = group_by_scenarios(tests, options)
+        in_even_groups_by_size(scenarios, num_groups)
+      end
+
+      def in_even_groups_by_size(items, num_groups, options= {})
+        groups = Array.new(num_groups) { {:items => [], :size => 0} }
+
+        # add all files that should run in a single process to one group
+        (options[:single_process] || []).each do |pattern|
+          matched, items = items.partition { |item, size| item =~ pattern }
+          matched.each { |item, size| add_to_group(groups.first, item, size) }
+        end
+
+        groups_to_fill = (options[:isolate] ? groups[1..-1] : groups)
+        group_features_by_size(items_to_group(items), groups_to_fill)
+
+        groups.map!{|g| g[:items].sort }
+      end
+
+      private
+
+      def largest_first(files)
+        files.sort_by{|item, size| size }.reverse
+      end
+
+      def smallest_group(groups)
+        groups.min_by{|g| g[:size] }
+      end
+
+      def add_to_group(group, item, size)
+        group[:items] << item
+        group[:size] += size
+      end
+
+      def build_features_with_steps(tests, options)
+        require 'parallel_tests/gherkin/listener'
+        listener = ParallelTests::Gherkin::Listener.new
+        listener.ignore_tag_pattern = Regexp.compile(options[:ignore_tag_pattern]) if options[:ignore_tag_pattern]
+        parser = ::Gherkin::Parser::Parser.new(listener, true, 'root')
+        tests.each{|file|
+          parser.parse(File.read(file), file, 0)
+        }
+        listener.collect.sort_by{|_,value| -value }
+      end
+
+      def group_by_scenarios(tests, options={})
+        require 'parallel_tests/cucumber/scenarios'
+        ParallelTests::Cucumber::Scenarios.all(tests, options)
+      end
+
+      def group_features_by_size(items, groups_to_fill)
+        items.each do |item, size|
+          size ||= 1
+          smallest = smallest_group(groups_to_fill)
+          add_to_group(smallest, item, size)
+        end
+      end
+
+      def items_to_group(items)
+        items.first && items.first.size == 2 ? largest_first(items) : items
+      end
+    end
+  end
+end

data/lib/parallel_tests/railtie.rb

@@ -0,0 +1,8 @@
+# rake tasks for Rails 3+
+module ParallelTests
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      require "parallel_tests/tasks"
+    end
+  end
+end

data/lib/parallel_tests/rspec/failures_logger.rb

@@ -0,0 +1,54 @@
+require 'parallel_tests/rspec/logger_base'
+require 'parallel_tests/rspec/runner'
+
+class ParallelTests::RSpec::FailuresLogger < ParallelTests::RSpec::LoggerBase
+  if RSPEC_3
+    RSpec::Core::Formatters.register self, :dump_failures, :dump_summary
+  end
+
+  # RSpec 1: does not keep track of failures, so we do
+  def example_failed(example, *args)
+    if RSPEC_1
+      @failed_examples ||= []
+      @failed_examples << example
+    else
+      super
+    end
+  end
+
+  if RSPEC_1
+    def dump_failure(*args)
+    end
+  else
+    def dump_failures(*args)
+    end
+  end
+
+  def dump_summary(*args)
+    lock_output do
+      if RSPEC_1
+        dump_commands_to_rerun_failed_examples_rspec_1
+      elsif RSPEC_3
+        notification = args.first
+        unless notification.failed_examples.empty?
+          colorizer = ::RSpec::Core::Formatters::ConsoleCodes
+          output.puts notification.colorized_rerun_commands(colorizer)
+        end
+      else
+        dump_commands_to_rerun_failed_examples
+      end
+    end
+    @output.flush
+  end
+
+  private
+
+  def dump_commands_to_rerun_failed_examples_rspec_1
+    (@failed_examples||[]).each do |example|
+      file, line = example.location.to_s.split(':')
+      next unless file and line
+      file.gsub!(%r(^.*?/spec/), './spec/')
+      @output.puts "#{ParallelTests::RSpec::Runner.send(:executable)} #{file}:#{line} # #{example.description}"
+    end
+  end
+end

data/lib/parallel_tests/rspec/logger_base.rb

@@ -0,0 +1,55 @@
+module ParallelTests
+  module RSpec
+  end
+end
+
+begin
+  require 'rspec/core/formatters/base_text_formatter'
+  base = RSpec::Core::Formatters::BaseTextFormatter
+rescue LoadError
+  require 'spec/runner/formatter/base_text_formatter'
+  base = Spec::Runner::Formatter::BaseTextFormatter
+end
+
+ParallelTests::RSpec::LoggerBaseBase = base
+
+class ParallelTests::RSpec::LoggerBase < ParallelTests::RSpec::LoggerBaseBase
+  RSPEC_1 = !defined?(RSpec::Core::Formatters::BaseTextFormatter) # do not test for Spec, this will trigger deprecation warning in rspec 2
+  RSPEC_3 = !RSPEC_1 && RSpec::Core::Version::STRING.start_with?('3')
+
+  def initialize(*args)
+    super
+
+    @output ||= args[1] || args[0] # rspec 1 has output as second argument
+
+    if String === @output # a path ?
+      FileUtils.mkdir_p(File.dirname(@output))
+      File.open(@output, 'w'){} # overwrite previous results
+      @output = File.open(@output, 'a')
+    elsif File === @output # close and restart in append mode
+      @output.close
+      @output = File.open(@output.path, 'a')
+    end
+  end
+
+  #stolen from Rspec
+  def close(*args)
+    @output.close  if (IO === @output) & (@output != $stdout)
+  end
+
+  protected
+
+  # do not let multiple processes get in each others way
+  def lock_output
+    if File === @output
+      begin
+        @output.flock File::LOCK_EX
+        yield
+      ensure
+        @output.flock File::LOCK_UN
+      end
+    else
+      yield
+    end
+  end
+end

data/lib/parallel_tests/rspec/runner.rb

@@ -0,0 +1,73 @@
+require "parallel_tests/test/runner"
+
+module ParallelTests
+  module RSpec
+    class Runner < ParallelTests::Test::Runner
+      DEV_NULL = (WINDOWS ? "NUL" : "/dev/null")
+      NAME = 'RSpec'
+
+      class << self
+        def run_tests(test_files, process_number, num_processes, options)
+          exe = executable # expensive, so we cache
+          version = (exe =~ /\brspec\b/ ? 2 : 1)
+          cmd = [exe, options[:test_options], (rspec_2_color if version == 2), spec_opts, *test_files].compact.join(" ")
+          options = options.merge(:env => rspec_1_color) if version == 1
+          execute_command(cmd, process_number, num_processes, options)
+        end
+
+        def determine_executable
+          cmd = case
+          when File.exists?("bin/rspec")
+            WINDOWS ? "ruby bin/rspec" : "bin/rspec"
+          when File.file?("script/spec")
+            "script/spec"
+          when ParallelTests.bundler_enabled?
+            cmd = (run("bundle show rspec-core") =~ %r{Could not find gem.*} ? "spec" : "rspec")
+            "bundle exec #{cmd}"
+          else
+            %w[spec rspec].detect{|cmd| system "#{cmd} --version > #{DEV_NULL} 2>&1" }
+          end
+
+          cmd or raise("Can't find executables rspec or spec")
+        end
+
+        def runtime_log
+          'tmp/parallel_runtime_rspec.log'
+        end
+
+        def test_file_name
+          "spec"
+        end
+
+        def test_suffix
+          /_spec\.rb$/
+        end
+
+        private
+
+        # so it can be stubbed....
+        def run(cmd)
+          `#{cmd}`
+        end
+
+        def rspec_1_color
+          if $stdout.tty?
+            {'RSPEC_COLOR' => "1"}
+          else
+            {}
+          end
+        end
+
+        def rspec_2_color
+          '--color --tty' if $stdout.tty?
+        end
+
+        def spec_opts
+          options_file = ['.rspec_parallel', 'spec/parallel_spec.opts', 'spec/spec.opts'].detect{|f| File.file?(f) }
+          return unless options_file
+          "-O #{options_file}"
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/rspec/runtime_logger.rb

@@ -0,0 +1,59 @@
+require 'parallel_tests'
+require 'parallel_tests/rspec/logger_base'
+
+class ParallelTests::RSpec::RuntimeLogger < ParallelTests::RSpec::LoggerBase
+  def initialize(*args)
+    super
+    @example_times = Hash.new(0)
+    @group_nesting = 0 unless RSPEC_1
+  end
+
+  if RSPEC_3
+    RSpec::Core::Formatters.register self, :example_group_started, :example_group_finished, :start_dump
+  end
+
+  if RSPEC_1
+    def example_started(*args)
+      @time = ParallelTests.now
+      super
+    end
+
+    def example_passed(example)
+      file = example.location.split(':').first
+      @example_times[file] += ParallelTests.now - @time
+      super
+    end
+  else
+    def example_group_started(example_group)
+      @time = ParallelTests.now if @group_nesting == 0
+      @group_nesting += 1
+      super
+    end
+
+    def example_group_finished(notification)
+      @group_nesting -= 1
+      if @group_nesting == 0
+        path = (RSPEC_3 ? notification.group.file_path : notification.file_path)
+        @example_times[path] += ParallelTests.now - @time
+      end
+      super if defined?(super)
+    end
+  end
+
+  def dump_summary(*args);end
+  def dump_failures(*args);end
+  def dump_failure(*args);end
+  def dump_pending(*args);end
+
+  def start_dump(*args)
+    return unless ENV['TEST_ENV_NUMBER'] #only record when running in parallel
+    # TODO: Figure out why sometimes time can be less than 0
+    lock_output do
+      @example_times.each do |file, time|
+        relative_path = file.sub(/^#{Regexp.escape Dir.pwd}\//,'')
+        @output.puts "#{relative_path}:#{time > 0 ? time : 0}"
+      end
+    end
+    @output.flush
+  end
+end