parallel_tests 0.10.4 → 0.11.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    parallel_tests (0.10.4)
+    parallel_tests (0.11.0)
       parallel
 
 GEM

data/lib/parallel_tests/cucumber/runner.rb

@@ -6,10 +6,9 @@ module ParallelTests
       NAME = 'Cucumber'
 
       def self.run_tests(test_files, process_number, num_processes, options)
-        color = ($stdout.tty? ? 'AUTOTEST=1 ; export AUTOTEST ;' : '')#display color when we are in a terminal
+        options = options.merge(:env => {"AUTOTEST" => "1"}) if $stdout.tty? # display color when we are in a terminal
         runtime_logging = " --format ParallelTests::Cucumber::RuntimeLogger --out #{runtime_log}"
         cmd = [
-          color,
           executable,
           (runtime_logging if File.directory?(File.dirname(runtime_log))),
           cucumber_opts(options[:test_options]),

data/lib/parallel_tests/rspec/runner.rb

@@ -8,7 +8,8 @@ module ParallelTests
       def self.run_tests(test_files, process_number, num_processes, options)
         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} #{test_files*' '}"
+        cmd = [exe, options[:test_options], (rspec_2_color if version == 2), spec_opts, *test_files].compact.join(" ")
+        options = options.merge(:env => rspec_1_color) if version == 1
         execute_command(cmd, process_number, num_processes, options)
       end
 
@@ -44,11 +45,15 @@ module ParallelTests
       end
 
       def self.rspec_1_color
-        'RSPEC_COLOR=1 ; export RSPEC_COLOR ;' if $stdout.tty?
+        if $stdout.tty?
+          {'RSPEC_COLOR' => "1"}
+        else
+          {}
+        end
       end
 
       def self.rspec_2_color
-        '--color --tty ' if $stdout.tty?
+        '--color --tty' if $stdout.tty?
       end
 
       def self.spec_opts

data/lib/parallel_tests/test/runner.rb

@@ -1,3 +1,5 @@
+require 'open3'
+
 module ParallelTests
   module Test
     class Runner
@@ -46,12 +48,35 @@ module ParallelTests
       end
 
       def self.execute_command(cmd, process_number,  num_processes, options)
-        prefix = "PARALLEL_TEST_GROUPS=#{ num_processes } ; export PARALLEL_TEST_GROUPS;"
-        cmd = "#{prefix} TEST_ENV_NUMBER=#{test_env_number(process_number)} ; export TEST_ENV_NUMBER; #{cmd}"
-        f = open("|#{cmd}", 'r')
-        output = fetch_output(f, options)
-        f.close
-        {:stdout => output, :exit_status => $?.exitstatus}
+        env = (options[:env] || {}).merge(
+          "TEST_ENV_NUMBER" => test_env_number(process_number),
+          "PARALLEL_TEST_GROUPS" => num_processes
+        )
+        execute_command_and_capture_output(env, cmd, options[:serialize_stdout])
+      end
+
+      def self.execute_command_and_capture_output(env, cmd, silence)
+        # make processes descriptive / visible in ps -ef
+        exports = env.map do |k,v|
+          "#{k}=#{v};export #{k}"
+        end.join(";")
+        cmd = "#{exports};#{cmd}"
+
+        output, errput, exitstatus = nil
+        if RUBY_VERSION =~ /^1\.8/
+          open("|#{cmd}", "r") do |output|
+            output, errput = capture_output(output, nil, silence)
+          end
+          exitstatus = $?.exitstatus
+        else
+          Open3.popen3(cmd) do |stdin, stdout, stderr, thread|
+            stdin.close
+            output, errput = capture_output(stdout, stderr, silence)
+            exitstatus = thread.value.exitstatus
+          end
+        end
+
+        {:stdout => output, :stderr => errput, :exit_status => exitstatus}
       end
 
       def self.find_results(test_output)
@@ -84,26 +109,29 @@ module ParallelTests
       def self.sum_up_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)|
+        counts.inject(Hash.new(0)) do |sum, (number, word)|
           sum[word] += number.to_i
           sum
         end
