parallel_tests 3.4.0 → 4.3.0

data/lib/parallel_tests/gherkin/listener.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ParallelTests
   module Gherkin
     class Listener
@@ -6,7 +7,8 @@ module ParallelTests
       attr_writer :ignore_tag_pattern
 
       def initialize
-        @steps, @uris = [], []
+        @steps = []
+        @uris = []
         @collect = {}
         @feature, @ignore_tag_pattern = nil
         reset_counters!
@@ -16,7 +18,7 @@ module ParallelTests
         @feature = feature
       end
 
-      def background(*args)
+      def background(*)
         @background = 1
       end
 
@@ -31,7 +33,7 @@ module ParallelTests
         @outline = 1
       end
 
-      def step(*args)
+      def step(*)
         return if @ignoring
         if @background == 1
           @background_steps += 1
@@ -51,12 +53,10 @@ module ParallelTests
       # @param  [Gherkin::Formatter::Model::Examples]  examples
       #
       def examples(examples)
-        if examples.rows.size > 0
-          @collect[@uri] += (@outline_steps * examples.rows.size)
-        end
+        @collect[@uri] += (@outline_steps * examples.rows.size) unless examples.rows.empty?
       end
 
-      def eof(*args)
+      def eof(*)
         @collect[@uri] += (@background_steps * @scenarios)
         reset_counters!
       end
@@ -67,8 +67,7 @@ module ParallelTests
       end
 
       # ignore lots of other possible callbacks ...
-      def method_missing(*args)
-      end
+      def method_missing(*); end # rubocop:disable Style/MissingRespondToMissing
 
       private
 
@@ -79,7 +78,7 @@ module ParallelTests
 
       # 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 }
+        @ignoring = @ignore_tag_pattern && all_tags(scenario).find { |tag| @ignore_tag_pattern === tag.name }
       end
     end
   end

data/lib/parallel_tests/gherkin/runner.rb

@@ -1,30 +1,27 @@
+# frozen_string_literal: true
 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(':')}" }
+            combined_scenarios = grouped.map do |file, files_and_lines|
+              "#{file}:#{files_and_lines.map(&:last).join(':')}"
+            end
           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.reject(&:empty?).join(' ')
+          options[:env] = options[:env].merge({ 'AUTOTEST' => '1' }) if $stdout.tty?
+
+          cmd = executable
+          cmd += runtime_logging if File.directory?(File.dirname(runtime_log))
+          cmd += combined_scenarios
+          cmd += cucumber_opts(options[:test_options])
           execute_command(cmd, process_number, num_processes, options)
         end
 
@@ -32,6 +29,10 @@ module ParallelTests
           @test_file_name || 'feature'
         end
 
+        def default_test_folder
+          'features'
+        end
+
         def test_suffix
           /\.feature$/
         end
@@ -44,42 +45,38 @@ module ParallelTests
         # 1 scenario (1 failed)
         # 1 step (1 failed)
         def summarize_results(results)
-          sort_order = %w[scenario step failed flaky undefined skipped pending passed]
+          sort_order = ['scenario', 'step', 'failed', 'flaky', 'undefined', 'skipped', 'pending', 'passed']
 
