friendlyfashion-parallel_tests 0.9.0

data/lib/parallel_tests/cucumber/gherkin_listener.rb

@@ -0,0 +1,60 @@
+require 'gherkin'
+
+module ParallelTests
+  module Cucumber
+    class GherkinListener
+      attr_reader :collect
+
+      def initialize
+        @steps, @uris = [], []
+        @collect = {}
+        reset_counters!
+      end
+
+      def background(*args)
+        @background = 1
+      end
+
+      def scenario(*args)
+        @scenarios += 1
+        @outline = @background = 0
+      end
+
+      def scenario_outline(*args)
+        @outline = 1
+      end
+
+      def step(*args)
+        if @background == 1
+          @background_steps += 1
+        elsif @outline > 0
+          @outline_steps += 1
+        else
+          @collect[@uri] += 1
+        end
+      end
+
+      def uri(path)
+        @uri = path
+        @collect[@uri] = 0
+      end
+
+      def examples(*args)
+        @examples += 1
+      end
+
+      def eof(*args)
+        @collect[@uri] += (@background_steps * @scenarios) + (@outline_steps * @examples)
+        reset_counters!
+      end
+
+      def reset_counters!
+        @examples = @outline = @outline_steps = @background = @background_steps = @scenarios = 0
+      end
+
+      # ignore lots of other possible callbacks ...
+      def method_missing(*args)
+      end
+    end
+  end
+end

data/lib/parallel_tests/cucumber/runner.rb

@@ -0,0 +1,90 @@
+require 'parallel_tests/test/runner'
+
+module ParallelTests
+  module Cucumber
+    class Runner < ParallelTests::Test::Runner
+      def self.run_tests(test_files, process_number, options)
+        color = ($stdout.tty? ? 'AUTOTEST=1 ; export AUTOTEST ;' : '')#display color when we are in a terminal
+        runtime_logging = " --format ParallelTests::Cucumber::RuntimeLogger --out #{runtime_log}"
+        cmd = [
+          color,
+          executable,
+          (runtime_logging if File.directory?(File.dirname(runtime_log))),
+          cucumber_opts(options[:test_options]),
+          *test_files
+        ].compact.join(" ")
+        execute_command(cmd, process_number, options)
+      end
+
+      def self.executable
+        if ParallelTests.bundler_enabled?
+          "bundle exec cucumber"
+        elsif File.file?("script/cucumber")
+          "script/cucumber"
+        else
+          "cucumber"
+        end
+      end
+
+      def self.runtime_log
+        'tmp/parallel_runtime_cucumber.log'
+      end
+
+      def self.test_file_name
+        "feature"
+      end
+
+      def self.test_suffix
+        ".feature"
+      end
+
+      def self.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 self.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 self.cucumber_opts(given)
+        if given =~ /--profile/ or given =~ /(^|\s)-p /
+          given
+        else
+          [given, profile_from_config].compact.join(" ")
+        end
+      end
+
+      def self.profile_from_config
+        # copied from https://github.com/cucumber/cucumber/blob/master/lib/cucumber/cli/profile_loader.rb#L85
+        config = Dir.glob('{,.config/,config/}cucumber{.yml,.yaml}').first
+        if config && File.read(config) =~ /^parallel:/
+          "--profile parallel"
+        end
+      end
+
+      def self.tests_in_groups(tests, num_groups, options={})
+        if options[:group_by] == :steps
+          Grouper.by_steps(find_tests(tests, options), num_groups)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/cucumber/runtime_logger.rb

@@ -0,0 +1,58 @@
+module ParallelTests
+  module Cucumber
+    class RuntimeLogger
+      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 = Time.now.to_f
+      end
+
+      def after_feature(feature)
+        @example_times[feature.file] += Time.now.to_f - @start_at
+      end
+
+      def after_features(*args)
+        lock_output do
+          @io.puts @example_times.map { |file, time| "#{file}:#{time}" }
+        end
+      end
+
+      private
+
+      def prepare_io(path_or_io)
+        if path_or_io.respond_to?(:write)
+          path_or_io
+        else # its a path
+          File.open(path_or_io, 'w').close # clean out the file
+          file = File.open(path_or_io, 'a')
+
+          at_exit do
+            unless file.closed?
+              file.flush
+              file.close
+            end
+          end
+
+          file
+        end
+      end
+
+      # do not let multiple processes get in each others way
+      def lock_output
+        if File === @io
+          begin
+            @io.flock File::LOCK_EX
+            yield
+          ensure
+            @io.flock File::LOCK_UN
+          end
+        else
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/grouper.rb

