parallel_tests 3.7.3 → 4.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 042cf590688332180e07fcf6472cc9b88b740276df0511677cf77f7fe649fa2e
-  data.tar.gz: cb4fd166b030e16574bf5d4790e5d1e0a3d57001d5474ab81c3d54613af976e2
+  metadata.gz: a9044c95c595a48f89a621563c609a4c9fa89d851792ca694a30fcaf947a2119
+  data.tar.gz: 248e38e467b9070c1666819e2c1dc9149b791644b42e8a90cd53df82ebb80eed
 SHA512:
-  metadata.gz: 98e679733a74273ac77e71db47bc3af3f0f5a928dab351be9419644a0e7fe2bc004a81c929928ef0bd98ea2b8e5b63d1ab9fadcf75e22d098a65c5164343fe0b
-  data.tar.gz: 2ce2dd070733cd0bb61d0cb610f886a5590d5e267cc43613ab7d08fc251d989ebd4a58ad2f0a9c88478499fe55ff4cb7386fabc2eba8ee7fb3440d4899594654
+  metadata.gz: 363e8d317a43d03043a270c19d05f60071bd05a9b435a0545454e81b96d875b694dd4fadc74669ba136990d57d863883132a19ff7fd1c9c4169e2c16a8e2db38
+  data.tar.gz: ef251fa00adf1310c5281ee4985119ce6b4810d121d87a3a4a7f6b6a03aa968ed9be7847eec127e74a118983e4454b181635d1538b1a17b5f242fbb11839caa9

data/Readme.md

