right_popen 1.0.11 → 1.0.16

data/spec/right_popen/linux/utilities_spec.rb

@@ -0,0 +1,178 @@
+#--  -*- mode: ruby; encoding: utf-8 -*-
+# Copyright: Copyright (c) 2011 RightScale, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+module RightScale::RightPopen
+  describe Utilities do
+    describe :run do
+      it 'should collect stdout and stderr' do
+        out, err = Utilities::run("echo foo; echo bar >&2")
+        out.should == "foo\n"
+        err.should == "bar\n"
+      end
+
+      it 'should handle utilities that expect input' do
+        out, err = Utilities::run("echo foo; read; echo bar >&2")
+        out.should == "foo\n"
+        err.should == "bar\n"
+      end
+
+      it 'should raise an error if the command fails' do
+        lambda { Utilities::run("false") }.should raise_exception(/Command "false" failed with exit status 1/)
+      end
+
+      it 'should raise an error if the command gets killed' do
+        lambda { Utilities::run("kill $$") }.should raise_exception(/Command ".*" failed due to SIGTERM/)
+      end
+
+      it 'should not invoke the shell when inappropriate' do
+        out, err = Utilities::run(["echo", "foo;", "echo", "bar", ">&2"])
+        out.should == "foo; echo bar >&2\n"
+        err.should be_empty
+      end
+    end
+
+    describe :run_collecting_output do
+      it 'should work' do
+        status, out, err = Utilities::run_collecting_output("echo foo; echo bar >&2")
+        status.should be_success
+        out.should == "foo\n"
+        err.should == "bar\n"
+      end
+
+      it 'should handle the command failing gracefully' do
+        status, out, err = Utilities::run_collecting_output("false")
+        status.should_not be_success
+        status.exitstatus.should == 1
+        out.should be_empty
+        err.should be_empty
+      end
+
+      it 'should handle the command self terminating gracefully' do
+        status, out, err = Utilities::run_collecting_output("kill $$")
+        status.should_not be_success
+        status.exitstatus.should be_nil
+        status.termsig.should == 15
+        out.should be_empty
+        err.should be_empty
+      end
+
+      it 'should not invoke the shell when inappropriate' do
+        status, out, err = Utilities::run_collecting_output(["echo", "foo;", "read", "foo", ";", "echo", "bar", ">&2"])
+        status.should be_success
+        out.should == "foo; read foo ; echo bar >&2\n"
+        err.should be_empty
+      end
+    end
+
+    describe :run_with_stdin_collecting_output do
+      it 'should work even if subprocess ignores stdin' do
+        status, out, err = Utilities::run_with_stdin_collecting_output("echo foo; echo bar >&2", "foo")
+        status.should be_success
+        out.should == "foo\n"
+        err.should == "bar\n"
+      end
+
+      it 'should handle utilities that expect input' do
+        status, out, err = Utilities::run_with_stdin_collecting_output("echo foo; read foo; echo $foo >&2", "blotz")
+        status.should be_success
+        out.should == "foo\n"
+        err.should == "blotz\n"
+      end
+
+      it 'should handle the command failing gracefully' do
+        status, out, err = Utilities::run_with_stdin_collecting_output("false", "blotz")
+        status.should_not be_success
+        status.exitstatus.should == 1
+        out.should be_empty
+        err.should be_empty
+      end
+
+      it 'should handle the command self terminating gracefully' do
+        status, out, err = Utilities::run_with_stdin_collecting_output("kill $$", "blotz")
+        status.should_not be_success
+        status.exitstatus.should be_nil
+        status.termsig.should == 15
+        out.should be_empty
+        err.should be_empty
+      end
+
+      it 'should not invoke the shell when inappropriate' do
+        status, out, err = Utilities::run_with_stdin_collecting_output(["echo", "foo;", "read", "foo", ";", "echo", "bar", ">&2"], "blotz")
+        status.should be_success
+        out.should == "foo; read foo ; echo bar >&2\n"
+        err.should be_empty
+      end
+    end
+
+    describe :run_with_blocks do
+      it 'should work even if subprocess ignores stdin' do
+        status = Utilities::run_with_blocks("echo foo; echo bar >&2",
+                                            lambda { "foo" },
+                                            lambda { |b| b.should == "foo\n" },
+                                            lambda { |b| b.should == "bar\n" })
+        status.should be_success
+      end
+
+      it 'should handle interaction' do
+        output_counter = 0
+        seen = {}
+        in_block = lambda {
+          if seen[output_counter]
+            ""
+          else
+            seen[output_counter] = true
+            "foo\n"
+          end
+        }
+        status = Utilities::run_with_blocks("for x in 1 2 3; do read var; echo $var; done; echo bar >&2",
+                                            in_block,
+                                            lambda { |b| output_counter += 1; b.should == "foo\n" },
+                                            lambda { |b| b.should == "bar\n" })
+        status.should be_success
+        output_counter.should == 3
+      end
+
+      it 'should handle the command failing gracefully' do
+        status = Utilities::run_with_blocks("echo foo; echo bar >&2; false",
+                                            lambda { "blotz" }, nil, nil)
+        status.should_not be_success
+        status.exitstatus.should == 1
+      end
+
+      it 'should handle the command self terminating gracefully' do
+        status = Utilities::run_with_blocks("echo foo; echo bar >&2; kill $$",
+                                            lambda { "blotz" }, nil, nil)
+        status.should_not be_success
+        status.exitstatus.should be_nil
+        status.termsig.should == 15
+      end
+
+      it 'should not invoke the shell when inappropriate' do
+        status, out, err = Utilities::run_with_blocks(["echo", "foo;", "read", "foo", ";", "echo", "bar", ">&2"], nil, lambda {|b| b.should == "foo; read foo ; echo bar >&2\n"}, nil)
+        status.should be_success
+      end
+    end
+  end
+end