-
-        sums
       end
 
       # read output of the process and print it in chunks
-      def self.fetch_output(process, options)
-        all = ''
-        while buffer = process.readpartial(1000000)
-          all << buffer
-          unless options[:serialize_stdout]
-            $stdout.print buffer
-            $stdout.flush
+      def self.capture_output(out, err, silence)
+        results = ["", ""]
+        loop do
+          [[out, $stdout, 0], [err, $stderr, 1]].each do |input, output, index|
+            next unless input
+            begin
+              read = input.readpartial(1000000) # read whatever chunk we can get
+              results[index] << read
+              output.print read if index == 1 || !silence
+
+            rescue EOFError
+              raise if index == 0 # we only care about the end of stdout
+            end
           end
         end rescue EOFError
-
-        all
+        results
       end
 
       def self.with_runtime_info(tests)

data/lib/parallel_tests/version.rb

@@ -1,3 +1,3 @@
 module ParallelTests
-  VERSION = Version = '0.10.4'
+  VERSION = Version = '0.11.0'
 end

data/spec/integration_spec.rb

@@ -188,7 +188,7 @@ describe 'CLI' do
   end
 
   it "can wait_for_other_processes_to_finish" do
-    write "test/a_test.rb", "require 'parallel_tests'; ParallelTests.wait_for_other_processes_to_finish; puts 'a'"
+    write "test/a_test.rb", "require 'parallel_tests'; sleep 0.5 ; ParallelTests.wait_for_other_processes_to_finish; puts 'a'"
     write "test/b_test.rb", "sleep 1; puts 'b'"
     write "test/c_test.rb", "sleep 1.5; puts 'c'"
     write "test/d_test.rb", "sleep 2; puts 'd'"

data/spec/parallel_tests/cucumber/runner_spec.rb

@@ -15,54 +15,36 @@ describe ParallelTests::Cucumber do
       ParallelTests::Cucumber::Runner.run_tests(*args)
     end
 
-    it "uses TEST_ENV_NUMBER=blank when called for process 0" do
-      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER= /}.and_return mocked_process
-      call(['xxx'],0,22,{})
-    end
-
-    it "uses TEST_ENV_NUMBER=2 when called for process 1" do
-      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER=2/}.and_return mocked_process
-      call(['xxx'],1,22,{})
-    end
-
-    it 'sets PARALLEL_TEST_GROUPS so child processes know that they are being run under parallel_tests' do
-      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x=~/PARALLEL_TEST_GROUPS=22/}.and_return mocked_process
-      call(['xxx'],1,22,{})
+    def should_run_with(regex)
+      ParallelTests::Test::Runner.should_receive(:execute_command).with{|a,b,c,d| a =~ regex}
     end
 
     it "allows to override runner executable via PARALLEL_TESTS_EXECUTABLE" do
       ENV['PARALLEL_TESTS_EXECUTABLE'] = 'script/custom_rspec'
-      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x=~/script\/custom_rspec/}.and_return mocked_process
+      should_run_with /script\/custom_rspec/
       call(['xxx'],1,22,{})
       ENV.delete('PARALLEL_TESTS_EXECUTABLE')
     end
 
-    it "returns the output" do
-      io = open('spec/spec_helper.rb')
-      $stdout.stub!(:print)
-      ParallelTests::Cucumber::Runner.should_receive(:open).and_return io
-      call(['xxx'],1,22,{})[:stdout].should =~ /\$LOAD_PATH << File/
-    end
-
     it "runs bundle exec cucumber when on bundler 0.9" do
       ParallelTests.stub!(:bundler_enabled?).and_return true
-      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x =~ %r{bundle exec cucumber}}.and_return mocked_process
+      should_run_with %r{bundle exec cucumber}
       call(['xxx'],1,22,{})
     end
 
     it "runs script/cucumber when script/cucumber is found" do
-      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x =~ %r{script/cucumber}}.and_return mocked_process
+      should_run_with %r{script/cucumber}
       call(['xxx'],1,22,{})
     end
 
     it "runs cucumber by default" do
       File.stub!(:file?).with('script/cucumber').and_return false
