parallel_tests 2.21.1 → 2.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 859dbc6f86dedda88f0eddc04d5f07e949e737ff
-  data.tar.gz: c62eacaa3c1d018957fd94d47d025df1e06e9d6d
+SHA256:
+  metadata.gz: f9f48375f06f2320fdda57c5c1340b8aedf1761541d4c802c5a17b6f21cbf858
+  data.tar.gz: 8e91a9f26aa2710aa023b6d779d7fdf0e768213262d75b7d9969751a3e825089
 SHA512:
-  metadata.gz: b306f589ad75ed0ac4ad636cbdda41f370ab58f036d1013536c997a2dc80fce8662e0ed83e157e7809b514ba2c149b88588af6c252d56531b84daaf775f14fc9
-  data.tar.gz: ebf66916a6ddb13e185013251f8e1f3a1b5a7be8d84d4815ad79e8adb336e2c6878cd036d4d2e9afa0e9e420cefecf99991f3e894a3b1fc01c14e343e2cd8d8f
+  metadata.gz: 6468e8bbb055db1eaee1a8512cb4226ceeb7acc2ba880d8be30117d863f8b870629088835d2628d28981e9b193a40239646d8a4de8e61467bd0bc48fae50e92e
+  data.tar.gz: 0dcd9f3aee1aead8329b76e770eb814ef62f465803629fe236d764b6a874eb827458b008aea240689ecadafa02388d49e71291d2c3cca5e74bc24d66137960ce

data/Readme.md