data/spec/right_popen_spec.rb

@@ -1,298 +1,230 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'runner'))
 
-describe 'RightScale::popen3' do
-
-  module RightPopenSpec
-    class Runner
-      class RunnerStatus
-        def initialize(command, block)
-          @output_text = ""
-          @error_text  = ""
-          @status      = nil
-          @did_timeout = false
-          @callback    = block
-          @pid         = nil
-          EM.next_tick do
-            @timeout = EM::Timer.new(2) do
-              puts "\n** Failed to run #{command.inspect}: Timeout"
-              @did_timeout = true
-              @callback.call(self)
-            end
-          end
-        end
-
-        attr_accessor :output_text, :error_text, :status, :did_timeout, :pid
+module RightScale
+  describe 'popen3' do
+    def is_windows?
+      return !!(RUBY_PLATFORM =~ /mswin/)
+    end
 
-        def on_read_stdout(data)
-          @output_text << data
-        end
+    it 'should redirect output' do
+      command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_output.rb'))}\" \"#{STANDARD_MESSAGE}\" \"#{ERROR_MESSAGE}\""
+      runner = Runner.new
+      status = runner.run_right_popen(command)
+      status.status.exitstatus.should == 0
+      status.output_text.should == STANDARD_MESSAGE + "\n"
+      status.error_text.should == ERROR_MESSAGE + "\n"
+      status.pid.should > 0
+    end
 
-        def on_read_stderr(data)
-          @error_text << data
-        end
+    it 'should return the right status' do
+      command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_status.rb'))}\" #{EXIT_STATUS}"
+      runner = Runner.new
+      status = runner.run_right_popen(command)
+      status.status.exitstatus.should == EXIT_STATUS
+      status.output_text.should == ''
+      status.error_text.should == ''
+      status.pid.should > 0
+    end
 
-        def on_pid(pid)
-          raise "PID already set!" unless @pid.nil?
-          @pid = pid
+    it 'should correctly handle many small processes' do
+      pending 'Set environment variable TEST_STRESS to enable' unless ENV['TEST_STRESS']
+      TO_RUN = 100
+      command = is_windows? ? "cmd.exe /c exit 0" : "exit 0"
+      runner = Runner.new
+      @completed = 0
+      @started = 0
+      run_cmd = Proc.new do
+        runner.do_right_popen(command) do |status|
+          @completed += 1
+          status.status.exitstatus.should == 0
+          status.output_text.should == ''
+          status.error_text.should == ''
+          status.pid.should > 0
         end
-
-        def on_exit(status)
-          @timeout.cancel if @timeout
-          @status = status
-          @callback.call(self)
+        @started += 1
+        if @started < TO_RUN
+          EM.next_tick { run_cmd.call }
         end
       end
+      EM.run do
+        EM.next_tick { run_cmd.call }
 
-      def initialize
-        @count          = 0
-        @done           = false
-        @last_exception = nil
-        @last_iteration = 0
-      end
-
-      def do_right_popen(command, env=nil, input=nil, &callback)
-        status = RunnerStatus.new(command, callback)
-        RightScale.popen3(:command        => command,
-                          :input          => input,
-                          :target         => status,
-                          :environment    => env,
-                          :stdout_handler => :on_read_stdout,
-                          :stderr_handler => :on_read_stderr,
-                          :pid_handler    => :on_pid,
-                          :exit_handler   => :on_exit)
-        status
-      end
-
-      def run_right_popen(command, env=nil, input=nil, count=1)
-        begin
-          @iterations = 0
-          EM.run do
-            EM.next_tick do
-              do_right_popen(command, env, input) do |status|
-                maybe_continue(status)
-              end
-            end
+        EM::PeriodicTimer.new(1) do
+          if @completed >= TO_RUN
+            EM.stop
           end
