vinted-parallel_tests 0.13.3

data/lib/parallel_tests/cucumber/gherkin_listener.rb

@@ -0,0 +1,82 @@
+require 'gherkin'
+
+module ParallelTests
+  module Cucumber
+    class GherkinListener
+      attr_reader :collect
+
+      attr_writer :ignore_tag_pattern
+
+      def initialize
+        @steps, @uris = [], []
+        @collect = {}
+        reset_counters!
+      end
+
+      def feature(feature)
+        @feature = feature
+      end
+
+      def background(*args)
+        @background = 1
+      end
+
+      def scenario(scenario)
+        @outline = @background = 0
+        return if should_ignore(scenario)
+        @scenarios += 1
+      end
+
+      def scenario_outline(outline)
+        return if should_ignore(outline)
+        @outline = 1
+      end
+
+      def step(*args)
+        return if @ignoring
+        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
+        @ignoring = nil
+      end
+
+      # ignore lots of other possible callbacks ...
+      def method_missing(*args)
+      end
+
+      private
+
+      # Return a combination of tags declared on this scenario/outline and the feature it belongs to
+      def all_tags(scenario)
+        (scenario.tags || []) + ((@feature && @feature.tags) || [])
+      end
+
+      # Set @ignoring if we should ignore this scenario/outline based on its tags
+      def should_ignore(scenario)
+        @ignoring = @ignore_tag_pattern && all_tags(scenario).find{ |tag| @ignore_tag_pattern === tag.name }
+      end
+    end
+  end
+end

data/lib/parallel_tests/cucumber/io.rb

@@ -0,0 +1,41 @@
+require 'parallel_tests'
+
+module ParallelTests
+  module Cucumber
+    module Io
+
+      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/cucumber/runner.rb

@@ -0,0 +1,98 @@
+require "parallel_tests/test/runner"
+require 'shellwords'
+
+module ParallelTests
+  module Cucumber
+    class Runner < ParallelTests::Test::Runner
+      NAME = 'Cucumber'
+
+      class << self
+        def run_tests(test_files, process_number, num_processes, options)
+          sanitized_test_files = test_files.map { |val| Shellwords.escape(val) }
+          options = options.merge(:env => {"AUTOTEST" => "1"}) if $stdout.tty? # display color when we are in a terminal
+          runtime_logging = " --format ParallelTests::Cucumber::RuntimeLogger --out #{runtime_log}"
+          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 determine_executable
+          case
+          when File.exists?("bin/cucumber")
+            "bin/cucumber"
+          when ParallelTests.bundler_enabled?
+            "bundle exec cucumber"
+          when File.file?("script/cucumber")
+            "script/cucumber"
+          else
+            "cucumber"
+          end
+        end
+
+        def runtime_log
+          'tmp/parallel_runtime_cucumber.log'
+        end
+
+        def 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/}cucumber{.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] == :steps
+            Grouper.by_steps(find_tests(tests, options), num_groups, options)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/cucumber/runtime_logger.rb

@@ -0,0 +1,28 @@
+require 'parallel_tests/cucumber/io'
+
+module ParallelTests
+  module Cucumber
+    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,56 @@
+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 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
+
+      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/cucumber/gherkin_listener'
+        listener = Cucumber::GherkinListener.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
+    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.send(: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,72 @@
+require "parallel_tests/test/runner"
+
+module ParallelTests
+  module RSpec
+    class Runner < ParallelTests::Test::Runner
+      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")
+            "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,54 @@
+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 if !RSPEC_1
+  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(example_group)
+      @group_nesting -= 1
+      if @group_nesting == 0
+        @example_times[example_group.file_path] += ParallelTests.now - @time
+      end
+      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

data/lib/parallel_tests/rspec/summary_logger.rb

@@ -0,0 +1,19 @@
+require 'parallel_tests/rspec/failures_logger'
+
+class ParallelTests::RSpec::SummaryLogger < ParallelTests::RSpec::LoggerBase
+  # RSpec 1: dumps 1 failed spec
+  def dump_failure(*args)
+    lock_output do
+      super
+    end
+    @output.flush
+  end
+
+  # RSpec 2: dumps all failed specs
+  def dump_failures(*args)
+    lock_output do
+      super
+    end
+    @output.flush
+  end
+end