moxiesoft_parallel_tests 0.4.13 → 0.6.18

data/lib/parallel_tests.rb

@@ -5,18 +5,23 @@ require 'parallel_tests/railtie'
 class ParallelTests
   VERSION = File.read( File.join(File.dirname(__FILE__),'..','VERSION') ).strip
 
-  # parallel:spec[2,controller] <-> parallel:spec[controller]
+  # parallel:spec[:count, :pattern, :options]
   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]
+    # order as given by user
+    args = [args[:count], args[:pattern], args[:options]]
+
+    # count given or empty ?
+    # parallel:spec[2,models,options]
+    # parallel:spec[,models,options]
+    count = args.shift if args.first.to_s =~ /^\d*$/
+    num_processes = count.to_i unless count.to_s.empty?
+    num_processes ||= ENV['PARALLEL_TEST_PROCESSORS'].to_i if ENV['PARALLEL_TEST_PROCESSORS']
+    num_processes ||= Parallel.processor_count
+
+    pattern = args.shift
+    options = args.shift
+
+    [num_processes.to_i, pattern.to_s, options.to_s]
   end
 
   # finds all tests and partitions them into groups
@@ -24,34 +29,29 @@ class ParallelTests
     if root.nil?
       root = ['unit', 'functional', 'integration'].collect { |dir| File.join(Dir.pwd, 'test', dir) }
     end
-
+    tests = find_tests(root, options)
     if options[:no_sort] == true
-      Grouper.in_groups(find_tests(root), num_groups)
+      Grouper.in_groups(tests, num_groups)
     else
-      Grouper.in_even_groups_by_size(tests_with_runtime(root), num_groups)
+      tests = with_runtime_info(tests)
+      Grouper.in_even_groups_by_size(tests, num_groups, options)
     end
   end
 
   def self.run_tests(test_files, process_number, options)
-    require_list = test_files.map { |filename| "\"#{filename}\"" }.join(",")
-    cmd = "ruby -Itest #{options} -e '[#{require_list}].each {|f| require f }'"
-    execute_command(cmd, process_number)
+    require_list = test_files.map { |filename| %{"#{File.expand_path filename}"} }.join(",")
+    cmd = "ruby -Itest -e '[#{require_list}].each {|f| require f }' -- #{options[:test_options]}"
+    execute_command(cmd, process_number, options)
   end
 
-  def self.execute_command(cmd, process_number)
+  def self.execute_command(cmd, process_number, options)
     cmd = "TEST_ENV_NUMBER=#{test_env_number(process_number)} ; export TEST_ENV_NUMBER; #{cmd}"
     print "starting #{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
+    output = fetch_output(f, options)
     f.close
     print "finished #{cmd}"
-    {:stdout => all, :exit_status => $?.exitstatus}
+    {:stdout => output, :exit_status => $?.exitstatus}
   end
 
   def self.find_results(test_output)
@@ -66,11 +66,54 @@ class ParallelTests
     process_number == 0 ? '' : process_number + 1
   end
 
+  def self.runtime_log
+    'tmp/parallel_runtime_test.log'
+  end
+
+  def self.summarize_results(results)
+    results = results.join(' ').gsub(/s\b/,'') # combine and singularize results
+    counts = results.scan(/(\d+) (\w+)/)
+    sums = counts.inject(Hash.new(0)) do |sum, (number, word)|
+      sum[word] += number.to_i
+      sum
+    end
+    sums.sort.map{|word, number|  "#{number} #{word}#{'s' if number != 1}" }.join(', ')
+  end
+
   protected
 
+  # read output of the process and print in in chucks
+  def self.fetch_output(process, options)
+    all = ''
+    buffer = ''
+    timeout = options[:chunk_timeout] || 0.2
+    flushed = Time.now.to_f
+
+    while char = process.getc
+      char = (char.is_a?(Fixnum) ? char.chr : char) # 1.8 <-> 1.9
+      all << char
+
+      # print in chunks so large blocks stay together
+      now = Time.now.to_f
+      buffer << char
+      if flushed + timeout < now
+        print buffer
+        STDOUT.flush
+        buffer = ''
+        flushed = now
+      end
+    end
+
+    # print the remainder
+    print buffer
+    STDOUT.flush
+
+    all
+  end
+
   # copied from http://github.com/carlhuda/bundler Bundler::SharedHelpers#find_gemfile
   def self.bundler_enabled?
-    return true if Object.const_defined?(:Bundler) 
+    return true if Object.const_defined?(:Bundler)
 
     previous = nil
     current = File.expand_path(Dir.pwd)