-          @status
-        rescue Exception => e
-          puts "\n** Failed: #{e.message} FROM\n#{e.backtrace.join("\n")}"
-          raise e
-        end
-      end
-
-      def maybe_continue(status)
-        @iterations += 1
-        if @iterations < @count
-          do_right_popen(command, env, input) {|status| maybe_continue(status)}
-        else
-          @status = status
-          EM.stop
         end
       end
     end
-  end
 
-  def is_windows?
-    return !!(RUBY_PLATFORM =~ /mswin/)
-  end
-
-  it 'should redirect output' do
-    command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_output.rb'))}\" \"#{STANDARD_MESSAGE}\" \"#{ERROR_MESSAGE}\""
-    runner = RightPopenSpec::Runner.new
-    status = runner.run_right_popen(command)
-    status.status.exitstatus.should == 0
-    status.output_text.should == STANDARD_MESSAGE + "\n"
-    status.error_text.should == ERROR_MESSAGE + "\n"
-    status.pid.should > 0
-  end
-
-  it 'should return the right status' do
-    command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_status.rb'))}\" #{EXIT_STATUS}"
-    runner = RightPopenSpec::Runner.new
-    status = runner.run_right_popen(command)
-    status.status.exitstatus.should == EXIT_STATUS
-    status.output_text.should == ''
-    status.error_text.should == ''
-    status.pid.should > 0
-  end
-
-  it 'should correctly handle many small processes' do
-    pending 'Set environment variable TEST_STRESS to enable' unless ENV['TEST_STRESS']
-    TO_RUN = 100
-    command = is_windows? ? "cmd.exe /c exit 0" : "exit 0"
-    runner = RightPopenSpec::Runner.new
-    @completed = 0
-    @started = 0
-    run_cmd = Proc.new do
-      runner.do_right_popen(command) do |status|
-        @completed += 1
-        status.status.exitstatus.should == 0
-        status.output_text.should == ''
-        status.error_text.should == ''
-        status.pid.should > 0
-      end
-      @started += 1
-      if @started < TO_RUN
-        EM.next_tick { run_cmd.call }
-      end
-    end
-    EM.run do
-      EM.next_tick { run_cmd.call }
+    it 'should preserve the integrity of stdout when stderr is unavailable' do
+      count = LARGE_OUTPUT_COUNTER
+      command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_stdout_only.rb'))}\" #{count}"
+      runner = Runner.new
+      status = runner.run_right_popen(command)
+      status.status.exitstatus.should == 0
 
-      EM::PeriodicTimer.new(1) do
-        if @completed >= TO_RUN
-          EM.stop
-        end
+      results = ''
+      count.times do |i|
+        results << "stdout #{i}\n"
       end
+      status.output_text.should == results
+      status.error_text.should == ''
+      status.pid.should > 0
     end
-  end
-
-  it 'should preserve the integrity of stdout when stderr is unavailable' do
-    count = LARGE_OUTPUT_COUNTER
-    command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_stdout_only.rb'))}\" #{count}"
-    runner = RightPopenSpec::Runner.new
-    status = runner.run_right_popen(command)
-    status.status.exitstatus.should == 0
-
-    results = ''
-    count.times do |i|
-      results << "stdout #{i}\n"
-    end
-    status.output_text.should == results
-    status.error_text.should == ''
-    status.pid.should > 0
-  end
 
-  it 'should preserve the integrity of stderr when stdout is unavailable' do
-    count = LARGE_OUTPUT_COUNTER
-    command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_stderr_only.rb'))}\" #{count}"
-    runner = RightPopenSpec::Runner.new
-    status = runner.run_right_popen(command)
-    status.status.exitstatus.should == 0
+    it 'should preserve the integrity of stderr when stdout is unavailable' do
+      count = LARGE_OUTPUT_COUNTER
+      command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_stderr_only.rb'))}\" #{count}"
+      runner = Runner.new
+      status = runner.run_right_popen(command)
+      status.status.exitstatus.should == 0
 
-    results = ''
-    count.times do |i|
-      results << "stderr #{i}\n"
+      results = ''
+      count.times do |i|
+        results << "stderr #{i}\n"
+      end
+      status.error_text.should == results
+      status.output_text.should == ''
+      status.pid.should > 0
     end
