moxiesoft_parallel_tests 0.4.13 → 0.6.18

data/Gemfile

@@ -3,7 +3,9 @@ source :rubygems
 gem 'parallel'
 
 group :dev do
+  gem 'test-unit', :platform => :ruby_19
+  gem 'rspec', '>=2.4'
+  gem 'cucumber'
   gem 'rake'
-  gem 'rspec', '~>2'
   gem 'jeweler'
-end
+end

data/Gemfile.lock

@@ -1,34 +1,42 @@
 GEM
   remote: http://rubygems.org/
   specs:
+    builder (3.0.0)
+    cucumber (1.1.4)
+      builder (>= 2.1.2)
+      diff-lcs (>= 1.1.2)
+      gherkin (~> 2.7.1)
+      json (>= 1.4.6)
+      term-ansicolor (>= 1.0.6)
     diff-lcs (1.1.2)
-    gemcutter (0.6.1)
+    gherkin (2.7.6)
+      json (>= 1.4.6)
     git (1.2.5)
-    jeweler (1.4.0)
-      gemcutter (>= 0.1.0)
+    jeweler (1.6.3)
+      bundler (~> 1.0)
       git (>= 1.2.5)
-      rubyforge (>= 2.0.0)
-    json_pure (1.4.6)
+      rake
+    json (1.6.4)
     parallel (0.5.1)
     rake (0.8.7)
-    rspec (2.0.1)
-      rspec-core (~> 2.0.1)
-      rspec-expectations (~> 2.0.1)
-      rspec-mocks (~> 2.0.1)
-    rspec-core (2.0.1)
-    rspec-expectations (2.0.1)
-      diff-lcs (>= 1.1.2)
-    rspec-mocks (2.0.1)
-      rspec-core (~> 2.0.1)
-      rspec-expectations (~> 2.0.1)
-    rubyforge (2.0.4)
-      json_pure (>= 1.1.7)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    term-ansicolor (1.0.7)
+    test-unit (2.4.4)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  cucumber
   jeweler
   parallel
   rake
-  rspec (~> 2)
+  rspec (>= 2.4)
+  test-unit

data/Rakefile

@@ -10,12 +10,12 @@ begin
     gem.name     = "moxiesoft_parallel_tests"
     gem.summary  = "Run tests / specs / features in parallel"
     gem.email    = "grosser.michael@gmail.com"
-    gem.homepage = "http://github.com/edebill-moxiesoft/#{gem.name}"
-    gem.authors  = ['Michael Grosser', 'Erik DeBill']
+    gem.homepage = "http://github.com/ssherman/#{gem.name}"
+    gem.authors  = ['Michael Grosser', 'Eric DeBill']
     gem.add_dependency "parallel"
   end
 
   Jeweler::GemcutterTasks.new
 rescue LoadError
   puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install jeweler"
-end
+end

data/Readme.md

@@ -1,37 +1,53 @@
-Speedup Test::Unit + RSpec + Cucumber by running parallel on multiple CPUs(or cores).
+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.
 
 Setup for Rails
 ===============
-
 ## Install
 ### Rails 3
+If you use RSpec: ensure you got >= 2.4
+
 As gem
-    sudo gem install parallel_tests
+
     # add to Gemfile
-    gem "parallel_tests", :group=>:development
+    gem "parallel_tests", :group => :development
 
 OR as plugin
-    sudo gem install parallel
+
     rails plugin install git://github.com/grosser/parallel_tests.git
 
+    # add to Gemfile
+    gem "parallel", :group => :development
+
+
 ### Rails 2
 
 As gem
-    sudo gem install parallel_tests
+
+    gem install parallel_tests
+
     # add to config/environments/development.rb
     config.gem "parallel_tests"
+
     # add to Rakefile
     begin; require 'parallel_tests/tasks'; rescue LoadError; end
 
 OR as plugin
 
-    sudo gem install parallel
+    gem install parallel
+
+    # add to config/environments/development.rb
+    config.gem "parallel"
+
     ./script/plugin install git://github.com/grosser/parallel_tests.git
 
 ## Setup
+ParallelTests uses 1 database per test-process, 2 processes will use `*_test` and `*_test2`.
+
+
 ### 1: Add to `config/database.yml`
     test:
