parallel_tests 3.3.0 → 4.2.0

data/lib/parallel_tests/cucumber/features_with_steps.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 begin
   gem "cuke_modeler", "~> 3.0"
   require 'cuke_modeler'
@@ -12,7 +13,7 @@ module ParallelTests
         def all(tests, options)
           ignore_tag_pattern = options[:ignore_tag_pattern].nil? ? nil : Regexp.compile(options[:ignore_tag_pattern])
           # format of hash will be FILENAME => NUM_STEPS
-          steps_per_file = tests.each_with_object({}) do |file,steps|
+          steps_per_file = tests.each_with_object({}) do |file, steps|
             feature = ::CukeModeler::FeatureFile.new(file).feature
 
             # skip feature if it matches tag regex
@@ -20,8 +21,8 @@ module ParallelTests
 
             # count the number of steps in the file
             # will only include a feature if the regex does not match
-            all_steps = feature.scenarios.map{|a| a.steps.count if a.tags.grep(ignore_tag_pattern).empty? }.compact
-            steps[file] = all_steps.inject(0,:+)
+            all_steps = feature.scenarios.map { |a| a.steps.count if a.tags.grep(ignore_tag_pattern).empty? }.compact
+            steps[file] = all_steps.sum
           end
           steps_per_file.sort_by { |_, value| -value }
         end

data/lib/parallel_tests/cucumber/runner.rb

@@ -1,16 +1,21 @@
+# frozen_string_literal: true
 require "parallel_tests/gherkin/runner"
 
 module ParallelTests
   module Cucumber
     class Runner < ParallelTests::Gherkin::Runner
-      SCENARIOS_RESULTS_BOUNDARY_REGEX = /^(Failing|Flaky) Scenarios:$/
-      SCENARIO_REGEX = /^cucumber features\/.+:\d+/
+      SCENARIOS_RESULTS_BOUNDARY_REGEX = /^(Failing|Flaky) Scenarios:$/.freeze
+      SCENARIO_REGEX = %r{^cucumber features/.+:\d+}.freeze
 
       class << self
         def name
           'cucumber'
         end
 
+        def default_test_folder
+          'features'
+        end
+
         def line_is_result?(line)
           super || line =~ SCENARIO_REGEX || line =~ SCENARIOS_RESULTS_BOUNDARY_REGEX
         end
@@ -21,9 +26,7 @@ module ParallelTests
           scenario_groups = results.slice_before(SCENARIOS_RESULTS_BOUNDARY_REGEX).group_by(&:first)
           scenario_groups.each do |header, group|
             scenarios = group.flatten.grep(SCENARIO_REGEX)
-            if scenarios.any?
-              output << ([header] + scenarios).join("\n")
-            end
+            output << ([header] + scenarios).join("\n") if scenarios.any?
           end
 
           output << super
@@ -32,8 +35,8 @@ module ParallelTests
         end
 
         def command_with_seed(cmd, seed)
-          clean = cmd.sub(/\s--order\s+random(:\d+)?\b/, '')
-          "#{clean} --order random:#{seed}"
+          clean = remove_command_arguments(cmd, '--order')
+          [*clean, '--order', "random:#{seed}"]
         end
       end
     end

data/lib/parallel_tests/cucumber/scenario_line_logger.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ParallelTests
   module Cucumber
     module Formatters
@@ -10,7 +11,7 @@ module ParallelTests
         end
 
         def visit_feature_element(uri, feature_element, feature_tags, line_numbers: [])
-          scenario_tags = feature_element.tags.map { |tag| tag.name }
+          scenario_tags = feature_element.tags.map(&:name)
           scenario_tags = feature_tags + scenario_tags
           if feature_element.is_a?(CukeModeler::Scenario) # :Scenario
             test_line = feature_element.source_line
@@ -26,7 +27,7 @@ module ParallelTests
               example_tags = example.tags.map(&:name)
               example_tags = scenario_tags + example_tags
               next unless matches_tags?(example_tags)
-              example.rows[1..-1].each do |row|
+              example.rows[1..].each do |row|
                 test_line = row.source_line
                 next if line_numbers.any? && !line_numbers.include?(test_line)
 