-    status.error_text.should == results
-    status.output_text.should == ''
-    status.pid.should > 0
-  end
 
-  it 'should preserve the integrity of stdout and stderr despite interleaving' do
-    count = LARGE_OUTPUT_COUNTER
-    command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_mixed_output.rb'))}\" #{count}"
-    runner = RightPopenSpec::Runner.new
-    status = runner.run_right_popen(command)
-    status.status.exitstatus.should == 99
+    it 'should preserve the integrity of stdout and stderr despite interleaving' do
+      count = LARGE_OUTPUT_COUNTER
+      command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_mixed_output.rb'))}\" #{count}"
+      runner = Runner.new
+      status = runner.run_right_popen(command)
+      status.status.exitstatus.should == 99
 
-    results = ''
-    count.times do |i|
-      results << "stdout #{i}\n"
-    end
-    status.output_text.should == results
+      results = ''
+      count.times do |i|
+        results << "stdout #{i}\n"
+      end
+      status.output_text.should == results
 
-    results = ''
-    count.times do |i|
-      (results << "stderr #{i}\n") if 0 == i % 10
+      results = ''
+      count.times do |i|
+        (results << "stderr #{i}\n") if 0 == i % 10
+      end
+      status.error_text.should == results
+      status.pid.should > 0
     end
-    status.error_text.should == results
-    status.pid.should > 0
-  end
 
-  it 'should setup environment variables' do
-    command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'print_env.rb'))}\""
-    runner = RightPopenSpec::Runner.new
-    status = runner.run_right_popen(command)
-    status.status.exitstatus.should == 0
-    status.output_text.should_not include('_test_')
-    status = runner.run_right_popen(command, :__test__ => '42')
-    status.status.exitstatus.should == 0
-    status.output_text.should match(/^__test__=42$/)
-    status.pid.should > 0
-  end
-
-  it 'should restore environment variables' do
-    begin
-      ENV['__test__'] = '41'
-      old_envs = {}
-      ENV.each { |k, v| old_envs[k] = v }
+    it 'should setup environment variables' do
       command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'print_env.rb'))}\""
-      runner = RightPopenSpec::Runner.new
+      runner = Runner.new
+      status = runner.run_right_popen(command)
+      status.status.exitstatus.should == 0
+      status.output_text.should_not include('_test_')
       status = runner.run_right_popen(command, :__test__ => '42')
       status.status.exitstatus.should == 0
       status.output_text.should match(/^__test__=42$/)
-      ENV.each { |k, v| old_envs[k].should == v }
-      old_envs.each { |k, v| ENV[k].should == v }
       status.pid.should > 0
-    ensure
-      ENV.delete('__test__')
     end
-  end
 
-  if is_windows?
-    # FIX: this behavior is currently specific to Windows but should probably be
-    # implemented for Linux.
-    it 'should merge the PATH variable instead of overriding it' do
-      command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'print_env.rb'))}\""
-      runner = RightPopenSpec::Runner.new
-      status = runner.run_right_popen(command, 'PATH' => "c:/bogus\\bin")
-      status.status.exitstatus.should == 0
-      status.output_text.should include('PATH=c:\\bogus\\bin;')
-      status.pid.should > 0
+    it 'should restore environment variables' do
+      begin
+        ENV['__test__'] = '41'
+        old_envs = {}
+        ENV.each { |k, v| old_envs[k] = v }
+        command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'print_env.rb'))}\""
+        runner = Runner.new
+        status = runner.run_right_popen(command, :__test__ => '42')
+        status.status.exitstatus.should == 0
+        status.output_text.should match(/^__test__=42$/)
+        ENV.each { |k, v| old_envs[k].should == v }
+        old_envs.each { |k, v| ENV[k].should == v }
+        status.pid.should > 0
+      ensure
+        ENV.delete('__test__')
+      end
+    end
+
+    if is_windows?
+      # FIX: this behavior is currently specific to Windows but should probably be
+      # implemented for Linux.
+      it 'should merge the PATH variable instead of overriding it' do
+        command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'print_env.rb'))}\""
+        runner = Runner.new
+        status = runner.run_right_popen(command, 'PATH' => "c:/bogus\\bin")
+        status.status.exitstatus.should == 0
+        status.output_text.should include('c:\\bogus\\bin;')
+        status.pid.should > 0
+      end
+    else
+      it 'should allow running bash command lines starting with a built-in command' do
+        command = "for i in 1 2 3 4 5; do echo $i;done"
+        runner = Runner.new
+        status = runner.run_right_popen(command)
+        status.status.exitstatus.should == 0
+        status.output_text.should == "1\n2\n3\n4\n5\n"
+        status.pid.should > 0
+      end
+
+      it 'should support running background processes' do
+        command = "(sleep 20)&"
+        now = Time.now
+        runner = Runner.new
+        status = runner.run_right_popen(command)
+        finished = Time.now
+        (finished - now).should < 20
+        status.did_timeout.should be_false
+        status.status.exitstatus.should == 0
+        status.output_text.should == ""
+        status.pid.should > 0
+      end
     end
