parallel_tests 2.32.0 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9f48375f06f2320fdda57c5c1340b8aedf1761541d4c802c5a17b6f21cbf858
-  data.tar.gz: 8e91a9f26aa2710aa023b6d779d7fdf0e768213262d75b7d9969751a3e825089
+  metadata.gz: fd8878310c757d2a906bbf5ca62b68e21941cc79472a9833944f88087449c229
+  data.tar.gz: d55a5ac186f1c16d9568b8f6bb145e0016bafc1c2fb9748593e96997eaf2034c
 SHA512:
-  metadata.gz: 6468e8bbb055db1eaee1a8512cb4226ceeb7acc2ba880d8be30117d863f8b870629088835d2628d28981e9b193a40239646d8a4de8e61467bd0bc48fae50e92e
-  data.tar.gz: 0dcd9f3aee1aead8329b76e770eb814ef62f465803629fe236d764b6a874eb827458b008aea240689ecadafa02388d49e71291d2c3cca5e74bc24d66137960ce
+  metadata.gz: f01821e38506525feaafb8a9ff5a480ab1f6f2b0bed849088d72682a699f82ae50bb2a78b94526f243a65c2474ff8f2d3a06c204b44431a7687d877cbbc91dd8
+  data.tar.gz: 2823702fc7e5d047a69c57d3ee4c0b72afbb51603d58e34a3656899d0026a4b749e94494b9edf234fdcc5fd81bae59dfba55f920d777f5f7d1f7c21fb5219552

data/Readme.md

@@ -82,6 +82,8 @@ Running things once
 ===================
 
 ```Ruby
+require "parallel_tests"
+
 # preparation:
 # affected by race-condition: first process may boot slower than the second
 # either sleep a bit or use a lock for example File.lock
@@ -97,7 +99,6 @@ at_exit do
     undo_something
   end
 end
-
 ```
 
 Even test group run-times
@@ -192,7 +193,6 @@ Setup for non-rails
 
 Options are:
 <!-- copy output from bundle exec ./bin/parallel_test -h -->
-
     -n [PROCESSES]                   How many processes to use, default: available CPUs
     -p, --pattern [PATTERN]          run tests matching this regex pattern
         --exclude-pattern [PATTERN]  exclude tests matching this regex pattern
@@ -205,7 +205,9 @@ Options are:
           default - runtime when runtime log is filled otherwise filesize
     -m, --multiply-processes [FLOAT] use given number as a multiplier of processes to run
     -s, --single [PATTERN]           Run all matching files in the same process
-    -i, --isolate                    Do not run any other tests in the group used by --single(-s)
+    -i, --isolate                    Do not run any other tests in the group used by --single(-s).
+                                     Automatically turned on if --isolate-n is set above 0.
+        --isolate-n                  Number of processes for isolated groups. Default to 1 when --isolate is on.
         --only-group INT[, INT]
     -e, --exec [COMMAND]             execute this code parallel and with ENV['TEST_ENV_NUMBER']
     -o, --test-options '[OPTIONS]'   execute test commands with those options
@@ -222,12 +224,14 @@ Options are:
         --ignore-tags [PATTERN]      When counting steps ignore scenarios with tags that match this pattern
         --nice                       execute test commands with low priority.
         --runtime-log [PATH]         Location of previously recorded test runtimes
-        --allowed-missing            Allowed percentage of missing runtimes (default = 50)
+        --allowed-missing [INT]      Allowed percentage of missing runtimes (default = 50)
         --unknown-runtime [FLOAT]    Use given number as unknown runtime (otherwise use average time)