@@ -36,8 +37,7 @@ module ParallelTests
           end
         end
 
-        def method_missing(*args)
-        end
+        def method_missing(*); end # # rubocop:disable Style/MissingRespondToMissing
 
         private
 

data/lib/parallel_tests/cucumber/scenarios.rb

@@ -1,9 +1,9 @@
+# frozen_string_literal: true
 require 'cucumber/tag_expressions/parser'
 require 'cucumber/runtime'
 require 'cucumber'
 require 'parallel_tests/cucumber/scenario_line_logger'
 require 'parallel_tests/gherkin/listener'
-require 'shellwords'
 
 begin
   gem "cuke_modeler", "~> 3.0"
@@ -16,11 +16,11 @@ module ParallelTests
   module Cucumber
     class Scenarios
       class << self
-        def all(files, options={})
+        def all(files, options = {})
           # Parse tag expression from given test options and ignore tag pattern. Refer here to understand how new tag expression syntax works - https://github.com/cucumber/cucumber/tree/master/tag-expressions
           tags = []
-          words = options[:test_options].to_s.shellsplit
-          words.each_with_index { |w,i| tags << words[i+1] if ["-t", "--tags"].include?(w) }
+          words = options[:test_options] || []
+          words.each_with_index { |w, i| tags << words[i + 1] if ["-t", "--tags"].include?(w) }
           if ignore = options[:ignore_tag_pattern]
             tags << "not (#{ignore})"
           end
@@ -31,8 +31,7 @@ module ParallelTests
 
         private
 
-        def split_into_scenarios(files, tags='')
-
+        def split_into_scenarios(files, tags = '')
           # Create the tag expression instance from cucumber tag expressions parser, this is needed to know if the scenario matches with the tags invoked by the request
           # Create the ScenarioLineLogger which will filter the scenario we want
           args = []
@@ -40,7 +39,7 @@ module ParallelTests
           scenario_line_logger = ParallelTests::Cucumber::Formatters::ScenarioLineLogger.new(*args)
 
           # here we loop on the files map, each file will contain one or more scenario
-          features ||= files.map do |path|
+          files.each do |path|
             # Gather up any line numbers attached to the file path
             path, *test_lines = path.split(/:(?=\d+)/)
             test_lines.map!(&:to_i)
@@ -53,7 +52,9 @@ module ParallelTests
             feature_tags = feature.tags.map(&:name)
 
             # We loop on each children of the feature
-            feature.tests.each do |test|
+            test_models = feature.tests
+            test_models += feature.rules.flat_map(&:tests) if feature.respond_to?(:rules) # cuke_modeler >= 3.2 supports rules
+            test_models.each do |test|
               # It's a scenario, we add it to the scenario_line_logger
               scenario_line_logger.visit_feature_element(document.path, test, feature_tags, line_numbers: test_lines)
             end

data/lib/parallel_tests/gherkin/io.rb

@@ -1,9 +1,9 @@
+# frozen_string_literal: true
 require 'parallel_tests'
 
 module ParallelTests
   module Gherkin
     module Io
-
       def prepare_io(path_or_io)
         if path_or_io.respond_to?(:write)
           path_or_io
@@ -24,7 +24,7 @@ module ParallelTests
 
       # do not let multiple processes get in each others way
       def lock_output
-        if File === @io
+        if @io.is_a?(File)
           begin
             @io.flock File::LOCK_EX
             yield
@@ -35,7 +35,6 @@ module ParallelTests
           yield
         end
       end
-
     end
   end
 end

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] || []
@@ -27,11 +30,15 @@ module ParallelTests
           raise 'Number of isolated processes must be less than total the number of processes'
         end
 
+        if isolate_count >= num_groups
+          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 +52,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 +107,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 +124,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,10 +1,10 @@
+# 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
+    def dump_failures(*args); end
   else
     RSpec::Core::Formatters.register self, :dump_summary
   end

data/lib/parallel_tests/rspec/logger_base.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ParallelTests
   module RSpec
   end
@@ -13,26 +14,27 @@ class ParallelTests::RSpec::LoggerBase < RSpec::Core::Formatters::BaseTextFormat
 
     @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