@@ -92,17 +135,17 @@ class ParallelTests
     "_test.rb"
   end
 
-  def self.tests_with_runtime(root)
-    tests = find_tests(root)
-    runtime_file = File.join(root,'..','tmp','parallel_profile.log')
-    lines = File.read(runtime_file).split("\n") rescue []
+  def self.with_runtime_info(tests)
+    lines = File.read(runtime_log).split("\n") rescue []
 
     # use recorded test runtime if we got enough data
     if lines.size * 1.5 > tests.size
+      puts "Using recorded test runtime"
       times = Hash.new(1)
       lines.each do |line|
         test, time = line.split(":")
-        times[test] = time.to_f
+        next unless test and time
+        times[File.expand_path(test)] = time.to_f
       end
       tests.sort.map{|test| [test, times[test]] }
     else # use file sizes
@@ -110,15 +153,16 @@ class ParallelTests
     end
   end
 
-  def self.find_tests(root)
+  def self.find_tests(root, options={})
     if root.is_a?(Array)
-      if root.first && Dir.exists?(root.first)
-        root.collect { |dir| find_tests(dir) }.flatten
-      else
-        root
-      end
+      root
     else
-      Dir["#{root}**/**/*#{self.test_suffix}"]
+      # follow one symlink and direct children
+      # http://stackoverflow.com/questions/357754/can-i-traverse-symlinked-directories-in-ruby-with-a-glob
+      files = Dir["#{root}/**{,/*/**}/*#{test_suffix}"].uniq
+      files = files.map{|f| f.sub(root+'/','') }
+      files = files.grep(/#{options[:pattern]}/)
+      files.map{|f| "#{root}/#{f}" }
     end
   end
 end

data/parallel_tests.gemspec

@@ -0,0 +1,64 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "parallel_tests"
+  s.version = "0.6.18"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael Grosser"]
+  s.date = "2012-02-08"
+  s.email = "grosser.michael@gmail.com"
+  s.executables = ["parallel_cucumber", "parallel_spec", "parallel_test"]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "Rakefile",
+    "Readme.md",
+    "VERSION",
+    "bin/parallel_cucumber",
+    "bin/parallel_spec",
+    "bin/parallel_test",
+    "lib/parallel_cucumber.rb",
+    "lib/parallel_cucumber/runtime_logger.rb",
+    "lib/parallel_specs.rb",
+    "lib/parallel_specs/spec_failures_logger.rb",
+    "lib/parallel_specs/spec_logger_base.rb",
+    "lib/parallel_specs/spec_runtime_logger.rb",
+    "lib/parallel_specs/spec_summary_logger.rb",
+    "lib/parallel_tests.rb",
+    "lib/parallel_tests/grouper.rb",
+    "lib/parallel_tests/railtie.rb",
+    "lib/parallel_tests/runtime_logger.rb",
+    "lib/parallel_tests/tasks.rb",
+    "lib/tasks/parallel_tests.rake",
+    "parallel_tests.gemspec",
+    "spec/integration_spec.rb",
+    "spec/parallel_cucumber_spec.rb",
+    "spec/parallel_specs/spec_failure_logger_spec.rb",
+    "spec/parallel_specs/spec_runtime_logger_spec.rb",
+    "spec/parallel_specs/spec_summary_logger_spec.rb",
+    "spec/parallel_specs_spec.rb",
+    "spec/parallel_tests/runtime_logger_spec.rb",
+    "spec/parallel_tests_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/grosser/parallel_tests"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "Run tests / specs / features in parallel"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<parallel>, [">= 0"])
+    else
+      s.add_dependency(%q<parallel>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<parallel>, [">= 0"])
+  end
+end

data/spec/integration_spec.rb

@@ -1,4 +1,4 @@
-require 'spec/spec_helper'
+require 'spec_helper'
 
 describe 'CLI' do
   before do
@@ -14,7 +14,7 @@ describe 'CLI' do
   end
 
   def write(file, content)
-    path = "#{folder}/spec/#{file}"
+    path = "#{folder}/#{file}"
     `mkdir -p #{File.dirname(path)}` unless File.exist?(File.dirname(path))
     File.open(path, 'w'){|f| f.write content }
     path
@@ -28,39 +28,48 @@ describe 'CLI' do
     "#{bin_folder}/parallel_test"
   end
 
-  def run_specs(options={})
-    `cd #{folder} && #{executable} -t spec -n #{options[:processes]||2} #{options[:add]} 2>&1`
+  def run_tests(options={})
+    `cd #{folder} && #{executable} --chunk-timeout 999 -t #{options[:type] || 'spec'} -n #{options[:processes]||2} #{options[:add]} 2>&1`
   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
