parallel_tests 1.3.7 → 3.7.3

data/lib/parallel_tests/rspec/failures_logger.rb

@@ -1,54 +1,26 @@
+# frozen_string_literal: true
 require 'parallel_tests/rspec/logger_base'
 require 'parallel_tests/rspec/runner'
 
 class ParallelTests::RSpec::FailuresLogger < ParallelTests::RSpec::LoggerBase
-  if RSPEC_3
-    RSpec::Core::Formatters.register self, :dump_failures, :dump_summary
-  end
-
-  # RSpec 1: does not keep track of failures, so we do
-  def example_failed(example, *args)
-    if RSPEC_1
-      @failed_examples ||= []
-      @failed_examples << example
-    else
-      super
-    end
-  end
-
-  if RSPEC_1
-    def dump_failure(*args)
-    end
+  if RSPEC_2
+    def dump_failures(*args); end
   else
-    def dump_failures(*args)
-    end
+    RSpec::Core::Formatters.register self, :dump_summary
   end
 
   def dump_summary(*args)
     lock_output do
-      if RSPEC_1
-        dump_commands_to_rerun_failed_examples_rspec_1
-      elsif RSPEC_3
+      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
-      else
-        dump_commands_to_rerun_failed_examples
       end
     end
     @output.flush
   end
-
-  private
-
-  def dump_commands_to_rerun_failed_examples_rspec_1
-    (@failed_examples||[]).each do |example|
-      file, line = example.location.to_s.split(':')
-      next unless file and line
-      file.gsub!(%r(^.*?/spec/), './spec/')
-      @output.puts "#{ParallelTests::RSpec::Runner.send(:executable)} #{file}:#{line} # #{example.description}"
-    end
-  end
 end

data/lib/parallel_tests/rspec/logger_base.rb

@@ -1,47 +1,40 @@
+# frozen_string_literal: true
 module ParallelTests
   module RSpec
   end
 end
 
-begin
-  require 'rspec/core/formatters/base_text_formatter'
-  base = RSpec::Core::Formatters::BaseTextFormatter
-rescue LoadError
-  require 'spec/runner/formatter/base_text_formatter'
-  base = Spec::Runner::Formatter::BaseTextFormatter
-end
-
-ParallelTests::RSpec::LoggerBaseBase = base
+require 'rspec/core/formatters/base_text_formatter'
 
-class ParallelTests::RSpec::LoggerBase < ParallelTests::RSpec::LoggerBaseBase
-  RSPEC_1 = !defined?(RSpec::Core::Formatters::BaseTextFormatter) # do not test for Spec, this will trigger deprecation warning in rspec 2
-  RSPEC_3 = !RSPEC_1 && RSpec::Core::Version::STRING.start_with?('3')
+class ParallelTests::RSpec::LoggerBase < RSpec::Core::Formatters::BaseTextFormatter
+  RSPEC_2 = RSpec::Core::Version::STRING.start_with?('2')
 
   def initialize(*args)
     super
 
-    @output ||= args[1] || args[0] # rspec 1 has output as second argument
+    @output ||= args[0]
 
-    if String === @output # a path ?
+    case @output
+    when String # a path ?
       FileUtils.mkdir_p(File.dirname(@output))
-      File.open(@output, 'w'){} # overwrite previous results
+      File.open(@output, 'w') {} # overwrite previous results
       @output = File.open(@output, 'a')
-    elsif File === @output # close and restart in append mode
+    when File # close and restart in append mode
       @output.close
       @output = File.open(@output.path, 'a')
     end
   end
 
-  #stolen from Rspec
-  def close(*args)
-    @output.close  if (IO === @output) & (@output != $stdout)
+  # stolen from Rspec
+  def close(*)
+    @output.close if (IO === @output) & (@output != $stdout)
   end
 
   protected
 
   # do not let multiple processes get in each others way
   def lock_output
-    if File === @output
+    if @output.is_a?(File)
       begin
         @output.flock File::LOCK_EX
         yield

data/lib/parallel_tests/rspec/runner.rb

@@ -1,38 +1,33 @@
+# frozen_string_literal: true
 require "parallel_tests/test/runner"
 
 module ParallelTests
   module RSpec
     class Runner < ParallelTests::Test::Runner
       DEV_NULL = (WINDOWS ? "NUL" : "/dev/null")
-      NAME = 'RSpec'
-
       class << self
         def run_tests(test_files, process_number, num_processes, options)
           exe = executable # expensive, so we cache
-          version = (exe =~ /\brspec\b/ ? 2 : 1)
-          cmd = [exe, options[:test_options], (rspec_2_color if version == 2), spec_opts, *test_files].compact.join(" ")
-          options = options.merge(:env => rspec_1_color) if version == 1
+          cmd = [exe, options[:test_options], color, spec_opts, *test_files].compact.join(" ")
           execute_command(cmd, process_number, num_processes, options)
         end
 
         def determine_executable
