parallel_tests 0.3.0

data/.gitignore

@@ -0,0 +1 @@
+*.sh

data/README.markdown

@@ -0,0 +1,119 @@
+Speedup Test::Unit + RSpec + Cucumber by running parallel on multiple CPUs.
+
+Setup for Rails
+===============
+
+    sudo gem install parallel
+    script/plugin install git://github.com/grosser/parallel_tests.git
+
+### 1: Add to `config/database.yml`
+    test:
+      database: xxx_test<%= ENV['TEST_ENV_NUMBER'] %>
+
+### 2: Create additional database(s)
+    script/db_console
+    create database xxx_test2;
+    ...
+
+### 3: Copy development schema (repeat after migrations)
+    rake parallel:prepare
+
+### 4: Run!
+    rake parallel:test          # Test::Unit
+    rake parallel:spec          # RSpec
+    rake parallel:features      # Cucumber
+
+    rake parallel:test[1] --> force 1 CPU --> 86 seconds
+    rake parallel:test    --> got 2 CPUs? --> 47 seconds
+    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]
+
+    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)
+-----------------
+Add to your `spec/parallel_specs.opts` (or `spec/spec.opts`) :
+    --format ParallelSpecs::SpecRuntimeLogger:tmp/parallel_profile.log
+It will log test runtime and partition the test-load accordingly.
+
+Setup for non-rails
+===================
+    sudo gem install parallel_tests
+    # go to your project dir
+    parallel_test OR parallel_spec OR parallel_cucumber
+    # [Optional] use ENV['TEST_ENV_NUMBER'] inside your tests for separate db/resources/etc.
+
+Options are:
+    -n [PROCESSES]                   How many processes to use, default: available CPUs
+    -p, --path [PATH]                run tests inside this path only
+    -r, --root [PATH]                execute test commands from this path
+    -e, --exec [COMMAND]             execute this code parallel and with ENV['TEST_ENV_NUM']
+    -o, --test-options [SOMETHING]   execute test commands with those options
+    -t, --type [TYPE]                which type of tests to run? test, spec or features
+    -v, --version                    Show Version
+    -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 ""
+    hello from process "3"
+    hello from process "5"
+    hello from process "4"
+
+<table>
+<tr><td></td><td>1 Process</td><td>2 Processes</td><td>4 Processes</td></tr>
+<tr><td>RSpec spec-suite</td><td>18</td><td>14</td><td>10</td></tr>
+<tr><td>Rails-ActionPack</td><td>88</td><td>53</td><td>44</td></tr>
+</table>
+
+TIPS
+====
+ - [RSpec] add a `spec/parallel_spec.opts` to use different options, e.g. no --drb (default: `spec/spec.opts`) 
+ - [RSpec] if something looks fishy try to delete `script/spec`
+ - [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)
+ - [Bundler] if you have a `.bundle/environment.rb` then `bundle exec xxx` will be used to run tests 
+ - with zsh this would be `rake "parallel:prepare[3]"`
+
+TODO
+====
+ - build parallel:bootstrap [idea/basics](http://github.com/garnierjm/parallel_specs/commit/dd8005a2639923dc5adc6400551c4dd4de82bf9a)
+ - make jRuby compatible [basics](http://yehudakatz.com/2009/07/01/new-rails-isolation-testing/)
+ - make windows compatible (does anyone care ?)
+
+Authors
+====
+inspired by [pivotal labs](http://pivotallabs.com/users/miked/blog/articles/849-parallelize-your-rspec-suite)  
+
+###Contributors (alphabetical)
+ - [Charles Finkel](http://charlesfinkel.com/)
+ - [Jason Morrison](http://jayunit.net)
+ - [Joakim Kolsjö](http://www.rubyblocks.se)
+ - [Kpumuk](http://kpumuk.info/)
+ - [Maksim Horbu](http://github.com/mhorbul)
+ - [Rohan Deshpande](http://github.com/rdeshpande)
+ - [Tchandy](http://thiagopradi.net/)
+ - [Terence Lee](http://hone.heroku.com/)
+ - [Will Bryant](http://willbryant.net/)
+
+[Michael Grosser](http://pragmatig.wordpress.com)  
+grosser.michael@gmail.com  
+Hereby placed under public domain, do what you want, just do not hold me accountable...

data/Rakefile

@@ -0,0 +1,19 @@
+task :default => :spec
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new {|t| t.spec_opts = ['--color']}
+
+begin
+  require 'jeweler'
+  project_name = 'parallel_tests'
+  Jeweler::Tasks.new do |gem|
+    gem.name = project_name
+    gem.summary = "Run tests / specs / features in parallel"
+    gem.email = "grosser.michael@gmail.com"
+    gem.homepage = "http://github.com/grosser/#{project_name}"
+    gem.authors = ["Michael Grosser"]
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/bin/parallel_cucumber

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+exec "#{File.join(File.dirname(__FILE__), 'parallel_test')} -t features #{ARGV * ' '}"

data/bin/parallel_spec

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+exec "#{File.join(File.dirname(__FILE__), 'parallel_test')} -t spec #{ARGV * ' '}"

data/bin/parallel_test

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'optparse'
+lib_folder = File.join(File.dirname(__FILE__), '..', 'lib')
+require File.join(lib_folder, "parallel_tests")
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = <<BANNER
+Run tests in parallel, giving each process ENV['TEST_ENV_NUMBER'] ('', '2', '3', ...)
+
+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("-r", '--root [PATH]', "execute test commands from this path"){|path| options[:root] = path }
+  opts.on("-e", '--exec [COMMAND]', "execute this code parallel and with ENV['TEST_ENV_NUM']"){|path| options[:execute] = path }
+  opts.on("-o", '--test-options [SOMETHING]', "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('-v', '--version', 'Show Version'){ puts ParallelTests::VERSION; exit}
+  opts.on("-h", "--help", "Show this.") { puts opts; exit }
+end.parse!
+
+require 'parallel'
+num_processes = options[:count] || Parallel.processor_count
+
+if options[:execute]
+  require File.join(lib_folder, "parallel_tests")
+  Parallel.in_processes(num_processes) do |i|
+    ParallelTests.execute_command(options[:execute], i)
+  end
+else
+  lib, name, task = {
+    'test' => ["tests", "test", "test"],
+    'spec' => ["specs", "spec", "spec"],
+    'features' => ["cucumber", "feature", "features"]
+  }[options[:type]||'test']
+
+  require File.join(lib_folder, "parallel_#{lib}")
+  klass = eval("Parallel#{lib.capitalize}")
+
+  start = Time.now
+
+  tests_folder = File.join(task, options[:path_prefix].to_s)
+  tests_folder = File.join(options[:root], tests_folder) unless options[:root].to_s.empty?
+
+  groups = klass.tests_in_groups(tests_folder, num_processes)
+  num_processes = groups.size
+
+  #adjust processes to groups
+  abort "no #{name}s found!" if groups.size == 0
+
+  num_tests = groups.inject(0){|sum,item| sum + item.size }
+  puts "#{num_processes} processes for #{num_tests} #{name}s, ~ #{num_tests / groups.size} #{name}s per process"
+
+  output = Parallel.map(groups, :in_processes => num_processes) do |group|
+    klass.run_tests(group, groups.index(group), options[:test_options])
+  end
+
+  #parse and print results
+  results = klass.find_results(output*"")
+  puts ""
+  puts "Results:"
+  results.each{|r| puts r}
+
+  #report total time taken
+  puts ""
+  puts "Took #{Time.now - start} seconds"
+
+  #exit with correct status code
+  # - rake parallel:test && echo 123 ==> 123 should not show up when test failed
+  # - rake parallel:test db:reset ==> works when tests succeed
+  abort "#{name.capitalize}s Failed" if klass.failed?(results)
+end

data/lib/parallel_cucumber.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), 'parallel_tests')
+
+class ParallelCucumber < ParallelTests
+  def self.run_tests(test_files, process_number, options)
+    color = ($stdout.tty? ? 'export AUTOTEST=1 ;' : '')#display color when we are in a terminal
+    cmd = "export RAILS_ENV=test ; #{color} #{executable} #{options} #{test_files*' '}"
+    execute_command(cmd, process_number)
+  end
+
+  def self.executable
+    if File.file?(".bundle/environment.rb")
+      "bundle exec cucumber"
+    elsif File.file?("script/cucumber")
+      "script/cucumber"
+    else
+      "cucumber"
+    end
+  end
+
+  protected
+
+  def self.line_is_result?(line)
+    line =~ /^\d+ (steps|scenarios)/
+  end
+  
+  def self.line_is_failure?(line)
+    line =~ /^\d+ (steps|scenarios).*(\d{2,}|[1-9]) failed/
+  end
+
+  def self.find_tests(root)
+    Dir["#{root}**/**/*.feature"]
+  end
+end

data/lib/parallel_specs.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), 'parallel_tests')
+
+class ParallelSpecs < ParallelTests
+  def self.run_tests(test_files, process_number, options)
+    spec_opts = ['spec/parallel_spec.opts', 'spec/spec.opts'].detect{|f| File.file?(f) }
+    spec_opts = (spec_opts ? "-O #{spec_opts}" : nil)
+    color = ($stdout.tty? ? 'export RSPEC_COLOR=1 ;' : '')#display color when we are in a terminal
+    cmd = "export RAILS_ENV=test ; #{color} #{executable} #{options} #{spec_opts} #{test_files*' '}"
+    execute_command(cmd, process_number)
+  end
+
+  def self.executable
+    if File.file?(".bundle/environment.rb")
+      "bundle exec spec"
+    elsif File.file?("script/spec")
+      "script/spec"
+    else
+      "spec"
+    end
+  end
+
+  protected
+
+  def self.find_tests(root)
+    Dir["#{root}**/**/*_spec.rb"]
+  end
+end

data/lib/parallel_specs/spec_runtime_logger.rb

@@ -0,0 +1,49 @@
+require 'spec/runner/formatter/progress_bar_formatter'
+
+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
+    @example_times = Hash.new(0)
+  end
+
+  def example_started(*args)
+    @time = Time.now
+  end
+
+  def example_passed(example)
+    file = example.location.split(':').first
+    @example_times[file] += Time.now - @time
+  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}" }
+    @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

data/lib/parallel_tests.rb

@@ -0,0 +1,119 @@
+require 'parallel'
+
+class ParallelTests
+  VERSION = File.read( File.join(File.dirname(__FILE__),'..','VERSION') ).strip
+
+  # parallel:spec[2,controller] <-> parallel:spec[controller]
+  def self.parse_rake_args (args)
+    num_processes = Parallel.processor_count
+    options = ""
+    if args[:count].to_s =~ /^\d*$/ # number or empty
+      num_processes = args[:count] unless args[:count].to_s.empty?
+      prefix = args[:path_prefix]
+      options = args[:options] if args[:options]
+    else # something stringy
+      prefix = args[:count]
+    end
+    [num_processes.to_i, prefix.to_s, options]
+  end
+
+  # finds all tests and partitions them into groups
+  def self.tests_in_groups(root, num)
+    tests_with_sizes = slow_specs_first(find_tests_with_sizes(root))
+
+    groups = []
+    current_group = current_size = 0
+    tests_with_sizes.each do |test, size|
+      # inserts into next group if current is full and we are not in the last group
+      if (0.5*size + current_size) > group_size(tests_with_sizes, num) and num > current_group + 1
+        current_size = size
+        current_group += 1
+      else
+        current_size += size
+      end
+      groups[current_group] ||= []
+      groups[current_group] << test
+    end
+    groups.compact
+  end
+
+  def self.run_tests(test_files, process_number, options)
+    require_list = test_files.map { |filename| "\"#{filename}\"" }.join(",")
+    cmd = "export RAILS_ENV=test ; ruby -Itest #{options} -e '[#{require_list}].each {|f| require f }'"
+    execute_command(cmd, process_number)
+  end
+
+  def self.execute_command(cmd, process_number)
+    cmd = "export TEST_ENV_NUMBER=#{test_env_number(process_number)} ; #{cmd}"
+    f = open("|#{cmd}", 'r')
+    all = ''
+    while char = f.getc
+      char = (char.is_a?(Fixnum) ? char.chr : char) # 1.8 <-> 1.9
+      all << char
+      print char
+      STDOUT.flush
+    end
+    all
+  end
+
+  def self.find_results(test_output)
+    test_output.split("\n").map {|line|
+      line = line.gsub(/\.|F|\*/,'')
+      next unless line_is_result?(line)
+      line
+    }.compact
+  end
+
+  def self.failed?(results)
+    return true if results.empty?
+    !! results.detect{|line| line_is_failure?(line)}
+  end
+
+  def self.test_env_number(process_number)
+    process_number == 0 ? '' : process_number + 1
+  end
+
+  protected
+
+  def self.slow_specs_first(tests)
+    tests.sort_by{|test, size| size }.reverse
+  end
+  
+  def self.line_is_result?(line)
+    line =~ /\d+ failure/
+  end
+  
+  def self.line_is_failure?(line)
+    line =~ /(\d{2,}|[1-9]) (failure|error)/
+  end
+
+  def self.group_size(tests_with_sizes, num_groups)
+    total_size = tests_with_sizes.inject(0) { |sum, test| sum += test[1] }
+    total_size / num_groups.to_f
+  end
+
+  def self.find_tests_with_sizes(root)
+    tests = find_tests(root).sort
+
+    #TODO get the real root, atm this only works for complete runs when root point to e.g. real_root/spec
+    runtime_file = File.join(root,'..','tmp','parallel_profile.log')
+    lines = File.read(runtime_file).split("\n") rescue []
+
+    if lines.size * 1.5 > tests.size
+      # use recorded test runtime if we got enough data
+      times = Hash.new(1)
+      lines.each do |line|
+        test, time = line.split(":")
+        times[test] = time.to_f
+      end
+      tests.map { |test| [ test, times[test] ] }
+    else
+      # use file sizes
+      tests.map { |test| [ test, File.stat(test).size ] }
+    end
+  end
+
+  def self.find_tests(root)
+    Dir["#{root}**/**/*_test.rb"]
+  end
+end

data/parallel_tests.gemspec

@@ -0,0 +1,61 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{parallel_tests}
+  s.version = "0.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael Grosser"]
+  s.date = %q{2010-03-02}
+  s.email = %q{grosser.michael@gmail.com}
+  s.executables = ["parallel_test", "parallel_spec", "parallel_cucumber"]
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "bin/parallel_cucumber",
+     "bin/parallel_spec",
+     "bin/parallel_test",
+     "lib/parallel_cucumber.rb",
+     "lib/parallel_specs.rb",
+     "lib/parallel_specs/spec_runtime_logger.rb",
+     "lib/parallel_tests.rb",
+     "parallel_tests.gemspec",
+     "spec/integration_spec.rb",
+     "spec/parallel_cucumber_spec.rb",
+     "spec/parallel_specs_spec.rb",
+     "spec/parallel_tests_spec.rb",
+     "spec/spec_helper.rb",
+     "tasks/parallel_specs.rake"
+  ]
+  s.homepage = %q{http://github.com/grosser/parallel_tests}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Run tests / specs / features in parallel}
+  s.test_files = [
+    "spec/spec_helper.rb",
+     "spec/parallel_tests_spec.rb",
+     "spec/parallel_specs_spec.rb",
+     "spec/parallel_cucumber_spec.rb",
+     "spec/integration_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/spec/integration_spec.rb

@@ -0,0 +1,83 @@
+describe 'CLI' do
+  before do
+    `rm -rf #{folder}`
+  end
+
+  after do
+    `rm -rf #{folder}`
+  end
+
+  def folder
+    "/tmp/parallel_tests_tests"
+  end
+
+  def write(file, content)
+    path = "#{folder}/spec/#{file}"
+    `mkdir -p #{File.dirname(path)}` unless File.exist?(File.dirname(path))
+    File.open(path, 'w'){|f| f.write content }
+    path
+  end
+
+  def bin_folder
+    "#{File.expand_path(File.dirname(__FILE__))}/../bin"
+  end
+
+  def executable
+    "#{bin_folder}/parallel_test"
+  end
+
+  def run_specs(options={})
+    `cd #{folder} && #{executable} -t spec -n #{options[:processes]||2} 2>&1 && echo 'i ran!'`
+  end
+
+  it "runs tests in parallel" do
+    write 'xxx_spec.rb', 'describe("it"){it("should"){puts "TEST1"}}'
+    write 'xxx2_spec.rb', 'describe("it"){it("should"){puts "TEST2"}}'
+    result = run_specs
+
+    # test ran and gave their puts
+    result.should include('TEST1')
+    result.should include('TEST2')
+
+    # all results present
+    result.scan('1 example, 0 failure').size.should == 4 # 2 results + 2 result summary
+    result.scan(/Finished in \d+\.\d+ seconds/).size.should == 2
+    result.scan(/Took \d+\.\d+ seconds/).size.should == 1 # parallel summary
+
+    result.should include('i ran!')
+  end
+
+  it "fails when tests fail" do
+    write 'xxx_spec.rb', 'describe("it"){it("should"){puts "TEST1"}}'
+    write 'xxx2_spec.rb', 'describe("it"){it("should"){1.should == 2}}'
+    result = run_specs
+
+    result.scan('1 example, 1 failure').size.should == 2
+    result.scan('1 example, 0 failure').size.should == 2
+    result.should =~ /specs failed/i
+    result.should_not include('i ran!')
+  end
+
+  it "can exec given commands with ENV['TEST_ENV_NUM']" do
+    result = `#{executable} -e 'ruby -e "puts ENV[:TEST_ENV_NUMBER.to_s].inspect"' -n 4`
+    result.split("\n").sort.should == %w["" "2" "3" "4"]
+  end
+
+  it "can run through parallel_spec / parallel_cucumber" do
+    version = `#{executable} -v`
+    `#{bin_folder}/parallel_spec -v`.should == version
+    `#{bin_folder}/parallel_cucumber -v`.should == version
+  end
+
+  it "runs faster with more processes" do
+    write 'xxx_spec.rb', 'describe("it"){it("should"){sleep 2}}'
+    write 'xxx2_spec.rb', 'describe("it"){it("should"){sleep 2}}'
+    write 'xxx3_spec.rb', 'describe("it"){it("should"){sleep 2}}'
+    write 'xxx4_spec.rb', 'describe("it"){it("should"){sleep 2}}'
+    write 'xxx5_spec.rb', 'describe("it"){it("should"){sleep 2}}'
+    write 'xxx6_spec.rb', 'describe("it"){it("should"){sleep 2}}'
+    t = Time.now
+    run_specs :processes => 6
+    (Time.now - t).should < 5
+  end
+end

data/spec/parallel_cucumber_spec.rb

@@ -0,0 +1,101 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe ParallelCucumber do
+  test_tests_in_groups(ParallelCucumber, 'features', ".feature")
+
+  describe :run_tests do
+    before(:each) do
+      File.stub!(:file?).with('.bundle/environment.rb').and_return false
+      File.stub!(:file?).with('script/cucumber').and_return true
+    end
+
+    it "uses TEST_ENV_NUMBER=blank when called for process 0" do
+      ParallelCucumber.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER= /}.and_return mock(:getc=>false)
+      ParallelCucumber.run_tests(['xxx'],0,'')
+    end
+
+    it "uses TEST_ENV_NUMBER=2 when called for process 1" do
+      ParallelCucumber.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER=2/}.and_return mock(:getc=>false)
+      ParallelCucumber.run_tests(['xxx'],1,'')
+    end
+
+    it "returns the output" do
+      io = open('spec/spec_helper.rb')
+      ParallelCucumber.stub!(:print)
+      ParallelCucumber.should_receive(:open).and_return io
+      ParallelCucumber.run_tests(['xxx'],1,'').should =~ /\$LOAD_PATH << File/
+    end
+
+    it "runs bundle exec cucumber when on bundler 0.9" do
+      File.stub!(:file?).with('.bundle/environment.rb').and_return true
+      ParallelCucumber.should_receive(:open).with{|x,y| x =~ %r{bundle exec cucumber}}.and_return mock(:getc=>false)
+      ParallelCucumber.run_tests(['xxx'],1,'')
+    end
+
+    it "runs script/cucumber when script/cucumber is found" do
+      ParallelCucumber.should_receive(:open).with{|x,y| x =~ %r{script/cucumber}}.and_return mock(:getc=>false)
+      ParallelCucumber.run_tests(['xxx'],1,'')
+    end
+
+    it "runs cucumber by default" do
+      File.stub!(:file?).with('script/cucumber').and_return false
+      ParallelCucumber.should_receive(:open).with{|x,y| x !~ %r{(script/cucumber)|(bundle exec cucumber)}}.and_return mock(:getc=>false)
+      ParallelCucumber.run_tests(['xxx'],1,'')
+    end
+
+    it "uses options passed in" do
+      ParallelCucumber.should_receive(:open).with{|x,y| x =~ %r{script/cucumber -p default}}.and_return mock(:getc=>false)
+      ParallelCucumber.run_tests(['xxx'],1,'-p default')
+    end
+  end
+
+  describe :find_results do
+    it "finds multiple results in test output" do
+      output = <<EOF
+And I should not see "/en/"                                       # features/step_definitions/webrat_steps.rb:87
+
+7 scenarios (3 failed, 4 passed)
+33 steps (3 failed, 2 skipped, 28 passed)
+/apps/rs/features/signup.feature:2
+    Given I am on "/"                                           # features/step_definitions/common_steps.rb:12
+    When I click "register"                                     # features/step_definitions/common_steps.rb:6
+    And I should have "2" emails                                # features/step_definitions/user_steps.rb:25
+
+4 scenarios (4 passed)
+40 steps (40 passed)
+
+EOF
+      ParallelCucumber.find_results(output).should == ["7 scenarios (3 failed, 4 passed)", "33 steps (3 failed, 2 skipped, 28 passed)", "4 scenarios (4 passed)", "40 steps (40 passed)"]
+    end
+  end
+
+  describe :failed do
+    it "fails with single failed" do
+      ParallelCucumber.failed?(['40 steps (40 passed)','33 steps (3 failed, 2 skipped, 28 passed)']).should == true
+    end
+
+    it "fails with multiple failed tests" do
+      ParallelCucumber.failed?(['33 steps (3 failed, 2 skipped, 28 passed)','33 steps (3 failed, 2 skipped, 28 passed)']).should == true
+    end
+    
+    it "fails with a single scenario failure during setup phase" do
+      ParallelCucumber.failed?(['1 scenarios (1 failed)']).should == true
+    end
+
+    it "fails with scenario failures during setup phase when other steps pass" do
+      ParallelCucumber.failed?(['7 scenarios (3 failed, 4 passed)','40 steps (40 passed)']).should == true
+    end
+
+    it "does not fail with successful tests" do
+      ParallelCucumber.failed?(['4 scenarios (4 passed)','40 steps (40 passed)','4 scenarios (4 passed)','40 steps (40 passed)']).should == false
+    end
+
+    it "does not fail with 0 failures" do
+      ParallelCucumber.failed?(['4 scenarios (4 passed 0 failed)','40 steps (40 passed 0 failed)','4 scenarios (4 passed 0 failed)','40 steps (40 passed)']).should == false
+    end
+
+    it "does fail with 10 failures" do
+      ParallelCucumber.failed?(['40 steps (40 passed 10 failed)','40 steps (40 passed)']).should == true
+    end
+  end
+end

data/spec/parallel_specs_spec.rb

@@ -0,0 +1,134 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe ParallelSpecs do
+  test_tests_in_groups(ParallelSpecs, 'spec', '_spec.rb')
+
+  describe :run_tests do
+    before do
+      File.stub!(:file?).with('.bundle/environment.rb').and_return false
+      File.stub!(:file?).with('script/spec').and_return true
+      File.stub!(:file?).with('spec/spec.opts').and_return true
+      File.stub!(:file?).with('spec/parallel_spec.opts').and_return false
+    end
+
+    it "uses TEST_ENV_NUMBER=blank when called for process 0" do
+      ParallelSpecs.should_receive(:open).with{|x,y|x=~/TEST_ENV_NUMBER= /}.and_return mock(:getc=>false)
+      ParallelSpecs.run_tests(['xxx'],0,'')
+    end
+
+    it "uses TEST_ENV_NUMBER=2 when called for process 1" do
+      ParallelSpecs.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER=2/}.and_return mock(:getc=>false)
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "runs with color when called from cmdline" do
+      ParallelSpecs.should_receive(:open).with{|x,y| x=~/RSPEC_COLOR=1/}.and_return mock(:getc=>false)
+      $stdout.should_receive(:tty?).and_return true
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "runs without color when not called from cmdline" do
+      ParallelSpecs.should_receive(:open).with{|x,y| x !~ /RSPEC_COLOR/}.and_return mock(:getc=>false)
+      $stdout.should_receive(:tty?).and_return false
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "run bundle exec spec when on bundler 0.9" do
+      File.stub!(:file?).with('.bundle/environment.rb').and_return true
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{bundle exec spec}}.and_return mock(:getc=>false)
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "runs script/spec when script/spec can be found" do
+      File.should_receive(:file?).with('script/spec').and_return true
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{script/spec}}.and_return mock(:getc=>false)
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "runs spec when script/spec cannot be found" do
+      File.stub!(:file?).with('script/spec').and_return false
+      ParallelSpecs.should_receive(:open).with{|x,y| x !~ %r{(script/spec)|(bundle exec spec)}}.and_return mock(:getc=>false)
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "uses no -O when no opts where found" do
+      File.stub!(:file?).with('spec/spec.opts').and_return false
+      ParallelSpecs.should_receive(:open).with{|x,y| x !~ %r{spec/spec.opts}}.and_return mock(:getc=>false)
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "uses spec/spec.opts when found" do
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{script/spec\s+-O spec/spec.opts}}.and_return mock(:getc=>false)
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "uses spec/parallel_spec.opts when found" do
+      File.should_receive(:file?).with('spec/parallel_spec.opts').and_return true
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{script/spec\s+-O spec/parallel_spec.opts}}.and_return mock(:getc=>false)
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "uses options passed in" do
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{script/spec -f n}}.and_return mock(:getc=>false)
+      ParallelSpecs.run_tests(['xxx'],1,'-f n')
+    end
+
+    it "returns the output" do
+      io = open('spec/spec_helper.rb')
+      ParallelSpecs.stub!(:print)
+      ParallelSpecs.should_receive(:open).and_return io
+      ParallelSpecs.run_tests(['xxx'],1,'').should =~ /\$LOAD_PATH << File/
+    end
+  end
+
+  describe :find_results do
+    it "finds multiple results in spec output" do
+      output = <<EOF
+....F...
+..
+failute fsddsfsd
+...
+ff.**..
+0 examples, 0 failures, 0 pending
+ff.**..
+1 example, 1 failure, 1 pending
+EOF
+
+      ParallelSpecs.find_results(output).should == ['0 examples, 0 failures, 0 pending','1 example, 1 failure, 1 pending']
+    end
+
+    it "is robust against scrambeled output" do
+      output = <<EOF
+....F...
+..
+failute fsddsfsd
+...
+ff.**..
+0 exFampl*es, 0 failures, 0 pend.ing
+ff.**..
+1 exampF.les, 1 failures, 1 pend.ing
+EOF
+
+      ParallelSpecs.find_results(output).should == ['0 examples, 0 failures, 0 pending','1 examples, 1 failures, 1 pending']
+    end
+  end
+
+  describe :failed do
+    it "fails with single failed specs" do
+      ParallelSpecs.failed?(['0 examples, 0 failures, 0 pending','1 examples, 1 failure, 1 pending']).should == true
+    end
+
+    it "fails with multiple failed specs" do
+      ParallelSpecs.failed?(['0 examples, 1 failure, 0 pending','1 examples, 111 failures, 1 pending']).should == true
+    end
+
+    it "does not fail with successful specs" do
+      ParallelSpecs.failed?(['0 examples, 0 failures, 0 pending','1 examples, 0 failures, 1 pending']).should == false
+    end
+
+    it "does fail with 10 failures" do
+      ParallelSpecs.failed?(['0 examples, 10 failures, 0 pending','1 examples, 0 failures, 1 pending']).should == true
+    end
+
+  end
+end

data/spec/parallel_tests_spec.rb

@@ -0,0 +1,130 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe ParallelTests do
+  test_tests_in_groups(ParallelTests, 'test', '_test.rb')
+
+  describe :parse_rake_args do
+    it "should return the count" do
+      args = {:count => 2}
+      ParallelTests.parse_rake_args(args).should == [2, '', ""]
+    end
+
+    it "should default to the prefix" do
+      args = {:count => "models"}
+      ParallelTests.parse_rake_args(args).should == [2, "models", ""]
+    end
+
+    it "should return the count and prefix" do
+      args = {:count => 2, :path_prefix => "models"}
+      ParallelTests.parse_rake_args(args).should == [2, "models", ""]
+    end
+
+    it "should return the count, prefix, and options" do
+      args = {:count => 2, :path_prefix => "plain", :options => "-p default" }
+      ParallelTests.parse_rake_args(args).should == [2, "plain", "-p default"]
+    end
+  end
+
+  describe :run_tests do
+    it "uses TEST_ENV_NUMBER=blank when called for process 0" do
+      ParallelTests.should_receive(:open).with{|x,y|x=~/TEST_ENV_NUMBER= /}.and_return mock(:getc=>false)
+      ParallelTests.run_tests(['xxx'],0,'')
+    end
+
+    it "uses TEST_ENV_NUMBER=2 when called for process 1" do
+      ParallelTests.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER=2/}.and_return mock(:getc=>false)
+      ParallelTests.run_tests(['xxx'],1,'')
+    end
+
+    it "uses options" do
+      ParallelTests.should_receive(:open).with{|x,y| x=~ %r{ruby -Itest -v}}.and_return mock(:getc=>false)
+      ParallelTests.run_tests(['xxx'],1,'-v')
+    end
+
+    it "returns the output" do
+      io = open('spec/spec_helper.rb')
+      ParallelTests.stub!(:print)
+      ParallelTests.should_receive(:open).and_return io
+      ParallelTests.run_tests(['xxx'],1,'').should =~ /\$LOAD_PATH << File/
+    end
+  end
+
+  describe :find_results do
+    it "finds multiple results in test output" do
+      output = <<EOF
+Loaded suite /opt/ruby-enterprise/lib/ruby/gems/1.8/gems/rake-0.8.4/lib/rake/rake_test_loader
+Started
+..............
+Finished in 0.145069 seconds.
+
+10 tests, 20 assertions, 0 failures, 0 errors
+Loaded suite /opt/ruby-enterprise/lib/ruby/gems/1.8/gems/rake-0.8.4/lib/rake/rake_test_loader
+Started
+..............
+Finished in 0.145069 seconds.
+
+14 tests, 20 assertions, 0 failures, 0 errors
+
+EOF
+
+      ParallelTests.find_results(output).should == ['10 tests, 20 assertions, 0 failures, 0 errors','14 tests, 20 assertions, 0 failures, 0 errors']
+    end
+
+    it "is robust against scrambeled output" do
+      output = <<EOF
+Loaded suite /opt/ruby-enterprise/lib/ruby/gems/1.8/gems/rake-0.8.4/lib/rake/rake_test_loader
+Started
+..............
+Finished in 0.145069 seconds.
+
+10 tests, 20 assertions, 0 failures, 0 errors
+Loaded suite /opt/ruby-enterprise/lib/ruby/gems/1.8/gems/rake-0.8.4/lib/rake/rake_test_loader
+Started
+..............
+Finished in 0.145069 seconds.
+
+14 te.dsts, 20 assertions, 0 failures, 0 errors
+EOF
+
+      ParallelTests.find_results(output).should == ['10 tests, 20 assertions, 0 failures, 0 errors','14 tedsts, 20 assertions, 0 failures, 0 errors']
+    end
+  end
+
+  describe :failed do
+    it "fails with single failed" do
+      ParallelTests.failed?(['10 tests, 20 assertions, 0 failures, 0 errors','10 tests, 20 assertions, 1 failure, 0 errors']).should == true
+    end
+
+    it "fails with single error" do
+      ParallelTests.failed?(['10 tests, 20 assertions, 0 failures, 1 errors','10 tests, 20 assertions, 0 failures, 0 errors']).should == true
+    end
+
+    it "fails with failed and error" do
+      ParallelTests.failed?(['10 tests, 20 assertions, 0 failures, 1 errors','10 tests, 20 assertions, 1 failures, 1 errors']).should == true
+    end
+
+    it "fails with multiple failed tests" do
+      ParallelTests.failed?(['10 tests, 20 assertions, 2 failures, 0 errors','10 tests, 1 assertion, 1 failures, 0 errors']).should == true
+    end
+
+    it "does not fail with successful tests" do
+      ParallelTests.failed?(['10 tests, 20 assertions, 0 failures, 0 errors','10 tests, 20 assertions, 0 failures, 0 errors']).should == false
+    end
+
+    it "does fail with 10 failures" do
+      ParallelTests.failed?(['10 tests, 20 assertions, 10 failures, 0 errors','10 tests, 20 assertions, 0 failures, 0 errors']).should == true
+    end
+
+    it "is not failed with empty results" do
+      ParallelTests.failed?(['0 tests, 0 assertions, 0 failures, 0 errors']).should == false
+    end
+
+    it "is failed when there are no results" do
+      ParallelTests.failed?([]).should == true
+    end
+  end
+
+  it "has a version" do
+    ParallelTests::VERSION.should =~ /^\d+\.\d+\.\d+$/
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,78 @@
+# ---- requirements
+$LOAD_PATH << File.expand_path("../lib", File.dirname(__FILE__))
+require 'rubygems'
+
+FAKE_RAILS_ROOT = '/tmp/pspecs/fixtures'
+
+require 'parallel_specs'
+require 'parallel_cucumber'
+
+def size_of(group)
+  group.inject(0) { |sum, test| sum += File.stat(test).size }
+end
+
+def test_tests_in_groups(klass, folder, suffix)
+  test_root = "#{FAKE_RAILS_ROOT}/#{folder}"
+
+  describe :tests_in_groups do
+    before :all do
+      system "rm -rf #{FAKE_RAILS_ROOT}; mkdir -p #{test_root}/temp"
+
+      @files = [0,1,2,3,4,5,6,7].map do |i|
+        size = 99
+        file = "#{test_root}/temp/x#{i}#{suffix}"
+        File.open(file, 'w') { |f| f.puts 'x' * size }
+        file
+      end
+
+      @log = "#{FAKE_RAILS_ROOT}/tmp/parallel_profile.log"
+      `mkdir #{File.dirname(@log)}`
+      `rm -f #{@log}`
+    end
+
+    it "finds all tests" do
+      found = klass.tests_in_groups(test_root, 1)
+      all = [ Dir["#{test_root}/**/*#{suffix}"] ]
+      (found.flatten - all.flatten).should == []
+    end
+
+    it "partitions them into groups by equal size" do
+      groups = klass.tests_in_groups(test_root, 2)
+      groups.size.should == 2
+      size_of(groups[0]).should == 400
+      size_of(groups[1]).should == 400
+    end
+
+    it 'should partition correctly with a group size of 4' do
+      groups = klass.tests_in_groups(test_root, 4)
+      groups.size.should == 4
+      size_of(groups[0]).should == 200
+      size_of(groups[1]).should == 200
+      size_of(groups[2]).should == 200
+      size_of(groups[3]).should == 200
+    end
+
+    it 'should partition correctly with an uneven group size' do
+      groups = klass.tests_in_groups(test_root, 3)
+      groups.size.should == 3
+      size_of(groups[0]).should == 300
+      size_of(groups[1]).should == 300
+      size_of(groups[2]).should == 200
+    end
+
+    it "partitions by runtime when runtime-data is available" do
+      File.open(@log,'w') do |f|
+        @files[1..-1].each{|file| f.puts "#{file}:#{@files.index(file)}"}
+        f.puts "#{@files[0]}:10"
+      end
+
+      groups = klass.tests_in_groups(test_root, 2)
+      groups.size.should == 2
+      # 10 + 7 = 17
+      groups[0].should == [@files[0],@files[7]]
+      # 6+5+4+3+2+1 = 21
+      # still room for optimization...
+      groups[1].should == [@files[6],@files[5],@files[4],@files[3],@files[2],@files[1]]
+    end
+  end
+end