-      database: xxx_test<%= ENV['TEST_ENV_NUMBER'] %>
+      database: yourproject_test<%= ENV['TEST_ENV_NUMBER'] %>
 
 ### 2: Create additional database(s)
     rake parallel:create
@@ -49,29 +65,80 @@ OR as plugin
     rake parallel:test    --> got 4 CPUs? --> 26 seconds
     ...
 
-Test just a subfolder (e.g. use one integration server per subfolder)
-    rake parallel:test[models]
-    rake parallel:test[something/else]
+Test by pattern (e.g. use one integration server per subfolder / see if you broke any 'user'-related tests)
+
+    rake parallel:test[^unit] # everything in test/unit folder (every test file matching /^unit/)
+    rake parallel:test[user]  # run users_controller + user_helper + user tests
+    rake parallel:test['user|product']  # run user and product related tests
 
-    partial paths are OK too...
-    rake parallel:test[functional] == rake parallel:test[fun]
 
 Example output
 --------------
     2 processes for 210 specs, ~ 105 specs per process
     ... test output ...
 
-    Results:
-    877 examples, 0 failures, 11 pending
     843 examples, 0 failures, 1 pending
 
     Took 29.925333 seconds
 
-Even process runtimes (for specs only atm)
+Loggers
+===================
+
+Even process runtimes
 -----------------
-Add to your `spec/parallel_spec.opts` (or `spec/spec.opts`) :
-    --format ParallelSpecs::SpecRuntimeLogger:tmp/parallel_profile.log
-It will log test runtime and partition the test-load accordingly.
+
+Log test runtime to give each process the same runtime.
+
+Rspec: Add to your `spec/parallel_spec.opts` (or `spec/spec.opts`) :
+
+    RSpec 1.x:
+      --format progress
+      --require parallel_specs/spec_runtime_logger
+      --format ParallelSpecs::SpecRuntimeLogger:tmp/parallel_profile.log
+    RSpec >= 2.4:
+      If installed as plugin: -I vendor/plugins/parallel_tests/lib
+      --format progress
+      --format ParallelSpecs::SpecRuntimeLogger --out tmp/parallel_profile.log
+
+Test::Unit:  Add to your `test_helper.rb`:
+    require 'parallel_tests/runtime_logger'
+
+
+SpecSummaryLogger
+--------------------
+
+This logger logs the test output without the different processes overwriting each other.
+
+Add the following to your `spec/parallel_spec.opts` (or `spec/spec.opts`) :
+
+    RSpec 1.x:
+      --format progress
+      --require parallel_specs/spec_summary_logger
+      --format ParallelSpecs::SpecSummaryLogger:tmp/spec_summary.log
+    RSpec >= 2.2:
+      If installed as plugin: -I vendor/plugins/parallel_tests/lib
+      --format progress
+      --format ParallelSpecs::SpecSummaryLogger --out tmp/spec_summary.log
+
+SpecFailuresLogger
+-----------------------
+
+This logger produces pasteable command-line snippets for each failed example.
+
+E.g.
+
+    rspec /path/to/my_spec.rb:123 # should do something
+
+Add the following to your `spec/parallel_spec.opts` (or `spec/spec.opts`) :
+
+    RSpec 1.x:
+      --format progress
+      --require parallel_specs/spec_failures_logger
+      --format ParallelSpecs::SpecFailuresLogger:tmp/failing_specs.log
+    RSpec >= 2.4:
+      If installed as plugin: -I vendor/plugins/parallel_tests/lib
+      --format progress
+      --format ParallelSpecs::SpecFailuresLogger --out tmp/failing_specs.log
 
 Setup for non-rails
 ===================
@@ -81,9 +148,11 @@ Setup for non-rails
     # [Optional] use ENV['TEST_ENV_NUMBER'] inside your tests to select separate db/memcache/etc.
 
 [optional] Only run selected files & folders:
-    parallel_test test/bar test/baz/xxx_text.rb
+
+    parallel_test test/bar test/baz/foo_text.rb
 
 Options are:
+
     -n [PROCESSES]                   How many processes to use, default: available CPUs
     -p, --path [PATH]                run tests inside this path only
         --no-sort                    do not sort files before running them
@@ -97,6 +166,7 @@ Options are:
     -h, --help                       Show this.
 
 You can run any kind of code with -e / --execute