-          cmd = case
-          when File.exist?("bin/rspec")
-            WINDOWS ? "ruby bin/rspec" : "bin/rspec"
-          when File.file?("script/spec")
-            "script/spec"
-          when ParallelTests.bundler_enabled?
-            cmd = (run("bundle show rspec-core") =~ %r{Could not find gem.*} ? "spec" : "rspec")
-            "bundle exec #{cmd}"
+          if File.exist?("bin/rspec")
+            ParallelTests.with_ruby_binary("bin/rspec")
+          elsif ParallelTests.bundler_enabled?
+            "bundle exec rspec"
           else
-            %w[spec rspec].detect{|cmd| system "#{cmd} --version > #{DEV_NULL} 2>&1" }
+            "rspec"
           end
-
-          cmd or raise("Can't find executables rspec or spec")
         end
 
         def runtime_log
-          'tmp/parallel_runtime_rspec.log'
+          "tmp/parallel_runtime_rspec.log"
+        end
+
+        def default_test_folder
+          "spec"
         end
 
         def test_file_name
@@ -43,6 +38,37 @@ module ParallelTests
           /_spec\.rb$/
         end
 
+        def line_is_result?(line)
+          line =~ /\d+ examples?, \d+ failures?/
+        end
+
+        # remove old seed and add new seed
+        # --seed 1234
+        # --order rand
+        # --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}"
+        end
+
+        # Summarize results from threads and colorize results based on failure and pending counts.
+        #
+        def summarize_results(results)
+          text = super
+          return text unless $stdout.tty?
+          sums = sum_up_results(results)
+          color =
+            if sums['failure'] > 0
+              31 # red
+            elsif sums['pending'] > 0
+              33 # yellow
+            else
+              32 # green
+            end
+          "\e[#{color}m#{text}\e[0m"
+        end
+
         private
 
         # so it can be stubbed....
@@ -50,20 +76,12 @@ module ParallelTests
           `#{cmd}`
         end
 
-        def rspec_1_color
-          if $stdout.tty?
-            {'RSPEC_COLOR' => "1"}
-          else
-            {}
-          end
-        end
-
-        def rspec_2_color
+        def color
           '--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) }
+          options_file = ['.rspec_parallel', 'spec/parallel_spec.opts', 'spec/spec.opts'].detect { |f| File.file?(f) }
           return unless options_file
           "-O #{options_file}"
         end

data/lib/parallel_tests/rspec/runtime_logger.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'parallel_tests'
 require 'parallel_tests/rspec/logger_base'
 
@@ -5,52 +6,39 @@ class ParallelTests::RSpec::RuntimeLogger < ParallelTests::RSpec::LoggerBase
   def initialize(*args)
     super
     @example_times = Hash.new(0)
-    @group_nesting = 0 unless RSPEC_1
+    @group_nesting = 0
   end
 
-  if RSPEC_3
-    RSpec::Core::Formatters.register self, :example_group_started, :example_group_finished, :start_dump
+  RSpec::Core::Formatters.register self, :example_group_started, :example_group_finished, :start_dump unless RSPEC_2
+
+  def example_group_started(example_group)
+    @time = ParallelTests.now if @group_nesting == 0
+    @group_nesting += 1
+    super
   end
 
-  if RSPEC_1
-    def example_started(*args)
-      @time = ParallelTests.now
-      super
+  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
     end
+    super if defined?(super)
+  end
 
-    def example_passed(example)
-      file = example.location.split(':').first
-      @example_times[file] += ParallelTests.now - @time
-      super
-    end
-  else
-    def example_group_started(example_group)
-      @time = ParallelTests.now if @group_nesting == 0
-      @group_nesting += 1
-      super
-    end
+  def dump_summary(*); end
 
-    def example_group_finished(notification)
-      @group_nesting -= 1
-      if @group_nesting == 0
-        path = (RSPEC_3 ? notification.group.file_path : notification.file_path)
-        @example_times[path] += ParallelTests.now - @time
-      end
-      super if defined?(super)
-    end
-  end
+  def dump_failures(*); end
+
+  def dump_failure(*); end
 
-  def dump_summary(*args);end
-  def dump_failures(*args);end
-  def dump_failure(*args);end
-  def dump_pending(*args);end
+  def dump_pending(*); end
 
-  def start_dump(*args)
-    return unless ENV['TEST_ENV_NUMBER'] #only record when running in parallel
-    # TODO: Figure out why sometimes time can be less than 0
+  def start_dump(*)
+    return unless ENV['TEST_ENV_NUMBER'] # only record when running in parallel
     lock_output do
       @example_times.each do |file, time|