@@ -2,7 +2,7 @@
 
 [![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://ci.appveyor.com/api/projects/status/708b1up4pqc34x3y?svg=true)](https://ci.appveyor.com/project/grosser/parallel-tests)
+[![Build status](https://github.com/grosser/parallel_tests/workflows/windows/badge.svg)](https://github.com/grosser/parallel_tests/actions?query=workflow%3Awindows)
 
 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.
@@ -113,9 +113,9 @@ Rspec: Add to your `.rspec_parallel` (or `.rspec`) :
     --format progress
     --format ParallelTests::RSpec::RuntimeLogger --out tmp/parallel_runtime_rspec.log
 
-To use a custom logfile location (default: `tmp/parallel_runtime_spec.log`), use the CLI: `parallel_test spec -t rspec --runtime-log my.log`
+To use a custom logfile location (default: `tmp/parallel_runtime_rspec.log`), use the CLI: `parallel_test spec -t rspec --runtime-log my.log`
 
-### Test::Unit & Minitest 4/5
+### Minitest
 
 Add to your `test_helper.rb`:
 ```ruby
@@ -195,6 +195,7 @@ Options are:
 
     -n [PROCESSES]                   How many processes to use, default: available CPUs
     -p, --pattern [PATTERN]          run tests matching this regex pattern
+        --exclude-pattern [PATTERN]  exclude tests matching this regex pattern
         --group-by [TYPE]            group tests by:
           found - order of finding files
           steps - number of cucumber/spinach steps
@@ -223,7 +224,10 @@ Options are:
         --runtime-log [PATH]         Location of previously recorded test runtimes
         --allowed-missing            Allowed percentage of missing runtimes (default = 50)
         --unknown-runtime [FLOAT]    Use given number as unknown runtime (otherwise use average time)
-        --verbose                    Print more output
+        --verbose                    Print debug output
+        --verbose-process-command    Print the command that will be executed by each process before it begins
+        --verbose-rerun-command      After a process fails, print the command executed by that process
+        --quiet                      Print only test output
     -v, --version                    Show Version
     -h, --help                       Show this.
 
@@ -252,7 +256,8 @@ TIPS
  - Instantly see failures (instead of just a red F) with [rspec-instafail](https://github.com/grosser/rspec-instafail)
  - Use [rspec-retry](https://github.com/NoRedInk/rspec-retry) (not rspec-rerun) to rerun failed tests.
  - [JUnit formatter configuration](https://github.com/grosser/parallel_tests/wiki#with-rspec_junit_formatter----by-jgarber)
-
+ - Use [parallel_split_test](https://github.com/grosser/parallel_split_test) to run multiple scenarios in a single spec file, concurrently. (`parallel_tests` [works at the file-level and intends to stay that way](https://github.com/grosser/parallel_tests/issues/747#issuecomment-580216980))
+ 
 ### Cucumber
 
  - Add a `parallel: foo` profile to your `config/cucumber.yml` and it will be used to run parallel tests
@@ -262,14 +267,13 @@ TIPS
    - Builds a HTML report from JSON with support for debug msgs & embedded Base64 images.
 
 ### General
- - [SQL schema format] use :ruby schema format to get faster parallel:prepare`
  - [ZSH] use quotes to use rake arguments `rake "parallel:prepare[3]"`
  - [Memcached] use different namespaces<br/>
    e.g. `config.cache_store = ..., namespace: "test_#{ENV['TEST_ENV_NUMBER']}"`
  - Debug errors that only happen with multiple files using `--verbose` and [cleanser](https://github.com/grosser/cleanser)
  - `export PARALLEL_TEST_PROCESSORS=13` to override default processor count
  - Shell alias: `alias prspec='parallel_rspec -m 2 --'`
- - [Spring] to use spring you have to [patch it](https://github.com/grosser/parallel_tests/wiki/Spring)
+ - [Spring] Add the [spring-commands-parallel-tests](https://github.com/DocSpring/spring-commands-parallel-tests) gem to your `Gemfile` to get `parallel_tests` working with Spring.
  - `--first-is-1` will make the first environment be `1`, so you can test while running your full suite.<br/>
    `export PARALLEL_TEST_FIRST_IS_1=true` will provide the same result
  - [email_spec and/or action_mailer_cache_delivery](https://github.com/grosser/parallel_tests/wiki)
@@ -279,13 +283,7 @@ TIPS
  - [Sphinx setup](https://github.com/grosser/parallel_tests/wiki)
  - [Capistrano setup](https://github.com/grosser/parallel_tests/wiki/Remotely-with-capistrano) let your tests run on a big box instead of your laptop
 
-Contribute your own gotaches to the [Wiki](https://github.com/grosser/parallel_tests/wiki) or even better open a PR :)
-
-TODO
-====
- - fix tests vs cucumber >= 1.2 `unknown option --format`
- - add unit tests for cucumber runtime formatter
- - fix windows bugs / get windows CI green
+Contribute your own gotchas to the [Wiki](https://github.com/grosser/parallel_tests/wiki) or even better open a PR :)
 
 Authors
 ====
@@ -368,6 +366,14 @@ inspired by [pivotal labs](https://blog.pivotal.io/labs/labs/parallelize-your-rs
  - [Jerry](https://github.com/boblington)
  - [Aleksei Gusev](https://github.com/hron)
  - [Scott Olsen](https://github.com/scottolsen)
+ - [Andrei Botalov](https://github.com/abotalov)
+ - [Zachary Attas](https://github.com/snackattas)
+ - [David Rodríguez](https://github.com/deivid-rodriguez)
+ - [Justin Doody](https://github.com/justindoody)
+ - [Sandeep Singh](https://github.com/sandeepnagra)
+ - [Calaway](https://github.com/calaway)
+ - [alboyadjian](https://github.com/alboyadjian)
+ - [Nathan Broadbent](https://github.com/ndbroadbent)
 
 [Michael Grosser](http://grosser.it)<br/>
 michael@grosser.it<br/>

data/lib/parallel_tests/cli.rb

@@ -2,6 +2,7 @@ require 'optparse'
 require 'tempfile'
 require 'parallel_tests'
 require 'shellwords'
+require 'pathname'
 
 module ParallelTests
   class CLI
@@ -40,16 +41,12 @@ module ParallelTests
     def execute_in_parallel(items, num_processes, options)
       Tempfile.open 'parallel_tests-lock' do |lock|
         ParallelTests.with_pid_file do
-          progress_indicator = simulate_output_for_ci if options[:serialize_stdout]
-
-          Parallel.map(items, :in_threads => num_processes) do |item|
-            result = yield(item)
-            if progress_indicator && progress_indicator.alive?
-              progress_indicator.exit
-              puts
+          simulate_output_for_ci options[:serialize_stdout] do
+            Parallel.map(items, :in_threads => num_processes) do |item|
+              result = yield(item)
+              reprint_output(result, lock.path) if options[:serialize_stdout]
+              result
             end
-            reprint_output(result, lock.path) if options[:serialize_stdout]
-            result
           end
         end
       end
@@ -58,25 +55,31 @@ module ParallelTests
     def run_tests_in_parallel(num_processes, options)
       test_results = nil
 
-      report_time_taken do
+      run_tests_proc = -> {
         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].collect{|i| groups[i - 1]}.compact
-          report_number_of_tests(groups_to_run)
+          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)
+          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
         end
 
-        report_results(test_results, options)
+        report_results(test_results, options) unless options[:quiet]
+      }
+
+      if options[:quiet]
+        run_tests_proc.call
+      else
+        report_time_taken(&run_tests_proc)
       end
 
       abort final_fail_message if any_test_failed?(test_results)
@@ -92,6 +95,7 @@ module ParallelTests
 
     def reprint_output(result, lockfile)
       lock(lockfile) do
+        $stdout.puts
         $stdout.puts result[:stdout]
         $stdout.flush
       end
@@ -121,7 +125,7 @@ module ParallelTests
       failing_sets = test_results.reject { |r| r[:exit_status] == 0 }
       return if failing_sets.none?
 
-      if options[:verbose]
+      if options[:verbose] || options[:verbose_rerun_command]
         puts "\n\nTests have failed for a parallel_test group. Use the following command to run the group again:\n\n"
         failing_sets.each do |failing_set|
           command = failing_set[:command]
@@ -161,6 +165,7 @@ module ParallelTests
         BANNER
         opts.on("-n [PROCESSES]", Integer, "How many processes to use, default: available CPUs") { |n| options[:count] = n }
         opts.on("-p", "--pattern [PATTERN]", "run tests matching this regex pattern") { |pattern| options[:pattern] = /#{pattern}/ }
+        opts.on("--exclude-pattern", "--exclude-pattern [PATTERN]", "exclude tests matching this regex pattern") { |pattern| options[:exclude_pattern] = /#{pattern}/ }
         opts.on("--group-by [TYPE]", <<-TEXT.gsub(/^          /, '')
           group tests by:
                     found - order of finding files
@@ -215,11 +220,18 @@ module ParallelTests
         opts.on("--allowed-missing [INT]", Integer, "Allowed percentage of missing runtimes (default = 50)") { |percent| options[:allowed_missing_percent] = percent }
         opts.on("--unknown-runtime [FLOAT]", Float, "Use given number as unknown runtime (otherwise use average time)") { |time| options[:unknown_runtime] = time }
         opts.on("--first-is-1", "Use \"1\" as TEST_ENV_NUMBER to not reuse the default test environment") { options[:first_is_1] = true }
-        opts.on("--verbose", "Print more output") { options[:verbose] = 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("--quiet", "Print only tests output") { options[:quiet] = true }
         opts.on("-v", "--version", "Show Version") { puts ParallelTests::VERSION; exit }
         opts.on("-h", "--help", "Show this.") { puts opts; exit }
       end.parse!(argv)
 
+      if options[:verbose] && options[:quiet]
+        raise "Both options are mutually exclusive: verbose & quiet"
+      end
+
       if options[:count] == 0
         options.delete(:count)
         options[:non_parallel] = true
@@ -228,7 +240,7 @@ module ParallelTests
       files, remaining = extract_file_paths(argv)
       unless options[:execute]
         abort "Pass files or folders to run" unless files.any?
-        options[:files] = files
+        options[:files] = files.map { |file_path| Pathname.new(file_path).cleanpath.to_s }
       end
 
       append_test_options(options, remaining)
@@ -320,13 +332,20 @@ module ParallelTests
     end
 
     # CI systems often fail when there is no output for a long time, so simulate some output
-    def simulate_output_for_ci
-      Thread.new do
-        interval = ENV.fetch('PARALLEL_TEST_HEARTBEAT_INTERVAL', 60).to_f
-        loop do
-          sleep interval
-          print '.'
+    def simulate_output_for_ci(simulate)
+      if simulate
+        progress_indicator = Thread.new do
+          interval = Float(ENV.fetch('PARALLEL_TEST_HEARTBEAT_INTERVAL', 60))
+          loop do
+            sleep interval
+            print '.'
+          end
         end
+        test_results = yield
+        progress_indicator.exit
+        test_results
+      else
+        yield
       end
     end
   end

data/lib/parallel_tests/cucumber/scenario_line_logger.rb

@@ -1,3 +1,4 @@
+require 'cucumber/tag_expressions/parser'
 require 'cucumber/core/gherkin/tag_expression'
 
 module ParallelTests
@@ -12,7 +13,7 @@ module ParallelTests
         end
 
         def visit_feature_element(uri, feature_element, feature_tags, line_numbers: [])
-          scenario_tags = feature_element[:tags].map {|tag| ::Cucumber::Core::Ast::Tag.new(tag[:location], tag[:name])}
+          scenario_tags = feature_element[:tags].map { |tag| tag[:name] }
           scenario_tags = feature_tags + scenario_tags
           if feature_element[:examples].nil? # :Scenario
             test_line = feature_element[:location][:line]
@@ -25,7 +26,7 @@ module ParallelTests
             @scenarios << [uri, feature_element[:location][:line]].join(":")
           else # :ScenarioOutline
             feature_element[:examples].each do |example|
-              example_tags = example[:tags].map {|tag| ::Cucumber::Core::Ast::Tag.new(tag[:location], tag[:name])}
+              example_tags = example[:tags].map { |tag| tag[:name] }
               example_tags = scenario_tags + example_tags
               next unless @tag_expression.evaluate(example_tags)
               rows = example[:tableBody].select { |body| body[:type] == :TableRow }

data/lib/parallel_tests/cucumber/scenarios.rb

@@ -1,31 +1,38 @@
+require 'cucumber/tag_expressions/parser'
 require 'cucumber/core/gherkin/tag_expression'
 require 'cucumber/runtime'
 require 'cucumber'
 require 'parallel_tests/cucumber/scenario_line_logger'
 require 'parallel_tests/gherkin/listener'
 require 'gherkin/errors'
+require 'shellwords'
 
 module ParallelTests
   module Cucumber
     class Scenarios
       class << self
         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 = []
-          tags.concat options[:ignore_tag_pattern].to_s.split(/\s*,\s*/).map {|tag| "~#{tag}" }
-          tags.concat options[:test_options].to_s.scan(/(?:-t|--tags) (~?@[\w,~@]+)/).flatten
+          words = options[:test_options].to_s.shellsplit
+          words.each_with_index { |w,i| tags << words[i+1] if ["-t", "--tags"].include?(w) }
+          if ignore = options[:ignore_tag_pattern]
+            tags << "not (#{ignore})"
+          end
+          tags_exp = tags.compact.join(" and ")
 
-          split_into_scenarios files, tags.uniq
+          split_into_scenarios files, tags_exp
         end
 
         private
 
-        def split_into_scenarios(files, tags=[])
-
-          # Create the tag expression instance from gherkin, this is needed to know if the scenario matches with the tags invoked by the request
-          tag_expression = ::Cucumber::Core::Gherkin::TagExpression.new(tags)
+        def split_into_scenarios(files, tags='')
 
+          # Create the tag expression instance from cucumber tag expressions parser, this is needed to know if the scenario matches with the tags invoked by the request
           # Create the ScenarioLineLogger which will filter the scenario we want
-          scenario_line_logger = ParallelTests::Cucumber::Formatters::ScenarioLineLogger.new(tag_expression)
+          args = []
+          args << ::Cucumber::TagExpressions::Parser.new.parse(tags) unless tags.empty?
+          scenario_line_logger = ParallelTests::Cucumber::Formatters::ScenarioLineLogger.new(*args)
 
           # here we loop on the files map, each file will contain one or more scenario
           features ||= files.map do |path|
@@ -45,7 +52,7 @@ module ParallelTests
             begin
               # We make an attempt to parse the gherkin document, this could be failed if the document is not well formatted
               result = parser.parse(scanner)
-              feature_tags = result[:feature][:tags].map { |tag| ::Cucumber::Core::Ast::Tag.new(tag[:location], tag[:name]) }
+              feature_tags = result[:feature][:tags].map { |tag| tag[:name] }
 
               # We loop on each children of the feature
               result[:feature][:children].each do |feature_element|

data/lib/parallel_tests/gherkin/listener.rb

@@ -10,6 +10,7 @@ module ParallelTests
       def initialize
         @steps, @uris = [], []
         @collect = {}
+        @feature, @ignore_tag_pattern = nil
         reset_counters!
       end
 

data/lib/parallel_tests/gherkin/runtime_logger.rb

@@ -5,22 +5,22 @@ module ParallelTests
     class RuntimeLogger
       include Io
 
-      def initialize(step_mother, path_or_io, options)
-        @io = prepare_io(path_or_io)
+      def initialize(config)
+        @io = prepare_io(config.out_stream)
         @example_times = Hash.new(0)
-      end
 
-      def before_feature(_)
-        @start_at = ParallelTests.now.to_f
-      end
+        config.on_event :test_case_started do |_|
+          @start_at = ParallelTests.now.to_f
+        end
 
-      def after_feature(feature)
-        @example_times[feature.file] += ParallelTests.now.to_f - @start_at
-      end
+        config.on_event :test_case_finished do |event|
+          @example_times[event.test_case.feature.file] += ParallelTests.now.to_f - @start_at
+        end
 
-      def after_features(*args)
-        lock_output do
-          @io.puts @example_times.map { |file, time| "#{file}:#{time}" }
+        config.on_event :test_run_finished do |_|
+          lock_output do
+            @io.puts @example_times.map { |file, time| "#{file}:#{time}" }
+          end
         end
       end
     end

data/lib/parallel_tests/pids.rb

@@ -2,7 +2,7 @@ require 'json'
 
 module ParallelTests
   class Pids
-    attr_reader :pids, :file_path, :mutex
+    attr_reader :file_path, :mutex
 
     def initialize(file_path)
       @file_path = file_path

data/lib/parallel_tests/rspec/runner.rb

@@ -14,17 +14,14 @@ module ParallelTests
         end
 
         def determine_executable
-          cmd = case
+          case
           when File.exist?("bin/rspec")
             ParallelTests.with_ruby_binary("bin/rspec")
           when ParallelTests.bundler_enabled?
-            cmd = (run("bundle show rspec-core") =~ %r{Could not find gem.*} ? "spec" : "rspec")
-            "bundle exec #{cmd}"
+            "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

data/lib/parallel_tests/rspec/runtime_logger.rb

@@ -34,7 +34,6 @@ class ParallelTests::RSpec::RuntimeLogger < ParallelTests::RSpec::LoggerBase
 
   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
     lock_output do
       @example_times.each do |file, time|
         relative_path = file.sub(/^#{Regexp.escape Dir.pwd}\//,'').sub(/^\.\//, "")

data/lib/parallel_tests/tasks.rb

@@ -1,4 +1,5 @@
 require 'rake'
+require 'shellwords'
 
 module ParallelTests
   module Tasks
@@ -7,13 +8,27 @@ module ParallelTests
         ENV['RAILS_ENV'] || '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__), '..'))
+        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:test:purge') ? 'db:test:purge' : 'app:db:test:purge'
+          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?
         # Using the relative path to find the binary allow to run a specific version of it
         executable = File.expand_path("../../../bin/parallel_test", __FILE__)
@@ -59,10 +74,10 @@ 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]
@@ -71,8 +86,9 @@ module ParallelTests
         num_processes = count.to_i unless count.to_s.empty?
         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
@@ -81,78 +97,93 @@ end
 namespace :parallel do
   desc "Setup test databases via db:setup --> parallel:setup[num_cpus]"
   task :setup, :count do |_,args|
-    command = "rake db:setup RAILS_ENV=#{ParallelTests::Tasks.rails_env}"
+    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("rake db:create RAILS_ENV=#{ParallelTests::Tasks.rails_env}", 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 |_,args|
-    ParallelTests::Tasks.run_in_parallel("rake db:drop RAILS_ENV=#{ParallelTests::Tasks.rails_env} DISABLE_DATABASE_ENVIRONMENT_CHECK=1", 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 |_,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 = (ActiveRecord::Base.schema_format == :ruby ? "schema" : "structure")
+      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
+      # slow: dump and load in in serial
       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)
+      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 |_,args|
-    ParallelTests::Tasks.run_in_parallel("rake db:migrate RAILS_ENV=#{ParallelTests::Tasks.rails_env}", 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("rake db:rollback RAILS_ENV=#{ParallelTests::Tasks.rails_env}", 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 |_,args|
-    command = "rake #{ParallelTests::Tasks.purge_before_load} db:schema:load RAILS_ENV=#{ParallelTests::Tasks.rails_env} DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
+    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 |_,args|
-    ParallelTests::Tasks.run_in_parallel("rake #{ParallelTests::Tasks.purge_before_load} db:structure:load RAILS_ENV=#{ParallelTests::Tasks.rails_env} DISABLE_DATABASE_ENVIRONMENT_CHECK=1", 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 |_,args|
-    ParallelTests::Tasks.run_in_parallel("rake db:seed RAILS_ENV=#{ParallelTests::Tasks.rails_env}", 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, :count do |_, args|
-    ParallelTests::Tasks.run_in_parallel("RAILS_ENV=#{ParallelTests::Tasks.rails_env} rake #{args.command}", 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|
+    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',
@@ -166,10 +197,12 @@ namespace :parallel do
       # 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} " \
+      command = "#{ParallelTests.with_ruby_binary(Shellwords.escape(executable))} #{type} " \
+        "--type #{test_framework} "        \
         "-n #{count} "                     \
         "--pattern '#{pattern}' "          \
-        "--test-options '#{options}'"
+        "--test-options '#{options}' "     \
+        "#{pass_through}"
       abort unless system(command) # allow to chain tasks e.g. rake parallel:spec parallel:features
     end
   end

data/lib/parallel_tests/test/runner.rb

@@ -78,7 +78,7 @@ module ParallelTests
           cmd = "nice #{cmd}" if options[:nice]
           cmd = "#{cmd} 2>&1" if options[:combine_stderr]
 
-          puts cmd if options[:verbose]
+          puts cmd if report_process_command?(options) && !options[:serialize_stdout]
 
           execute_command_and_capture_output(env, cmd, options)
         end
@@ -94,6 +94,10 @@ module ParallelTests
           exitstatus = $?.exitstatus
           seed = output[/seed (\d+)/,1]
 
+          if report_process_command?(options) && options[:serialize_stdout]
+            output = [cmd, output].join("\n")
+          end
+
           {:stdout => output, :exit_status => exitstatus, :command => cmd, :seed => seed}
         end
 
@@ -173,7 +177,10 @@ module ParallelTests
           tests.sort!
           tests.map! do |test|
             allowed_missing -= 1 unless time = runtimes[test]
-            raise "Too little runtime info" if allowed_missing < 0
+            if allowed_missing < 0
+              log = options[:runtime_log] || runtime_log
+              raise "Runtime log file '#{log}' does not contain sufficient data to sort #{tests.size} test files, please update it."
+            end
             [test, time]
           end
 
@@ -181,11 +188,7 @@ module ParallelTests
             puts "Runtime found for #{tests.count(&:last)} of #{tests.size} tests"
           end
 
-          # fill gaps with unknown-runtime if given, average otherwise
-          known, unknown = tests.partition(&:last)
-          average = (known.any? ? known.map!(&:last).inject(:+) / known.size : 1)
-          unknown_runtime = options[:unknown_runtime] || average
-          unknown.each { |set| set[1] = unknown_runtime }
+          set_unknown_runtime tests, options
         end
 
         def runtimes(tests, options)
@@ -204,14 +207,20 @@ module ParallelTests
         end
 
         def find_tests(tests, options = {})
-          (tests || []).map do |file_or_folder|
+          suffix_pattern = options[:suffix] || test_suffix
+          include_pattern = options[:pattern] || //
+          exclude_pattern = options[:exclude_pattern]
+
+          (tests || []).flat_map do |file_or_folder|
             if File.directory?(file_or_folder)
               files = files_in_folder(file_or_folder, options)
-              files.grep(options[:suffix]||test_suffix).grep(options[:pattern]||//)
+              files = files.grep(suffix_pattern).grep(include_pattern)
+              files -= files.grep(exclude_pattern) if exclude_pattern
+              files
             else
               file_or_folder
             end
-          end.flatten.uniq
+          end.uniq
         end
 
         def files_in_folder(folder, options={})
@@ -224,6 +233,22 @@ module ParallelTests
           end
           Dir[File.join(folder, pattern)].uniq
         end
+
+        private
+
+        # fill gaps with unknown-runtime if given, average otherwise
+        # NOTE: an optimization could be doing runtime by average runtime per file size, but would need file checks
+        def set_unknown_runtime(tests, options)
+          known, unknown = tests.partition(&:last)
+          return if unknown.empty?
+          unknown_runtime = options[:unknown_runtime] ||
+            (known.empty? ? 1 : known.map!(&:last).inject(:+) / known.size) # average
+          unknown.each { |set| set[1] = unknown_runtime }
+        end
+
+        def report_process_command?(options)
+          options[:verbose] || options[:verbose_process_command]
+        end
       end
     end
   end

data/lib/parallel_tests/test/runtime_logger.rb

@@ -92,38 +92,4 @@ if defined?(Minitest::Runnable) # Minitest 5
       end
     end)
   end
-elsif defined?(MiniTest::Unit) # Minitest 4
-  MiniTest::Unit.class_eval do
-    alias_method :_run_suite_without_runtime_log, :_run_suite
-    def _run_suite(*args)
-      ParallelTests::Test::RuntimeLogger.log_test_run(args.first) do
-        _run_suite_without_runtime_log(*args)
-      end
-    end
-
-    alias_method :_run_suites_without_runtime_log, :_run_suites
-    def _run_suites(*args)
-      result = _run_suites_without_runtime_log(*args)
-      ParallelTests::Test::RuntimeLogger.unique_log
-      result
-    end
-  end
-else # Test::Unit
-  require 'test/unit/testsuite'
-  class ::Test::Unit::TestSuite
-    alias_method :run_without_timing, :run
-
-    def run(result, &block)
-      test = tests.first
-
-      if test.is_a? ::Test::Unit::TestSuite # all tests ?
-        run_without_timing(result, &block)
-        ParallelTests::Test::RuntimeLogger.unique_log
-      else
-        ParallelTests::Test::RuntimeLogger.log_test_run(test.class) do
-          run_without_timing(result, &block)
-        end
-      end
-    end
-  end
 end

data/lib/parallel_tests/version.rb

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

data/lib/parallel_tests.rb

@@ -88,13 +88,8 @@ module ParallelTests
       pids.count
     end
 
-    # real time even if someone messed with timecop in tests
     def now
-      if Time.respond_to?(:now_without_mock_time) # Timecop
-        Time.now_without_mock_time
-      else
-        Time.now
-      end
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
     def delta

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel_tests
 version: !ruby/object:Gem::Version
-  version: 2.21.1
+  version: 2.32.0
 platform: ruby
 authors:
 - Michael Grosser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-26 00:00:00.000000000 Z
+date: 2020-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -62,10 +62,14 @@ files:
 - lib/parallel_tests/test/runner.rb
 - lib/parallel_tests/test/runtime_logger.rb
 - lib/parallel_tests/version.rb
-homepage: http://github.com/grosser/parallel_tests
+homepage: https://github.com/grosser/parallel_tests
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/grosser/parallel_tests/issues
+  documentation_uri: https://github.com/grosser/parallel_tests/blob/v2.32.0/Readme.md
+  source_code_uri: https://github.com/grosser/parallel_tests/tree/v2.32.0
+  wiki_uri: https://github.com/grosser/parallel_tests/wiki
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -74,15 +78,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Run Test::Unit / RSpec / Cucumber / Spinach in parallel