+    write 'spec/xxx_spec.rb', 'describe("it"){it("should"){puts "TEST1"}}'
+    write 'spec/xxx2_spec.rb', 'describe("it"){it("should"){puts "TEST2"}}'
+    result = run_tests
 
     # 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('1 example, 0 failure').size.should == 2 # 2 results
+    result.scan('2 examples, 0 failures').size.should == 1 # 1 summary
     result.scan(/Finished in \d+\.\d+ seconds/).size.should == 2
     result.scan(/Took \d+\.\d+ seconds/).size.should == 1 # parallel summary
     $?.success?.should == true
   end
 
+  it "does not run any tests if there are none" do
+    write 'spec/xxx_spec.rb', '1'
+    result = run_tests
+    result.should include('No examples found')
+    result.should include('Took')
+  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
+    write 'spec/xxx_spec.rb', 'describe("it"){it("should"){puts "TEST1"}}'
+    write 'spec/xxx2_spec.rb', 'describe("it"){it("should"){1.should == 2}}'
+    result = run_tests
 
-    result.scan('1 example, 1 failure').size.should == 2
-    result.scan('1 example, 0 failure').size.should == 2
+    result.scan('1 example, 1 failure').size.should == 1
+    result.scan('1 example, 0 failure').size.should == 1
+    result.scan('2 examples, 1 failure').size.should == 1
     $?.success?.should == false
   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"]
+    result = `#{executable} -e 'ruby -e "print ENV[:TEST_ENV_NUMBER.to_s].to_i"' -n 4`
+    result.gsub('"','').split('').sort.should == %w[0 2 3 4]
   end
 
   it "can exec given command non-parallel" do
@@ -83,32 +92,70 @@ describe 'CLI' do
   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}}'
+    2.times{|i|
+      write "spec/xxx#{i}_spec.rb",  'describe("it"){it("should"){sleep 5}}; $stderr.puts ENV["TEST_ENV_NUMBER"]'
+    }
     t = Time.now
-    run_specs :processes => 6
+    run_tests(:processes => 2)
     expected = 10
     (Time.now - t).should <= expected
   end
 
   it "can can with given files" do
-    write "x1_spec.rb", "puts '111'"
-    write "x2_spec.rb", "puts '222'"
-    write "x3_spec.rb", "puts '333'"
-    result = run_specs(:add => 'spec/x1_spec.rb spec/x3_spec.rb')
+    write "spec/x1_spec.rb", "puts '111'"
+    write "spec/x2_spec.rb", "puts '222'"
+    write "spec/x3_spec.rb", "puts '333'"
+    result = run_tests(:add => 'spec/x1_spec.rb spec/x3_spec.rb')
     result.should include('111')
     result.should include('333')
     result.should_not include('222')
   end
 
   it "can run with test-options" do
-    write "x1_spec.rb", ""
-    write "x2_spec.rb", ""
-    result = run_specs(:add => "--test-options ' --version'", :processes => 2)
+    write "spec/x1_spec.rb", "111"
+    write "spec/x2_spec.rb", "111"
+    result = run_tests(:add => "--test-options ' --version'", :processes => 2)
     result.should =~ /\d+\.\d+\.\d+.*\d+\.\d+\.\d+/m # prints version twice
   end
-end
+
+  context "Test::Unit" do
+    it "runs" do
+      write "test/x1_test.rb", "require 'test/unit'; class XTest < Test::Unit::TestCase; def test_xxx; end; end"
+      result = run_tests(:type => :test)
+      result.should include('1 test')
+      $?.success?.should == true
+    end
+
+    it "passes test options" do
+      write "test/x1_test.rb", "require 'test/unit'; class XTest < Test::Unit::TestCase; def test_xxx; end; end"
+      result = run_tests(:type => :test, :add => '--test-options "-v"')
+      result.should include('test_xxx') # verbose output of every test
+    end
+  end
+
+  context "Cucumber" do
+    it "passes TEST_ENV_NUMBER when running with pattern (issue #86)" do
+      write "features/good1.feature", "Feature: xxx\n  Scenario: xxx\n    Given I print TEST_ENV_NUMBER"
+      write "features/good2.feature", "Feature: xxx\n  Scenario: xxx\n    Given I print TEST_ENV_NUMBER"
+      write "features/b.feature", "Feature: xxx\n  Scenario: xxx\n    Given I FAIL"
+      write "features/steps/a.rb", "Given('I print TEST_ENV_NUMBER'){ puts \"YOUR TEST ENV IS \#{ENV['TEST_ENV_NUMBER']}!\" }"
+
+      result = run_tests :type => 'features', :add => '--pattern good'
+      $?.success?.should == true
+
+      result.should include('YOUR TEST ENV IS 2!')
+      result.should include('YOUR TEST ENV IS !')
+      result.should_not include('I FAIL')
+    end
+
+    it "runs each feature once when there are more processes then features (issue #89)" do
+      write "features/steps/a.rb", "Given('I print TEST_ENV_NUMBER'){ puts \"YOUR TEST ENV IS \#{ENV['TEST_ENV_NUMBER']}!\" }"
+      2.times{|i|
+        write "features/good#{i}.feature", "Feature: xxx\n  Scenario: xxx\n    Given I print TEST_ENV_NUMBER"
+      }
+      result = run_tests :type => 'features', :add => '-n 3'
+      $?.success?.should == true
+      result.scan(/YOUR TEST ENV IS \d?!/).sort.should == ["YOUR TEST ENV IS !", "YOUR TEST ENV IS 2!"]
+    end
+  end
+end