-        relative_path = file.sub(/^#{Regexp.escape Dir.pwd}\//,'').sub(/^\.\//, "")
+        relative_path = file.sub(%r{^#{Regexp.escape Dir.pwd}/}, '').sub(%r{^\./}, "")
         @output.puts "#{relative_path}:#{time > 0 ? time : 0}"
       end
     end

data/lib/parallel_tests/rspec/summary_logger.rb

@@ -1,19 +1,11 @@
+# frozen_string_literal: true
 require 'parallel_tests/rspec/failures_logger'
 
 class ParallelTests::RSpec::SummaryLogger < ParallelTests::RSpec::LoggerBase
-  if RSPEC_3
-    RSpec::Core::Formatters.register self, :dump_failures
-  end
+  RSpec::Core::Formatters.register self, :dump_failures unless RSPEC_2
 
-  if RSPEC_1
-    def dump_failure(*args)
-      lock_output { super }
-      @output.flush
-    end
-  else
-    def dump_failures(*args)
-      lock_output { super }
-      @output.flush
-    end
+  def dump_failures(*args)
+    lock_output { super }
+    @output.flush
   end
 end

data/lib/parallel_tests/spinach/runner.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "parallel_tests/gherkin/runner"
 
 module ParallelTests
@@ -8,11 +9,14 @@ module ParallelTests
           'spinach'
         end
 
+        def default_test_folder
+          'features'
+        end
+
         def runtime_logging
-          #Not Yet Supported
+          # Not Yet Supported
           ""
         end
-
       end
     end
   end

data/lib/parallel_tests/tasks.rb

@@ -1,21 +1,45 @@
+# frozen_string_literal: true
 require 'rake'
+require 'shellwords'
 
 module ParallelTests
   module Tasks
     class << self
       def rails_env
-        ENV['RAILS_ENV'] || 'test'
+        'test'
       end
 
-      def run_in_parallel(cmd, options={})
+      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__), '..'))
+        require "parallel_tests"
+      end
+
+      def purge_before_load
+        if Gem::Version.new(Rails.version) > Gem::Version.new('4.2.0')
+          Rake::Task.task_defined?('db:purge') ? 'db:purge' : 'app:db:purge'
+        end
+      end
+
+      def run_in_parallel(cmd, options = {})
+        load_lib
         count = " -n #{options[:count]}" unless options[:count].to_s.empty?
-        executable = File.expand_path("../../../bin/parallel_test", __FILE__)
-        command = "#{executable} --exec '#{cmd}'#{count}#{' --non-parallel' if options[:non_parallel]}"
+        # 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)
       end
 
       # this is a crazy-complex solution for a very simple problem:
-      # removing certain lines from the output without chaning the exit-status
+      # removing certain lines from the output without changing the exit-status
       # normally I'd not do this, but it has been lots of fun and a great learning experience :)
       #
       # - sed does not support | without -r
@@ -28,17 +52,21 @@ module ParallelTests
       # - 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 = %Q{(grep -v "#{ignore_regex}" || test 1)}
+        remove_ignored_lines = %{(grep -v "#{ignore_regex}" || test 1)}
 
         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
-          %Q{/bin/bash -c '"'"'#{activate_pipefail} && (#{command}) | #{remove_ignored_lines}'"'"'}
+          %{/bin/bash -c '"'"'#{activate_pipefail} && (#{command}) | #{remove_ignored_lines}'"'"'}
         else
           command
         end
       end
 
+      def suppress_schema_load_output(command)
+        ParallelTests::Tasks.suppress_output(command, "^   ->\\|^-- ")
+      end
+
       def check_for_pending_migrations
         ["db:abort_if_pending_migrations", "app:db:abort_if_pending_migrations"].each do |abort_migrations|
           if Rake::Task.task_defined?(abort_migrations)
@@ -48,109 +76,147 @@ module ParallelTests
         end
       end
 
-      # parallel:spec[:count, :pattern, :options]
+      # parallel:spec[:count, :pattern, :options, :pass_through]
       def parse_args(args)
         # order as given by user
-        args = [args[:count], args[:pattern], args[:options]]
+        args = [args[:count], args[:pattern], args[:options], args[:pass_through]]
 
         # count given or empty ?
         # parallel:spec[2,models,options]
         # parallel:spec[,models,options]
         count = args.shift if args.first.to_s =~ /^\d*$/
-        num_processes = count.to_i unless count.to_s.empty?
+        num_processes = (count.to_s.empty? ? nil : Integer(count))
         pattern = args.shift
         options = args.shift
+        pass_through = args.shift
 
-        [num_processes, pattern.to_s, options.to_s]
+        [num_processes, pattern.to_s, options.to_s, pass_through.to_s]
       end
     end
   end
 end
 
 namespace :parallel do
-  desc "create test databases via db:create --> parallel:create[num_cpus]"
-  task :create, :count do |t,args|
-    ParallelTests::Tasks.run_in_parallel("rake db:create RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+  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}"
+    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
+    )
   end
 
