childprocess 0.9.0

data/spec/abstract_io_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe ChildProcess::AbstractIO do
+  let(:io) { ChildProcess::AbstractIO.new }
+
+  it "inherits the parent's IO streams" do
+    io.inherit!
+
+    expect(io.stdout).to eq STDOUT
+    expect(io.stderr).to eq STDERR
+  end
+end

data/spec/childprocess_spec.rb

@@ -0,0 +1,422 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper', __FILE__)
+require 'rubygems/mock_gem_ui'
+
+
+describe ChildProcess do
+
+  here = File.dirname(__FILE__)
+
+  let(:gemspec) { eval(File.read "#{here}/../childprocess.gemspec") }
+
+  it 'validates cleanly' do
+    mock_ui = Gem::MockGemUi.new
+    Gem::DefaultUserInteraction.use_ui(mock_ui) { gemspec.validate }
+
+    expect(mock_ui.error).to_not match(/warn/i)
+  end
+
+
+  it "returns self when started" do
+    process = sleeping_ruby
+
+    expect(process.start).to eq process
+    expect(process).to be_alive
+  end
+
+  # We can't detect failure to execve() when using posix_spawn() on Linux
+  # without waiting for the child to exit with code 127.
+  #
+  # See e.g. http://repo.or.cz/w/glibc.git/blob/669704fd:/sysdeps/posix/spawni.c#l34
+  #
+  # We could work around this by doing the PATH search ourselves, but not sure
+  # it's worth it.
+  it "raises ChildProcess::LaunchError if the process can't be started", :posix_spawn_on_linux => false do
+    expect { invalid_process.start }.to raise_error(ChildProcess::LaunchError)
+  end
+
+  it 'raises ArgumentError if given a non-string argument' do
+    expect { ChildProcess.build(nil, "unlikelytoexist") }.to raise_error(ArgumentError)
+    expect { ChildProcess.build("foo", 1) }.to raise_error(ArgumentError)
+  end
+
+  it "knows if the process crashed" do
+    process = exit_with(1).start
+    process.wait
+
+    expect(process).to be_crashed
+  end
+
+  it "knows if the process didn't crash" do
+    process = exit_with(0).start
+    process.wait
+
+    expect(process).to_not be_crashed
+  end
+
+  it "can wait for a process to finish" do
+    process = exit_with(0).start
+    return_value = process.wait
+
+    expect(process).to_not be_alive
+    expect(return_value).to eq 0
+  end
+
+  it 'ignores #wait if process already finished' do
+    process = exit_with(0).start
+    sleep 0.01 until process.exited?
+
+    expect(process.wait).to eql 0
+  end
+
+  it "escalates if TERM is ignored" do
+    process = ignored('TERM').start
+    process.stop
+    expect(process).to be_exited
+  end
+
+  it "accepts a timeout argument to #stop" do
+    process = sleeping_ruby.start
+    process.stop(exit_timeout)
+  end
+
+  it "lets child process inherit the environment of the current process" do
+    Tempfile.open("env-spec") do |file|
+      with_env('INHERITED' => 'yes') do
+        process = write_env(file.path).start
+        process.wait
+      end
+
+      child_env = eval rewind_and_read(file)
+      expect(child_env['INHERITED']).to eql 'yes'
+    end
+  end
+
+  it "can override env vars only for the current process" do
+    Tempfile.open("env-spec") do |file|
+      process = write_env(file.path)
+      process.environment['CHILD_ONLY'] = '1'
+      process.start
+
+      expect(ENV['CHILD_ONLY']).to be_nil
+
+      process.wait
+
+      child_env = eval rewind_and_read(file)
+      expect(child_env['CHILD_ONLY']).to eql '1'
+    end
+  end
+
+  it "inherits the parent's env vars also when some are overridden" do
+    Tempfile.open("env-spec") do |file|
+      with_env('INHERITED' => 'yes', 'CHILD_ONLY' => 'no') do
+        process = write_env(file.path)
+        process.environment['CHILD_ONLY'] = 'yes'
+
+        process.start
+        process.wait
+
+        child_env = eval rewind_and_read(file)
+
+        expect(child_env['INHERITED']).to eq 'yes'
+        expect(child_env['CHILD_ONLY']).to eq 'yes'
+      end
+    end
+  end
+
+  it "can unset env vars" do
+    Tempfile.open("env-spec") do |file|
+      ENV['CHILDPROCESS_UNSET'] = '1'
+      process = write_env(file.path)
+      process.environment['CHILDPROCESS_UNSET'] = nil
+      process.start
+
+      process.wait
+
+      child_env = eval rewind_and_read(file)
+      expect(child_env).to_not have_key('CHILDPROCESS_UNSET')
+    end
+  end
+
+  it 'does not see env vars unset in parent' do
+    Tempfile.open('env-spec') do |file|
+      ENV['CHILDPROCESS_UNSET'] = nil
+      process = write_env(file.path)
+      process.start
+
+      process.wait
+
+      child_env = eval rewind_and_read(file)
+      expect(child_env).to_not have_key('CHILDPROCESS_UNSET')
+    end
+  end
+
+
+  it "passes arguments to the child" do
+    args = ["foo", "bar"]
+
+    Tempfile.open("argv-spec") do |file|
+      process = write_argv(file.path, *args).start
+      process.wait
+
+      expect(rewind_and_read(file)).to eql args.inspect
+    end
+  end
+
+  it "lets a detached child live on" do
+    p_pid = nil
+    c_pid = nil
+
+    Tempfile.open('grandparent_out') do |gp_file|
+      # Create a parent and detached child process that will spit out their PID. Make sure that the child process lasts longer than the parent.
+      p_process = ruby("require 'childprocess' ; c_process = ChildProcess.build('ruby', '-e', 'puts \\\"Child PID: \#{Process.pid}\\\" ; sleep 5') ; c_process.io.inherit! ; c_process.detach = true ;  c_process.start ; puts \"Child PID: \#{c_process.pid}\" ; puts \"Parent PID: \#{Process.pid}\"")
+      p_process.io.stdout = p_process.io.stderr = gp_file
+
+      # Let the parent process die
+      p_process.start
+      p_process.wait
+
+
+      # Gather parent and child PIDs
+      pids = rewind_and_read(gp_file).split("\n")
+      pids.collect! { |pid| pid[/\d+/].to_i }
+      c_pid, p_pid = pids
+    end
+
+    # Check that the parent process has dies but the child process is still alive
+    expect(alive?(p_pid)).to_not be true
+    expect(alive?(c_pid)).to be true
+  end
+
+  it "preserves Dir.pwd in the child" do
+    Tempfile.open("dir-spec-out") do |file|
+      process = ruby("print Dir.pwd")
+      process.io.stdout = process.io.stderr = file
+
+      expected_dir = nil
+      Dir.chdir(Dir.tmpdir) do
+        expected_dir = Dir.pwd
+        process.start
+      end
+
+      process.wait
+
+      expect(rewind_and_read(file)).to eq expected_dir
+    end
+  end
+
+  it "can handle whitespace, special characters and quotes in arguments" do
+    args = ["foo bar", 'foo\bar', "'i-am-quoted'", '"i am double quoted"']
+
+    Tempfile.open("argv-spec") do |file|
+      process = write_argv(file.path, *args).start
+      process.wait
+
+      expect(rewind_and_read(file)).to eq args.inspect
+    end
+  end
+
+  it 'handles whitespace in the executable name' do
+    path = File.expand_path('foo bar')
+
+    with_executable_at(path) do |proc|
+      expect(proc.start).to eq proc
+      expect(proc).to be_alive
+    end
+  end
+
+  it "times out when polling for exit" do
+    process = sleeping_ruby.start
+    expect { process.poll_for_exit(0.1) }.to raise_error(ChildProcess::TimeoutError)
+  end
+
+  it "can change working directory" do
+    process = ruby "print Dir.pwd"
+
+    with_tmpdir { |dir|
+      process.cwd = dir
+
+      orig_pwd = Dir.pwd
+
+      Tempfile.open('cwd') do |file|
+        process.io.stdout = file
+
+        process.start
+        process.wait
+
+        expect(rewind_and_read(file)).to eq dir
+      end
+
+      expect(Dir.pwd).to eq orig_pwd
+    }
+  end
+
+  it 'kills the full process tree', :process_builder => false do
+    Tempfile.open('kill-process-tree') do |file|
+      process = write_pid_in_sleepy_grand_child(file.path)
+      process.leader = true
+      process.start
+
+      pid = wait_until(30) do
+        Integer(rewind_and_read(file)) rescue nil
+      end
+
+      process.stop
+      wait_until(3) { expect(alive?(pid)).to eql(false) }
+    end
+  end
+
+  it 'releases the GIL while waiting for the process' do
+    time = Time.now
+    threads = []
+
+    threads << Thread.new { sleeping_ruby(1).start.wait }
+    threads << Thread.new(time) { expect(Time.now - time).to be < 0.5 }
+
+    threads.each { |t| t.join }
+  end
+
+  it 'can check if a detached child is alive' do
+    proc = ruby_process("-e", "sleep")
+    proc.detach = true
+
+    proc.start
+
+    expect(proc).to be_alive
+    proc.stop(0)
+
+    expect(proc).to be_exited
+  end
+
+  describe 'OS detection' do
+
+    before(:all) do
+      # Save off original OS so that it can be restored later
+      @original_host_os = RbConfig::CONFIG['host_os']
+    end
+
+    after(:each) do
+      # Restore things to the real OS instead of the fake test OS
+      RbConfig::CONFIG['host_os'] = @original_host_os
+      ChildProcess.instance_variable_set(:@os, nil)
+    end
+
+
+    # TODO: add tests for other OSs
+    context 'on a BSD system' do
+
+      let(:bsd_patterns) { ['bsd', 'dragonfly'] }
+
+      it 'correctly identifies BSD systems' do
+        bsd_patterns.each do |pattern|
+          RbConfig::CONFIG['host_os'] = pattern
+          ChildProcess.instance_variable_set(:@os, nil)
+
+          expect(ChildProcess.os).to eq(:bsd)
+        end
+      end
+
+    end
+
+  end
+
+  it 'has a logger' do
+    expect(ChildProcess).to respond_to(:logger)
+  end
+
+  it 'can change its logger' do
+    expect(ChildProcess).to respond_to(:logger=)
+
+    original_logger = ChildProcess.logger
+    begin
+      ChildProcess.logger = :some_other_logger
+      expect(ChildProcess.logger).to eq(:some_other_logger)
+    ensure
+      ChildProcess.logger = original_logger
+    end
+  end
+
+
+  describe 'logger' do
+
+    before(:each) do
+      ChildProcess.logger = logger
+    end
+
+    after(:all) do
+      ChildProcess.logger = nil
+    end
+
+
+    context 'with the default logger' do
+
+      let(:logger) { nil }
+
+
+      it 'logs at INFO level by default' do
+        expect(ChildProcess.logger.level).to eq(Logger::INFO)
+      end
+
+      it 'logs at DEBUG level by default if $DEBUG is on' do
+        original_debug = $DEBUG
+
+        begin
+          $DEBUG = true
+
+          expect(ChildProcess.logger.level).to eq(Logger::DEBUG)
+        ensure
+          $DEBUG = original_debug
+        end
+      end
+
+      it "logs to stderr by default" do
+        cap = capture_std { generate_log_messages }
+
+        expect(cap.stdout).to be_empty
+        expect(cap.stderr).to_not be_empty
+      end
+
+    end
+
+    context 'with a custom logger' do
+
+      let(:logger) { Logger.new($stdout) }
+
+      it "logs to configured logger" do
+        cap = capture_std { generate_log_messages }
+
+        expect(cap.stdout).to_not be_empty
+        expect(cap.stderr).to be_empty
+      end
+
+    end
+
+  end
+
+  describe '#started?' do
+    subject { process.started? }
+
+    context 'when not started' do
+      let(:process) { sleeping_ruby(1) }
+
+      it { is_expected.to be false }
+    end
+
+    context 'when started' do
+      let(:process) { sleeping_ruby(1).start }
+
+      it { is_expected.to be true }
+    end
+
+    context 'when finished' do
+      before(:each) { process.wait }
+
+      let(:process) { sleeping_ruby(0).start }
+
+      it { is_expected.to be true }
+    end
+
+  end
+
+end