-          %w[scenario step].map do |group|
+          ['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
+              plural = "s" if (word == group) && (number != 1)
               "#{number} #{word}#{plural}"
             end
-            "#{sums[0]} (#{sums[1..-1].join(", ")})"
+            "#{sums[0]} (#{sums[1..].join(", ")})"
           end.compact.join("\n")
         end
 
         def cucumber_opts(given)
-          if given =~ /--profile/ or given =~ /(^|\s)-p /
+          if given&.include?('--profile') || given&.include?('-p')
             given
           else
-            [given, profile_from_config].compact.join(" ")
+            [*given, *profile_from_config]
           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
+          ['--profile', 'parallel'] if config && File.read(config) =~ /^parallel:/
         end
 
-        def tests_in_groups(tests, num_groups, options={})
-          if options[:group_by] == :scenarios
-            @test_file_name = "scenario"
-          end
+        def tests_in_groups(tests, num_groups, options = {})
+          @test_file_name = "scenario" if options[:group_by] == :scenarios
           method = "by_#{options[:group_by]}"
           if Grouper.respond_to?(method)
             Grouper.send(method, find_tests(tests, options), num_groups, options)
@@ -88,9 +85,8 @@ module ParallelTests
           end
         end
 
-
         def runtime_logging
-          "--format ParallelTests::Gherkin::RuntimeLogger --out #{runtime_log}"
+          ['--format', 'ParallelTests::Gherkin::RuntimeLogger', '--out', runtime_log]
         end
 
         def runtime_log
@@ -98,18 +94,16 @@ module ParallelTests
         end
 
         def determine_executable
-          case
-          when File.exist?("bin/#{name}")
+          if File.exist?("bin/#{name}")
             ParallelTests.with_ruby_binary("bin/#{name}")
-          when ParallelTests.bundler_enabled?
-            "bundle exec #{name}"
-          when File.file?("script/#{name}")
+          elsif ParallelTests.bundler_enabled?
+            ["bundle", "exec", name]
+          elsif File.file?("script/#{name}")
             ParallelTests.with_ruby_binary("script/#{name}")
           else
-            "#{name}"
+            [name.to_s]
           end
         end
-
       end
     end
   end

data/lib/parallel_tests/gherkin/runtime_logger.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'parallel_tests/gherkin/io'
 
 module ParallelTests
@@ -19,7 +20,7 @@ module ParallelTests
 
         config.on_event :test_run_finished do |_|
           lock_output do
-            @io.puts @example_times.map { |file, time| "#{file}:#{time}" }
+            @io.puts(@example_times.map { |file, time| "#{file}:#{time}" })
           end
         end
       end

data/lib/parallel_tests/grouper.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ParallelTests
   class Grouper
     class << self
@@ -6,13 +7,15 @@ module ParallelTests
         in_even_groups_by_size(features_with_steps, num_groups)
       end
 
-      def by_scenarios(tests, num_groups, options={})
+      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} }
+      def in_even_groups_by_size(items, num_groups, options = {})
+        groups = Array.new(num_groups) { { items: [], size: 0 } }
+
+        return specify_groups(items, num_groups, options, groups) if options[:specify_groups]
 
         # add all files that should run in a single process to one group
         single_process_patterns = options[:single_process] || []
@@ -24,14 +27,14 @@ module ParallelTests
         isolate_count = isolate_count(options)
 
         if isolate_count >= num_groups
-          raise 'Number of isolated processes must be less than total the number of processes'
+          raise 'Number of isolated processes must be >= total number of processes'
         end
 
         if isolate_count >= 1
           # add all files that should run in a multiple isolated processes to their own groups
           group_features_by_size(items_to_group(single_items), groups[0..(isolate_count - 1)])
           # group the non-isolated by size
-          group_features_by_size(items_to_group(items), groups[isolate_count..-1])
+          group_features_by_size(items_to_group(items), groups[isolate_count..])
         else
           # add all files that should run in a single non-isolated process to first group
           single_items.each { |item, size| add_to_group(groups.first, item, size) }
@@ -45,6 +48,50 @@ module ParallelTests
 
       private
 
+      def specify_groups(items, num_groups, options, groups)
+        specify_test_process_groups = options[:specify_groups].split('|')
+        if specify_test_process_groups.count > num_groups
+          raise 'Number of processes separated by pipe must be less than or equal to the total number of processes'
+        end
+
+        all_specified_tests = specify_test_process_groups.map { |group| group.split(',') }.flatten
+        specified_items_found, items = items.partition { |item, _size| all_specified_tests.include?(item) }
+
+        specified_specs_not_found = all_specified_tests - specified_items_found.map(&:first)
+        if specified_specs_not_found.any?
+          raise "Could not find #{specified_specs_not_found} from --specify-groups in the selected files & folders"
+        end
+
+        if specify_test_process_groups.count == num_groups && items.flatten.any?
+          raise(
+            <<~ERROR
+              The number of groups in --specify-groups matches the number of groups from -n but there were other specs
+              found in the selected files & folders not specified in --specify-groups. Make sure -n is larger than the
+              number of processes in --specify-groups if there are other specs that need to be run. The specs that aren't run:
+              #{items.map(&:first)}
+            ERROR
+          )
+        end
+
+        # First order the specify_groups into the main groups array
+        specify_test_process_groups.each_with_index do |specify_test_process, i|
+          groups[i] = specify_test_process.split(',')
+        end
+
+        # Return early when processed specify_groups tests exactly match the items passed in
+        return groups if specify_test_process_groups.count == num_groups
+
+        # Now sort the rest of the items into the main groups array
+        specified_range = specify_test_process_groups.count..-1
+        remaining_groups = groups[specified_range]
+        group_features_by_size(items_to_group(items), remaining_groups)
+        # Don't sort all the groups, only sort the ones not specified in specify_groups
+        sorted_groups = remaining_groups.map { |g| g[:items].sort }
+        groups[specified_range] = sorted_groups
+
+        groups
+      end
+
       def isolate_count(options)
         if options[:isolate_count] && options[:isolate_count] > 1
           options[:isolate_count]
@@ -56,7 +103,7 @@ module ParallelTests
       end
 
       def largest_first(files)