data/tasks/parallel_specs.rake

@@ -0,0 +1,56 @@
+namespace :parallel do
+  desc "update test databases by running db:test:prepare for each --> parallel:prepare[num_cpus]"
+  task :prepare, :count do |t,args|
+    require File.join(File.dirname(__FILE__), '..', 'lib', "parallel_tests")
+
+    Parallel.in_processes(args[:count] ? args[:count].to_i : nil) do |i|
+      puts "Preparing test database #{i + 1}"
+      `export TEST_ENV_NUMBER=#{ParallelTests.test_env_number(i)} ; rake db:test:prepare`
+    end
+  end
+
+  # Useful when dumping/resetting takes too long
+  desc "update test databases by running db:mgrate for each --> parallel:migrate[num_cpus]"
+  task :migrate, :count do |t,args|
+    require File.join(File.dirname(__FILE__), '..', 'lib', "parallel_tests")
+
+    Parallel.in_processes(args[:count] ? args[:count].to_i : nil) do |i|
+      puts "Migrating test database #{i + 1}"
+      `export TEST_ENV_NUMBER=#{ParallelTests.test_env_number(i)} ; rake db:migrate RAILS_ENV=test`
+    end
+  end
+
+  ['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|
+      require File.join(File.dirname(__FILE__), '..', 'lib', "parallel_tests")
+      count, prefix, options = ParallelTests.parse_rake_args(args)
+      sh "#{File.join(File.dirname(__FILE__), '..', 'bin', 'parallel_test')} --type #{type} -n #{count} -p '#{prefix}' -r '#{RAILS_ROOT}' -o '#{options}'"
+    end
+  end
+end
+
+#backwards compatability
+#spec:parallel:prepare
+#spec:parallel
+#test:parallel
+namespace :spec do
+  namespace :parallel do
+    task :prepare, :count do |t,args|
+      $stderr.puts "WARNING -- Deprecated!  use parallel:prepare"
+      Rake::Task['parallel:prepare'].invoke(args[:count])
+    end
+  end
+
+  task :parallel, :count, :path_prefix do |t,args|
+    $stderr.puts "WARNING -- Deprecated! use parallel:spec"
+    Rake::Task['parallel:spec'].invoke(args[:count], args[:path_prefix])
+  end
+end
+
+namespace :test do
+  task :parallel, :count, :path_prefix do |t,args|
+    $stderr.puts "WARNING -- Deprecated! use parallel:test"
+    Rake::Task['parallel:test'].invoke(args[:count], args[:path_prefix])
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: parallel_tests
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
+platform: ruby
+authors: 
+- Michael Grosser
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-02 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: grosser.michael@gmail.com
+executables: 
+- parallel_test
+- parallel_spec
+- parallel_cucumber
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- .gitignore
+- README.markdown
+- Rakefile
+- VERSION
+- bin/parallel_cucumber
+- bin/parallel_spec
+- bin/parallel_test
+- lib/parallel_cucumber.rb
+- lib/parallel_specs.rb
+- lib/parallel_specs/spec_runtime_logger.rb
+- lib/parallel_tests.rb
+- parallel_tests.gemspec
+- spec/integration_spec.rb
+- spec/parallel_cucumber_spec.rb
+- spec/parallel_specs_spec.rb
+- spec/parallel_tests_spec.rb
+- spec/spec_helper.rb
+- tasks/parallel_specs.rake
+has_rdoc: true
+homepage: http://github.com/grosser/parallel_tests
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Run tests / specs / features in parallel
+test_files: 
+- spec/spec_helper.rb
+- spec/parallel_tests_spec.rb
+- spec/parallel_specs_spec.rb
+- spec/parallel_cucumber_spec.rb
+- spec/integration_spec.rb