@@ -1,8 +1,7 @@
 # parallel_tests
 
 [![Gem Version](https://badge.fury.io/rb/parallel_tests.svg)](https://rubygems.org/gems/parallel_tests)
-[![Build Status](https://travis-ci.org/grosser/parallel_tests.svg)](https://travis-ci.org/grosser/parallel_tests/builds)
-[![Build status](https://github.com/grosser/parallel_tests/workflows/windows/badge.svg)](https://github.com/grosser/parallel_tests/actions?query=workflow%3Awindows)
+[![Build status](https://github.com/grosser/parallel_tests/workflows/test/badge.svg)](https://github.com/grosser/parallel_tests/actions?query=workflow%3Atest)
 
 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.
@@ -42,7 +41,7 @@ test:
 
 ### Setup environment from scratch (create db and loads schema, useful for CI)
     rake parallel:setup
-    
+
 ### Drop all test databases
     rake parallel:drop
 
@@ -193,15 +192,15 @@ Setup for non-rails
  - use `ENV['TEST_ENV_NUMBER']` inside your tests to select separate db/memcache/etc. (docker compose: expose it)
 
  - Only run a subset of files / folders:
- 
+
     `parallel_test test/bar test/baz/foo_text.rb`
 
  - Pass test-options and files via `--`:
- 
+
     `parallel_rspec -- -t acceptance -f progress -- spec/foo_spec.rb spec/acceptance`
-    
+
  - Pass in test options, by using the -o flag (wrap everything in quotes):
- 
+
     `parallel_cucumber -n 2 -o '-p foo_profile --tags @only_this_tag or @only_that_tag --format summary'`
 
 Options are:
@@ -250,8 +249,7 @@ Options are:
         --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    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            Displays the command that will be executed by each process and 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.
@@ -402,6 +400,9 @@ inspired by [pivotal labs](https://blog.pivotal.io/labs/labs/parallelize-your-rs
  - [Vikram B Kumar](https://github.com/v-kumar)
  - [Joshua Pinter](https://github.com/joshuapinter)
  - [Zach Dennis](https://github.com/zdennis)
+ - [Jon Dufresne](https://github.com/jdufresne)
+ - [Eric Kessler](https://github.com/enkessler)
+ - [Adis Osmonov](https://github.com/adis-io)
 
 [Michael Grosser](http://grosser.it)<br/>
 michael@grosser.it<br/>

data/lib/parallel_tests/cli.rb

@@ -20,7 +20,7 @@ module ParallelTests
       options[:first_is_1] ||= first_is_1?
 
       if options[:execute]
-        execute_shell_command_in_parallel(options[:execute], num_processes, options)
+        execute_command_in_parallel(options[:execute], num_processes, options)
       else
         run_tests_in_parallel(num_processes, options)
       end
@@ -32,9 +32,23 @@ module ParallelTests
       @graceful_shutdown_attempted ||= false
       Kernel.exit if @graceful_shutdown_attempted
 
-      # The Pid class's synchronize method can't be called directly from a trap
-      # Using Thread workaround https://github.com/ddollar/foreman/issues/332
-      Thread.new { ParallelTests.stop_all_processes }
+      # In a shell, all sub-processes also get an interrupt, so they shut themselves down.
+      # In a background process this does not happen and we need to do it ourselves.
+      # We cannot always send the interrupt since then the sub-processes would get interrupted twice when in foreground
+      # and that messes with interrupt handling.
+      #
+      # (can simulate detached with `(bundle exec parallel_rspec test/a_spec.rb -n 2 &)`)
+      # also the integration test "passes on int signal to child processes" is detached.
+      #
+      # On windows getpgid does not work so we resort to always killing which is the smaller bug.
+      #
+      # The ParallelTests::Pids `synchronize` method can't be called directly from a trap,
+      # using Thread workaround https://github.com/ddollar/foreman/issues/332
+      Thread.new do
+        if Gem.win_platform? || ((child_pid = ParallelTests.pids.all.first) && Process.getpgid(child_pid) != Process.pid)
+          ParallelTests.stop_all_processes
+        end
+      end
 
       @graceful_shutdown_attempted = true
     end
@@ -61,20 +75,15 @@ module ParallelTests
         groups = @runner.tests_in_groups(options[:files], num_processes, options)
         groups.reject!(&:empty?)
 
-        test_results = if options[:only_group]
-          groups_to_run = options[:only_group].map { |i| groups[i - 1] }.compact
-          report_number_of_tests(groups_to_run) unless options[:quiet]
-          execute_in_parallel(groups_to_run, groups_to_run.size, options) do |group|
-            run_tests(group, groups_to_run.index(group), 1, options)
-          end
-        else
-          report_number_of_tests(groups) unless options[:quiet]
-
-          execute_in_parallel(groups, groups.size, options) do |group|
-            run_tests(group, groups.index(group), num_processes, options)
-          end
+        if options[:only_group]
+          groups = options[:only_group].map { |i| groups[i - 1] }.compact
+          num_processes = 1
         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)
+        end
         report_results(test_results, options) unless options[:quiet]
       end
 
@@ -100,7 +109,7 @@ module ParallelTests
 
     def run_tests(group, process_number, num_processes, options)
       if group.empty?
-        { stdout: '', exit_status: 0, command: '', seed: nil }
+        { stdout: '', exit_status: 0, command: nil, seed: nil }
       else
         @runner.run_tests(group, process_number, num_processes, options)
       end
@@ -136,13 +145,12 @@ module ParallelTests
       failing_sets = test_results.reject { |r| r[:exit_status] == 0 }
       return if failing_sets.none?
 
-      if options[:verbose] || options[:verbose_rerun_command]
+      if options[:verbose] || options[:verbose_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]
-          command = command.gsub(/;export [A-Z_]+;/, ' ') # remove ugly export statements
           command = @runner.command_with_seed(command, failing_set[:seed]) if failing_set[:seed]
-          puts command
+          @runner.print_command(command, failing_set[:env] || {})
         end
       end
     end
@@ -229,7 +237,7 @@ module ParallelTests
             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_tests -n 3 . --specify-groups '1_spec.rb,2_spec.rb|3_spec.rb'
+            $ parallel_test -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
@@ -238,8 +246,8 @@ module ParallelTests
 
         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 }
-        opts.on("-o", "--test-options '[OPTIONS]'", "execute test commands with those options") { |arg| options[:test_options] = arg.lstrip }
+        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
@@ -267,8 +275,7 @@ module ParallelTests
         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 }
+        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("--quiet", "Print only tests output") { options[:quiet] = true }
         opts.on("-v", "--version", "Show Version") do
           puts ParallelTests::VERSION
@@ -322,20 +329,20 @@ module ParallelTests
     def extract_file_paths(argv)
       dash_index = argv.rindex("--")
       file_args_at = (dash_index || -1) + 1
-      [argv[file_args_at..-1], argv[0...(dash_index || 0)]]
+      [argv[file_args_at..], argv[0...(dash_index || 0)]]
     end
 
     def extract_test_options(argv)
       dash_index = argv.index("--") || -1
-      argv[dash_index + 1..-1]
+      argv[dash_index + 1..]
     end
 
     def append_test_options(options, argv)
       new_opts = extract_test_options(argv)
       return if new_opts.empty?
 
-      prev_and_new = [options[:test_options], new_opts.shelljoin]
-      options[:test_options] = prev_and_new.compact.join(' ')
+      options[:test_options] ||= []
+      options[:test_options] += new_opts
     end
 
     def load_runner(type)
@@ -345,7 +352,7 @@ module ParallelTests
       klass_name.split('::').inject(Object) { |x, y| x.const_get(y) }
     end
 
-    def execute_shell_command_in_parallel(command, num_processes, options)
+    def execute_command_in_parallel(command, num_processes, options)
       runs = if options[:only_group]
         options[:only_group].map { |g| g - 1 }
       else
@@ -397,7 +404,7 @@ module ParallelTests
     def simulate_output_for_ci(simulate)
       if simulate
         progress_indicator = Thread.new do
-          interval = Float(ENV.fetch('PARALLEL_TEST_HEARTBEAT_INTERVAL', 60))
+          interval = Float(ENV['PARALLEL_TEST_HEARTBEAT_INTERVAL'] || 60)
           loop do
             sleep interval
             print '.'

data/lib/parallel_tests/cucumber/runner.rb

@@ -35,8 +35,8 @@ module ParallelTests
         end
 
         def command_with_seed(cmd, seed)
-          clean = cmd.sub(/\s--order\s+random(:\d+)?\b/, '')
-          "#{clean} --order random:#{seed}"
+          clean = remove_command_arguments(cmd, '--order')
+          [*clean, '--order', "random:#{seed}"]
         end
       end
     end

data/lib/parallel_tests/cucumber/scenario_line_logger.rb

@@ -27,7 +27,7 @@ module ParallelTests
               example_tags = example.tags.map(&:name)
               example_tags = scenario_tags + example_tags
               next unless matches_tags?(example_tags)
-              example.rows[1..-1].each do |row|
+              example.rows[1..].each do |row|
                 test_line = row.source_line
                 next if line_numbers.any? && !line_numbers.include?(test_line)
 

data/lib/parallel_tests/cucumber/scenarios.rb

@@ -4,7 +4,6 @@ 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"
@@ -20,7 +19,7 @@ module ParallelTests
         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 = options[:test_options] || []
           words.each_with_index { |w, i| tags << words[i + 1] if ["-t", "--tags"].include?(w) }
           if ignore = options[:ignore_tag_pattern]
             tags << "not (#{ignore})"
@@ -53,7 +52,9 @@ module ParallelTests
             feature_tags = feature.tags.map(&:name)
 
             # We loop on each children of the feature
-            feature.tests.each do |test|
+            test_models = feature.tests
+            test_models += feature.rules.flat_map(&:tests) if feature.respond_to?(:rules) # cuke_modeler >= 3.2 supports rules
+            test_models.each do |test|
               # It's a scenario, we add it to the scenario_line_logger
               scenario_line_logger.visit_feature_element(document.path, test, feature_tags, line_numbers: test_lines)
             end

data/lib/parallel_tests/gherkin/runner.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 require "parallel_tests/test/runner"
-require 'shellwords'
 
 module ParallelTests
   module Gherkin
@@ -16,17 +15,13 @@ module ParallelTests
             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?
 
-          cmd = [
-            executable,
-            (runtime_logging if File.directory?(File.dirname(runtime_log))),
-            *sanitized_test_files,
-            cucumber_opts(options[:test_options])
-          ].compact.reject(&:empty?).join(' ')
+          cmd = executable
+          cmd += runtime_logging if File.directory?(File.dirname(runtime_log))
+          cmd += combined_scenarios
+          cmd += cucumber_opts(options[:test_options])
           execute_command(cmd, process_number, num_processes, options)
         end
 
@@ -62,22 +57,22 @@ module ParallelTests
               plural = "s" if (word == group) && (number != 1)
               "#{number} #{word}#{plural}"
             end
-            "#{sums[0]} (#{sums[1..-1].join(", ")})"
+            "#{sums[0]} (#{sums[1..].join(", ")})"
           end.compact.join("\n")
         end
 
         def cucumber_opts(given)
-          if given =~ (/--profile/) || given =~ (/(^|\s)-p /)
+          if given&.include?('--profile') || given&.include?('-p')
             given
           else
-            [given, profile_from_config].compact.join(" ")
+            [*given, *profile_from_config]
           end
         end
 
         def profile_from_config
           # copied from https://github.com/cucumber/cucumber/blob/master/lib/cucumber/cli/profile_loader.rb#L85
           config = Dir.glob("{,.config/,config/}#{name}{.yml,.yaml}").first
-          "--profile parallel" if config && File.read(config) =~ /^parallel:/
+          ['--profile', 'parallel'] if config && File.read(config) =~ /^parallel:/
         end
 
         def tests_in_groups(tests, num_groups, options = {})
@@ -91,7 +86,7 @@ module ParallelTests
         end
 
         def runtime_logging
-          "--format ParallelTests::Gherkin::RuntimeLogger --out #{runtime_log}"
+          ['--format', 'ParallelTests::Gherkin::RuntimeLogger', '--out', runtime_log]
         end
 
         def runtime_log
@@ -102,11 +97,11 @@ module ParallelTests
           if File.exist?("bin/#{name}")
             ParallelTests.with_ruby_binary("bin/#{name}")
           elsif ParallelTests.bundler_enabled?
-            "bundle exec #{name}"
+            ["bundle", "exec", name]
           elsif File.file?("script/#{name}")
             ParallelTests.with_ruby_binary("script/#{name}")
           else
-            name.to_s
+            [name.to_s]
           end
         end
       end

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
@@ -38,7 +34,7 @@ module ParallelTests
           # add all files that should run in a multiple isolated processes to their own groups
           group_features_by_size(items_to_group(single_items), groups[0..(isolate_count - 1)])
           # group the non-isolated by size
-          group_features_by_size(items_to_group(items), groups[isolate_count..-1])
+          group_features_by_size(items_to_group(items), groups[isolate_count..])
         else
           # add all files that should run in a single non-isolated process to first group
           single_items.each { |item, size| add_to_group(groups.first, item, size) }

data/lib/parallel_tests/pids.rb

@@ -43,14 +43,14 @@ module ParallelTests
 
     def read
       sync do
-        contents = IO.read(file_path)
+        contents = File.read(file_path)
         return if contents.empty?
         @pids = JSON.parse(contents)
       end
     end
 
     def save
-      sync { IO.write(file_path, pids.to_json) }
+      sync { File.write(file_path, pids.to_json) }
     end
 
     def sync(&block)

data/lib/parallel_tests/rspec/runner.rb

@@ -7,8 +7,7 @@ module ParallelTests
       DEV_NULL = (WINDOWS ? "NUL" : "/dev/null")
       class << self
         def run_tests(test_files, process_number, num_processes, options)
-          exe = executable # expensive, so we cache
-          cmd = [exe, options[:test_options], color, spec_opts, *test_files].compact.join(" ")
+          cmd = [*executable, *options[:test_options], *color, *spec_opts, *test_files]
           execute_command(cmd, process_number, num_processes, options)
         end
 
@@ -16,9 +15,9 @@ module ParallelTests
           if File.exist?("bin/rspec")
             ParallelTests.with_ruby_binary("bin/rspec")
           elsif ParallelTests.bundler_enabled?
-            "bundle exec rspec"
+            ["bundle", "exec", "rspec"]
           else
-            "rspec"
+            ["rspec"]
           end
         end
 
@@ -48,8 +47,8 @@ module ParallelTests
         # --order rand:1234
         # --order random:1234
         def command_with_seed(cmd, seed)
-          clean = cmd.sub(/\s--(seed\s+\d+|order\s+rand(om)?(:\d+)?)\b/, '')
-          "#{clean} --seed #{seed}"
+          clean = remove_command_arguments(cmd, '--seed', '--order')
+          [*clean, '--seed', seed]
         end
 
         # Summarize results from threads and colorize results based on failure and pending counts.
@@ -71,19 +70,13 @@ module ParallelTests
 
         private
 
-        # so it can be stubbed....
-        def run(cmd)
-          `#{cmd}`
-        end
-
         def color
-          '--color --tty' if $stdout.tty?
+          ['--color', '--tty'] if $stdout.tty?
         end
 
         def spec_opts
           options_file = ['.rspec_parallel', 'spec/parallel_spec.opts', 'spec/spec.opts'].detect { |f| File.file?(f) }
-          return unless options_file
-          "-O #{options_file}"
+          ["-O", options_file] if options_file
         end
       end
     end

data/lib/parallel_tests/tasks.rb

@@ -9,16 +9,8 @@ module ParallelTests
         'test'
       end
 
-      def rake_bin
-        # Prevent 'Exec format error' Errno::ENOEXEC on Windows
-        return "rake" if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
-        binstub_path = File.join('bin', 'rake')
-        return binstub_path if File.exist?(binstub_path)
-        "rake"
-      end
-
       def load_lib
-        $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..'))
+        $LOAD_PATH << File.expand_path('..', __dir__)
         require "parallel_tests"
       end
 
@@ -30,12 +22,15 @@ module ParallelTests
 
       def run_in_parallel(cmd, options = {})
         load_lib
-        count = " -n #{options[:count]}" unless options[:count].to_s.empty?
+
         # Using the relative path to find the binary allow to run a specific version of it
         executable = File.expand_path('../../bin/parallel_test', __dir__)
-        non_parallel = (options[:non_parallel] ? ' --non-parallel' : '')
-        command = "#{ParallelTests.with_ruby_binary(Shellwords.escape(executable))} --exec '#{cmd}'#{count}#{non_parallel}"
-        abort unless system(command)
+        command = ParallelTests.with_ruby_binary(executable)
+        command += ['--exec', Shellwords.join(cmd)]
+        command += ['-n', options[:count]] unless options[:count].to_s.empty?
+        command << '--non-parallel' if options[:non_parallel]
+
+        abort unless system(*command)
       end
 
       # this is a crazy-complex solution for a very simple problem:
@@ -48,16 +43,14 @@ module ParallelTests
       # - pipefail makes pipe fail with exitstatus of first failed command
       # - pipefail is not supported in (zsh)
       # - defining a new rake task like silence_schema would force users to load parallel_tests in test env
-      # - do not use ' since run_in_parallel uses them to quote stuff
       # - simple system "set -o pipefail" returns nil even though set -o pipefail exists with 0
       def suppress_output(command, ignore_regex)
         activate_pipefail = "set -o pipefail"
-        remove_ignored_lines = %{(grep -v "#{ignore_regex}" || test 1)}
+        remove_ignored_lines = %{(grep -v #{Shellwords.escape(ignore_regex)} || true)}
 
-        if File.executable?('/bin/bash') && system('/bin/bash', '-c', "#{activate_pipefail} 2>/dev/null && test 1")
-          # We need to shell escape single quotes (' becomes '"'"') because
-          # run_in_parallel wraps command in single quotes
-          %{/bin/bash -c '"'"'#{activate_pipefail} && (#{command}) | #{remove_ignored_lines}'"'"'}
+        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]
         else
           command
         end
@@ -90,7 +83,56 @@ module ParallelTests
         options = args.shift
         pass_through = args.shift
 
-        [num_processes, pattern.to_s, options.to_s, pass_through.to_s]
+        [num_processes, pattern, options, pass_through]
+      end
+
+      def schema_format_based_on_rails_version
+        if rails_7_or_greater?
+          ActiveRecord.schema_format
+        else
+          ActiveRecord::Base.schema_format
+        end
+      end
+
+      def schema_type_based_on_rails_version
+        if rails_61_or_greater? || schema_format_based_on_rails_version == :ruby
+          "schema"
+        else
+          "structure"
+        end
+      end
+
+      def build_run_command(type, args)
+        count, pattern, options, pass_through = ParallelTests::Tasks.parse_args(args)
+        test_framework = {
+          'spec' => 'rspec',
+          'test' => 'test',
+          'features' => 'cucumber',
+          'features-spinach' => 'spinach'
+        }.fetch(type)
+
+        type = 'features' if test_framework == 'spinach'
+
+        # Using the relative path to find the binary allow to run a specific version of it
+        executable = File.expand_path('../../bin/parallel_test', __dir__)
+        executable = ParallelTests.with_ruby_binary(executable)
+
+        command = [*executable, type, '--type', test_framework]
+        command += ['-n', count.to_s] if count
+        command += ['--pattern', pattern] if pattern
+        command += ['--test-options', options] if options
+        command += Shellwords.shellsplit pass_through if pass_through
+        command
+      end
+
+      private
+
+      def rails_7_or_greater?
+        Gem::Version.new(Rails.version) >= Gem::Version.new('7.0')
+      end
+
+      def rails_61_or_greater?
+        Gem::Version.new(Rails.version) >= Gem::Version.new('6.1.0')
       end
     end
   end
@@ -99,36 +141,38 @@ end
 namespace :parallel do
   desc "Setup test databases via db:setup --> parallel:setup[num_cpus]"
   task :setup, :count do |_, args|
-    command = "#{ParallelTests::Tasks.rake_bin} db:setup RAILS_ENV=#{ParallelTests::Tasks.rails_env}"
+    command = [$0, "db:setup", "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"]
     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(
-      "#{ParallelTests::Tasks.rake_bin} db:create RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args
+      [$0, "db:create", "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"],
+      args
     )
   end
 
   desc "Drop test databases via db:drop --> parallel:drop[num_cpus]"
   task :drop, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} db:drop RAILS_ENV=#{ParallelTests::Tasks.rails_env} " \
-      "DISABLE_DATABASE_ENVIRONMENT_CHECK=1", args
+      [
+        $0,
+        "db:drop",
+        "RAILS_ENV=#{ParallelTests::Tasks.rails_env}",
+        "DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
+      ],
+      args
     )
   end
 
   desc "Update test databases by dumping and loading --> parallel:prepare[num_cpus]"
   task(:prepare, [:count]) do |_, args|
     ParallelTests::Tasks.check_for_pending_migrations
-    if defined?(ActiveRecord::Base) && [:ruby, :sql].include?(ActiveRecord::Base.schema_format)
+
+    if defined?(ActiveRecord) && [:ruby, :sql].include?(ParallelTests::Tasks.schema_format_based_on_rails_version)
       # fast: dump once, load in parallel
-      type =
-        if Gem::Version.new(Rails.version) >= Gem::Version.new('6.1.0')
-          "schema"
-        else
-          ActiveRecord::Base.schema_format == :ruby ? "schema" : "structure"
-        end
+      type = ParallelTests::Tasks.schema_type_based_on_rails_version
 
       Rake::Task["db:#{type}:dump"].invoke
 
@@ -140,7 +184,7 @@ namespace :parallel do
       # slow: dump and load in in serial
       args = args.to_hash.merge(non_parallel: true) # normal merge returns nil
       task_name = Rake::Task.task_defined?('db:test:prepare') ? 'db:test:prepare' : 'app:db:test:prepare'
-      ParallelTests::Tasks.run_in_parallel("#{ParallelTests::Tasks.rake_bin} #{task_name}", args)
+      ParallelTests::Tasks.run_in_parallel([$0, task_name], args)
       next
     end
   end
@@ -149,22 +193,29 @@ namespace :parallel do
   desc "Update test databases via db:migrate --> parallel:migrate[num_cpus]"
   task :migrate, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} db:migrate RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args
+      [$0, "db:migrate", "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"],
+      args
     )
   end
 
   desc "Rollback test databases via db:rollback --> parallel:rollback[num_cpus]"
   task :rollback, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} db:rollback RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args
+      [$0, "db:rollback", "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"],
+      args
     )
   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 = "#{ParallelTests::Tasks.rake_bin} #{ParallelTests::Tasks.purge_before_load} " \
-      "db:schema:load RAILS_ENV=#{ParallelTests::Tasks.rails_env} DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
+    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)
   end
 
@@ -173,23 +224,34 @@ namespace :parallel do
   desc "Load structure for test databases via db:schema:load --> parallel:load_structure[num_cpus]"
   task :load_structure, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} #{ParallelTests::Tasks.purge_before_load} " \
-      "db:structure:load RAILS_ENV=#{ParallelTests::Tasks.rails_env} DISABLE_DATABASE_ENVIRONMENT_CHECK=1", args
+      [
+        $0,
+        ParallelTests::Tasks.purge_before_load,
+        "db:structure:load",
+        "RAILS_ENV=#{ParallelTests::Tasks.rails_env}",
+        "DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
+      ],
+      args
     )
   end
 
   desc "Load the seed data from db/seeds.rb via db:seed --> parallel:seed[num_cpus]"
   task :seed, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} db:seed RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args
+      [
+        $0,
+        "db:seed",
+        "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"
+      ],
+      args
     )
   end
 
   desc "Launch given rake command in parallel"
   task :rake, :command, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "RAILS_ENV=#{ParallelTests::Tasks.rails_env} #{ParallelTests::Tasks.rake_bin} " \
-      "#{args.command}", args
+      [$0, args.command, "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"],
+      args
     )
   end
 
@@ -198,26 +260,9 @@ namespace :parallel do
     task type, [:count, :pattern, :options, :pass_through] do |_t, args|
       ParallelTests::Tasks.check_for_pending_migrations
       ParallelTests::Tasks.load_lib
+      command = ParallelTests::Tasks.build_run_command(type, args)
 
-      count, pattern, options, pass_through = ParallelTests::Tasks.parse_args(args)
-      test_framework = {
-        'spec' => 'rspec',
-        'test' => 'test',
-        'features' => 'cucumber',
-        'features-spinach' => 'spinach'
-      }[type]
-
-      type = 'features' if test_framework == 'spinach'
-      # Using the relative path to find the binary allow to run a specific version of it
-      executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallel_test')
-
-      command = "#{ParallelTests.with_ruby_binary(Shellwords.escape(executable))} #{type} " \
-        "--type #{test_framework} "        \
-        "-n #{count} "                     \
-        "--pattern '#{pattern}' "          \
-        "--test-options '#{options}' "     \
-        "#{pass_through}"
-      abort unless system(command) # allow to chain tasks e.g. rake parallel:spec parallel:features
+      abort unless system(*command) # allow to chain tasks e.g. rake parallel:spec parallel:features
     end
   end
 end

data/lib/parallel_tests/test/runner.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
+require 'shellwords'
 require 'parallel_tests'
 
 module ParallelTests
   module Test
     class Runner
+      RuntimeLogTooSmallError = Class.new(StandardError)
+
       class << self
         # --- usually overwritten by other runners
 
@@ -25,7 +28,14 @@ module ParallelTests
 
         def run_tests(test_files, process_number, num_processes, options)
           require_list = test_files.map { |file| file.gsub(" ", "\\ ") }.join(" ")
-          cmd = "#{executable} -Itest -e '%w[#{require_list}].each { |f| require %{./\#{f}} }' -- #{options[:test_options]}"
+          cmd = [
+            *executable,
+            '-Itest',
+            '-e',
+            "%w[#{require_list}].each { |f| require %{./\#{f}} }",
+            '--',
+            *options[:test_options]
+          ]
           execute_command(cmd, process_number, num_processes, options)
         end
 
@@ -63,7 +73,7 @@ module ParallelTests
               []
             end
             if runtimes.size * 1.5 > tests.size
-              puts "Using recorded test runtime"
+              puts "Using recorded test runtime" unless options[:quiet]
               sort_by_runtime(tests, runtimes)
             else
               sort_by_filesize(tests)
@@ -76,22 +86,33 @@ module ParallelTests
         end
 
         def execute_command(cmd, process_number, num_processes, options)
+          number = test_env_number(process_number, options).to_s
           env = (options[:env] || {}).merge(
-            "TEST_ENV_NUMBER" => test_env_number(process_number, options).to_s,
+            "TEST_ENV_NUMBER" => number,
             "PARALLEL_TEST_GROUPS" => num_processes.to_s,
             "PARALLEL_PID_FILE" => ParallelTests.pid_file_path
           )
-          cmd = "nice #{cmd}" if options[:nice]
-          cmd = "#{cmd} 2>&1" if options[:combine_stderr]
+          cmd = ["nice", *cmd] if options[:nice]
+
+          # being able to run with for example `-output foo-$TEST_ENV_NUMBER` worked originally and is convenient
+          cmd = cmd.map { |c| c.gsub("$TEST_ENV_NUMBER", number).gsub("${TEST_ENV_NUMBER}", number) }
 
-          puts cmd if report_process_command?(options) && !options[:serialize_stdout]
+          print_command(cmd, env) if report_process_command?(options) && !options[:serialize_stdout]
 
           execute_command_and_capture_output(env, cmd, options)
         end
 
+        def print_command(command, env)
+          env_str = ['TEST_ENV_NUMBER', 'PARALLEL_TEST_GROUPS'].map { |e| "#{e}=#{env[e]}" }.join(' ')
+          puts [env_str, Shellwords.shelljoin(command)].compact.join(' ')
+        end
+
         def execute_command_and_capture_output(env, cmd, options)
+          popen_options = {} # do not add `pgroup: true`, it will break `binding.irb` inside the test
+          popen_options[:err] = [:child, :out] if options[:combine_stderr]
+
           pid = nil
-          output = IO.popen(env, cmd) do |io|
+          output = IO.popen(env, cmd, popen_options) do |io|
             pid = io.pid
             ParallelTests.pids.add(pid)
             capture_output(io, env, options)
@@ -100,9 +121,9 @@ module ParallelTests
           exitstatus = $?.exitstatus
           seed = output[/seed (\d+)/, 1]
 
-          output = [cmd, output].join("\n") if report_process_command?(options) && options[:serialize_stdout]
+          output = "#{Shellwords.shelljoin(cmd)}\n#{output}" if report_process_command?(options) && options[:serialize_stdout]
 
-          { stdout: output, exit_status: exitstatus, command: cmd, seed: seed }
+          { env: env, stdout: output, exit_status: exitstatus, command: cmd, seed: seed }
         end
 
         def find_results(test_output)
@@ -129,18 +150,22 @@ module ParallelTests
 
         # remove old seed and add new seed
         def command_with_seed(cmd, seed)
-          clean = cmd.sub(/\s--seed\s+\d+\b/, '')
-          "#{clean} --seed #{seed}"
+          clean = remove_command_arguments(cmd, '--seed')
+          [*clean, '--seed', seed]
         end
 
         protected
 
         def executable
-          ENV['PARALLEL_TESTS_EXECUTABLE'] || determine_executable
+          if (executable = ENV['PARALLEL_TESTS_EXECUTABLE'])
+            [executable]
+          else
+            determine_executable
+          end
         end
 
         def determine_executable
-          "ruby"
+          ["ruby"]
         end
 
         def sum_up_results(results)
@@ -184,7 +209,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 or remove it."
+              raise RuntimeLogTooSmallError, "Runtime log file '#{log}' does not contain sufficient data to sort #{tests.size} test files, please update or remove it."
             end
             [test, time]
           end
@@ -237,6 +262,21 @@ module ParallelTests
           Dir[File.join(folder, pattern)].uniq.sort
         end
 
+        def remove_command_arguments(command, *args)
+          remove_next = false
+          command.select do |arg|
+            if remove_next
+              remove_next = false
+              false
+            elsif args.include?(arg)
+              remove_next = true
+              false
+            else
+              true
+            end
+          end
+        end
+
         private
 
         # fill gaps with unknown-runtime if given, average otherwise
@@ -250,7 +290,7 @@ module ParallelTests
         end
 
         def report_process_command?(options)
-          options[:verbose] || options[:verbose_process_command]
+          options[:verbose] || options[:verbose_command]
         end
       end
     end

data/lib/parallel_tests/version.rb

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

data/lib/parallel_tests.rb

@@ -76,7 +76,7 @@ module ParallelTests
     end
 
     def with_ruby_binary(command)
-      WINDOWS ? "#{RUBY_BINARY} -- #{command}" : command
+      WINDOWS ? [RUBY_BINARY, '--', command] : [command]
     end
 
     def wait_for_other_processes_to_finish

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel_tests
 version: !ruby/object:Gem::Version
-  version: 3.7.3
+  version: 4.2.1
 platform: ruby
 authors:
 - Michael Grosser
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-17 00:00:00.000000000 Z
+date: 2023-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -24,7 +24,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email: michael@grosser.it
 executables:
 - parallel_spinach
@@ -68,10 +68,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/grosser/parallel_tests/issues
-  documentation_uri: https://github.com/grosser/parallel_tests/blob/v3.7.3/Readme.md
-  source_code_uri: https://github.com/grosser/parallel_tests/tree/v3.7.3
+  documentation_uri: https://github.com/grosser/parallel_tests/blob/v4.2.1/Readme.md
+  source_code_uri: https://github.com/grosser/parallel_tests/tree/v4.2.1
   wiki_uri: https://github.com/grosser/parallel_tests/wiki
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -79,15 +79,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.16
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: Run Test::Unit / RSpec / Cucumber / Spinach in parallel
 test_files: []