-        files.sort_by{|_item, size| size }.reverse
+        files.sort_by { |_item, size| size }.reverse
       end
 
       def smallest_group(groups)
@@ -73,7 +120,7 @@ module ParallelTests
         ParallelTests::Cucumber::FeaturesWithSteps.all(tests, options)
       end
 
-      def group_by_scenarios(tests, options={})
+      def group_by_scenarios(tests, options = {})
         require 'parallel_tests/cucumber/scenarios'
         ParallelTests::Cucumber::Scenarios.all(tests, options)
       end

data/lib/parallel_tests/pids.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'json'
 
 module ParallelTests
@@ -42,18 +43,18 @@ module ParallelTests
 
     def read
       sync do
-        contents = IO.read(file_path)
+        contents = File.read(file_path)
         return if contents.empty?
         @pids = JSON.parse(contents)
       end
     end
 
     def save
-      sync { IO.write(file_path, pids.to_json) }
+      sync { File.write(file_path, pids.to_json) }
     end
 
-    def sync
-      mutex.synchronize { yield }
+    def sync(&block)
+      mutex.synchronize(&block)
     end
   end
 end

data/lib/parallel_tests/railtie.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # rake tasks for Rails 3+
 module ParallelTests
   class Railtie < ::Rails::Railtie

data/lib/parallel_tests/rspec/failures_logger.rb

@@ -1,24 +1,16 @@
+# frozen_string_literal: true
 require 'parallel_tests/rspec/logger_base'
 require 'parallel_tests/rspec/runner'
 
 class ParallelTests::RSpec::FailuresLogger < ParallelTests::RSpec::LoggerBase
-  if RSPEC_2
-    def dump_failures(*args)
-    end
-  else
-    RSpec::Core::Formatters.register self, :dump_summary
-  end
+  RSpec::Core::Formatters.register(self, :dump_summary)
 
   def dump_summary(*args)
     lock_output do
-      if RSPEC_2
-        dump_commands_to_rerun_failed_examples
-      else
-        notification = args.first
-        unless notification.failed_examples.empty?
-          colorizer = ::RSpec::Core::Formatters::ConsoleCodes
-          output.puts notification.colorized_rerun_commands(colorizer)
-        end
+      notification = args.first
+      unless notification.failed_examples.empty?
+        colorizer = ::RSpec::Core::Formatters::ConsoleCodes
+        output.puts notification.colorized_rerun_commands(colorizer)
       end
     end
     @output.flush

data/lib/parallel_tests/rspec/logger_base.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ParallelTests
   module RSpec
   end
@@ -6,33 +7,32 @@ end
 require 'rspec/core/formatters/base_text_formatter'
 
 class ParallelTests::RSpec::LoggerBase < RSpec::Core::Formatters::BaseTextFormatter
-  RSPEC_2 = RSpec::Core::Version::STRING.start_with?('2')
-
   def initialize(*args)
     super
 
     @output ||= args[0]
 
-    if String === @output # a path ?
+    case @output
+    when String # a path ?
       FileUtils.mkdir_p(File.dirname(@output))
-      File.open(@output, 'w'){} # overwrite previous results
+      File.open(@output, 'w') {} # overwrite previous results
       @output = File.open(@output, 'a')
-    elsif File === @output # close and restart in append mode
+    when File # 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)
+  # stolen from Rspec
+  def close(*)
+    @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
+    if @output.is_a?(File)
       begin
         @output.flock File::LOCK_EX
         yield

data/lib/parallel_tests/rspec/runner.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "parallel_tests/test/runner"
 
 module ParallelTests
@@ -6,32 +7,36 @@ module ParallelTests
       DEV_NULL = (WINDOWS ? "NUL" : "/dev/null")
       class << self
         def run_tests(test_files, process_number, num_processes, options)
-          exe = executable # expensive, so we cache
-          cmd = [exe, options[:test_options], color, spec_opts, *test_files].compact.join(" ")
+          cmd = [*executable, *options[:test_options], *color, *spec_opts, *test_files]
           execute_command(cmd, process_number, num_processes, options)
         end
 
         def determine_executable
-          case
-          when File.exist?("bin/rspec")
+          if File.exist?("bin/rspec")
             ParallelTests.with_ruby_binary("bin/rspec")
-          when ParallelTests.bundler_enabled?
-            "bundle exec rspec"
+          elsif ParallelTests.bundler_enabled?
+            ["bundle", "exec", "rspec"]
           else
-            "rspec"
+            ["rspec"]
           end
         end
 
         def runtime_log
-          'tmp/parallel_runtime_rspec.log'
+          "tmp/parallel_runtime_rspec.log"
+        end
+
+        def default_test_folder
+          "spec"
         end
 
         def test_file_name
           "spec"
         end
 