data/spec/parallel_cucumber_spec.rb

@@ -1,4 +1,4 @@
-require 'spec/spec_helper'
+require 'spec_helper'
 
 describe ParallelCucumber do
   test_tests_in_groups(ParallelCucumber, 'features', ".feature")
@@ -12,41 +12,41 @@ describe ParallelCucumber do
 
     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 mocked_process
-      ParallelCucumber.run_tests(['xxx'],0,'')
+      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 mocked_process
-      ParallelCucumber.run_tests(['xxx'],1,'')
+      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,'')[:stdout].should =~ /\$LOAD_PATH << File/
+      ParallelCucumber.run_tests(['xxx'],1,{})[:stdout].should =~ /\$LOAD_PATH << File/
     end
 
     it "runs bundle exec cucumber when on bundler 0.9" do
       ParallelCucumber.stub!(:bundler_enabled?).and_return true
       ParallelCucumber.should_receive(:open).with{|x,y| x =~ %r{bundle exec cucumber}}.and_return mocked_process
-      ParallelCucumber.run_tests(['xxx'],1,'')
+      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 mocked_process
-      ParallelCucumber.run_tests(['xxx'],1,'')
+      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 mocked_process
-      ParallelCucumber.run_tests(['xxx'],1,'')
+      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 mocked_process
-      ParallelCucumber.run_tests(['xxx'],1,'-p default')
+      ParallelCucumber.should_receive(:open).with{|x,y| x =~ %r{script/cucumber .* -p default}}.and_return mocked_process
+      ParallelCucumber.run_tests(['xxx'],1,:test_options => '-p default')
     end
   end
 
@@ -69,4 +69,4 @@ 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
-end
+end

data/spec/parallel_specs_spec.rb

@@ -1,4 +1,7 @@
-require 'spec/spec_helper'
+require 'spec_helper'
+require 'parallel_specs/spec_runtime_logger'
+require 'parallel_specs/spec_summary_logger'
+require 'parallel_specs/spec_failures_logger'
 
 describe ParallelSpecs do
   test_tests_in_groups(ParallelSpecs, 'spec', '_spec.rb')
@@ -8,29 +11,44 @@ describe ParallelSpecs do
       File.stub!(:file?).with('script/spec').and_return false
       File.stub!(:file?).with('spec/spec.opts').and_return false
       File.stub!(:file?).with('spec/parallel_spec.opts').and_return false
+      File.stub!(:file?).with('.rspec_parallel').and_return false
       ParallelSpecs.stub!(:bundler_enabled?).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 mocked_process
-      ParallelSpecs.run_tests(['xxx'],0,'')
+      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 mocked_process
-      ParallelSpecs.run_tests(['xxx'],1,'')
+      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 mocked_process
+      ParallelSpecs.should_receive(:open).with{|x,y| x=~/ --tty /}.and_return mocked_process
       $stdout.should_receive(:tty?).and_return true
-      ParallelSpecs.run_tests(['xxx'],1,'')
+      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 mocked_process
+      ParallelSpecs.should_receive(:open).with{|x,y| x !~ / --tty /}.and_return mocked_process
       $stdout.should_receive(:tty?).and_return false
