parallel_tests 4.2.0 → 4.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1bcc6e9cd8a207f7a7ec8253139040265cf1c1962e5d25629bca37e5cd2b111e
-  data.tar.gz: 7db53c69e2048799c12504a6ce7b56b6b7b4833ef77fdc298ba50c61fe8ed742
+  metadata.gz: 40c390881f78ed6c146e2f11deee7e19fc5df5fa99494779a15743ce6a8463a0
+  data.tar.gz: 89cc457abaea5d29160f745ccc6cd57e2ba365f53f64b82248eb3033533da804
 SHA512:
-  metadata.gz: f682ef1d3752cd3893e186879d905954456b51900ce0d4cfd2213f1c226d13fb38d1a3f251dc75bccb8da663273f59ef977e0aa92707f3ede49db381a53c40f5
-  data.tar.gz: 7a3bad92876b0b225f381b60b89e7049f84e9069a89b710749ecad0e6beed6a60952ed3d850dbe90621a731a974b7694b9182bb02a0f5e3e5292ccb2b6226614
+  metadata.gz: d1cc1c8645f580ea2eb43ee650e24a1c314c1af93937a5d11a8591e405bbc429b23fcfc79ed92bc50f9d15ec3a1aa35abe1db2a718927dbab50b1077a4fa91c6
+  data.tar.gz: b50b820699c76f128d1bce2495d5f2363cac1a53e978713c6e3a51b5e298f841292153a898514ded1153d7c99c230e67c95f3f23c6a4416a78dc26991c875b11

data/Readme.md

