parallel_tests 1.3.7 → 3.7.3

data/lib/parallel_tests/cucumber/scenario_line_logger.rb

@@ -1,49 +1,48 @@
-require 'gherkin/tag_expression'
-
+# frozen_string_literal: true
 module ParallelTests
   module Cucumber
     module Formatters
       class ScenarioLineLogger
         attr_reader :scenarios
 
-        def initialize(tag_expression = ::Gherkin::TagExpression.new([]))
+        def initialize(tag_expression = nil)
           @scenarios = []
           @tag_expression = tag_expression
         end
 
-        def visit_feature_element(feature_element)
-          return unless @tag_expression.evaluate(feature_element.source_tags)
+        def visit_feature_element(uri, feature_element, feature_tags, line_numbers: [])
+          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
 
-          case feature_element
-          when ::Cucumber::Ast::Scenario
-            line = if feature_element.respond_to?(:line)
-              feature_element.line
-            else
-              feature_element.instance_variable_get(:@line)
-            end
-            @scenarios << [feature_element.feature.file, line].join(":")
-          when ::Cucumber::Ast::ScenarioOutline
-            sections = feature_element.instance_variable_get(:@example_sections)
-            sections.each { |section|
-              rows = if section[1].respond_to?(:rows)
-                section[1].rows
-              else
-                section[1].instance_variable_get(:@rows)
+            # We don't accept the feature_element if the current tags are not valid
+            return unless matches_tags?(scenario_tags)
+            # or if it is not at the correct location
+            return if line_numbers.any? && !line_numbers.include?(test_line)
+
+            @scenarios << [uri, feature_element.source_line].join(":")
+          else # :ScenarioOutline
+            feature_element.examples.each do |example|
+              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|
+                test_line = row.source_line
+                next if line_numbers.any? && !line_numbers.include?(test_line)
+
+                @scenarios << [uri, test_line].join(':')
               end
-              rows.each_with_index { |row, index|
-                next if index == 0  # slices didn't work with jruby data structure
-                line = if row.respond_to?(:line)
-                  row.line
-                else
-                  row.instance_variable_get(:@line)
-                end
-                @scenarios << [feature_element.feature.file, line].join(":")
-              }
-            }
+            end
           end
         end
 
-        def method_missing(*args)
+        def method_missing(*); end # # rubocop:disable Style/MissingRespondToMissing
+
+        private
+
+        def matches_tags?(tags)
+          @tag_expression.nil? || @tag_expression.evaluate(tags)
         end
       end
     end

data/lib/parallel_tests/cucumber/scenarios.rb

@@ -1,29 +1,62 @@
-require 'gherkin/tag_expression'
+# 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"
+  require 'cuke_modeler'
+rescue LoadError
+  raise 'Grouping by individual cucumber scenarios requires the `cuke_modeler` modeler gem with requirement `~> 3.0`.  Add `gem "cuke_modeler", "~> 3.0"` to your `Gemfile`, run `bundle install` and try again.'
+end
 
 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 = []
-          tags.concat options[:ignore_tag_pattern].to_s.split(/\s*,\s*/).map {|tag| "~#{tag}" }
-          tags.concat options[:test_options].to_s.scan(/(?:-t|--tags) (~?@[\w,~@]+)/).flatten
-          split_into_scenarios files, tags.uniq
+          words = options[:test_options].to_s.shellsplit
+          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
+          tags_exp = tags.compact.join(" and ")
+
+          split_into_scenarios files, tags_exp
         end
 
         private
 
-        def split_into_scenarios(files, tags=[])
-          tag_expression = ::Gherkin::TagExpression.new(tags)
-          scenario_line_logger = ParallelTests::Cucumber::Formatters::ScenarioLineLogger.new(tag_expression)
-          loader = ::Cucumber::Runtime::FeaturesLoader.new(files, [], tag_expression)
+        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 = []
+          args << ::Cucumber::TagExpressions::Parser.new.parse(tags) unless tags.empty?
+          scenario_line_logger = ParallelTests::Cucumber::Formatters::ScenarioLineLogger.new(*args)
+
+          # here we loop on the files map, each file will contain one or more scenario
+          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)
+
+            # We create a Gherkin document, this will be used to decode the details of each scenario
+            document = ::CukeModeler::FeatureFile.new(path)
+            feature = document.feature
+
+            # We make an attempt to parse the gherkin document, this could be failed if the document is not well formatted
+            feature_tags = feature.tags.map(&:name)
 
-          loader.features.each do |feature|
-            feature.accept(scenario_line_logger)
+            # We loop on each children of the feature
+            feature.tests.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
           end
 
           scenario_line_logger.scenarios

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,5 +1,4 @@
-require 'gherkin'
-
+# frozen_string_literal: true
 module ParallelTests
   module Gherkin
     class Listener
@@ -8,8 +7,10 @@ module ParallelTests
       attr_writer :ignore_tag_pattern
 
       def initialize
-        @steps, @uris = [], []
+        @steps = []
+        @uris = []
         @collect = {}
