parallel_tests 2.29.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68ba592f56ce42eab34cf1c1691bfde23de8ded652d9b171880bdadb1573a92e
-  data.tar.gz: f5438fa50a6e072b0074dc25724e9533912f120bc8d8537ccd76fd83e15988ec
+  metadata.gz: 0c8f92fb8fb19ff4348080358222c4984bcc5721ddd4779433ad4b8beead46a0
+  data.tar.gz: e3fb4beed5a5391401e8fcd729a5308c274ac2ddc61b3cd548e655a25009ba5d
 SHA512:
-  metadata.gz: bc8d70e18409b6dc5d67065e0854f9873c63c8097d64f8d81237e896a9878e614c1eed741a4f2235f85553af42745509d7d4b7f3a4c044b8f057aef1bcddd0d7
-  data.tar.gz: 4626db276c737f3daee5b37837bdee6466791ec440c267a6781eb1341d52db8afba19e56e2c8c212cbe58d994d47a88a53d534645313bd717a7e3f88878b5f7a
+  metadata.gz: bff5dfd53ba1acc4bb654d17f49d9d9deb1c86eff894232fc698dd3100fd2fbb7dd15ad11c1ebdc501438003ce62b2f65a7befcbc970e15d2b3e340f47ebf928
+  data.tar.gz: a5ded77e36a14a8bebea03777666e6de95f787edaf79dcf27b8d99d91c69b4779cb43e5ba5daf13f7940b2b262ad49eede907e8c9482749e30e2b272cf965245

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.
@@ -256,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
@@ -266,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)
@@ -373,6 +373,7 @@ inspired by [pivotal labs](https://blog.pivotal.io/labs/labs/parallelize-your-rs
  - [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
@@ -239,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)
@@ -315,9 +316,8 @@ module ParallelTests
     end
 
     def final_fail_message
-      fail_message = "#{@runner.name}s Failed"
+      fail_message = "Tests Failed"
       fail_message = "\e[31m#{fail_message}\e[0m" if use_colors?
-
       fail_message
     end
 

data/lib/parallel_tests/cucumber/features_with_steps.rb

@@ -0,0 +1,31 @@
+begin
+  gem "cuke_modeler", "~> 3.0"
+  require 'cuke_modeler'
+rescue LoadError
+  raise 'Grouping by number of cucumber steps requires the `cuke_modeler` modeler gem with requirement `~> 3.0`. Add `gem "cuke_modeler", "~> 3.0"` to your `Gemfile`, run `bundle install` and try again.'
+end
+
+module ParallelTests
+  module Cucumber
+    class FeaturesWithSteps
+      class << self
+        def all(tests, options)
+          ignore_tag_pattern = options[:ignore_tag_pattern].nil? ? nil : Regexp.compile(options[:ignore_tag_pattern])
+          # format of hash will be FILENAME => NUM_STEPS
+          steps_per_file = tests.each_with_object({}) do |file,steps|
+            feature = ::CukeModeler::FeatureFile.new(file).feature
+
+            # skip feature if it matches tag regex
+            next if feature.tags.grep(ignore_tag_pattern).any?
+
+            # count the number of steps in the file
+            # will only include a feature if the regex does not match
+            all_steps = feature.scenarios.map{|a| a.steps.count if a.tags.grep(ignore_tag_pattern).empty? }.compact
+            steps[file] = all_steps.inject(0,:+)
+          end
+          steps_per_file.sort_by { |_, value| -value }
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/cucumber/scenario_line_logger.rb

@@ -1,37 +1,33 @@
-require 'cucumber/tag_expressions/parser'
-require 'cucumber/core/gherkin/tag_expression'
-
 module ParallelTests
   module Cucumber
     module Formatters
       class ScenarioLineLogger
         attr_reader :scenarios
 
-        def initialize(tag_expression = ::Cucumber::Core::Gherkin::TagExpression.new([]))
+        def initialize(tag_expression = nil)
           @scenarios = []
           @tag_expression = tag_expression
         end
 
         def visit_feature_element(uri, feature_element, feature_tags, line_numbers: [])
-          scenario_tags = feature_element[:tags].map { |tag| 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]
+          if feature_element.is_a?(CukeModeler::Scenario) # :Scenario
+            test_line = feature_element.source_line
 
             # We don't accept the feature_element if the current tags are not valid
-            return unless @tag_expression.evaluate(scenario_tags)
+            return unless matches_tags?(scenario_tags)
             # or if it is not at the correct location
             return if line_numbers.any? && !line_numbers.include?(test_line)
 
-            @scenarios << [uri, feature_element[:location][:line]].join(":")
+            @scenarios << [uri, feature_element.source_line].join(":")
           else # :ScenarioOutline
-            feature_element[:examples].each do |example|
-              example_tags = example[:tags].map { |tag| tag[:name] }
+            feature_element.examples.each do |example|
+              example_tags = example.tags.map(&:name)
               example_tags = scenario_tags + example_tags
-              next unless @tag_expression.evaluate(example_tags)
-              rows = example[:tableBody].select { |body| body[:type] == :TableRow }
-              rows.each do |row|
-                test_line = row[:location][:line]
+              next unless matches_tags?(example_tags)
+              example.rows[1..-1].each do |row|
+                test_line = row.source_line
                 next if line_numbers.any? && !line_numbers.include?(test_line)
 
                 @scenarios << [uri, test_line].join(':')
@@ -42,6 +38,12 @@ module ParallelTests
 
         def method_missing(*args)
         end
+
+        private
+
+        def matches_tags?(tags)
+          @tag_expression.nil? || @tag_expression.evaluate(tags)
+        end
       end
     end
   end

data/lib/parallel_tests/cucumber/scenarios.rb

@@ -1,12 +1,17 @@
 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'
 
+begin
+  gem "cuke_modeler", "~> 3.0"
+  require 'cuke_modeler'
+rescue LoadError
+  raise 'Grouping by individual cucumber scenarios requires the `cuke_modeler` modeler gem with requirement `~> 3.0`.  Add `gem "cuke_modeler", "~> 3.0"` to your `Gemfile`, run `bundle install` and try again.'
+end
+
 module ParallelTests
   module Cucumber
     class Scenarios
@@ -40,32 +45,17 @@ module ParallelTests
             path, *test_lines = path.split(/:(?=\d+)/)
             test_lines.map!(&:to_i)
 
-            # We encode the file and get the content of it
-            source = ::Cucumber::Runtime::NormalisedEncodingFile.read(path)
             # We create a Gherkin document, this will be used to decode the details of each scenario
-            document = ::Cucumber::Core::Gherkin::Document.new(path, source)
-
-            # We create a parser for the gherkin document
-            parser  = ::Gherkin::Parser.new()
-            scanner = ::Gherkin::TokenScanner.new(document.body)
-
-            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| tag[:name] }
-
-              # We loop on each children of the feature
-              result[:feature][:children].each do |feature_element|
-                # If the type of the child is not a scenario or scenario outline, we continue, we are only interested by the name of the scenario here
-                next unless /Scenario/.match(feature_element[:type])
+            document = ::CukeModeler::FeatureFile.new(path)
+            feature = document.feature
 