-      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x !~ %r{(script/cucumber)|(bundle exec cucumber)}}.and_return mocked_process
+      should_run_with %r{^cucumber}
       call(['xxx'],1,22,{})
     end
 
     it "uses options passed in" do
-      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x =~ %r{script/cucumber .* -p default}}.and_return mocked_process
+      should_run_with %r{script/cucumber .* -p default}
       call(['xxx'],1,22,:test_options => '-p default')
     end
 
@@ -74,31 +56,31 @@ describe ParallelTests::Cucumber do
       end
 
       it "uses parallel profile" do
-        ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x =~ %r{script/cucumber .* foo bar --profile parallel xxx}}.and_return mocked_process
+        should_run_with %r{script/cucumber .* foo bar --profile parallel xxx}
         call(['xxx'],1,22, :test_options => 'foo bar')
       end
 
       it "uses given profile via --profile" do
-        ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x =~ %r{script/cucumber .* --profile foo xxx$}}.and_return mocked_process
+        should_run_with %r{script/cucumber .* --profile foo xxx$}
         call(['xxx'],1,22, :test_options => '--profile foo')
       end
 
       it "uses given profile via -p" do
-        ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x =~ %r{script/cucumber .* -p foo xxx$}}.and_return mocked_process
+        should_run_with  %r{script/cucumber .* -p foo xxx$}
         call(['xxx'],1,22, :test_options => '-p foo')
       end
     end
 
     it "does not use parallel profile if config/cucumber.yml does not contain it" do
       file_contents = 'blob: -f progress'
-      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x =~ %r{script/cucumber .* foo bar}}.and_return mocked_process
+      should_run_with  %r{script/cucumber .* foo bar}
       Dir.should_receive(:glob).and_return ['config/cucumber.yml']
       File.should_receive(:read).with('config/cucumber.yml').and_return file_contents
       call(['xxx'],1,22,:test_options => 'foo bar')
     end
 
     it "does not use the parallel profile if config/cucumber.yml does not exist" do
-      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x =~ %r{script/cucumber .*}}.and_return mocked_process
+      should_run_with %r{script/cucumber} # TODO this test looks useless...
       Dir.should_receive(:glob).and_return []
       call(['xxx'],1,22,{})
     end

data/spec/parallel_tests/rspec/runner_spec.rb

@@ -17,107 +17,93 @@ describe ParallelTests::RSpec::Runner do
       ParallelTests::RSpec::Runner.run_tests(*args)
     end
 
-    it "uses TEST_ENV_NUMBER=blank when called for process 0" do
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y|x=~/TEST_ENV_NUMBER= /}.and_return mocked_process
-      call(['xxx'], 0, 22, {})
+    def should_run_with(regex)
+      ParallelTests::Test::Runner.should_receive(:execute_command).with{|a,b,c,d| a =~ regex}
     end
 
-    it "uses TEST_ENV_NUMBER=2 when called for process 1" do
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER=2/}.and_return mocked_process
-      call(['xxx'],1,22,{})
-    end
-
-    it 'sets PARALLEL_TEST_GROUPS so child processes know that they are being run under parallel_tests' do
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x=~/PARALLEL_TEST_GROUPS=22/}.and_return mocked_process
-      call(['xxx'],1,22,{})
-    end
-
-    it "allows to override runner executable via PARALLEL_TESTS_EXECUTABLE" do
-      ENV['PARALLEL_TESTS_EXECUTABLE'] = 'script/custom_rspec'
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x=~/script\/custom_rspec/}.and_return mocked_process
-      call(['xxx'],1,22,{})
-      ENV.delete('PARALLEL_TESTS_EXECUTABLE')
+    def should_not_run_with(regex)
+      ParallelTests::Test::Runner.should_receive(:execute_command).with{|a,b,c,d| a !~ regex}
     end
 
     it "runs with color when called from cmdline" do
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x=~/ --tty /}.and_return mocked_process
+      should_run_with %r{ --tty}
       $stdout.should_receive(:tty?).and_return true