-  else
-    it 'should allow running bash command lines starting with a built-in command' do
-      command = "for i in 1 2 3 4 5; do echo $i;done"
-      runner = RightPopenSpec::Runner.new
+
+    it 'should support raw command arguments' do
+      command = is_windows? ? ["cmd.exe", "/c", "echo", "*"] : ["echo", "*"]
+      runner = Runner.new
       status = runner.run_right_popen(command)
       status.status.exitstatus.should == 0
-      status.output_text.should == "1\n2\n3\n4\n5\n"
+      status.output_text.should == "*\n"
       status.pid.should > 0
     end
 
-    it 'should support running background processes' do
-      command = "(sleep 20)&"
-      now = Time.now
-      runner = RightPopenSpec::Runner.new
-      status = runner.run_right_popen(command)
-      finished = Time.now
-      (finished - now).should < 20
-      status.did_timeout.should be_false
+    it 'should run repeatedly without leaking resources' do
+      pending 'Set environment variable TEST_LEAK to enable' unless ENV['TEST_LEAK']
+      command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_output.rb'))}\" \"#{STANDARD_MESSAGE}\" \"#{ERROR_MESSAGE}\""
+      runner = Runner.new
+      status = runner.run_right_popen(command, nil, nil, REPEAT_TEST_COUNTER)
       status.status.exitstatus.should == 0
-      status.output_text.should == ""
+      status.output_text.should == STANDARD_MESSAGE + "\n"
+      status.error_text.should == ERROR_MESSAGE + "\n"
       status.pid.should > 0
     end
-  end
 
-  it 'should support raw command arguments' do
-    command = is_windows? ? ["cmd.exe", "/c", "echo", "*"] : ["echo", "*"]
-    runner = RightPopenSpec::Runner.new
-    status = runner.run_right_popen(command)
-    status.status.exitstatus.should == 0
-    status.output_text.should == "*\n"
-    status.pid.should > 0
-  end
+    it 'should pass input to child process' do
+      command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'increment.rb'))}\""
+      runner = Runner.new
+      status = runner.run_right_popen(command, nil, "42\n")
+      status.status.exitstatus.should == 0
+      status.output_text.should == "43\n"
+      status.error_text.should be_empty
+      status.pid.should > 0
+    end
 
-  it 'should run repeatedly without leaking resources' do
-    pending 'Set environment variable TEST_LEAK to enable' unless ENV['TEST_LEAK']
-    command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_output.rb'))}\" \"#{STANDARD_MESSAGE}\" \"#{ERROR_MESSAGE}\""
-    runner = RightPopenSpec::Runner.new
-    status = runner.run_right_popen(command, nil, nil, REPEAT_TEST_COUNTER)
-    status.status.exitstatus.should == 0
-    status.output_text.should == STANDARD_MESSAGE + "\n"
-    status.error_text.should == ERROR_MESSAGE + "\n"
-    status.pid.should > 0
-  end
+    it 'should handle child processes that close stdout but keep running' do
+	  pending 'not implemented for windows' if is_windows?
+      command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'stdout.rb'))}\""
+      runner = Runner.new
+      status = runner.run_right_popen(command, nil, nil)
+      status.did_timeout.should be_true
+      status.output_text.should be_empty
+      status.error_text.should == "Closing stdout\n"
+    end
 
-  it 'should pass input to child process' do
-    command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'increment.rb'))}\""
-    runner = RightPopenSpec::Runner.new
-    status = runner.run_right_popen(command, nil, "42\n")
-    status.status.exitstatus.should == 0
-    status.output_text.should == "43\n"
-    status.error_text.should be_empty
-    status.pid.should > 0
+    it 'should handle child processes that spawn long running background processes' do
+	  pending 'not implemented for windows' if is_windows?
+      command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'background.rb'))}\""
+      runner = Runner.new
+      status = runner.run_right_popen(command, nil, nil)
+      status.status.exitstatus.should == 0
+      status.did_timeout.should be_false
+      status.output_text.should be_empty
+      status.error_text.should be_empty
+    end
   end
-
 end