-  desc "drop test databases via db:drop --> parallel:drop[num_cpus]"
-  task :drop, :count do |t,args|
-    ParallelTests::Tasks.run_in_parallel("rake db:drop RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+  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
+    )
   end
 
-  desc "update test databases by dumping and loading --> parallel:prepare[num_cpus]"
-  task(:prepare, [:count]) do |t,args|
+  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) && ActiveRecord::Base.schema_format == :ruby
-      # dump then load in parallel
-      Rake::Task['db:schema:dump'].invoke
-      Rake::Task['parallel:load_schema'].invoke(args[:count])
+    if defined?(ActiveRecord::Base) && [:ruby, :sql].include?(ActiveRecord::Base.schema_format)
+      # 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
+
+      Rake::Task["db:#{type}:dump"].invoke
+
+      # remove database connection to prevent "database is being accessed by other users"
+      ActiveRecord::Base.remove_connection if ActiveRecord::Base.configurations.any?
+
+      Rake::Task["parallel:load_#{type}"].invoke(args[:count])
     else
-      # there is no separate dump / load for schema_format :sql -> do it safe and slow
-      args = args.to_hash.merge(:non_parallel => true) # normal merge returns nil
-      taskname = Rake::Task.task_defined?('db:test:prepare') ? 'db:test:prepare' : 'app:db:test:prepare'
-      ParallelTests::Tasks.run_in_parallel("rake #{taskname}", args)
+      # 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)
+      next
     end
   end
 
   # when dumping/resetting takes too long
-  desc "update test databases via db:migrate --> parallel:migrate[num_cpus]"
-  task :migrate, :count do |t,args|
-    ParallelTests::Tasks.run_in_parallel("rake db:migrate RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+  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
+    )
+  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
+    )
   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 |t,args|
-    command = "rake db:schema:load RAILS_ENV=#{ParallelTests::Tasks.rails_env}"
-    ParallelTests::Tasks.run_in_parallel(ParallelTests::Tasks.suppress_output(command, "^   ->\\|^-- "), args)
+  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"
+    ParallelTests::Tasks.run_in_parallel(ParallelTests::Tasks.suppress_schema_load_output(command), args)
   end
 
   # load the structure from the structure.sql file
-  desc "load structure for test databases via db:structure:load --> parallel:load_structure[num_cpus]"
-  task :load_structure, :count do |t,args|
-    ParallelTests::Tasks.run_in_parallel("rake db:structure:load RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+  # (faster for rails < 6.1, deprecated after and only configured by `ActiveRecord::Base.schema_format`)
+  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
+    )
   end
 
-  desc "load the seed data from db/seeds.rb via db:seed --> parallel:seed[num_cpus]"
-  task :seed, :count do |t,args|
-    ParallelTests::Tasks.run_in_parallel("rake db:seed RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+  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
+    )
   end
 
-  desc "launch given rake command in parallel"
-  task :rake, :command do |t, args|
-    ParallelTests::Tasks.run_in_parallel("RAILS_ENV=#{ParallelTests::Tasks.rails_env} rake #{args.command}")
+  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
+    )
   end
 
   ['test', 'spec', 'features', 'features-spinach'].each do |type|
-    desc "run #{type} in parallel with parallel:#{type}[num_cpus]"
-    task type, [:count, :pattern, :options] do |t, args|
+    desc "Run #{type} in parallel with parallel:#{type}[num_cpus]"
+    task type, [:count, :pattern, :options, :pass_through] do |_t, args|
       ParallelTests::Tasks.check_for_pending_migrations
+      ParallelTests::Tasks.load_lib
 
-      $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..'))
-      require "parallel_tests"
-
-      count, pattern, options = ParallelTests::Tasks.parse_args(args)
+      count, pattern, options, pass_through = ParallelTests::Tasks.parse_args(args)
       test_framework = {
         'spec' => 'rspec',
         'test' => 'test',
         'features' => 'cucumber',
-        'features-spinach' => 'spinach',
+        'features-spinach' => 'spinach'
       }[type]
 
-      if test_framework == 'spinach'
-        type = 'features'
-      end
+      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 = "#{executable} #{type} --type #{test_framework} " \
+      command = "#{ParallelTests.with_ruby_binary(Shellwords.escape(executable))} #{type} " \
+        "--type #{test_framework} "        \
         "-n #{count} "                     \
         "--pattern '#{pattern}' "          \
-        "--test-options '#{options}'"
-      if ParallelTests::WINDOWS
-        ruby_binary = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
-        command = "#{ruby_binary} #{command}"
-      end
+        "--test-options '#{options}' "     \
+        "#{pass_through}"
       abort unless system(command) # allow to chain tasks e.g. rake parallel:spec parallel:features
     end
   end