-      call(['xxx'],1,22,{})
+      call('xxx', 1, 22, {})
     end
 
     it "runs without color when not called from cmdline" do
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x !~ / --tty /}.and_return mocked_process
+      should_not_run_with %r{ --tty}
       $stdout.should_receive(:tty?).and_return false
-      call(['xxx'],1,22,{})
+      call('xxx', 1, 22, {})
     end
 
     it "runs with color for rspec 1 when called for the cmdline" do
       File.should_receive(:file?).with('script/spec').and_return true
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x=~/ RSPEC_COLOR=1 /}.and_return mocked_process
+      ParallelTests::Test::Runner.should_receive(:execute_command).with { |a, b, c, d| d[:env] == {"RSPEC_COLOR" => "1"} }
       $stdout.should_receive(:tty?).and_return true
-      call(['xxx'],1,22,{})
+      call('xxx', 1, 22, {})
     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
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x !~ / RSPEC_COLOR=1 /}.and_return mocked_process
+      ParallelTests::Test::Runner.should_receive(:execute_command).with { |a, b, c, d| d[:env] == {} }
       $stdout.should_receive(:tty?).and_return false
-      call(['xxx'],1,22,{})
+      call('xxx', 1, 22, {})
     end
 
     it "run bundle exec spec when on bundler rspec 1" do
       File.stub!(:file?).with('script/spec').and_return false
       ParallelTests.stub!(:bundler_enabled?).and_return true
       ParallelTests::RSpec::Runner.stub!(:run).with("bundle show rspec-core").and_return "Could not find gem 'rspec-core' in bundler."
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{bundle exec spec}}.and_return mocked_process
-      call(['xxx'],1,22,{})
+      should_run_with %r{bundle exec spec}
+      call('xxx', 1, 22, {})
     end
 
     it "run bundle exec rspec when on bundler rspec 2" do
       File.stub!(:file?).with('script/spec').and_return false
       ParallelTests.stub!(:bundler_enabled?).and_return true
       ParallelTests::RSpec::Runner.stub!(:run).with("bundle show rspec-core").and_return "/foo/bar/rspec-core-2.0.2"
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{bundle exec rspec}}.and_return mocked_process
-      call(['xxx'],1,22,{})
+      should_run_with %r{bundle exec rspec}
+      call('xxx', 1, 22, {})
     end
 
     it "runs script/spec when script/spec can be found" do
       File.should_receive(:file?).with('script/spec').and_return true
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{script/spec}}.and_return mocked_process
-      call(['xxx'],1,22,{})
+      should_run_with %r{script/spec}
+      call('xxx' ,1, 22, {})
     end
 
     it "runs spec when script/spec cannot be found" do
       File.stub!(:file?).with('script/spec').and_return false
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x !~ %r{script/spec}}.and_return mocked_process
-      call(['xxx'],1,22,{})
+      should_not_run_with %r{ script/spec}
+      call('xxx', 1, 22, {})
     end
 
     it "uses no -O when no opts where found" do
       File.stub!(:file?).with('spec/spec.opts').and_return false
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x !~ %r{spec/spec.opts}}.and_return mocked_process
-      call(['xxx'],1,22,{})
+      should_not_run_with %r{spec/spec.opts}
+      call('xxx', 1, 22, {})
     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
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{script/spec\s+ -O spec/spec.opts}}.and_return mocked_process
-      call(['xxx'],1,22,{})
+      should_run_with %r{script/spec\s+-O spec/spec.opts}
+      call('xxx', 1, 22, {})
     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
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{script/spec\s+ -O spec/parallel_spec.opts}}.and_return mocked_process
-      call(['xxx'],1,22,{})
+      should_run_with %r{script/spec\s+-O spec/parallel_spec.opts}
+      call('xxx', 1, 22, {})
     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
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{script/spec\s+ -O .rspec_parallel}}.and_return mocked_process
-      call(['xxx'],1,22,{})
+      should_run_with %r{script/spec\s+-O .rspec_parallel}
+      call('xxx', 1, 22, {})
     end
 
     it "uses -O spec/parallel_spec.opts with rspec1" do