-                # It's a scenario, we add it to the scenario_line_logger
-                scenario_line_logger.visit_feature_element(document.uri, feature_element, feature_tags, line_numbers: test_lines)
-              end
+            # We make an attempt to parse the gherkin document, this could be failed if the document is not well formatted
+            feature_tags = feature.tags.map(&:name)
 
-            rescue StandardError => e
-              # Exception if the document is no well formated or error in the tags
-              raise ::Cucumber::Core::Gherkin::ParseError.new("#{document.uri}: #{e.message}")
+            # We loop on each children of the feature
+            feature.tests.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
           end
 

data/lib/parallel_tests/gherkin/listener.rb

@@ -1,5 +1,3 @@
-require 'gherkin/parser'
-
 module ParallelTests
   module Gherkin
     class Listener

data/lib/parallel_tests/gherkin/runtime_logger.rb

@@ -14,7 +14,7 @@ module ParallelTests
         end
 
         config.on_event :test_case_finished do |event|
-          @example_times[event.test_case.feature.file] += ParallelTests.now.to_f - @start_at
+          @example_times[event.test_case.location.file] += ParallelTests.now.to_f - @start_at
         end
 
         config.on_event :test_run_finished do |_|

data/lib/parallel_tests/grouper.rb

@@ -2,7 +2,7 @@ module ParallelTests
   class Grouper
     class << self
       def by_steps(tests, num_groups, options)
