vinted-parallel_tests 0.13.3 → 1.7.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 14191ef3ae581ab27537c66e193d840bda6cd543
-  data.tar.gz: b8a86d1c3f2ca975d563c0c7531fe7871ac3a06c
+  metadata.gz: c24065e6ecc117e7e693090d95bf2233b28bb83b
+  data.tar.gz: 959293ff1bc3211d8ef3f302f79e82313a1f8f50
 SHA512:
-  metadata.gz: fdcf4a6e6456c7c142ab7fe45ceb751886f6d124585f6a3e1cc8d46dcf09d418ef30c4b5ed6c3426a55b8f901921c3518198ba7ce57ab547e806cb73ca59cce5
-  data.tar.gz: fc9842768d2028f2943e43d905028b2bf0f692682265eae17c0c9ff3ac080073454f8a9cfd7826518e1084c85f277f570a479f8d0da9261645609bc0a5184e35
+  metadata.gz: b9a7b68b7a4c0ee89c2d6b3ad829a19eda204d383b5322131af6cdc46c4befb8836719bf2711b80445b9832283570707057eaf856285f2fe655534cae32dfc74
+  data.tar.gz: 58642970a41d300b6de94a702ef7891a6151e50f6439501133fb93fe3185f2af587c946e030eef4161347b910e953b65b452e3317d38b7b1a472e062ca5202e4

data/Readme.md

@@ -1,36 +1,28 @@
-Speedup Test::Unit + RSpec + Cucumber by running parallel on multiple CPUs (or cores).<br/>
-ParallelTests splits tests into even groups(by number of tests or runtime) and runs each group in a single process with its own database.
+# parallel_tests
 