@@ -126,8 +112,8 @@ describe ParallelTests::RSpec::Runner do
       ParallelTests.stub!(:bundler_enabled?).and_return true
       ParallelTests::RSpec::Runner.stub!(:run).with("bundle show rspec-core").and_return "Could not find gem 'rspec-core'."
 
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{spec\s+ -O spec/parallel_spec.opts}}.and_return mocked_process
-      call(['xxx'],1,22,{})
+      should_run_with %r{spec\s+-O spec/parallel_spec.opts}
+      call('xxx', 1, 22, {})
     end
 
     it "uses -O spec/parallel_spec.opts with rspec2" do
@@ -136,20 +122,18 @@ describe ParallelTests::RSpec::Runner do
       ParallelTests.stub!(:bundler_enabled?).and_return true
       ParallelTests::RSpec::Runner.stub!(:run).with("bundle show rspec-core").and_return "/foo/bar/rspec-core-2.4.2"
 
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{rspec\s+ --color --tty -O spec/parallel_spec.opts}}.and_return mocked_process
-      call(['xxx'],1,22,{})
+      should_run_with %r{rspec\s+--color --tty -O spec/parallel_spec.opts}
+      call('xxx', 1, 22, {})
     end
 
     it "uses options passed in" do
-      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{rspec -f n}}.and_return mocked_process
-      call(['xxx'],1,22, :test_options => '-f n')
+      should_run_with %r{rspec -f n}
+      call('xxx', 1, 22, :test_options => '-f n')
     end
 
     it "returns the output" do
-      io = open('spec/spec_helper.rb')
-      $stdout.stub!(:print)
-      ParallelTests::RSpec::Runner.should_receive(:open).and_return io
-      call(['xxx'],1,22,{})[:stdout].should =~ /\$LOAD_PATH << File/
+      ParallelTests::RSpec::Runner.should_receive(:execute_command).and_return :x => 1
+      call('xxx', 1, 22, {}).should == {:x => 1}
     end
   end
 

data/spec/parallel_tests/test/runner_spec.rb

@@ -4,57 +4,33 @@ require "parallel_tests/test/runner"
 describe ParallelTests::Test::Runner do
   test_tests_in_groups(ParallelTests::Test::Runner, 'test', '_test.rb')
 
-  describe :run_tests do
+  describe ".run_tests" do
     def call(*args)
       ParallelTests::Test::Runner.run_tests(*args)
     end
 
-    it "uses TEST_ENV_NUMBER=blank when called for process 0" do
-      ParallelTests::Test::Runner.should_receive(:open).with{|x,y|x=~/TEST_ENV_NUMBER= /}.and_return mocked_process
-      call(['xxx'],0,22,{})
-    end
-
-    it "uses TEST_ENV_NUMBER=2 when called for process 1" do
-      ParallelTests::Test::Runner.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER=2/}.and_return mocked_process
-      call(['xxx'],1,22,{})
-    end
-
-    it 'sets PARALLEL_TEST_GROUPS so child processes know that they are being run under parallel_tests' do
-      ENV['PARALLEL_TEST_PROCESSORS'] = '22'
-      ParallelTests::Test::Runner.should_receive(:open).with{|x,y| x=~/PARALLEL_TEST_GROUPS=22/}.and_return mocked_process
-      call(['xxx'],1,22,{})
-      ENV.delete('PARALLEL_TEST_PROCESSORS')
-    end
-
     it "allows to override runner executable via PARALLEL_TESTS_EXECUTABLE" do
-      ENV['PARALLEL_TESTS_EXECUTABLE'] = 'script/custom_rspec'
-      ParallelTests::Test::Runner.should_receive(:open).with{|x,y| x=~/script\/custom_rspec/}.and_return mocked_process
-      call(['xxx'],1,22,{})
-      ENV.delete('PARALLEL_TESTS_EXECUTABLE')
+      begin
+        ENV['PARALLEL_TESTS_EXECUTABLE'] = 'script/custom_rspec'
+        ParallelTests::Test::Runner.should_receive(:execute_command).with{|a,b,c,d| a.include?("script/custom_rspec") }
+        call(['xxx'], 1, 22, {})
+      ensure
+        ENV.delete('PARALLEL_TESTS_EXECUTABLE')
+      end
     end
 
     it "uses options" do