@@ -0,0 +1,53 @@
+module ParallelTests
+  class Grouper
+    def self.in_even_groups_by_size(items_with_sizes, 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_with_sizes = items_with_sizes.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)
+
+      # add all other files
+      largest_first(items_with_sizes).each do |item, size|
+        smallest = smallest_group(groups_to_fill)
+        add_to_group(smallest, item, size)
+      end
+
+      groups.map!{|g| g[:items].sort }
+    end
+
+    def self.largest_first(files)
+      files.sort_by{|item, size| size }.reverse
+    end
+
+    private
+
+    def self.smallest_group(groups)
+      groups.min_by{|g| g[:size] }
+    end
+
+    def self.add_to_group(group, item, size)
+      group[:items] << item
+      group[:size] += size
+    end
+
+    def self.by_steps(tests, num_groups)
+      features_with_steps = build_features_with_steps(tests)
+      in_even_groups_by_size(features_with_steps, num_groups)
+    end
+
+    def self.build_features_with_steps(tests)
+      require 'parallel_tests/cucumber/gherkin_listener'
+      listener = Cucumber::GherkinListener.new
+      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
+  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,44 @@
+require 'parallel_tests/rspec/logger_base'
+require 'parallel_tests/rspec/runner'
+
+class ParallelTests::RSpec::FailuresLogger < ParallelTests::RSpec::LoggerBase
+  # 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
+
+  # RSpec 1: dumps 1 failed spec
+  def dump_failure(*args)
+  end
+
+  # RSpec 2: dumps all failed specs
+  def dump_failures(*args)
+  end
+
+  def dump_summary(*args)
+    lock_output do
+      if RSPEC_1
+        dump_commands_to_rerun_failed_examples_rspec_1
+      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.executable} #{file}:#{line} # #{example.description}"
+    end
+  end
+end

data/lib/parallel_tests/rspec/logger_base.rb

@@ -0,0 +1,52 @@
+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
+
+  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
+    @output.close  if (IO === @output) & (@output != $stdout)
+  end
+
+  # 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,59 @@
+require 'parallel_tests/test/runner'
+
+module ParallelTests
+  module RSpec
+    class Runner < ParallelTests::Test::Runner
+      def self.run_tests(test_files, process_number, options)
+        exe = executable # expensive, so we cache
+        version = (exe =~ /\brspec\b/ ? 2 : 1)
+        cmd = "#{rspec_1_color if version == 1}#{exe} #{options[:test_options]} #{rspec_2_color if version == 2}#{spec_opts} #{test_files*' '}"
+        execute_command(cmd, process_number, options)
+      end
+
+      def self.executable
+        cmd = if File.file?("script/spec")
+          "script/spec"
+        elsif ParallelTests.bundler_enabled?
+          cmd = (run("bundle show rspec") =~ %r{/rspec-1[^/]+$} ? "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 self.runtime_log
+        'tmp/parallel_runtime_rspec.log'
+      end
+
+      def self.test_file_name
+        "spec"
+      end
+
+      def self.test_suffix
+        "_spec.rb"
+      end
+
+      private
+
+      # so it can be stubbed....
+      def self.run(cmd)
+        `#{cmd}`
+      end
+
+      def self.rspec_1_color
+        'RSPEC_COLOR=1 ; export RSPEC_COLOR ;' if $stdout.tty?
+      end
+
+      def self.rspec_2_color
+        '--color --tty ' if $stdout.tty?
+      end
+
+      def self.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

data/lib/parallel_tests/rspec/runtime_logger.rb

@@ -0,0 +1,34 @@
+require 'parallel_tests/rspec/logger_base'
+
+class ParallelTests::RSpec::RuntimeLogger < ParallelTests::RSpec::LoggerBase
+  def initialize(*args)
+    super
+    @example_times = Hash.new(0)
+  end
+
+  def example_started(*args)
+    @time = Time.now
+  end
+
+  def example_passed(example)
+    file = example.location.split(':').first
+    @example_times[file] += Time.now - @time
+  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