-        features_with_steps = build_features_with_steps(tests, options)
+        features_with_steps = group_by_features_with_steps(tests, options)
         in_even_groups_by_size(features_with_steps, num_groups)
       end
 
@@ -41,23 +41,9 @@ module ParallelTests
         group[:size] += size
       end
 
-      def build_features_with_steps(tests, options)
-        require 'gherkin/parser'
-        ignore_tag_pattern = options[:ignore_tag_pattern].nil? ? nil : Regexp.compile(options[:ignore_tag_pattern])
-        parser = ::Gherkin::Parser.new
-        # format of hash will be FILENAME => NUM_STEPS
-        steps_per_file = tests.each_with_object({}) do |file,steps|
-          feature = parser.parse(File.read(file)).fetch(:feature)
-
-          # skip feature if it matches tag regex
-          next if feature[:tags].grep(ignore_tag_pattern).any?
-
-          # count the number of steps in the file
-          # will only include a feature if the regex does not match
-          all_steps = feature[:children].map{|a| a[:steps].count if a[:tags].grep(ignore_tag_pattern).empty? }.compact
-          steps[file] = all_steps.inject(0,:+)
-        end
-        steps_per_file.sort_by { |_, value| -value }
+      def group_by_features_with_steps(tests, options)
+        require 'parallel_tests/cucumber/features_with_steps'
+        ParallelTests::Cucumber::FeaturesWithSteps.all(tests, options)
       end
 
       def group_by_scenarios(tests, options={})

data/lib/parallel_tests/rspec/runner.rb

@@ -4,8 +4,6 @@ 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
@@ -14,17 +12,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/tasks.rb

@@ -8,6 +8,14 @@ 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"
@@ -89,67 +97,84 @@ 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|
@@ -172,7 +197,8 @@ 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}' "     \

data/lib/parallel_tests/test/runner.rb

@@ -3,15 +3,9 @@ require 'parallel_tests'
 module ParallelTests
   module Test
     class Runner
-      NAME = 'Test'
-
       class << self
         # --- usually overwritten by other runners
 
-        def name
-          NAME
-        end
-
         def runtime_log
           'tmp/parallel_runtime_test.log'
         end
@@ -188,11 +182,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)
@@ -240,6 +230,16 @@ module ParallelTests
 
         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

data/lib/parallel_tests/version.rb

@@ -1,3 +1,3 @@
 module ParallelTests
-  VERSION = Version = '2.29.2'
+  VERSION = Version = '3.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel_tests
 version: !ruby/object:Gem::Version
-  version: 2.29.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Michael Grosser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-06 00:00:00.000000000 Z
+date: 2020-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -42,6 +42,7 @@ files:
 - lib/parallel_tests.rb
 - lib/parallel_tests/cli.rb
 - lib/parallel_tests/cucumber/failures_logger.rb
+- lib/parallel_tests/cucumber/features_with_steps.rb
 - lib/parallel_tests/cucumber/runner.rb
 - lib/parallel_tests/cucumber/scenario_line_logger.rb
 - lib/parallel_tests/cucumber/scenarios.rb
@@ -62,10 +63,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/v3.0.0/Readme.md
+  source_code_uri: https://github.com/grosser/parallel_tests/tree/v3.0.0
+  wiki_uri: https://github.com/grosser/parallel_tests/wiki
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -74,14 +79,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.3
 signing_key: 
 specification_version: 4
 summary: Run Test::Unit / RSpec / Cucumber / Spinach in parallel