+        --first-is-1                 Use "1" as TEST_ENV_NUMBER to not reuse the default test environment
+        --fail-fast                  Stop all groups when one group fails (best used with --test-options '--fail-fast' if supported
         --verbose                    Print debug output
-        --verbose-process-command    Print the command that will be executed by each process before it begins
-        --verbose-rerun-command      After a process fails, print the command executed by that process
-        --quiet                      Print only test output
+        --verbose-process-command    Displays only the command that will be executed by each process
+        --verbose-rerun-command      When there are failures, displays the command executed by each process that failed
+        --quiet                      Print only tests output
     -v, --version                    Show Version
     -h, --help                       Show this.
 
@@ -257,7 +261,7 @@ TIPS
  - Use [rspec-retry](https://github.com/NoRedInk/rspec-retry) (not rspec-rerun) to rerun failed tests.
  - [JUnit formatter configuration](https://github.com/grosser/parallel_tests/wiki#with-rspec_junit_formatter----by-jgarber)
  - Use [parallel_split_test](https://github.com/grosser/parallel_split_test) to run multiple scenarios in a single spec file, concurrently. (`parallel_tests` [works at the file-level and intends to stay that way](https://github.com/grosser/parallel_tests/issues/747#issuecomment-580216980))
- 
+
 ### Cucumber
 
  - Add a `parallel: foo` profile to your `config/cucumber.yml` and it will be used to run parallel tests
@@ -374,6 +378,7 @@ inspired by [pivotal labs](https://blog.pivotal.io/labs/labs/parallelize-your-rs
  - [Calaway](https://github.com/calaway)
  - [alboyadjian](https://github.com/alboyadjian)
  - [Nathan Broadbent](https://github.com/ndbroadbent)
+ - [Vikram B Kumar](https://github.com/v-kumar)
 
 [Michael Grosser](http://grosser.it)<br/>
 michael@grosser.it<br/>

data/lib/parallel_tests/cli.rb

@@ -42,9 +42,10 @@ module ParallelTests
       Tempfile.open 'parallel_tests-lock' do |lock|
         ParallelTests.with_pid_file do
           simulate_output_for_ci options[:serialize_stdout] do
-            Parallel.map(items, :in_threads => num_processes) do |item|
+            Parallel.map(items, in_threads: num_processes) do |item|
               result = yield(item)
               reprint_output(result, lock.path) if options[:serialize_stdout]
+              ParallelTests.stop_all_processes if options[:fail_fast] && result[:exit_status] != 0
               result
             end
           end
@@ -191,6 +192,12 @@ module ParallelTests
           options[:isolate] = true
         end
 
+        opts.on("--isolate-n [PROCESSES]",
+          Integer,
+          "Use 'isolate'  singles with number of processes, default: 1.") do |n|
+          options[:isolate_count] = n
+        end
+
         opts.on("--only-group INT[, INT]", Array) { |groups| options[:only_group] = groups.map(&:to_i) }
 
         opts.on("-e", "--exec [COMMAND]", "execute this code parallel and with ENV['TEST_ENV_NUMBER']") { |path| options[:execute] = path }
@@ -220,6 +227,7 @@ module ParallelTests
         opts.on("--allowed-missing [INT]", Integer, "Allowed percentage of missing runtimes (default = 50)") { |percent| options[:allowed_missing_percent] = percent }
         opts.on("--unknown-runtime [FLOAT]", Float, "Use given number as unknown runtime (otherwise use average time)") { |time| options[:unknown_runtime] = time }
         opts.on("--first-is-1", "Use \"1\" as TEST_ENV_NUMBER to not reuse the default test environment") { options[:first_is_1] = true }
+        opts.on("--fail-fast", "Stop all groups when one group fails (best used with --test-options '--fail-fast' if supported") { options[:fail_fast] = true }
         opts.on("--verbose", "Print debug output") { options[:verbose] = true }
         opts.on("--verbose-process-command", "Displays only the command that will be executed by each process") { options[:verbose_process_command] = true }
         opts.on("--verbose-rerun-command", "When there are failures, displays the command executed by each process that failed") { options[:verbose_rerun_command] = true }
@@ -316,9 +324,8 @@ module ParallelTests
     end
 
     def final_fail_message
-      fail_message = "#{@runner.name}s Failed"
+      fail_message = "Tests Failed"
       fail_message = "\e[31m#{fail_message}\e[0m" if use_colors?
-
       fail_message
     end
 

data/lib/parallel_tests/cucumber/features_with_steps.rb

@@ -0,0 +1,31 @@
+begin
+  gem "cuke_modeler", "~> 3.0"
+  require 'cuke_modeler'
+rescue LoadError
+  raise 'Grouping by number of cucumber steps 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 FeaturesWithSteps
+      class << self
+        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|
+            feature = ::CukeModeler::FeatureFile.new(file).feature
+
+            # skip feature if it matches tag regex
+            next if feature.tags.grep(ignore_tag_pattern).any?
+
+            # 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,:+)
+          end
+          steps_per_file.sort_by { |_, value| -value }
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/cucumber/scenario_line_logger.rb

@@ -1,37 +1,33 @@
-require 'cucumber/tag_expressions/parser'
-require 'cucumber/core/gherkin/tag_expression'
-
 module ParallelTests
   module Cucumber
     module Formatters
       class ScenarioLineLogger
         attr_reader :scenarios
 
-        def initialize(tag_expression = ::Cucumber::Core::Gherkin::TagExpression.new([]))
+        def initialize(tag_expression = nil)
           @scenarios = []
           @tag_expression = tag_expression
         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 { |tag| tag.name }
           scenario_tags = feature_tags + scenario_tags
-          if feature_element[:examples].nil? # :Scenario
-            test_line = feature_element[:location][:line]
+          if feature_element.is_a?(CukeModeler::Scenario) # :Scenario
+            test_line = feature_element.source_line
 
             # We don't accept the feature_element if the current tags are not valid
-            return unless @tag_expression.evaluate(scenario_tags)
+            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[:location][:line]].join(":")
+            @scenarios << [uri, feature_element.source_line].join(":")
           else # :ScenarioOutline
-            feature_element[:examples].each do |example|
-              example_tags = example[:tags].map { |tag| tag[:name] }
+            feature_element.examples.each do |example|
+              example_tags = example.tags.map(&:name)
               example_tags = scenario_tags + example_tags
-              next unless @tag_expression.evaluate(example_tags)
-              rows = example[:tableBody].select { |body| body[:type] == :TableRow }
-              rows.each do |row|
-                test_line = row[:location][:line]
+              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(':')
@@ -42,6 +38,12 @@ module ParallelTests
 
         def method_missing(*args)
         end
+
+        private
+
+        def matches_tags?(tags)
+          @tag_expression.nil? || @tag_expression.evaluate(tags)
+        end
       end
     end
   end

data/lib/parallel_tests/cucumber/scenarios.rb

@@ -1,12 +1,17 @@
 require 'cucumber/tag_expressions/parser'
-require 'cucumber/core/gherkin/tag_expression'
 require 'cucumber/runtime'
 require 'cucumber'
 require 'parallel_tests/cucumber/scenario_line_logger'
 require 'parallel_tests/gherkin/listener'
-require 'gherkin/errors'
 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
@@ -40,32 +45,17 @@ module ParallelTests
             path, *test_lines = path.split(/:(?=\d+)/)
             test_lines.map!(&:to_i)
 
-            # We encode the file and get the content of it
-            source = ::Cucumber::Runtime::NormalisedEncodingFile.read(path)
             # We create a Gherkin document, this will be used to decode the details of each scenario
-            document = ::Cucumber::Core::Gherkin::Document.new(path, source)
-
-            # We create a parser for the gherkin document
-            parser  = ::Gherkin::Parser.new()
-            scanner = ::Gherkin::TokenScanner.new(document.body)
-
-            begin
-              # We make an attempt to parse the gherkin document, this could be failed if the document is not well formatted
-              result = parser.parse(scanner)
-              feature_tags = result[:feature][:tags].map { |tag| tag[:name] }
-
-              # We loop on each children of the feature
-              result[:feature][:children].each do |feature_element|
-                # If the type of the child is not a scenario or scenario outline, we continue, we are only interested by the name of the scenario here
-                next unless /Scenario/.match(feature_element[:type])
+            document = ::CukeModeler::FeatureFile.new(path)
+            feature = document.feature
 
-                # It's a scenario, we add it to the scenario_line_logger
-                scenario_line_logger.visit_feature_element(document.uri, feature_element, feature_tags, line_numbers: test_lines)
-              end
+            # 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)
 
-            rescue StandardError => e
-              # Exception if the document is no well formated or error in the tags
-              raise ::Cucumber::Core::Gherkin::ParseError.new("#{document.uri}: #{e.message}")
+            # 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
 

data/lib/parallel_tests/gherkin/listener.rb

@@ -1,5 +1,3 @@
-require 'gherkin/parser'
-
 module ParallelTests
   module Gherkin
     class Listener

data/lib/parallel_tests/gherkin/runtime_logger.rb

@@ -14,7 +14,7 @@ module ParallelTests
         end
 
         config.on_event :test_case_finished do |event|
-          @example_times[event.test_case.feature.file] += ParallelTests.now.to_f - @start_at
+          @example_times[event.test_case.location.file] += ParallelTests.now.to_f - @start_at
         end
 
         config.on_event :test_run_finished do |_|

data/lib/parallel_tests/grouper.rb

@@ -2,7 +2,7 @@ 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
 
@@ -15,19 +15,46 @@ module ParallelTests
         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 = 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
 
-        groups_to_fill = (options[:isolate] ? groups[1..-1] : groups)
-        group_features_by_size(items_to_group(items), groups_to_fill)
+        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 >= 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 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
       end
@@ -41,23 +68,9 @@ module ParallelTests
         group[:size] += size
       end
 
-      def build_features_with_steps(tests, options)
-        require 'gherkin/parser'
-        ignore_tag_pattern = options[:ignore_tag_pattern].nil? ? nil : Regexp.compile(options[:ignore_tag_pattern])
-        parser = ::Gherkin::Parser.new
-        # format of hash will be FILENAME => NUM_STEPS
-        steps_per_file = tests.each_with_object({}) do |file,steps|
-          feature = parser.parse(File.read(file)).fetch(:feature)
-
-          # skip feature if it matches tag regex
-          next if feature[:tags].grep(ignore_tag_pattern).any?
-
-          # count the number of steps in the file
-          # will only include a feature if the regex does not match
-          all_steps = feature[:children].map{|a| a[:steps].count if a[:tags].grep(ignore_tag_pattern).empty? }.compact
-          steps[file] = all_steps.inject(0,:+)
-        end
-        steps_per_file.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={})

data/lib/parallel_tests/rspec/runner.rb

@@ -4,8 +4,6 @@ module ParallelTests
   module RSpec
     class Runner < ParallelTests::Test::Runner
       DEV_NULL = (WINDOWS ? "NUL" : "/dev/null")
-      NAME = 'RSpec'
-
       class << self
         def run_tests(test_files, process_number, num_processes, options)
           exe = executable # expensive, so we cache
@@ -50,6 +48,22 @@ module ParallelTests
           "#{clean} --seed #{seed}"
         end
 
+        # Summarize results from threads and colorize results based on failure and pending counts.
+        #
+        def summarize_results(results)
+          text = super
+          return text unless $stdout.tty?
+          sums = sum_up_results(results)
+          color =
+            if sums['failure'].positive?
+              31 # red
+            elsif sums['pending'].positive?
+              33 # yellow
+            else
+              32 # green
+            end
+          "\e[#{color}m#{text}\e[0m"
+        end
 
         private
 

data/lib/parallel_tests/tasks.rb

@@ -5,7 +5,7 @@ module ParallelTests
   module Tasks
     class << self
       def rails_env
-        ENV['RAILS_ENV'] || 'test'
+        'test'
       end
 
       def rake_bin

data/lib/parallel_tests/test/runner.rb

@@ -3,15 +3,9 @@ require 'parallel_tests'
 module ParallelTests
   module Test
     class Runner
-      NAME = 'Test'
-
       class << self
         # --- usually overwritten by other runners
 
-        def name
-          NAME
-        end
-
         def runtime_log
           'tmp/parallel_runtime_test.log'
         end
@@ -179,7 +173,7 @@ module ParallelTests
             allowed_missing -= 1 unless time = runtimes[test]
             if allowed_missing < 0
               log = options[:runtime_log] || runtime_log
-              raise "Runtime log file '#{log}' does not contain sufficient data to sort #{tests.size} test files, please update it."
+              raise "Runtime log file '#{log}' does not contain sufficient data to sort #{tests.size} test files, please update or remove it."
             end
             [test, time]
           end

data/lib/parallel_tests/version.rb

@@ -1,3 +1,3 @@
 module ParallelTests
-  VERSION = Version = '2.32.0'
+  VERSION = Version = '3.4.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel_tests
 version: !ruby/object:Gem::Version
-  version: 2.32.0
+  version: 3.4.0
 platform: ruby
 authors:
 - Michael Grosser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-15 00:00:00.000000000 Z
+date: 2020-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -42,6 +42,7 @@ files:
 - lib/parallel_tests.rb
 - lib/parallel_tests/cli.rb
 - lib/parallel_tests/cucumber/failures_logger.rb
+- lib/parallel_tests/cucumber/features_with_steps.rb
 - lib/parallel_tests/cucumber/runner.rb
 - lib/parallel_tests/cucumber/scenario_line_logger.rb
 - lib/parallel_tests/cucumber/scenarios.rb
@@ -67,8 +68,8 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/grosser/parallel_tests/issues
-  documentation_uri: https://github.com/grosser/parallel_tests/blob/v2.32.0/Readme.md
-  source_code_uri: https://github.com/grosser/parallel_tests/tree/v2.32.0
+  documentation_uri: https://github.com/grosser/parallel_tests/blob/v3.4.0/Readme.md
+  source_code_uri: https://github.com/grosser/parallel_tests/tree/v3.4.0
   wiki_uri: https://github.com/grosser/parallel_tests/wiki
 post_install_message: 
 rdoc_options: []
@@ -78,14 +79,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.3
 signing_key: 
 specification_version: 4
 summary: Run Test::Unit / RSpec / Cucumber / Spinach in parallel