+
     parallel_test -n 5 -e 'ruby -e "puts %[hello from process #{ENV[:TEST_ENV_NUMBER.to_s].inspect}]"'
     hello from process "2"
     hello from process ""
@@ -118,10 +188,14 @@ TIPS
  - [RSpec] if `script/spec` is missing parallel:spec uses just `spec` (which solves some issues with double-loaded environment.rb)
  - [RSpec] 'script/spec_server' or [spork](http://github.com/timcharper/spork/tree/master) do not work in parallel
  - [RSpec] `./script/generate rspec` if you are running rspec from gems (this plugin uses script/spec which may fail if rspec files are outdated)
+ - [RSpec] remove --loadby from you spec/*.opts
  - [Bundler] if you have a `Gemfile` then `bundle exec` will be used to run tests
  - [Capybara setup](https://github.com/grosser/parallel_tests/wiki)
  - [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
  - [SQL schema format] use :ruby schema format to get faster parallel:prepare`
+ - [ActiveRecord] if you do not have `db:abort_if_pending_migrations` add this to your Rakefile: `task('db:abort_if_pending_migrations'){}`
+ - `export PARALLEL_TEST_PROCESSORS=X` in your environment and parallel_tests will use this number of processors by default
  - with zsh this would be `rake "parallel:prepare[3]"`
 
 TODO
@@ -150,7 +224,17 @@ inspired by [pivotal labs](http://pivotallabs.com/users/miked/blog/articles/849-
  - [Fred Wu](http://fredwu.me)
  - [xxx](https://github.com/xxx)
  - [Levent Ali](http://purebreeze.com/)
+ - [Michael Kintzer](https://github.com/rockrep)
+ - [nathansobo](https://github.com/nathansobo)
+ - [Joe Yates](http://titusd.co.uk)
+ - [asmega](http://www.ph-lee.com)
+ - [Doug Barth](https://github.com/dougbarth)
+ - [Geoffrey Hichborn](https://github.com/phene)
+ - [Trae Robrock](https://github.com/trobrock)
+ - [Lawrence Wang](https://github.com/levity)
+ - [Sean Walbran](https://github.com/seanwalbran)
 
 [Michael Grosser](http://grosser.it)<br/>
 michael@grosser.it<br/>
-Hereby placed under public domain, do what you want, just do not hold me accountable...
+Hereby placed under public domain, do what you want, just do not hold me accountable...<br/>
+[![Flattr](http://api.flattr.com/button/flattr-badge-large.png)](https://flattr.com/submit/auto?user_id=grosser&url=https://github.com/grosser/parallel_tests&title=parallel_tests&language=en_GB&tags=github&category=software)

data/VERSION

@@ -1 +1 @@
-0.4.13
+0.6.18

data/bin/parallel_test

@@ -17,18 +17,25 @@ Run all tests in parallel, giving each process ENV['TEST_ENV_NUMBER'] ('', '2',
 Options are:
 BANNER
   opts.on("-n [PROCESSES]", Integer, "How many processes to use, default: available CPUs"){|n| options[:count] = n }
-  opts.on("-p", '--path [PATH]', "run tests inside this path only"){|path| options[:path_prefix] = path }
+  opts.on("-p", '--pattern [PATTERN]', "run tests matching this pattern"){|pattern| options[:pattern] = pattern }
   opts.on("--no-sort", "do not sort files before running them"){ |no_sort| options[:no_sort] = no_sort }
   opts.on("-m [FLOAT]", "--multiply-processes [FLOAT]", Float, "use given number as a multiplier of processes to run"){ |multiply| options[:multiply] = multiply }
   opts.on("-r", '--root [PATH]', "execute test commands from this path"){|path| options[:root] = path }
+  opts.on("-s [PATTERN]", "--single [PATTERN]", "Run all matching files in only one process") do |pattern|
+    options[:single_process] ||= []
+    options[:single_process] << /#{pattern}/
+  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]", "which type of tests to run? test, spec or features"){|type| options[:type] = type }
-  opts.on("--non-parallel", "execute same commands but do not in parallel, needs --exec"){|type| options[:non_parallel] = true }
+  opts.on("--non-parallel", "execute same commands but do not in parallel, needs --exec"){ options[:non_parallel] = true }
+  opts.on("--chunk-timeout [TIMEOUT]", "timeout before re-printing the output of a child-process"){|timeout| options[:chunk_timeout] = timeout.to_f }
   opts.on('-v', '--version', 'Show Version'){ puts ParallelTests::VERSION; exit}
   opts.on("-h", "--help", "Show this.") { puts opts; exit }
 end.parse!
 
+raise "--no-sort and --single-process are not supported" if options[:no_sort] and options[:single_process]
+
 # get files to run from arguments
 options[:files] = ARGV if ARGV.size > 0
 
@@ -39,11 +46,11 @@ if options[:execute]
   runs = (0...num_processes).to_a
   results = if options[:non_parallel]
     runs.map do |i|
-      ParallelTests.execute_command(options[:execute], i)
+      ParallelTests.execute_command(options[:execute], i, options)
     end
   else
     Parallel.map(runs, :in_processes => num_processes) do |i|
-      ParallelTests.execute_command(options[:execute], i)
+      ParallelTests.execute_command(options[:execute], i, options)
     end
   end.flatten
   abort if results.any?{|r| r[:exit_status] != 0 }
@@ -59,17 +66,10 @@ else
 
   start = Time.now
 
-  options[:path_prefix] = options[:path_prefix] ? options[:path_prefix].split(',') : ['']
-  tests_folder = options[:path_prefix].collect do |path| 
-    tests_folder = File.join(task, path.to_s)
-    tests_folder = File.join(options[:root], tests_folder) unless options[:root].to_s.empty?
-    tests_folder
-  end
-  tests_folder = nil if tests_folder.empty?
+  tests_folder = task
+  tests_folder = File.join(options[:root], tests_folder) unless options[:root].to_s.empty?
 
-  puts "test folders => #{tests_folder}" if tests_folder
-
-  groups = klass.tests_in_groups(options[:files] || tests_folder, num_processes, :no_sort => options[:no_sort])
+  groups = klass.tests_in_groups(options[:files] || tests_folder, num_processes, options)
   num_processes = groups.size
 
   #adjust processes to groups
@@ -79,14 +79,17 @@ else
   puts "#{num_processes} processes for #{num_tests} #{name}s, ~ #{num_tests / groups.size} #{name}s per process"
 
   test_results = Parallel.map(groups, :in_processes => num_processes) do |group|
-    klass.run_tests(group, groups.index(group), options[:test_options])
+    if group.empty?
+      {:stdout => '', :exit_status => 0}
+    else
+      klass.run_tests(group, groups.index(group), options)
+    end
   end
 
   #parse and print results
   results = klass.find_results(test_results.map{|result| result[:stdout] }*"")
   puts ""
-  puts "Results:"
-  results.each{|r| puts r }
+  puts klass.summarize_results(results)
 
   #report total time taken
   puts ""
@@ -95,4 +98,4 @@ else
   #exit with correct status code so rake parallel:test && echo 123 works
   failed = test_results.any?{|result| result[:exit_status] != 0 }
   abort "#{name.capitalize}s Failed" if failed
-end
+end

data/lib/parallel_cucumber.rb

@@ -1,10 +1,13 @@
-require File.join(File.dirname(__FILE__), 'parallel_tests')
+require 'parallel_tests'
 
 class ParallelCucumber < ParallelTests
   def self.run_tests(test_files, process_number, options)
     color = ($stdout.tty? ? 'AUTOTEST=1 ; export AUTOTEST ;' : '')#display color when we are in a terminal
-    cmd = "#{color} #{executable} #{options} #{test_files*' '}"
-    execute_command(cmd, process_number)
+    runtime_logging = " --format ParallelCucumber::RuntimeLogger --out #{runtime_log}"
+    cmd = "#{color} #{executable}"
+    cmd << runtime_logging if File.directory?(File.dirname(runtime_log))
+    cmd << " #{options[:test_options]} #{test_files*' '}"
+    execute_command(cmd, process_number, options)
   end
 
   def self.executable
@@ -17,6 +20,10 @@ class ParallelCucumber < ParallelTests
     end
   end
 
+  def self.runtime_log
+    'tmp/parallel_runtime_cucumber.log'
+  end
+
   protected
 
   def self.test_suffix

data/lib/parallel_specs/spec_runtime_logger.rb

@@ -1,14 +1,8 @@
-require 'spec/runner/formatter/progress_bar_formatter'
+require 'parallel_specs/spec_logger_base'
 
-class ParallelSpecs::SpecRuntimeLogger < Spec::Runner::Formatter::BaseTextFormatter
-  def initialize(options, output)
-    if String === output
-      FileUtils.mkdir_p(File.dirname(output))
-      File.open(output,'w'){|f| f.write ''} # clean the file
-      @output = File.open(output, 'a+') #append so that multiple processes can write at once
-    else
-      @output = output
-    end
+class ParallelSpecs::SpecRuntimeLogger < ParallelSpecs::SpecLoggerBase
+  def initialize(*args)
+    super
     @example_times = Hash.new(0)
   end
 
@@ -21,29 +15,20 @@ class ParallelSpecs::SpecRuntimeLogger < Spec::Runner::Formatter::BaseTextFormat
     @example_times[file] += Time.now - @time
   end
 
+  def dump_summary(*args);end
+  def dump_failures(*args);end
+  def dump_failure(*args);end
+  def dump_pending(*args);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
-    @output.puts @example_times.map { |file, time| "#{file}:#{time > 0 ? time : 0}" }
+    lock_output do
+      @example_times.each do |file, time|
+        relative_path = file.sub(/^#{Regexp.escape Dir.pwd}\//,'')
+        @output.puts "#{relative_path}:#{time > 0 ? time : 0}"
+      end
+    end
     @output.flush
   end
-
-  # stubs so that rspec doe not crash
-
-  def example_pending(*args)
-  end
-
-  def dump_summary(*args)
-  end
-
-  def dump_pending(*args)
-  end
-
-  def dump_failure(*args)
-  end
-
-  #stolen from Rspec
-  def close
-    @output.close  if (IO === @output) & (@output != $stdout)
-  end
-end
+end

data/lib/parallel_specs.rb

@@ -1,10 +1,11 @@
-require File.join(File.dirname(__FILE__), 'parallel_tests')
+require 'parallel_tests'
 
 class ParallelSpecs < ParallelTests
   def self.run_tests(test_files, process_number, options)
-    exe = executable # its expensive with bundler, so do not call it twice
-    cmd = "#{color} #{exe} #{options} #{spec_opts(exe)} #{test_files*' '}"
-    execute_command(cmd, process_number)
+    exe = executable # expensive, so we cache
+    version = (exe =~ /\brspec\b/ ? 2 : 1)
+    cmd = "#{rspec_1_color if version == 1}#{exe} #{options[:test_options]} #{rspec_2_color if version == 2}#{spec_opts(version)} #{test_files*' '}"
+    execute_command(cmd, process_number, options)
   end
 
   def self.executable
@@ -19,6 +20,11 @@ class ParallelSpecs < ParallelTests
     cmd or raise("Can't find executables rspec or spec")
   end
 
+  # legacy <-> people log to this file using rspec options
+  def self.runtime_log
+    'tmp/parallel_profile.log'
+  end
+
   protected
 
   # so it can be stubbed....
@@ -26,20 +32,18 @@ class ParallelSpecs < ParallelTests
     `#{cmd}`
   end
 
-  def self.spec_opts(executable)
-    opts = ['spec/parallel_spec.opts', 'spec/spec.opts'].detect{|f| File.file?(f) }
-    return unless opts
-    if executable =~ /\brspec\b/
-      # RSpec2 does not handle -O, so we inline the options
-      File.read(opts).tr("\n", ' ')
-    else
-      "-O #{opts}"
-    end
+  def self.rspec_1_color
+    'RSPEC_COLOR=1 ; export RSPEC_COLOR ;' if $stdout.tty?
+  end
+
+  def self.rspec_2_color
+    '--color --tty ' if $stdout.tty?
   end
 
-  #display color when we are in a terminal
-  def self.color
-    ($stdout.tty? ? 'RSPEC_COLOR=1 ; export RSPEC_COLOR ;' : '')
+  def self.spec_opts(rspec_version)
+    options_file = ['.rspec_parallel', 'spec/parallel_spec.opts', 'spec/spec.opts'].detect{|f| File.file?(f) }
+    return unless options_file
+    "-O #{options_file}"
   end
 
   def self.test_suffix

data/lib/parallel_tests/grouper.rb

@@ -1,31 +1,49 @@
 class ParallelTests
   class Grouper
     def self.in_groups(items, num_groups)
-      [].tap do |groups|
-        while ! items.empty?
-          (0...num_groups).map do |group_number|
-            groups[group_number] ||= []
-            groups[group_number] << items.shift
-          end
+      groups = Array.new(num_groups){ [] }
+
+      until items.empty?
+        num_groups.times do |group_number|
+          groups[group_number] << items.shift
         end
       end
+
+      groups.map!(&:sort!)
     end
 
-    def self.in_even_groups_by_size(items_with_sizes, num_groups)
-      items_with_size = smallest_first(items_with_sizes)
+    def self.in_even_groups_by_size(items_with_sizes, num_groups, options={})
       groups = Array.new(num_groups){{:items => [], :size => 0}}
-      items_with_size.each do |item, size|
-        # always add to smallest group
-        smallest = groups.sort_by{|g| g[:size] }.first
-        smallest[:items] << item
-        smallest[:size] += size
+
+      # add all files that should run in a single process to one group
+      (options[:single_process]||[]).each do |pattern|
+        matched, items_with_sizes = items_with_sizes.partition{|item, size| item =~ pattern }
+        smallest = smallest_group(groups)
+        matched.each{|item,size| add_to_group(smallest, item, size) }
+      end
+
+      # add all other files
+      largest_first(items_with_sizes).each do |item, size|
+        smallest = smallest_group(groups)
+        add_to_group(smallest, item, size)
       end
 
-      groups.map{|g| g[:items] }
+      groups.map!{|g| g[:items].sort }
     end
 
-    def self.smallest_first(files)
+    def self.largest_first(files)
       files.sort_by{|item, size| size }.reverse
     end
+
+  private
+
+    def self.smallest_group(groups)
+      groups.min_by{|g| g[:size] }
+    end
+
+    def self.add_to_group(group, item, size)
+      group[:items] << item
+      group[:size] += size
+    end
   end
-end
+end

data/lib/parallel_tests/tasks.rb

@@ -18,7 +18,7 @@ namespace :parallel do
 
   desc "update test databases by dumping and loading --> parallel:prepare[num_cpus]"
   task(:prepare, [:count] => 'db:abort_if_pending_migrations') do |t,args|
-    if ActiveRecord::Base.schema_format == :ruby
+    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])
@@ -30,7 +30,7 @@ namespace :parallel do
   end
 
   # when dumping/resetting takes too long
-  desc "update test databases via db:mgrate --> parallel:migrate[num_cpus]"
+  desc "update test databases via db:migrate --> parallel:migrate[num_cpus]"
   task :migrate, :count do |t,args|
     run_in_parallel('rake db:migrate RAILS_ENV=test', args)
   end
@@ -43,12 +43,12 @@ namespace :parallel do
 
   ['test', 'spec', 'features'].each do |type|
     desc "run #{type} in parallel with parallel:#{type}[num_cpus]"
-    task type, :count, :path_prefix, :options do |t,args|
+    task type, [:count, :pattern, :options] => 'db:abort_if_pending_migrations' do |t,args|
       $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..'))
       require "parallel_tests"
-      count, prefix, options = ParallelTests.parse_rake_args(args)
+      count, pattern, options = ParallelTests.parse_rake_args(args)
       executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallel_test')
-      command = "#{executable} --type #{type} -n #{count} -p '#{prefix}' -r '#{Rails.root}' -o '#{options}'"
+      command = "#{executable} --type #{type} -n #{count} -p '#{pattern}' -r '#{Rails.root}' -o '#{options}'"
       abort unless system(command) # allow to chain tasks e.g. rake parallel:spec parallel:features
     end
   end
@@ -66,15 +66,15 @@ namespace :spec do
     end
   end
 
-  task :parallel, :count, :path_prefix do |t,args|
+  task :parallel, :count, :pattern do |t,args|
     $stderr.puts "WARNING -- Deprecated! use parallel:spec"
-    Rake::Task['parallel:spec'].invoke(args[:count], args[:path_prefix])
+    Rake::Task['parallel:spec'].invoke(args[:count], args[:pattern])
   end
 end
 
 namespace :test do
-  task :parallel, :count, :path_prefix do |t,args|
+  task :parallel, :count, :pattern do |t,args|
     $stderr.puts "WARNING -- Deprecated! use parallel:test"
-    Rake::Task['parallel:test'].invoke(args[:count], args[:path_prefix])
+    Rake::Task['parallel:test'].invoke(args[:count], args[:pattern])
   end
 end