parallel_tests 3.7.3 → 4.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 042cf590688332180e07fcf6472cc9b88b740276df0511677cf77f7fe649fa2e
-  data.tar.gz: cb4fd166b030e16574bf5d4790e5d1e0a3d57001d5474ab81c3d54613af976e2
+  metadata.gz: e432543f3ce9e19888f91f4a11e14b073305a7f3fa8fa69a31cd3db96606d187
+  data.tar.gz: 1c78c9c74dbbef031ca758d3bec296e4b5d74e7beb8108f604679a45899db070
 SHA512:
-  metadata.gz: 98e679733a74273ac77e71db47bc3af3f0f5a928dab351be9419644a0e7fe2bc004a81c929928ef0bd98ea2b8e5b63d1ab9fadcf75e22d098a65c5164343fe0b
-  data.tar.gz: 2ce2dd070733cd0bb61d0cb610f886a5590d5e267cc43613ab7d08fc251d989ebd4a58ad2f0a9c88478499fe55ff4cb7386fabc2eba8ee7fb3440d4899594654
+  metadata.gz: 95cf6bc8c16eca666478417a73d674b5707506c798f3418bbfee339c27de173b5284de9e53d4120ebb4be6ee559f0a042b64e515bde05e4d7e3f08ff568baf21
+  data.tar.gz: a02b65aa9fdd77cb9c42f6c1e96ecff0c84affa85b525dc273b020dafc73d3715b40a0b4b64059d6cbc69940a5c7e3604bb1c9f61ff243c416bfe0aaedec3dd4

data/Readme.md

@@ -1,11 +1,10 @@
 # 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&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
 ===============
@@ -34,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
@@ -78,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
@@ -107,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
 
@@ -129,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
@@ -148,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
@@ -161,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
 -----------------------
 
@@ -193,15 +225,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:
@@ -219,8 +251,9 @@ Options are:
     -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)
-        --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)
+        --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
@@ -229,7 +262,8 @@ 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]
+        --only-group INT[,INT]       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
@@ -246,12 +280,14 @@ Options are:
         --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)
+        --allow-duplicates           When detecting files to run, allow duplicates
         --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    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.
@@ -402,6 +438,12 @@ 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)
+ - [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

@@ -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
@@ -43,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
@@ -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, index|
+          run_tests(group, index, num_processes, options)
+        end
         report_results(test_results, options) unless options[:quiet]
       end
 
@@ -87,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
@@ -100,7 +110,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
@@ -140,9 +150,8 @@ module ParallelTests
         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
@@ -215,12 +224,19 @@ module ParallelTests
         opts.on(
           "--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]",
@@ -236,10 +252,17 @@ module ParallelTests
           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 INT[,INT]",
+          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']") { |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
@@ -250,7 +273,7 @@ module ParallelTests
           "--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}/ }
@@ -263,12 +286,14 @@ module ParallelTests
         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('--allow-duplicates', 'When detecting files to run, allow duplicates') { options[:allow_duplicates] = true }
         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 }
+        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
@@ -316,26 +341,30 @@ 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
 
     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 +374,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 +426,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

@@ -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
@@ -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)