-      ParallelTests::Test::Runner.should_receive(:open).with{|x,y| x=~ %r{ruby -Itest .* -- -v}}.and_return mocked_process
-      call(['xxx'],1,22,:test_options => '-v')
+      ParallelTests::Test::Runner.should_receive(:execute_command).with{|a,b,c,d| a =~ %r{ruby -Itest .* -- -v}}
+      call(['xxx'], 1, 22, :test_options => '-v')
     end
 
     it "returns the output" do
-      io = open('spec/spec_helper.rb')
-      $stdout.stub!(:print)
-      ParallelTests::Test::Runner.should_receive(:open).and_return io
-      call(['xxx'],1,22,{})[:stdout].should =~ /\$LOAD_PATH << File/
-    end
-
-    it "does not output to stdout when serializing output" do
-      io = open('spec/spec_helper.rb')
-      $stdout.should_not_receive(:print)
-      $stdout.should_not_receive(:flush)
-      ParallelTests::Test::Runner.should_receive(:open).and_return io
-      call(['xxx'],1,22,{:serialize_stdout => true})[:stdout]
+      ParallelTests::Test::Runner.should_receive(:execute_command).and_return({:x => 1})
+      call(['xxx'], 1, 22, {}).should == {:x => 1}
     end
   end
 
-  describe :test_in_groups do
+  describe ".test_in_groups" do
     def call(*args)
       ParallelTests::Test::Runner.tests_in_groups(*args)
     end
@@ -98,7 +74,7 @@ describe ParallelTests::Test::Runner do
     end
   end
 
-  describe :find_results do
+  describe ".find_results" do
     def call(*args)
       ParallelTests::Test::Runner.find_results(*args)
     end
@@ -150,7 +126,7 @@ EOF
     end
   end
 
-  describe :find_tests do
+  describe ".find_tests" do
     def call(*args)
       ParallelTests::Test::Runner.send(:find_tests, *args)
     end
@@ -268,7 +244,7 @@ EOF
     end
   end
 
-  describe :summarize_results do
+  describe ".summarize_results" do
     def call(*args)
       ParallelTests::Test::Runner.summarize_results(*args)
     end
@@ -293,4 +269,155 @@ EOF
       call(['1 xxx 2 yyy']).should == '1 xxx, 2 yyys'
     end
   end