-      ParallelSpecs.run_tests(['xxx'],1,'')
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "runs with color for rspec 1 when called for the cmdline" do
+      File.should_receive(:file?).with('script/spec').and_return true
+      ParallelSpecs.should_receive(:open).with{|x,y| x=~/ RSPEC_COLOR=1 /}.and_return mocked_process
+      $stdout.should_receive(:tty?).and_return true
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "runs without color for rspec 1 when not called for the cmdline" do
+      File.should_receive(:file?).with('script/spec').and_return true
+      ParallelSpecs.should_receive(:open).with{|x,y| x !~ / RSPEC_COLOR=1 /}.and_return mocked_process
+      $stdout.should_receive(:tty?).and_return false
+      ParallelSpecs.run_tests(['xxx'],1,{})
     end
 
     it "run bundle exec spec when on bundler rspec 1" do
@@ -38,7 +56,7 @@ describe ParallelSpecs do
       ParallelSpecs.stub!(:bundler_enabled?).and_return true
       ParallelSpecs.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-1.0.2"
       ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{bundle exec spec}}.and_return mocked_process
-      ParallelSpecs.run_tests(['xxx'],1,'')
+      ParallelSpecs.run_tests(['xxx'],1,{})
     end
 
     it "run bundle exec rspec when on bundler rspec 2" do
@@ -46,39 +64,46 @@ describe ParallelSpecs do
       ParallelSpecs.stub!(:bundler_enabled?).and_return true
       ParallelSpecs.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-2.0.2"
       ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{bundle exec rspec}}.and_return mocked_process
-      ParallelSpecs.run_tests(['xxx'],1,'')
+      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 mocked_process
-      ParallelSpecs.run_tests(['xxx'],1,'')
+      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}}.and_return mocked_process
-      ParallelSpecs.run_tests(['xxx'],1,'')
+      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 mocked_process
-      ParallelSpecs.run_tests(['xxx'],1,'')
+      ParallelSpecs.run_tests(['xxx'],1,{})
     end
 
     it "uses -O spec/spec.opts when found (with script/spec)" do
       File.stub!(:file?).with('script/spec').and_return true
       File.stub!(:file?).with('spec/spec.opts').and_return true
-      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{script/spec\s+-O spec/spec.opts}}.and_return mocked_process
-      ParallelSpecs.run_tests(['xxx'],1,'')
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{script/spec\s+ -O spec/spec.opts}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,{})
     end
 
     it "uses -O spec/parallel_spec.opts when found (with script/spec)" do
       File.stub!(:file?).with('script/spec').and_return true
       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 mocked_process
-      ParallelSpecs.run_tests(['xxx'],1,'')
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{script/spec\s+ -O spec/parallel_spec.opts}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,{})
+    end
+
+    it "uses -O .rspec_parallel when found (with script/spec)" do
+      File.stub!(:file?).with('script/spec').and_return true
+      File.should_receive(:file?).with('.rspec_parallel').and_return true
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{script/spec\s+ -O .rspec_parallel}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,{})
     end
 
     it "uses -O spec/parallel_spec.opts with rspec1" do
@@ -88,30 +113,29 @@ describe ParallelSpecs do
       ParallelSpecs.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-1.0.2"
 
       ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{spec\s+ -O spec/parallel_spec.opts}}.and_return mocked_process
-      ParallelSpecs.run_tests(['xxx'],1,'')
+      ParallelSpecs.run_tests(['xxx'],1,{})
     end
 
-    it "uses inline options with rspec2" do
+    it "uses -O spec/parallel_spec.opts with rspec2" do
       File.should_receive(:file?).with('spec/parallel_spec.opts').and_return true
-      File.should_receive(:read).with('spec/parallel_spec.opts').and_return "--foo\n--bar\n"
 
       ParallelSpecs.stub!(:bundler_enabled?).and_return true
-      ParallelSpecs.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-2.0.2"
+      ParallelSpecs.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-2.4.2"
 
-      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{rspec\s+ --foo --bar}}.and_return mocked_process
-      ParallelSpecs.run_tests(['xxx'],1,'')
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{rspec\s+ --color --tty -O spec/parallel_spec.opts}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,{})
     end
 
     it "uses options passed in" do
       ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{rspec -f n}}.and_return mocked_process
-      ParallelSpecs.run_tests(['xxx'],1,'-f n')
+      ParallelSpecs.run_tests(['xxx'],1, :test_options => '-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,'')[:stdout].should =~ /\$LOAD_PATH << File/
+      ParallelSpecs.run_tests(['xxx'],1,{})[:stdout].should =~ /\$LOAD_PATH << File/
     end
   end
 
@@ -146,4 +170,4 @@ EOF
       ParallelSpecs.find_results(output).should == ['0 examples, 0 failures, 0 pending','1 examples, 1 failures, 1 pending']
     end
   end
-end
+end