-[upgrading from 0.6 ?](https://github.com/grosser/parallel_tests/wiki/Upgrading-0.6.x-to-0.7.x)
+[![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)
+
+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.
 
 Setup for Rails
 ===============
 [RailsCasts episode #413 Fast Tests](http://railscasts.com/episodes/413-fast-tests)
-[still using Rails 2?](https://github.com/grosser/parallel_tests/blob/master/ReadmeRails2.md)
 
 ### Install
-If you use RSpec: ensure you got >= 2.4
-
-As gem
-
-```ruby
-# add to Gemfile
-gem "parallel_tests", :group => :development
-```
-OR as plugin
-
-    rails plugin install git://github.com/grosser/parallel_tests.git
 
 ```ruby
-# add to Gemfile
-gem "parallel", :group => :development
+# Gemfile
+gem "parallel_tests", group: :development
 ```
 
 ### Add to `config/database.yml`
+
 ParallelTests uses 1 database per test-process.
 <table>
   <tr><td>Process number</td><td>1</td><td>2</td><td>3</td></tr>
-  <tr><td>`ENV['TEST_ENV_NUMBER']`</td><td>''</td><td>'2'</td><td>'3'</td></tr>
+  <tr><td>ENV['TEST_ENV_NUMBER']</td><td>''</td><td>'2'</td><td>'3'</td></tr>
 </table>
 
 ```yaml
@@ -48,6 +40,7 @@ test:
     rake parallel:test          # Test::Unit
     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    --> got 2 CPUs? --> 47 seconds
@@ -97,37 +90,44 @@ end
 Loggers
 ===================
 
-Even process runtimes
------------------
+Even test group run-times
+-------------------------
+
+### RSpec
 
-Log test runtime to give each process the same runtime.
+Add the `RuntimeLogger` to log how long each test takes to run.
+This log file will be loaded on the next test run, and the tests will be grouped
+so that each process should finish around the same time.
 
 Rspec: Add to your `.rspec_parallel` (or `.rspec`) :
 
-    If installed as plugin: -I vendor/plugins/parallel_tests/lib
     --format progress
     --format ParallelTests::RSpec::RuntimeLogger --out tmp/parallel_runtime_rspec.log
 
-Test::Unit:  Add to your `test_helper.rb`:
+### Test::Unit & Minitest 4/5
+
+Add to your `test_helper.rb`:
 ```ruby
-require 'parallel_tests/test/runtime_logger'
+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,
+so it is not always required or overwritten.
+
 RSpec: SummaryLogger
 --------------------
 
-This logger logs the test output without the different processes overwriting each other.
+Log the test output without the different processes overwriting each other.
 
 Add the following to your `.rspec_parallel` (or `.rspec`) :
 
-    If installed as plugin: -I vendor/plugins/parallel_tests/lib
     --format progress
     --format ParallelTests::RSpec::SummaryLogger --out tmp/spec_summary.log
 
 RSpec: FailuresLogger
 -----------------------
 
-This logger produces pasteable command-line snippets for each failed example.
+Produce pasteable command-line snippets for each failed example.
 
 E.g.
 
@@ -135,14 +135,13 @@ E.g.
 
 Add the following to your `.rspec_parallel` (or `.rspec`) :
 
-    If installed as plugin: -I vendor/plugins/parallel_tests/lib
     --format progress
     --format ParallelTests::RSpec::FailuresLogger --out tmp/failing_specs.log
 
 Cucumber: FailuresLogger
 -----------------------
 
-This logger logs failed cucumber scenarios to the specified file. The filename can be passed to cucumber, prefixed with '@' to rerun failures.
+Log failed cucumber scenarios to the specified file. The filename can be passed to cucumber, prefixed with '@' to rerun failures.
 
 Usage:
 
@@ -152,47 +151,65 @@ Or add the formatter to the `parallel:` profile of your `cucumber.yml`:
 
     parallel: --format progress --format ParallelTests::Cucumber::FailuresLogger --out tmp/cucumber_failures.log
 
+Note if your `cucumber.yml` default profile uses `<%= std_opts %>` you may need to insert this as follows `parallel: <%= std_opts %> --format progress...`
 
 To rerun failures:
 
-	cucumber @tmp/cucumber_failures.log
+    cucumber @tmp/cucumber_failures.log
 
 Setup for non-rails
 ===================
+
     gem install parallel_tests
     # go to your project dir
     parallel_test test/
     parallel_rspec spec/
     parallel_cucumber features/
+    parallel_spinach features/
 
- - use ENV['TEST_ENV_NUMBER'] inside your tests to select separate db/memcache/etc.
+ - use `ENV['TEST_ENV_NUMBER']` inside your tests to select separate db/memcache/etc.
  - Only run selected files & folders:
 
-    parallel_test test/bar test/baz/foo_text.rb
+    `parallel_test test/bar test/baz/foo_text.rb`
+
+ - Pass test-options and files via `--`:
+
+    `parallel_test -- -t acceptance -f progress -- spec/foo_spec.rb spec/acceptance`
 
 Options are:
+<!-- copy output from bundle exec ./bin/parallel_test -h -->
 
     -n [PROCESSES]                   How many processes to use, default: available CPUs
     -p, --pattern [PATTERN]          run tests matching this pattern
         --group-by [TYPE]            group tests by:
           found - order of finding files
-          steps - number of cucumber steps
-          default - runtime or filesize
+          steps - number of cucumber/spinach steps
+          scenarios - individual cucumber scenarios
+          filesize - by size of the file
+          runtime - info from runtime log
+          default - runtime when runtime log is filled otherwise filesize
     -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)
-    -e, --exec [COMMAND]             execute this code parallel and with ENV['TEST_ENV_NUM']
+        --only-group INT[, INT]
+    -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
+    -t, --type [TYPE]                test(default) / rspec / cucumber / spinach
+        --suffix [PATTERN]           override built in test file pattern (should match suffix):
+          '_spec.rb$' - matches rspec files
+          '_(test|spec).rb$' - matches test or spec files
         --serialize-stdout           Serialize stdout output, nothing will be written until everything is done
+        --combine-stderr             Combine stderr into stdout, useful in conjunction with --serialize-stdout
         --non-parallel               execute same commands but do not in parallel, needs --exec
         --no-symlinks                Do not traverse symbolic links to find test files
         --ignore-tags [PATTERN]      When counting steps ignore scenarios with tags that match this pattern
         --nice                       execute test commands with low priority.
+        --runtime-log [PATH]         Location of previously recorded test runtimes
+        --verbose                    Print more output
     -v, --version                    Show Version
     -h, --help                       Show this.
 
-You can run any kind of code in parallel with -e / --execute
+You can run any kind of code in parallel with -e / --exec
 
     parallel_test -n 5 -e 'ruby -e "puts %[hello from process #{ENV[:TEST_ENV_NUMBER.to_s].inspect}]"'
     hello from process "2"
@@ -210,11 +227,10 @@ You can run any kind of code in parallel with -e / --execute
 TIPS
 ====
  - [RSpec] add a `.rspec_parallel` to use different options, e.g. **no --drb**
- - [RSpec] delete `script/spec`
- - [[Spork](https://github.com/sporkrb/spork)] does not work with parallel_tests
- - [RSpec] remove --loadby from you spec/*.opts
+ - Spring does not work with parallel_tests, use `DISABLE_SPRING=1 rake parallel:spec` if you have spring hardcoded in your binaries
+ - [RSpec] remove `--loadby` from `.rspec`
  - [RSpec] Instantly see failures (instead of just a red F) with [rspec-instafail](https://github.com/grosser/rspec-instafail)
- - [Bundler] if you have a `Gemfile` then `bundle exec` will be used to run tests
+ - [RSpec] use [rspec-retry](https://github.com/NoRedInk/rspec-retry) (not rspec-rerun) to rerun failed tests.
  - [Cucumber] add a `parallel: foo` profile to your `config/cucumber.yml` and it will be used to run parallel tests
  - [Capybara setup](https://github.com/grosser/parallel_tests/wiki)
  - [Sphinx setup](https://github.com/grosser/parallel_tests/wiki)
@@ -223,13 +239,16 @@ TIPS
  - `export PARALLEL_TEST_PROCESSORS=X` in your environment and parallel_tests will use this number of processors by default
  - [ZSH] use quotes to use rake arguments `rake "parallel:prepare[3]"`
  - [email_spec and/or action_mailer_cache_delivery](https://github.com/grosser/parallel_tests/wiki)
- - [Memcached] use different namespaces e.g. `config.cache_store = ..., :namespace => "test_#{ENV['TEST_ENV_NUMBER']}"`
+ - [Memcached] use different namespaces e.g. `config.cache_store = ..., namespace: "test_#{ENV['TEST_ENV_NUMBER']}"`
+ - [zeus-parallel_tests](https://github.com/sevos/zeus-parallel_tests)
+ - [Distributed parallel test (e.g. Travis Support)](https://github.com/grosser/parallel_tests/wiki/Distributed-Parallel-Tests-and-Travis-Support)
+ - Debug errors that only happen with multiple files using `--verbose` and [cleanser](https://github.com/grosser/cleanser)
+ - Shell alias: `alias prspec='parallel_rspec -m 2 --'`
+ - Contribute your own gotaches to the [Wiki](https://github.com/grosser/parallel_tests/wiki) or even better open a PR :)
 
 TODO
 ====
- - make tests consistently pass with `--order random` in .rspec
  - fix tests vs cucumber >= 1.2 `unknown option --format`
- - add integration tests for the rake tasks, maybe generate a rails project ...
  - add unit tests for cucumber runtime formatter
  - make windows compatible
 
@@ -237,7 +256,7 @@ Authors
 ====
 inspired by [pivotal labs](http://pivotallabs.com/users/miked/blog/articles/849-parallelize-your-rspec-suite)
 
-### [Contributors](http://github.com/grosser/parallel_tests/contributors)
+### [Contributors](https://github.com/grosser/parallel_tests/contributors)
  - [Charles Finkel](http://charlesfinkel.com/)
  - [Indrek Juhkam](http://urgas.eu)
  - [Jason Morrison](http://jayunit.net)
@@ -286,8 +305,28 @@ inspired by [pivotal labs](http://pivotallabs.com/users/miked/blog/articles/849-
  - [Iain Beeston](https://github.com/iainbeeston)
  - [Alejandro Pulver](https://github.com/alepulver)
  - [Felix Clack](https://github.com/felixclack)
+ - [Izaak Alpert](https://github.com/karlhungus)
+ - [Micah Geisel](https://github.com/botandrose)
+ - [Exoth](https://github.com/Exoth)
+ - [sidfarkus](https://github.com/sidfarkus)
+ - [Colin Harris](https://github.com/aberant)
+ - [Wataru MIYAGUNI](https://github.com/gongo)
+ - [Brandon Turner](https://github.com/blt04)
+ - [Matt Hodgson](https://github.com/mhodgson)
+ - [bicarbon8](https://github.com/bicarbon8)
+ - [seichner](https://github.com/seichner)
+ - [Matt Southerden](https://github.com/mattsoutherden)
+ - [Stanislaw Wozniak](https://github.com/sponte)
+ - [Dmitry Polushkin](https://github.com/dmitry)
+ - [Samer Masry](https://github.com/smasry)
+ - [Volodymyr Mykhailyk](https:/github.com/volodymyr-mykhailyk)
+ - [Mike Mueller](https://github.com/mmueller)
+ - [Aaron Jensen](https://github.com/aaronjensen)
+ - [Ed Slocomb](https://github.com/edslocomb)
+ - [Cezary Baginski](https://github.com/e2)
+ - [Marius Ioana](https://github.com/mariusioana)
+
 
 [Michael Grosser](http://grosser.it)<br/>
 michael@grosser.it<br/>
-License: MIT<br/>
-[![Build Status](https://travis-ci.org/grosser/parallel_tests.png)](https://travis-ci.org/grosser/parallel_tests)
+License: MIT

data/bin/parallel_cucumber

@@ -1,5 +1,9 @@
 #!/usr/bin/env ruby
-$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+
+# enable local usage from cloned repo
+root = File.expand_path("../..", __FILE__)
+$LOAD_PATH << "#{root}/lib" if File.exist?("#{root}/Gemfile")
+
 require "parallel_tests"
 
 ParallelTests::CLI.new.run(["--type", "cucumber"] + ARGV)

data/bin/parallel_rspec

@@ -1,5 +1,9 @@
 #!/usr/bin/env ruby
-$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+
+# enable local usage from cloned repo
+root = File.expand_path("../..", __FILE__)
+$LOAD_PATH << "#{root}/lib" if File.exist?("#{root}/Gemfile")
+
 require "parallel_tests"
 
 ParallelTests::CLI.new.run(["--type", "rspec"] + ARGV)

data/bin/parallel_spinach

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+# enable local usage from cloned repo
+root = File.expand_path("../..", __FILE__)
+$LOAD_PATH << "#{root}/lib" if File.exist?("#{root}/Gemfile")
+
+require "parallel_tests"
+
+ParallelTests::CLI.new.run(["--type", "spinach"] + ARGV)

data/bin/parallel_test

@@ -1,5 +1,9 @@
 #!/usr/bin/env ruby
-$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+
+# enable local usage from cloned repo
+root = File.expand_path("../..", __FILE__)
+$LOAD_PATH << "#{root}/lib" if File.exist?("#{root}/Gemfile")
+
 require "parallel_tests"
 
 ParallelTests::CLI.new.run(["--type", "test"] + ARGV)

data/lib/parallel_tests.rb

@@ -1,8 +1,15 @@
 require "parallel"
 require "parallel_tests/railtie" if defined? Rails::Railtie
+require "rbconfig"
 
 module ParallelTests
-  GREP_PROCESSES_COMMAND = "ps -ef | grep [T]EST_ENV_NUMBER= 2>&1"
+  WINDOWS = (RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/)
+  GREP_PROCESSES_COMMAND = \
+  if WINDOWS
+    "wmic process get commandline | findstr TEST_ENV_NUMBER | find /c \"TEST_ENV_NUMBER=\" 2>&1"
+  else
+    "ps -ef | grep [T]EST_ENV_NUMBER= 2>&1"
+  end
 
   autoload :CLI, "parallel_tests/cli"
   autoload :VERSION, "parallel_tests/version"
@@ -26,7 +33,7 @@ module ParallelTests
 
       until !File.directory?(current) || current == previous
         filename = File.join(current, "Gemfile")
-        return true if File.exists?(filename)
+        return true if File.exist?(filename)
         current, previous = File.expand_path("..", current), current
       end
 
@@ -57,5 +64,11 @@ module ParallelTests
         Time.now
       end
     end
+
+    def delta
+      before = now.to_f
+      yield
+      now.to_f - before
+    end
   end
 end

data/lib/parallel_tests/cli.rb

@@ -1,6 +1,7 @@
 require 'optparse'
 require 'tempfile'
 require 'parallel_tests'
+require 'shellwords'
 
 module ParallelTests
   class CLI
@@ -23,7 +24,7 @@ module ParallelTests
       Tempfile.open 'parallel_tests-lock' do |lock|
         return Parallel.map(items, :in_threads => num_processes) do |item|
           result = yield(item)
-          report_output(result, lock) if options[:serialize_stdout]
+          reprint_output(result, lock.path) if options[:serialize_stdout]
           result
         end
       end
@@ -34,10 +35,20 @@ module ParallelTests
 
       report_time_taken do
         groups = @runner.tests_in_groups(options[:files], num_processes, options)
-        report_number_of_tests(groups)
+        groups.reject! &:empty?
 
-        test_results = execute_in_parallel(groups, groups.size, options) do |group|
-          run_tests(group, groups.index(group), num_processes, options)
+        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)
+          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)
+
+          execute_in_parallel(groups, groups.size, options) do |group|
+            run_tests(group, groups.index(group), num_processes, options)
+          end
         end
 
         report_results(test_results)
@@ -54,12 +65,23 @@ module ParallelTests
       end
     end
 
-    def report_output(result, lock)
-      lock.flock File::LOCK_EX
-      $stdout.puts result[:stdout]
-      $stdout.flush
-    ensure
-      lock.flock File::LOCK_UN
+    def reprint_output(result, lockfile)
+      lock(lockfile) do
+        $stdout.puts result[:stdout]
+        $stdout.flush
+      end
+    end
+
+    def lock(lockfile)
+      File.open(lockfile) do |lock|
+        begin
+          lock.flock File::LOCK_EX
+          yield
+        ensure
+          # This shouldn't be necessary, but appears to be
+          lock.flock File::LOCK_UN
+        end
+      end
     end
 
     def report_results(test_results)
@@ -71,8 +93,9 @@ module ParallelTests
     def report_number_of_tests(groups)
       name = @runner.test_file_name
       num_processes = groups.size
-      num_tests = groups.map(&:size).inject(:+)
-      puts "#{num_processes} processes for #{num_tests} #{name}s, ~ #{num_tests / groups.size} #{name}s per process"
+      num_tests = groups.map(&:size).inject(0, :+)
+      tests_per_process = (num_processes == 0 ? 0 : num_tests / num_processes)
+      puts "#{num_processes} processes for #{num_tests} #{name}s, ~ #{tests_per_process} #{name}s per process"
     end
 
     #exit with correct status code so rake parallel:test && echo 123 works
@@ -83,23 +106,29 @@ module ParallelTests
     def parse_options!(argv)
       options = {}
       OptionParser.new do |opts|
-        opts.banner = <<BANNER
-Run all tests in parallel, giving each process ENV['TEST_ENV_NUMBER'] ('', '2', '3', ...)
+        opts.banner = <<-BANNER.gsub(/^          /, '')
+          Run all tests in parallel, giving each process ENV['TEST_ENV_NUMBER'] ('', '2', '3', ...)
+
+          [optional] Only selected files & folders:
+            parallel_test test/bar test/baz/xxx_text.rb
 
-[optional] Only run selected files & folders:
-    parallel_test test/bar test/baz/xxx_text.rb
+          [optional] Pass test-options and files via `--`:
+            parallel_test -- -t acceptance -f progress -- spec/foo_spec.rb spec/acceptance
 
-Options are:
-BANNER
+          Options are:
+        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 pattern") { |pattern| options[:pattern] = /#{pattern}/ }
-        opts.on("--group-by [TYPE]", <<-TEXT
-group tests by:
-          found - order of finding files
-          steps - number of cucumber steps
-          default - runtime or filesize
-TEXT
-) { |type| options[:group_by] = type.to_sym }
+        opts.on("--group-by [TYPE]", <<-TEXT.gsub(/^          /, '')
+          group tests by:
+                    found - order of finding files
+                    steps - number of cucumber/spinach steps
+                    scenarios - individual cucumber scenarios
+                    filesize - by size of the file
+                    runtime - info from runtime log
+                    default - runtime when runtime log is filled otherwise filesize
+          TEXT
+          ) { |type| options[:group_by] = type.to_sym }
         opts.on("-m [FLOAT]", "--multiply-processes [FLOAT]", Float, "use given number as a multiplier of processes to run") { |multiply| options[:multiply] = multiply }
 
         opts.on("-s [PATTERN]", "--single [PATTERN]",
@@ -115,9 +144,11 @@ TEXT
           options[:isolate] = true
         end
 
-        opts.on("-e", "--exec [COMMAND]", "execute this code parallel and with ENV['TEST_ENV_NUM']") { |path| options[:execute] = path }
-        opts.on("-o", "--test-options '[OPTIONS]'", "execute test commands with those options") { |arg| options[:test_options] = arg }
-        opts.on("-t", "--type [TYPE]", "test(default) / rspec / cucumber") do |type|
+        opts.on("--only-group INT[, INT]", Array) { |groups| options[:only_group] = groups.map(&:to_i) }
+
+        opts.on("-e", "--exec [COMMAND]", "execute this code parallel and with ENV['TEST_ENV_NUMBER']") { |path| options[:execute] = path }
+        opts.on("-o", "--test-options '[OPTIONS]'", "execute test commands with those options") { |arg| options[:test_options] = arg.lstrip }
+        opts.on("-t", "--type [TYPE]", "test(default) / rspec / cucumber / spinach") do |type|
           begin
             @runner = load_runner(type)
           rescue NameError, LoadError => e
@@ -125,30 +156,73 @@ TEXT
             abort
           end
         end
+        opts.on("--suffix [PATTERN]", <<-TEXT.gsub(/^          /, '')
+          override built in test file pattern (should match suffix):
+                    '_spec\.rb$' - matches rspec files
+                    '_(test|spec).rb$' - matches test or spec files
+          TEXT
+          ) { |pattern| options[:suffix] = /#{pattern}/ }
         opts.on("--serialize-stdout", "Serialize stdout output, nothing will be written until everything is done") { options[:serialize_stdout] = true }
+        opts.on("--combine-stderr", "Combine stderr into stdout, useful in conjunction with --serialize-stdout") { options[:combine_stderr] = true }
         opts.on("--non-parallel", "execute same commands but do not in parallel, needs --exec") { options[:non_parallel] = true }
         opts.on("--no-symlinks", "Do not traverse symbolic links to find test files") { options[:symlinks] = false }
         opts.on("--advance-number [NUMBER]", Integer, "Advance test env number by specified number") { |n| options[:advance_number] = n }
         opts.on('--ignore-tags [PATTERN]', 'When counting steps ignore scenarios with tags that match this pattern')  { |arg| options[:ignore_tag_pattern] = arg }
         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("--unknown-runtime [FLOAT]", "Use given number as unknown runtime (otherwise use average time)") { |time| options[:unknown_runtime] = time.to_f }
+        opts.on("--verbose", "Print more output") { options[:verbose] = true }
         opts.on("-v", "--version", "Show Version") { puts ParallelTests::VERSION; exit }
         opts.on("-h", "--help", "Show this.") { puts opts; exit }
       end.parse!(argv)
 
-      raise "--group-by found and --single-process are not supported" if options[:group_by] == :found and options[:single_process]
-
       if options[:count] == 0
         options.delete(:count)
         options[:non_parallel] = true
       end
 
-      options[:files] = argv
+      files, remaining = extract_file_paths(argv)
+      unless options[:execute]
+        abort "Pass files or folders to run" unless files.any?
+        options[:files] = files
+      end
+
+      append_test_options(options, remaining)
+
+      options[:group_by] ||= :filesize if options[:only_group]
+
+      raise "--group-by found and --single-process are not supported" if options[:group_by] == :found and options[:single_process]
+      allowed = [:filesize, :runtime, :found]
+      if !allowed.include?(options[:group_by]) && options[:only_group]
+        raise "--group-by #{allowed.join(" or ")} is required for --only-group"
+      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)]]
+    end
+
+    def extract_test_options(argv)
+      dash_index = argv.index("--") || -1
+      argv[dash_index+1..-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(' ')
+    end
+
     def load_runner(type)
       require "parallel_tests/#{type}/runner"
-      klass_name = "ParallelTests::#{type.capitalize.sub("Rspec", "RSpec")}::Runner"
+      runner_classname = type.split("_").map(&:capitalize).join.sub("Rspec", "RSpec")
+      klass_name = "ParallelTests::#{runner_classname}::Runner"
       klass_name.split('::').inject(Object) { |x, y| x.const_get(y) }
     end
 
@@ -168,9 +242,15 @@ TEXT
     end
 
     def report_time_taken
-      start = Time.now
-      yield
-      puts "\nTook #{Time.now - start} seconds"
+      seconds = ParallelTests.delta { yield }.to_i
+      puts "\nTook #{seconds} seconds#{detailed_duration(seconds)}"
+    end
+
+    def detailed_duration(seconds)
+      parts = [ seconds / 3600, seconds % 3600 / 60, seconds % 60 ].drop_while(&:zero?)
+      return if parts.size < 2
+      parts = parts.map { |i| "%02d" % i }.join(':').sub(/^0/, '')
+      " (#{parts})"
     end
 
     def final_fail_message