+
+  describe ".execute_command" do
+    def call(*args)
+      ParallelTests::Test::Runner.execute_command(*args)
+    end
+
+    def capture_output
+      $stdout, $stderr = StringIO.new, StringIO.new
+      yield
+      [$stdout.string, $stderr.string]
+    ensure
+      $stdout, $stderr = STDOUT, STDERR
+    end
+
+    def run_with_file(content)
+      capture_output do
+        Tempfile.open("xxx") do |f|
+          f.write(content)
+          f.flush
+          yield f.path
+        end
+      end
+    end
+
+    it "sets process number to 2 for 1" do
+      run_with_file("puts ENV['TEST_ENV_NUMBER']") do |path|
+        result = call("ruby #{path}", 1, 4, {})
+        result.should == {
+          :stdout => "2\n",
+          :stderr => "",
+          :exit_status => 0
+        }
+      end
+    end
+
+    it "sets process number to '' for 0" do
+      run_with_file("puts ENV['TEST_ENV_NUMBER'].inspect") do |path|
+        result = call("ruby #{path}", 0, 4, {})
+        result.should == {
+          :stdout => "\"\"\n",
+          :stderr => "",
+          :exit_status => 0
+        }
+      end
+    end
+
+    it 'sets PARALLEL_TEST_GROUPS so child processes know that they are being run under parallel_tests' do
+      run_with_file("puts ENV['PARALLEL_TEST_GROUPS']") do |path|
+        result = call("ruby #{path}", 1, 4, {})
+        result.should == {
+          :stdout => "4\n",
+          :stderr => "",
+          :exit_status => 0
+        }
+      end
+    end
+
+    it "skips reads from stdin" do
+      if RUBY_VERSION =~ /^1\.8/
+        pending
+      else
+        run_with_file("$stdin.read; puts 123") do |path|
+          result = call("ruby #{path}", 1, 2, {})
+          result.should == {
+            :stdout => "123\n",
+            :stderr => "",
+            :exit_status => 0
+          }
+        end
+      end
+    end
+
+    it "waits for process to finish" do
+      run_with_file("sleep 0.5; puts 123; sleep 0.5; puts 345") do |path|
+        result = call("ruby #{path}", 1, 4, {})
+        result.should == {
+          :stdout => "123\n345\n",
+          :stderr => "",
+          :exit_status => 0
+        }
+      end
+    end
+
+    it "prints output while running" do
+      run_with_file("$stdout.sync = true; puts 123; sleep 0.1; print 345; sleep 0.1; puts 567") do |path|
+        $stdout.should_receive(:print).with("123\n")
+        if RUBY_VERSION =~ /^1\.8/
+          $stdout.should_receive(:print).with("345")
+          $stdout.should_receive(:print).with("567\n")
+        else
+          $stdout.should_receive(:print).with("345567\n")
+        end
+        result = call("ruby #{path}", 1, 4, {})
+        result.should == {
+          :stdout => "123\n345567\n",
+          :stderr => "",
+          :exit_status => 0
+        }
+      end
+    end
+
+    it "works with synced stdout" do
+      run_with_file("$stdout.sync = true; puts 123; sleep 0.1; puts 345") do |path|
+        result = call("ruby #{path}", 1, 4, {})
+        result.should == {
+          :stdout => "123\n345\n",
+          :stderr => "",
+          :exit_status => 0
+        }
+      end
+    end
+
+    it "does not print to stdout with :serialize_stdout" do
+      run_with_file("puts 123") do |path|
+        $stdout.should_not_receive(:print)
+        result = call("ruby #{path}", 1, 4, :serialize_stdout => true)
+        result.should == {
+          :stdout => "123\n",
+          :stderr => "",
+          :exit_status => 0
+        }
+      end
+    end
+
+    it "returns correct exit status" do
+      run_with_file("puts 123; exit 5") do |path|
+        result = call("ruby #{path}", 1, 4, {})
+        result.should == {
+          :stdout => "123\n",
+          :stderr => "",
+          :exit_status => 5
+        }
+      end
+    end
+
+    it "prints each stream to the correct stream" do
+      if RUBY_VERSION =~ /^1\.8/
+        pending
+      else
+        out, err = run_with_file("puts 123 ; $stderr.puts 345 ; exit 5") do |path|
+          result = call("ruby #{path}", 1, 4, {})
+          result.should == {
+            :stdout => "123\n",
+            :stderr => "345\n",
+            :exit_status => 5
+          }
+        end
+        err.should == "345\n"
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -27,7 +27,7 @@ RSpec.configure do |config|
 end
 
 def mocked_process
-  open('|cat /dev/null')
+  StringIO.new
 end
 
 def size_of(group)

metadata

@@ -1,41 +1,47 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: parallel_tests
-version: !ruby/object:Gem::Version
-  version: 0.10.4
+version: !ruby/object:Gem::Version 
+  hash: 51
   prerelease: 
+  segments: 
+  - 0
+  - 11
+  - 0
+  version: 0.11.0
 platform: ruby
-authors:
+authors: 
 - Michael Grosser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-25 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2013-04-13 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: parallel
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
+  type: :runtime
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id001
 description: 
 email: michael@grosser.it
-executables:
+executables: 
 - parallel_cucumber
 - parallel_rspec
 - parallel_test
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
 - .rspec
 - .travis.yml
@@ -79,34 +85,37 @@ files:
 - spec/parallel_tests_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/grosser/parallel_tests
-licenses:
+licenses: 
 - MIT
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-      segments:
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
       - 0
-      hash: -3747523208207304867
-required_rubygems_version: !ruby/object:Gem::Requirement
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-      segments:
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
       - 0
-      hash: -3747523208207304867
+      version: "0"
 requirements: []
+
 rubyforge_project: 
 rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Run Test::Unit / RSpec / Cucumber in parallel
 test_files: []
+