data/spec/io_spec.rb

@@ -0,0 +1,228 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe ChildProcess do
+  it "can run even when $stdout is a StringIO" do
+    begin
+      stdout = $stdout
+      $stdout = StringIO.new
+      expect { sleeping_ruby.start }.to_not raise_error
+    ensure
+      $stdout = stdout
+    end
+  end
+
+  it "can redirect stdout, stderr" do
+    process = ruby(<<-CODE)
+      [STDOUT, STDERR].each_with_index do |io, idx|
+        io.sync = true
+        io.puts idx
+      end
+    CODE
+
+    out = Tempfile.new("stdout-spec")
+    err = Tempfile.new("stderr-spec")
+
+    begin
+      process.io.stdout = out
+      process.io.stderr = err
+
+      process.start
+      expect(process.io.stdin).to be_nil
+      process.wait
+
+      expect(rewind_and_read(out)).to eq "0\n"
+      expect(rewind_and_read(err)).to eq "1\n"
+    ensure
+      out.close
+      err.close
+    end
+  end
+
+  it "can redirect stdout only" do
+    process = ruby(<<-CODE)
+      [STDOUT, STDERR].each_with_index do |io, idx|
+        io.sync = true
+        io.puts idx
+      end
+    CODE
+
+    out = Tempfile.new("stdout-spec")
+
+    begin
+      process.io.stdout = out
+
+      process.start
+      process.wait
+
+      expect(rewind_and_read(out)).to eq "0\n"
+    ensure
+      out.close
+    end
+  end
+
+  it "pumps all output" do
+    process = echo
+
+    out = Tempfile.new("pump")
+
+    begin
+      process.io.stdout = out
+
+      process.start
+      process.wait
+
+      expect(rewind_and_read(out)).to eq "hello\n"
+    ensure
+      out.close
+    end
+  end
+
+  it "can write to stdin if duplex = true" do
+    process = cat
+
+    out = Tempfile.new("duplex")
+    out.sync = true
+
+    begin
+      process.io.stdout = out
+      process.io.stderr = out
+      process.duplex = true
+
+      process.start
+      process.io.stdin.puts "hello world"
+      process.io.stdin.close
+
+      process.poll_for_exit(exit_timeout)
+
+      expect(rewind_and_read(out)).to eq "hello world\n"
+    ensure
+      out.close
+    end
+  end
+
+  it "can write to stdin interactively if duplex = true" do
+    process = cat
+
+    out = Tempfile.new("duplex")
+    out.sync = true
+
+    out_receiver = File.open(out.path, "rb")
+    begin
+      process.io.stdout = out
+      process.io.stderr = out
+      process.duplex = true
+
+      process.start
+
+      stdin = process.io.stdin
+
+      stdin.puts "hello"
+      stdin.flush
+      wait_until { expect(rewind_and_read(out_receiver)).to match(/\Ahello\r?\n\z/m) }
+
+      stdin.putc "n"
+      stdin.flush
+      wait_until { expect(rewind_and_read(out_receiver)).to match(/\Ahello\r?\nn\z/m) }
+
+      stdin.print "e"
+      stdin.flush
+      wait_until { expect(rewind_and_read(out_receiver)).to match(/\Ahello\r?\nne\z/m) }
+
+      stdin.printf "w"
+      stdin.flush
+      wait_until { expect(rewind_and_read(out_receiver)).to match(/\Ahello\r?\nnew\z/m) }
+
+      stdin.write "\nworld\n"
+      stdin.flush
+      wait_until { expect(rewind_and_read(out_receiver)).to match(/\Ahello\r?\nnew\r?\nworld\r?\n\z/m) }
+
+      stdin.close
+      process.poll_for_exit(exit_timeout)
+     ensure
+      out_receiver.close
+      out.close
+    end
+  end
+
+  #
+  # this works on JRuby 1.6.5 on my Mac, but for some reason
+  # hangs on Travis (running 1.6.5.1 + OpenJDK).
+  #
+  # http://travis-ci.org/#!/enkessler/childprocess/jobs/487331
+  #
+
+  it "works with pipes", :process_builder => false do
+    process = ruby(<<-CODE)
+      STDOUT.print "stdout"
+      STDERR.print "stderr"
+    CODE
+
+    stdout, stdout_w = IO.pipe
+    stderr, stderr_w = IO.pipe
+
+    process.io.stdout = stdout_w
+    process.io.stderr = stderr_w
+
+    process.duplex = true
+
+    process.start
+    process.wait
+
+    # write streams are closed *after* the process
+    # has exited - otherwise it won't work on JRuby
+    # with the current Process implementation
+
+    stdout_w.close
+    stderr_w.close
+
+    out = stdout.read
+    err = stderr.read
+
+    expect([out, err]).to eq %w[stdout stderr]
+  end
+
+  it "can set close-on-exec when IO is inherited" do
+    port = random_free_port
+    server = TCPServer.new("127.0.0.1", port)
+    ChildProcess.close_on_exec server
+
+    process = sleeping_ruby
+    process.io.inherit!
+
+    process.start
+    server.close
+
+    wait_until { can_bind? "127.0.0.1", port }
+  end
+
+  it "handles long output" do
+    process = ruby <<-CODE
+    print 'a'*3000
+    CODE
+
+    out = Tempfile.new("long-output")
+    out.sync = true
+
+    begin
+      process.io.stdout = out
+
+      process.start
+      process.wait
+
+      expect(rewind_and_read(out).size).to eq 3000
+    ensure
+      out.close
+    end
+  end
+
+  it 'should not inherit stdout and stderr by default' do
+    cap = capture_std do
+      process = echo
+      process.start
+      process.wait
+    end
+
+    expect(cap.stdout).to eq ''
+    expect(cap.stderr).to eq ''
+  end
+end