@@ -1,10 +1,10 @@
 # parallel_tests
 
 [![Gem Version](https://badge.fury.io/rb/parallel_tests.svg)](https://rubygems.org/gems/parallel_tests)
-[![Build status](https://github.com/grosser/parallel_tests/workflows/test/badge.svg)](https://github.com/grosser/parallel_tests/actions?query=workflow%3Atest)
+[![Build status](https://github.com/grosser/parallel_tests/workflows/test/badge.svg)](https://github.com/grosser/parallel_tests/actions?query=workflow%3Atest&branch=master)
 
-Speedup Test::Unit + RSpec + Cucumber + Spinach by running parallel on multiple CPU cores.<br/>
-ParallelTests splits tests into even groups (by number of lines or runtime) and runs each group in a single process with its own database.
+Speedup Minitest + RSpec + Turnip + Cucumber + Spinach by running parallel on multiple CPU cores.<br/>
+ParallelTests splits tests into balanced groups (by number of lines or runtime) and runs each group in a process with its own database.
 
 Setup for Rails
 ===============
@@ -33,35 +33,45 @@ test:
 ### Create additional database(s)
     rake parallel:create
 
+### (Multi-DB) Create individual database
+    rake parallel:create:<database>
+    rake parallel:create:secondary
+
 ### Copy development schema (repeat after migrations)
     rake parallel:prepare
 
 ### Run migrations in additional database(s) (repeat after migrations)
     rake parallel:migrate
 
+### (Multi-DB) Run migrations in individual database
+    rake parallel:migrate:<database>
+
 ### Setup environment from scratch (create db and loads schema, useful for CI)
     rake parallel:setup
 
 ### Drop all test databases
     rake parallel:drop
 
+### (Multi-DB) Drop individual test database
+    rake parallel:drop:<database>
+
 ### Run!
-    rake parallel:test          # Test::Unit
+    rake parallel:test          # Minitest
     rake parallel:spec          # RSpec
     rake parallel:features      # Cucumber
     rake parallel:features-spinach       # Spinach
 
-    rake parallel:test[1] --> force 1 CPU --> 86 seconds
+    rake "parallel:test[1]" --> force 1 CPU --> 86 seconds
     rake parallel:test    --> got 2 CPUs? --> 47 seconds
     rake parallel:test    --> got 4 CPUs? --> 26 seconds
     ...
 
 Test by pattern with Regex (e.g. use one integration server per subfolder / see if you broke any 'user'-related tests)
 
-    rake parallel:test[^test/unit] # every test file in test/unit folder
-    rake parallel:test[user]  # run users_controller + user_helper + user tests
-    rake parallel:test['user|product']  # run user and product related tests
-    rake parallel:spec['spec\/(?!features)'] # run RSpec tests except the tests in spec/features
+    rake "parallel:test[^test/unit]" # every test file in test/unit folder
+    rake "parallel:test[user]"  # run users_controller + user_helper + user tests
+    rake "parallel:test['user|product']"  # run user and product related tests
+    rake "parallel:spec['spec\/(?!features)']" # run RSpec tests except the tests in spec/features
 
 
 ### Example output
@@ -77,13 +87,13 @@ Test by pattern with Regex (e.g. use one integration server per subfolder / see
 ```Bash
 RAILS_ENV=test parallel_test -e "rake my:custom:task"
 # or
-rake parallel:rake[my:custom:task]
+rake "parallel:rake[my:custom:task]"
 # limited parallelism
-rake parallel:rake[my:custom:task,2]
+rake "parallel:rake[my:custom:task,2]"
 ```
 
 
-Running things once
+Running setup or teardown once
 ===================
 
 ```Ruby
@@ -106,11 +116,16 @@ at_exit do
 end
 ```
 
-Even test group run-times
-=========================
+Even test group runtimes
+========================
+
+Test groups will often run for different times, making the full test run as slow as the slowest group.
+
+**Step 1**: Use these loggers (see below) to record test runtime
 
-Test groups are often not balanced and will run for different times, making everything wait for the slowest group.
-Use these loggers to record test runtime and then use the recorded runtime to balance test groups more evenly.
+**Step 2**: The next test run will use the recorded test runtimes (use `--runtime-log <file>` if you picked a location different from below)
+
+**Step 3**: Automate upload/download of test runtime from your CI system [example](https://github.com/grosser/parallel_rails_example/blob/master/.github/workflows/test.yml) (chunks need to be combined, an alternative is [amend](https://github.com/grosser/amend))
 
 ### RSpec
 
@@ -128,7 +143,7 @@ Add to your `test_helper.rb`:
 require 'parallel_tests/test/runtime_logger' if ENV['RECORD_RUNTIME']
 ```
 
-results will be logged to tmp/parallel_runtime_test.log when `RECORD_RUNTIME` is set,
+results will be logged to `tmp/parallel_runtime_test.log` when `RECORD_RUNTIME` is set,
 so it is not always required or overwritten.
 
 Loggers
@@ -147,7 +162,7 @@ Add the following to your `.rspec_parallel` (or `.rspec`) :
 RSpec: FailuresLogger
 -----------------------
 
-Produce pastable command-line snippets for each failed example. For example:
+Produce pasteable command-line snippets for each failed example. For example:
 
 ```bash
 rspec /path/to/my_spec.rb:123 # should do something
@@ -160,6 +175,24 @@ Add to `.rspec_parallel` or use as CLI flag:
 
 (Not needed to retry failures, for that pass [--only-failures](https://relishapp.com/rspec/rspec-core/docs/command-line/only-failures) to rspec)
 
+
+RSpec: VerboseLogger
+-----------------------
+
+Prints a single line for starting and finishing each example, to see what is currently running in each process.
+
+```
+# PID, parallel process number, spec status, example description
+[14403] [2] [STARTED] Foo foo
+[14402] [1] [STARTED] Bar bar
+[14402] [1] [PASSED] Bar bar
+```
+
+Add to `.rspec_parallel` or use as CLI flag:
+
+      --format ParallelTests::RSpec::VerboseLogger
+
+
 Cucumber: FailuresLogger
 -----------------------
 
@@ -205,22 +238,23 @@ 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
-        --group-by [TYPE]            group tests by:
+    -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
+        --group-by TYPE              group tests by:
                                      found - order of finding files
                                      steps - number of cucumber/spinach steps
                                      scenarios - individual cucumber scenarios
                                      filesize - by size of the file
                                      runtime - info from runtime log
                                      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
+    -m, --multiply-processes COUNT   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)
-        --isolate-n [PROCESSES]      Use 'isolate'  singles with number of processes, default: 1.
+        --isolate-n PROCESSES        Use 'isolate'  singles with number of processes, default: 1
         --highest-exit-status        Exit with the highest exit status provided by test run(s)
-        --specify-groups [SPECS]     Use 'specify-groups' if you want to specify multiple specs running in multiple
+        --failure-exit-code INT      Specify the exit code to use when tests fail
+        --specify-groups SPECS       Use 'specify-groups' if you want to specify multiple specs running in multiple
                                      processes in a specific formation. Commas indicate specs in the same process,
                                      pipes indicate specs in a new process. Cannot use with --single, --isolate, or
                                      --isolate-n.  Ex.
@@ -228,11 +262,13 @@ Options are:
                                        Process 1 will contain 1_spec.rb and 2_spec.rb
                                        Process 2 will contain 3_spec.rb
                                        Process 3 will contain all other specs
-        --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
-    -t, --type [TYPE]                test(default) / rspec / cucumber / spinach
-        --suffix [PATTERN]           override built in test file pattern (should match suffix):
+        --only-group GROUP_INDEX[,GROUP_INDEX]
+                                     Only run the given group numbers.
+                                     Changes `--group-by` default to 'filesize'.
+    -e, --exec COMMAND               execute this code parallel and with ENV['TEST_ENV_NUMBER']
+    -o, --test-options 'OPTIONS'     execute test commands with those options
+    -t, --type TYPE                  test(default) / rspec / cucumber / spinach
+        --suffix PATTERN             override built in test file pattern (should match suffix):
                                      '_spec.rb$' - matches rspec files
                                      '_(test|spec).rb$' - matches test or spec files
         --serialize-stdout           Serialize stdout output, nothing will be written until everything is done
@@ -241,16 +277,19 @@ Options are:
         --combine-stderr             Combine stderr into stdout, useful in conjunction with --serialize-stdout
         --non-parallel               execute same commands but do not in parallel, needs --exec
         --no-symlinks                Do not traverse symbolic links to find test files
-        --ignore-tags [PATTERN]      When counting steps ignore scenarios with tags that match this pattern
+        --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 [INT]      Allowed percentage of missing runtimes (default = 50)
-        --unknown-runtime [FLOAT]    Use given number as unknown runtime (otherwise use average time)
+        --runtime-log PATH           Location of previously recorded test runtimes
+        --allowed-missing COUNT      Allowed percentage of missing runtimes (default = 50)
+        --allow-duplicates           When detecting files to run, allow duplicates
+        --unknown-runtime SECONDS    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
+        --test-file-limit LIMIT      Limit to this number of files per test run by batching (for windows set to ~100 to stay below 8192 max command limit, might have bugs from reusing test-env-number and summarizing partial results)
         --verbose                    Print debug 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
+        --verbose-command            Combines options --verbose-process-command and --verbose-rerun-command
+        --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 tests output
     -v, --version                    Show Version
     -h, --help                       Show this.
@@ -404,6 +443,9 @@ inspired by [pivotal labs](https://blog.pivotal.io/labs/labs/parallelize-your-rs
  - [Jon Dufresne](https://github.com/jdufresne)
  - [Eric Kessler](https://github.com/enkessler)
  - [Adis Osmonov](https://github.com/adis-io)
+ - [Josh Westbrook](https://github.com/joshwestbrook)
+ - [Jay Dorsey](https://github.com/jaydorsey)
+ - [hatsu](https://github.com/hatsu38)
 
 [Michael Grosser](http://grosser.it)<br/>
 michael@grosser.it<br/>

data/lib/parallel_tests/cli.rb

@@ -57,8 +57,8 @@ 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|
-              result = yield(item)
+            Parallel.map_with_index(items, in_threads: num_processes) do |item, index|
+              result = yield(item, index)
               reprint_output(result, lock.path) if options[:serialize_stdout]
               ParallelTests.stop_all_processes if options[:fail_fast] && result[:exit_status] != 0
               result
@@ -81,8 +81,8 @@ module ParallelTests
         end
 
         report_number_of_tests(groups) unless options[:quiet]
-        test_results = execute_in_parallel(groups, groups.size, options) do |group|
-          run_tests(group, groups.index(group), num_processes, options)
+        test_results = execute_in_parallel(groups, groups.size, options) do |group, index|
+          run_tests(group, index, num_processes, options)
         end
         report_results(test_results, options) unless options[:quiet]
       end
@@ -96,8 +96,9 @@ module ParallelTests
       if any_test_failed?(test_results)
         warn final_fail_message
 
-        # return the highest exit status to allow sub-processes to send things other than 1
-        exit_status = if options[:highest_exit_status]
+        exit_status = if options[:failure_exit_code]
+          options[:failure_exit_code]
+        elsif options[:highest_exit_status]
           test_results.map { |data| data.fetch(:exit_status) }.max
         else
           1
@@ -108,8 +109,19 @@ module ParallelTests
     end
 
     def run_tests(group, process_number, num_processes, options)
-      if group.empty?
-        { stdout: '', exit_status: 0, command: nil, seed: nil }
+      if (limit = options[:test_file_limit])
+        # TODO: will have some bugs with summarizing results and last process
+        results = group.each_slice(limit).map do |slice|
+          @runner.run_tests(slice, process_number, num_processes, options)
+        end
+        result = results[0]
+        results[1..].each do |res|
+          result[:stdout] = result[:stdout].to_s + res[:stdout].to_s
+          result[:exit_status] = [res[:exit_status], result[:exit_status]].max
+          # adding all files back in, not using original cmd to show what was actually run
+          result[:command] |= res[:command]
+        end
+        result
       else
         @runner.run_tests(group, process_number, num_processes, options)
       end
@@ -145,7 +157,7 @@ module ParallelTests
       failing_sets = test_results.reject { |r| r[:exit_status] == 0 }
       return if failing_sets.none?
 
-      if options[:verbose] || options[:verbose_command]
+      if options[:verbose] || options[:verbose_rerun_command]
         puts "\n\nTests have failed for a parallel_test group. Use the following command to run the group again:\n\n"
         failing_sets.each do |failing_set|
           command = failing_set[:command]
@@ -193,11 +205,11 @@ module ParallelTests
 
           Options are:
         BANNER
-        opts.on("-n [PROCESSES]", Integer, "How many processes to use, default: available CPUs") { |n| options[:count] = n }
-        opts.on("-p", "--pattern [PATTERN]", "run tests matching this regex pattern") { |pattern| options[:pattern] = /#{pattern}/ }
-        opts.on("--exclude-pattern", "--exclude-pattern [PATTERN]", "exclude tests matching this regex pattern") { |pattern| options[:exclude_pattern] = /#{pattern}/ }
+        opts.on("-n PROCESSES", Integer, "How many processes to use, default: available CPUs") { |n| options[:count] = n }
+        opts.on("-p", "--pattern PATTERN", "run tests matching this regex pattern") { |pattern| options[:pattern] = /#{pattern}/ }
+        opts.on("--exclude-pattern", "--exclude-pattern PATTERN", "exclude tests matching this regex pattern") { |pattern| options[:exclude_pattern] = /#{pattern}/ }
         opts.on(
-          "--group-by [TYPE]",
+          "--group-by TYPE",
           <<~TEXT.rstrip.split("\n").join("\n#{newline_padding}")
             group tests by:
             found - order of finding files
@@ -208,11 +220,11 @@ module ParallelTests
             default - runtime when runtime log is filled otherwise filesize
           TEXT
         ) { |type| options[:group_by] = type.to_sym }
-        opts.on("-m [FLOAT]", "--multiply-processes [FLOAT]", Float, "use given number as a multiplier of processes to run") do |multiply|
+        opts.on("-m COUNT", "--multiply-processes COUNT", Float, "use given number as a multiplier of processes to run") do |multiply|
           options[:multiply] = multiply
         end
 
-        opts.on("-s [PATTERN]", "--single [PATTERN]", "Run all matching files in the same process") do |pattern|
+        opts.on("-s PATTERN", "--single PATTERN", "Run all matching files in the same process") do |pattern|
           (options[:single_process] ||= []) << /#{pattern}/
         end
 
@@ -221,44 +233,58 @@ module ParallelTests
         end
 
         opts.on(
-          "--isolate-n [PROCESSES]",
+          "--isolate-n PROCESSES",
           Integer,
-          "Use 'isolate'  singles with number of processes, default: 1."
+          "Use 'isolate'  singles with number of processes, default: 1"
         ) { |n| options[:isolate_count] = n }
 
-        opts.on("--highest-exit-status", "Exit with the highest exit status provided by test run(s)") do
-          options[:highest_exit_status] = true
-        end
+        opts.on(
+          "--highest-exit-status",
+          "Exit with the highest exit status provided by test run(s)"
+        ) { options[:highest_exit_status] = true }
+
+        opts.on(
+          "--failure-exit-code INT",
+          Integer,
+          "Specify the exit code to use when tests fail"
+        ) { |code| options[:failure_exit_code] = code }
 
         opts.on(
-          "--specify-groups [SPECS]",
+          "--specify-groups SPECS",
           <<~TEXT.rstrip.split("\n").join("\n#{newline_padding}")
             Use 'specify-groups' if you want to specify multiple specs running in multiple
             processes in a specific formation. Commas indicate specs in the same process,
             pipes indicate specs in a new process. Cannot use with --single, --isolate, or
             --isolate-n.  Ex.
-            $ parallel_test -n 3 . --specify-groups '1_spec.rb,2_spec.rb|3_spec.rb'
+            $ parallel_tests -n 3 . --specify-groups '1_spec.rb,2_spec.rb|3_spec.rb'
               Process 1 will contain 1_spec.rb and 2_spec.rb
               Process 2 will contain 3_spec.rb
               Process 3 will contain all other specs
           TEXT
         ) { |groups| options[:specify_groups] = groups }
 
-        opts.on("--only-group INT[,INT]", Array) { |groups| options[:only_group] = groups.map(&:to_i) }
+        opts.on(
+          "--only-group GROUP_INDEX[,GROUP_INDEX]",
+          Array,
+          <<~TEXT.rstrip.split("\n").join("\n#{newline_padding}")
+            Only run the given group numbers.
+            Changes `--group-by` default to 'filesize'.
+          TEXT
+        ) { |groups| options[:only_group] = groups.map(&:to_i) }
 
-        opts.on("-e", "--exec [COMMAND]", "execute this code parallel and with ENV['TEST_ENV_NUMBER']") { |arg| options[:execute] = Shellwords.shellsplit(arg) }
-        opts.on("-o", "--test-options '[OPTIONS]'", "execute test commands with those options") { |arg| options[:test_options] = Shellwords.shellsplit(arg) }
-        opts.on("-t", "--type [TYPE]", "test(default) / rspec / cucumber / spinach") do |type|
+        opts.on("-e", "--exec COMMAND", "execute this code parallel and with ENV['TEST_ENV_NUMBER']") { |arg| options[:execute] = Shellwords.shellsplit(arg) }
+        opts.on("-o", "--test-options 'OPTIONS'", "execute test commands with those options") { |arg| options[:test_options] = Shellwords.shellsplit(arg) }
+        opts.on("-t", "--type TYPE", "test(default) / rspec / cucumber / spinach") do |type|
           @runner = load_runner(type)
         rescue NameError, LoadError => e
           puts "Runner for `#{type}` type has not been found! (#{e})"
           abort
         end
         opts.on(
-          "--suffix [PATTERN]",
+          "--suffix PATTERN",
           <<~TEXT.rstrip.split("\n").join("\n#{newline_padding}")
             override built in test file pattern (should match suffix):
-            '_spec\.rb$' - matches rspec files
+            '_spec.rb$' - matches rspec files
             '_(test|spec).rb$' - matches test or spec files
           TEXT
         ) { |pattern| options[:suffix] = /#{pattern}/ }
@@ -267,15 +293,19 @@ module ParallelTests
         opts.on("--combine-stderr", "Combine stderr into stdout, useful in conjunction with --serialize-stdout") { options[:combine_stderr] = true }
         opts.on("--non-parallel", "execute same commands but do not in parallel, needs --exec") { options[:non_parallel] = true }
         opts.on("--no-symlinks", "Do not traverse symbolic links to find test files") { options[:symlinks] = false }
-        opts.on('--ignore-tags [PATTERN]', 'When counting steps ignore scenarios with tags that match this pattern') { |arg| options[:ignore_tag_pattern] = arg }
+        opts.on('--ignore-tags PATTERN', 'When counting steps ignore scenarios with tags that match this pattern') { |arg| options[:ignore_tag_pattern] = arg }
         opts.on("--nice", "execute test commands with low priority.") { options[:nice] = true }
-        opts.on("--runtime-log [PATH]", "Location of previously recorded test runtimes") { |path| options[:runtime_log] = path }
-        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("--runtime-log PATH", "Location of previously recorded test runtimes") { |path| options[:runtime_log] = path }
+        opts.on("--allowed-missing COUNT", Integer, "Allowed percentage of missing runtimes (default = 50)") { |percent| options[:allowed_missing_percent] = percent }
+        opts.on('--allow-duplicates', 'When detecting files to run, allow duplicates') { options[:allow_duplicates] = true }
+        opts.on("--unknown-runtime SECONDS", 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("--test-file-limit LIMIT", Integer, "Limit to this number of files per test run by batching (for windows set to ~100 to stay below 8192 max command limit, might have bugs from reusing test-env-number and summarizing partial results)") { |limit| options[:test_file_limit] = limit }
         opts.on("--verbose", "Print debug output") { options[:verbose] = true }
-        opts.on("--verbose-command", "Displays the command that will be executed by each process and when there are failures displays the command executed by each process that failed") { options[:verbose_command] = true }
+        opts.on("--verbose-command", "Combines options --verbose-process-command and --verbose-rerun-command") { options.merge! verbose_process_command: true, verbose_rerun_command: true }
+        opts.on("--verbose-process-command", "Print the command that will be executed by each process before it begins") { options[:verbose_process_command] = true }
+        opts.on("--verbose-rerun-command", "After a process fails, print the command executed by that process") { options[:verbose_rerun_command] = true }
         opts.on("--quiet", "Print only tests output") { options[:quiet] = true }
         opts.on("-v", "--version", "Show Version") do
           puts ParallelTests::VERSION
@@ -323,6 +353,10 @@ module ParallelTests
         raise "Can't pass --specify-groups with any of these keys: --single, --isolate, or --isolate-n"
       end
 
+      if options[:failure_exit_code] && options[:highest_exit_status]
+        raise "Can't pass --failure-exit-code and --highest-exit-status"
+      end
+
       options
     end
 

data/lib/parallel_tests/cucumber/runner.rb

@@ -4,8 +4,8 @@ require "parallel_tests/gherkin/runner"
 module ParallelTests
   module Cucumber
     class Runner < ParallelTests::Gherkin::Runner
-      SCENARIOS_RESULTS_BOUNDARY_REGEX = /^(Failing|Flaky) Scenarios:$/.freeze
-      SCENARIO_REGEX = %r{^cucumber features/.+:\d+}.freeze
+      SCENARIOS_RESULTS_BOUNDARY_REGEX = /^(Failing|Flaky) Scenarios:$/
+      SCENARIO_REGEX = %r{^cucumber features/.+:\d+}
 
       class << self
         def name

data/lib/parallel_tests/grouper.rb

@@ -26,10 +26,6 @@ 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'
-        end
-
         if isolate_count >= num_groups
           raise 'Number of isolated processes must be >= total number of processes'
         end

data/lib/parallel_tests/rspec/failures_logger.rb

@@ -3,22 +3,14 @@ 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

@@ -7,8 +7,6 @@ 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
 

data/lib/parallel_tests/rspec/runner.rb

@@ -33,8 +33,10 @@ module ParallelTests
           "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)

data/lib/parallel_tests/rspec/runtime_logger.rb

@@ -9,7 +9,7 @@ class ParallelTests::RSpec::RuntimeLogger < ParallelTests::RSpec::LoggerBase
     @group_nesting = 0
   end
 
-  RSpec::Core::Formatters.register self, :example_group_started, :example_group_finished, :start_dump unless RSPEC_2
+  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
@@ -20,12 +20,13 @@ 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 seed(*); end
+
   def dump_summary(*); end
 
   def dump_failures(*); end
@@ -37,9 +38,11 @@ class ParallelTests::RSpec::RuntimeLogger < ParallelTests::RSpec::LoggerBase
   def start_dump(*)
     return unless ENV['TEST_ENV_NUMBER'] # only record when running in parallel
     lock_output do
+      # Order the output from slowest to fastest
+      @example_times = @example_times.sort_by(&:last).reverse
       @example_times.each do |file, time|
         relative_path = file.sub(%r{^#{Regexp.escape Dir.pwd}/}, '').sub(%r{^\./}, "")
-        @output.puts "#{relative_path}:#{time > 0 ? time : 0}"
+        @output.puts "#{relative_path}:#{[time, 0].max}"
       end
     end
     @output.flush

data/lib/parallel_tests/rspec/summary_logger.rb

@@ -2,7 +2,7 @@
 require 'parallel_tests/rspec/failures_logger'
 
 class ParallelTests::RSpec::SummaryLogger < ParallelTests::RSpec::LoggerBase
-  RSpec::Core::Formatters.register self, :dump_failures unless RSPEC_2
+  RSpec::Core::Formatters.register(self, :dump_failures)
 
   def dump_failures(*args)
     lock_output { super }

data/lib/parallel_tests/rspec/verbose_logger.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'rspec/core/formatters/base_text_formatter'
+require 'parallel_tests/rspec/runner'
+
+class ParallelTests::RSpec::VerboseLogger < RSpec::Core::Formatters::BaseTextFormatter
+  RSpec::Core::Formatters.register(
+    self,
+    :example_group_started,
+    :example_group_finished,
+    :example_started,
+    :example_passed,
+    :example_pending,
+    :example_failed
+  )
+
+  def initialize(output)
+    super
+    @line = []
+  end
+
+  def example_group_started(notification)
+    @line.push(notification.group.description)
+  end
+
+  def example_group_finished(_notification)
+    @line.pop
+  end
+
+  def example_started(notification)
+    @line.push(notification.example.description)
+    output_formatted_line('STARTED', :yellow)
+  end
+
+  def example_passed(_passed)
+    output_formatted_line('PASSED', :success)
+    @line.pop
+  end
+
+  def example_pending(_pending)
+    output_formatted_line('PENDING', :pending)
+    @line.pop
+  end
+
+  def example_failed(_failure)
+    output_formatted_line('FAILED', :failure)
+    @line.pop
+  end
+
+  private
+
+  def output_formatted_line(status, console_code)
+    prefix = ["[#{Process.pid}]"]
+    if ENV.include?('TEST_ENV_NUMBER')
+      test_env_number = ENV['TEST_ENV_NUMBER'] == '' ? 1 : Integer(ENV['TEST_ENV_NUMBER'])
+      prefix << "[#{test_env_number}]"
+    end
+    prefix << RSpec::Core::Formatters::ConsoleCodes.wrap("[#{status}]", console_code)
+
+    output.puts [*prefix, *@line].join(' ')
+  end
+end

data/lib/parallel_tests/spinach/runner.rb

@@ -15,7 +15,7 @@ module ParallelTests
 
         def runtime_logging
           # Not Yet Supported
-          ""
+          []
         end
       end
     end

data/lib/parallel_tests/tasks.rb

@@ -48,6 +48,9 @@ module ParallelTests
         activate_pipefail = "set -o pipefail"
         remove_ignored_lines = %{(grep -v #{Shellwords.escape(ignore_regex)} || true)}
 
+        # remove nil values (ex: #purge_before_load returns nil)
+        command.compact!
+
         if system('/bin/bash', '-c', "#{activate_pipefail} 2>/dev/null")
           shell_command = "#{activate_pipefail} && (#{Shellwords.shelljoin(command)}) | #{remove_ignored_lines}"
           ['/bin/bash', '-c', shell_command]
@@ -125,6 +128,24 @@ module ParallelTests
         command
       end
 
+      def configured_databases
+        return [] unless defined?(ActiveRecord) && rails_61_or_greater?
+
+        @@configured_databases ||= ActiveRecord::Tasks::DatabaseTasks.setup_initial_database_yaml
+      end
+
+      def for_each_database(&block)
+        # Use nil to represent all databases
+        block&.call(nil)
+
+        # skip if not rails or old rails version
+        return if !defined?(ActiveRecord::Tasks::DatabaseTasks) || !ActiveRecord::Tasks::DatabaseTasks.respond_to?(:for_each)
+
+        ActiveRecord::Tasks::DatabaseTasks.for_each(configured_databases) do |name|
+          block&.call(name)
+        end
+      end
+
       private
 
       def rails_7_or_greater?
@@ -145,25 +166,33 @@ namespace :parallel do
     ParallelTests::Tasks.run_in_parallel(ParallelTests::Tasks.suppress_schema_load_output(command), args)
   end
 
-  desc "Create test databases via db:create --> parallel:create[num_cpus]"
-  task :create, :count do |_, args|
-    ParallelTests::Tasks.run_in_parallel(
-      [$0, "db:create", "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"],
-      args
-    )
+  ParallelTests::Tasks.for_each_database do |name|
+    task_name = 'create'
+    task_name += ":#{name}" if name
+    desc "Create test#{" #{name}" if name} database via db:#{task_name} --> parallel:#{task_name}[num_cpus]"
+    task task_name.to_sym, :count do |_, args|
+      ParallelTests::Tasks.run_in_parallel(
+        [$0, "db:#{task_name}", "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"],
+        args
+      )
+    end
   end
 
-  desc "Drop test databases via db:drop --> parallel:drop[num_cpus]"
-  task :drop, :count do |_, args|
-    ParallelTests::Tasks.run_in_parallel(
-      [
-        $0,
-        "db:drop",
-        "RAILS_ENV=#{ParallelTests::Tasks.rails_env}",
-        "DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
-      ],
-      args
-    )
+  ParallelTests::Tasks.for_each_database do |name|
+    task_name = 'drop'
+    task_name += ":#{name}" if name
+    desc "Drop test#{" #{name}" if name} database via db:#{task_name} --> parallel:#{task_name}[num_cpus]"
+    task task_name.to_sym, :count do |_, args|
+      ParallelTests::Tasks.run_in_parallel(
+        [
+          $0,
+          "db:#{task_name}",
+          "RAILS_ENV=#{ParallelTests::Tasks.rails_env}",
+          "DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
+        ],
+        args
+      )
+    end
   end
 
   desc "Update test databases by dumping and loading --> parallel:prepare[num_cpus]"
@@ -190,12 +219,16 @@ namespace :parallel do
   end
 
   # when dumping/resetting takes too long
-  desc "Update test databases via db:migrate --> parallel:migrate[num_cpus]"
-  task :migrate, :count do |_, args|
-    ParallelTests::Tasks.run_in_parallel(
-      [$0, "db:migrate", "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"],
-      args
-    )
+  ParallelTests::Tasks.for_each_database do |name|
+    task_name = 'migrate'
+    task_name += ":#{name}" if name
+    desc "Update test#{" #{name}" if name} database via db:#{task_name} --> parallel:#{task_name}[num_cpus]"
+    task task_name.to_sym, :count do |_, args|
+      ParallelTests::Tasks.run_in_parallel(
+        [$0, "db:#{task_name}", "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"],
+        args
+      )
+    end
   end
 
   desc "Rollback test databases via db:rollback --> parallel:rollback[num_cpus]"
@@ -207,16 +240,24 @@ namespace :parallel do
   end
 
   # just load the schema (good for integration server <-> no development db)
-  desc "Load dumped schema for test databases via db:schema:load --> parallel:load_schema[num_cpus]"
-  task :load_schema, :count do |_, args|
-    command = [
-      $0,
-      ParallelTests::Tasks.purge_before_load,
-      "db:schema:load",
-      "RAILS_ENV=#{ParallelTests::Tasks.rails_env}",
-      "DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
-    ]
-    ParallelTests::Tasks.run_in_parallel(ParallelTests::Tasks.suppress_schema_load_output(command), args)
+  ParallelTests::Tasks.for_each_database do |name|
+    rails_task = 'db:schema:load'
+    rails_task += ":#{name}" if name
+
+    task_name = 'load_schema'
+    task_name += ":#{name}" if name
+
+    desc "Load dumped schema for test#{" #{name}" if name} database via #{rails_task} --> parallel:#{task_name}[num_cpus]"
+    task task_name.to_sym, :count do |_, args|
+      command = [
+        $0,
+        ParallelTests::Tasks.purge_before_load,
+        rails_task,
+        "RAILS_ENV=#{ParallelTests::Tasks.rails_env}",
+        "DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
+      ]
+      ParallelTests::Tasks.run_in_parallel(ParallelTests::Tasks.suppress_schema_load_output(command), args)
+    end
   end
 
   # load the structure from the structure.sql file

data/lib/parallel_tests/test/runner.rb

@@ -95,7 +95,7 @@ module ParallelTests
           cmd = ["nice", *cmd] if options[:nice]
 
           # being able to run with for example `-output foo-$TEST_ENV_NUMBER` worked originally and is convenient
-          cmd.map! { |c| c.gsub("$TEST_ENV_NUMBER", number).gsub("${TEST_ENV_NUMBER}", number) }
+          cmd = cmd.map { |c| c.gsub("$TEST_ENV_NUMBER", number).gsub("${TEST_ENV_NUMBER}", number) }
 
           print_command(cmd, env) if report_process_command?(options) && !options[:serialize_stdout]
 
@@ -158,7 +158,7 @@ module ParallelTests
 
         def executable
           if (executable = ENV['PARALLEL_TESTS_EXECUTABLE'])
-            [executable]
+            Shellwords.shellsplit(executable)
           else
             determine_executable
           end
@@ -238,8 +238,9 @@ module ParallelTests
           suffix_pattern = options[:suffix] || test_suffix
           include_pattern = options[:pattern] || //
           exclude_pattern = options[:exclude_pattern]
+          allow_duplicates = options[:allow_duplicates]
 
-          (tests || []).flat_map do |file_or_folder|
+          files = (tests || []).flat_map do |file_or_folder|
             if File.directory?(file_or_folder)
               files = files_in_folder(file_or_folder, options)
               files = files.grep(suffix_pattern).grep(include_pattern)
@@ -248,7 +249,9 @@ module ParallelTests
             else
               file_or_folder
             end
-          end.uniq
+          end
+
+          allow_duplicates ? files : files.uniq
         end
 
         def files_in_folder(folder, options = {})
@@ -290,7 +293,7 @@ module ParallelTests
         end
 
         def report_process_command?(options)
-          options[:verbose] || options[:verbose_command]
+          options[:verbose] || options[:verbose_process_command]
         end
       end
     end

data/lib/parallel_tests/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module ParallelTests
-  VERSION = '4.2.0'
+  VERSION = '4.8.0'
 end

data/lib/parallel_tests.rb

@@ -44,6 +44,8 @@ module ParallelTests
 
     def stop_all_processes
       pids.all.each { |pid| Process.kill(:INT, pid) }
+    rescue Errno::ESRCH, Errno::EPERM
+      # Process already terminated, do nothing
     end
 
     # copied from http://github.com/carlhuda/bundler Bundler::SharedHelpers#find_gemfile

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel_tests
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 4.8.0
 platform: ruby
 authors:
 - Michael Grosser
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-06 00:00:00.000000000 Z
+date: 2025-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -58,6 +58,7 @@ files:
 - lib/parallel_tests/rspec/runner.rb
 - lib/parallel_tests/rspec/runtime_logger.rb
 - lib/parallel_tests/rspec/summary_logger.rb
+- lib/parallel_tests/rspec/verbose_logger.rb
 - lib/parallel_tests/spinach/runner.rb
 - lib/parallel_tests/tasks.rb
 - lib/parallel_tests/test/runner.rb
@@ -68,9 +69,11 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/grosser/parallel_tests/issues
-  documentation_uri: https://github.com/grosser/parallel_tests/blob/v4.2.0/Readme.md
-  source_code_uri: https://github.com/grosser/parallel_tests/tree/v4.2.0
+  changelog_uri: https://github.com/grosser/parallel_tests/blob/v4.8.0/CHANGELOG.md
+  documentation_uri: https://github.com/grosser/parallel_tests/blob/v4.8.0/Readme.md
+  source_code_uri: https://github.com/grosser/parallel_tests/tree/v4.8.0
   wiki_uri: https://github.com/grosser/parallel_tests/wiki
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -79,14 +82,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Run Test::Unit / RSpec / Cucumber / Spinach in parallel