parallel_tests 3.0.0 → 3.5.0

data/lib/parallel_tests/cucumber/failures_logger.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'cucumber/formatter/rerun'
 require 'parallel_tests/gherkin/io'
 
@@ -21,7 +22,6 @@ module ParallelTests
           end
         end
       end
-
     end
   end
 end

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,10 +1,11 @@
+# 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
@@ -21,9 +22,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

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
@@ -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,3 +1,4 @@
+# frozen_string_literal: true
 require 'cucumber/tag_expressions/parser'
 require 'cucumber/runtime'
 require 'cucumber'
@@ -16,11 +17,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.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 +32,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 +40,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)

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,23 +1,25 @@
+# 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
+          options[:env] = options[:env].merge({ 'AUTOTEST' => '1' }) if $stdout.tty?
 
           cmd = [
             executable,
@@ -44,16 +46,16 @@ 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(", ")})"
@@ -61,7 +63,7 @@ module ParallelTests
         end
 
         def cucumber_opts(given)
-          if given =~ /--profile/ or given =~ /(^|\s)-p /
+          if given =~ (/--profile/) || given =~ (/(^|\s)-p /)
             given
           else
             [given, profile_from_config].compact.join(" ")
@@ -71,15 +73,11 @@ module ParallelTests
         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,7 +86,6 @@ module ParallelTests
           end
         end
 
-
         def runtime_logging
           "--format ParallelTests::Gherkin::RuntimeLogger --out #{runtime_log}"
         end
@@ -98,18 +95,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?
+          elsif ParallelTests.bundler_enabled?
             "bundle exec #{name}"
-          when File.file?("script/#{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,30 +7,107 @@ 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
-        (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) }
+        single_process_patterns = options[:single_process] || []
+
+        single_items, items = items.partition do |item, _size|
+          single_process_patterns.any? { |pattern| item =~ pattern }
+        end
+
+        isolate_count = isolate_count(options)
+
+        if isolate_count >= num_groups
+          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
 
-        groups_to_fill = (options[:isolate] ? groups[1..-1] : groups)
-        group_features_by_size(items_to_group(items), groups_to_fill)
+        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])
+        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) }
+
+          # group all by size
+          group_features_by_size(items_to_group(items), groups)
+        end
 
         groups.map! { |g| g[:items].sort }
       end
 
       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]
+        elsif options[:isolate]
+          1
+        else
+          0
+        end
+      end
+
       def largest_first(files)
-        files.sort_by{|_item, size| size }.reverse
+        files.sort_by { |_item, size| size }.reverse
       end
 
       def smallest_group(groups)
@@ -46,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