+        @feature, @ignore_tag_pattern = nil
         reset_counters!
       end
 
@@ -17,7 +18,7 @@ module ParallelTests
         @feature = feature
       end
 
-      def background(*args)
+      def background(*)
         @background = 1
       end
 
@@ -32,7 +33,7 @@ module ParallelTests
         @outline = 1
       end
 
-      def step(*args)
+      def step(*)
         return if @ignoring
         if @background == 1
           @background_steps += 1
@@ -52,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
@@ -68,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
 
@@ -80,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,29 +1,31 @@
+# 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,
             (runtime_logging if File.directory?(File.dirname(runtime_log))),
-            cucumber_opts(options[:test_options]),
-            *sanitized_test_files
+            *sanitized_test_files,
+            cucumber_opts(options[:test_options])
           ].compact.reject(&:empty?).join(' ')
           execute_command(cmd, process_number, num_processes, options)
         end
@@ -32,6 +34,10 @@ module ParallelTests
           @test_file_name || 'feature'
         end
 
+        def default_test_folder
+          'features'
+        end
+
         def test_suffix
           /\.feature$/
         end
@@ -44,16 +50,16 @@ module ParallelTests
         # 1 scenario (1 failed)
         # 1 step (1 failed)
         def summarize_results(results)
-          sort_order = %w[scenario step failed 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 +67,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 +77,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 +90,6 @@ module ParallelTests
           end
         end
 
-
         def runtime_logging
           "--format ParallelTests::Gherkin::RuntimeLogger --out #{runtime_log}"
         end
@@ -98,18 +99,16 @@ module ParallelTests
         end
 
         def determine_executable
-          case
-          when File.exist?("bin/#{name}")
-            "bin/#{name}"
-          when ParallelTests.bundler_enabled?
+          if File.exist?("bin/#{name}")
+            ParallelTests.with_ruby_binary("bin/#{name}")
+          elsif ParallelTests.bundler_enabled?
             "bundle exec #{name}"
-          when File.file?("script/#{name}")
-            "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
@@ -5,22 +6,22 @@ module ParallelTests
     class RuntimeLogger
       include Io
 
-      def initialize(step_mother, path_or_io, options=nil)
-        @io = prepare_io(path_or_io)
+      def initialize(config)
+        @io = prepare_io(config.out_stream)
         @example_times = Hash.new(0)
-      end
 
-      def before_feature(_)
-        @start_at = ParallelTests.now.to_f
-      end
+        config.on_event :test_case_started do |_|
+          @start_at = ParallelTests.now.to_f
+        end
 
-      def after_feature(feature)
-        @example_times[feature.file] += ParallelTests.now.to_f - @start_at
-      end
+        config.on_event :test_case_finished do |event|
+          @example_times[event.test_case.location.file] += ParallelTests.now.to_f - @start_at
+        end
 
-      def after_features(*args)
-        lock_output do
-          @io.puts @example_times.map { |file, time| "#{file}:#{time}" }
+        config.on_event :test_run_finished do |_|
+          lock_output do
+            @io.puts(@example_times.map { |file, time| "#{file}:#{time}" })
+          end
         end
       end
     end

data/lib/parallel_tests/grouper.rb

@@ -1,39 +1,117 @@
+# frozen_string_literal: true
 module ParallelTests
   class Grouper
     class << self
       def by_steps(tests, num_groups, options)
-        features_with_steps = build_features_with_steps(tests, options)
+        features_with_steps = group_by_features_with_steps(tests, options)
         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) }
 
-        groups.map!{|g| g[:items].sort }
+          # 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)
-        groups.min_by{|g| g[:size] }
+        groups.min_by { |g| g[:size] }
       end
 
       def add_to_group(group, item, size)
@@ -41,18 +119,12 @@ module ParallelTests
         group[:size] += size
       end
 
-      def build_features_with_steps(tests, options)
-        require 'parallel_tests/gherkin/listener'
-        listener = ParallelTests::Gherkin::Listener.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 }
+      def group_by_features_with_steps(tests, options)
+        require 'parallel_tests/cucumber/features_with_steps'
+        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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require 'json'
+
+module ParallelTests
+  class Pids
+    attr_reader :file_path, :mutex
+
+    def initialize(file_path)
+      @file_path = file_path
+      @mutex = Mutex.new
+    end
+
+    def add(pid)
+      pids << pid.to_i
+      save
+    end
+
+    def delete(pid)
+      pids.delete(pid.to_i)
+      save
+    end
+
+    def count
+      read
+      pids.count
+    end
+
+    def all
+      read
+      pids
+    end
+
+    private
+
+    def pids
+      @pids ||= []
+    end
+
+    def clear
+      @pids = []
+      save
+    end
+
+    def read
+      sync do
+        contents = IO.read(file_path)
+        return if contents.empty?
+        @pids = JSON.parse(contents)
+      end
+    end
+
+    def save
+      sync { IO.write(file_path, pids.to_json) }
+    end
+
+    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