+        # used to find all _spec.rb files
+        # supports also feature files used by rspec turnip extension
         def test_suffix
-          /_spec\.rb$/
+          /(_spec\.rb|\.feature)$/
         end
 
         def line_is_result?(line)
@@ -44,8 +49,8 @@ module ParallelTests
         # --order rand:1234
         # --order random:1234
         def command_with_seed(cmd, seed)
-          clean = cmd.sub(/\s--(seed\s+\d+|order\s+rand(om)?(:\d+)?)\b/, '')
-          "#{clean} --seed #{seed}"
+          clean = remove_command_arguments(cmd, '--seed', '--order')
+          [*clean, '--seed', seed]
         end
 
         # Summarize results from threads and colorize results based on failure and pending counts.
@@ -55,9 +60,9 @@ module ParallelTests
           return text unless $stdout.tty?
           sums = sum_up_results(results)
           color =
-            if sums['failure'].positive?
+            if sums['failure'] > 0
               31 # red
-            elsif sums['pending'].positive?
+            elsif sums['pending'] > 0
               33 # yellow
             else
               32 # green
@@ -67,19 +72,13 @@ module ParallelTests
 
         private
 
-        # so it can be stubbed....
-        def run(cmd)
-          `#{cmd}`
-        end
-
         def color
-          '--color --tty' if $stdout.tty?
+          ['--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}"
+          options_file = ['.rspec_parallel', 'spec/parallel_spec.opts', 'spec/spec.opts'].detect { |f| File.file?(f) }
+          ["-O", options_file] if options_file
         end
       end
     end

data/lib/parallel_tests/rspec/runtime_logger.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'parallel_tests'
 require 'parallel_tests/rspec/logger_base'
 
@@ -8,9 +9,7 @@ class ParallelTests::RSpec::RuntimeLogger < ParallelTests::RSpec::LoggerBase
     @group_nesting = 0
   end
 
-  unless RSPEC_2
-    RSpec::Core::Formatters.register self, :example_group_started, :example_group_finished, :start_dump
-  end
+  RSpec::Core::Formatters.register(self, :example_group_started, :example_group_finished, :start_dump)
 
   def example_group_started(example_group)
     @time = ParallelTests.now if @group_nesting == 0
@@ -21,23 +20,25 @@ class ParallelTests::RSpec::RuntimeLogger < ParallelTests::RSpec::LoggerBase
   def example_group_finished(notification)
     @group_nesting -= 1
     if @group_nesting == 0
-      path = (RSPEC_2 ? notification.file_path : notification.group.file_path)
-      @example_times[path] += ParallelTests.now - @time
+      @example_times[notification.group.file_path] += ParallelTests.now - @time
     end
     super if defined?(super)
   end
 
-  def dump_summary(*args);end
-  def dump_failures(*args);end
-  def dump_failure(*args);end
-  def dump_pending(*args);end
+  def dump_summary(*); end
+
+  def dump_failures(*); end
+
+  def dump_failure(*); end
+
+  def dump_pending(*); end
 
-  def start_dump(*args)
-    return unless ENV['TEST_ENV_NUMBER'] #only record when running in parallel
+  def start_dump(*)
+    return unless ENV['TEST_ENV_NUMBER'] # only record when running in parallel
     lock_output do
       @example_times.each do |file, time|
-        relative_path = file.sub(/^#{Regexp.escape Dir.pwd}\//,'').sub(/^\.\//, "")
-        @output.puts "#{relative_path}:#{time > 0 ? time : 0}"
+        relative_path = file.sub(%r{^#{Regexp.escape Dir.pwd}/}, '').sub(%r{^\./}, "")
+        @output.puts "#{relative_path}:#{[time, 0].max}"
       end
     end
     @output.flush

data/lib/parallel_tests/rspec/summary_logger.rb

@@ -1,9 +1,8 @@
+# frozen_string_literal: true
 require 'parallel_tests/rspec/failures_logger'
 
 class ParallelTests::RSpec::SummaryLogger < ParallelTests::RSpec::LoggerBase
-  unless RSPEC_2
-    RSpec::Core::Formatters.register self, :dump_failures
-  end
+  RSpec::Core::Formatters.register(self, :dump_failures)
 
   def dump_failures(*args)
     lock_output { super }

data/lib/parallel_tests/spinach/runner.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "parallel_tests/gherkin/runner"
 
 module ParallelTests
@@ -8,11 +9,14 @@ module ParallelTests
           'spinach'
         end
 
+        def default_test_folder
+          'features'
+        end
+
         def runtime_logging
-          #Not Yet Supported
+          # Not Yet Supported
           ""
         end
-
       end
     end
   end