childprocess 0.8.0

data/spec/jruby_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../spec_helper', __FILE__)
+require "pid_behavior"
+
+if ChildProcess.jruby? && !ChildProcess.windows?
+  describe ChildProcess::JRuby::IO do
+    let(:io) { ChildProcess::JRuby::IO.new }
+
+    it "raises an ArgumentError if given IO does not respond to :to_outputstream" do
+      expect { io.stdout = nil }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe ChildProcess::JRuby::Process do
+    if ChildProcess.unix?
+      it_behaves_like "a platform that provides the child's pid"
+    else
+      it "raises an error when trying to access the child's pid" do
+        process = exit_with(0)
+        process.start
+        expect { process.pid }.to raise_error(NotImplementedError)
+      end
+    end
+  end
+end

data/spec/pid_behavior.rb

@@ -0,0 +1,12 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+shared_examples_for "a platform that provides the child's pid" do
+  it "knows the child's pid" do
+    Tempfile.open("pid-spec") do |file|
+      process = write_pid(file.path).start
+      process.wait
+
+      expect(process.pid).to eq rewind_and_read(file).chomp.to_i
+    end
+  end
+end

data/spec/platform_detection_spec.rb

@@ -0,0 +1,86 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+# Q: Should platform detection concern be extracted from ChildProcess?
+describe ChildProcess do
+
+  describe ".arch" do
+    subject { described_class.arch }
+
+    before(:each) { described_class.instance_variable_set(:@arch, nil) }
+
+    after(:each) { described_class.instance_variable_set(:@arch, nil) }
+
+    shared_examples 'expected_arch_for_host_cpu' do |host_cpu, expected_arch|
+      context "when host_cpu is '#{host_cpu}'" do
+        before :each do
+          allow(RbConfig::CONFIG).
+            to receive(:[]).
+            with('host_cpu').
+            and_return(expected_arch)
+        end
+
+        it { is_expected.to eq expected_arch }
+      end
+    end
+
+    # Normal cases: not macosx - depends only on host_cpu
+    context "when os is *not* 'macosx'" do
+      before :each do
+        allow(described_class).to receive(:os).and_return(:not_macosx)
+      end
+
+      [
+        { host_cpu: 'i386',    expected_arch: 'i386'    },
+        { host_cpu: 'i486',    expected_arch: 'i386'    },
+        { host_cpu: 'i586',    expected_arch: 'i386'    },
+        { host_cpu: 'i686',    expected_arch: 'i386'    },
+        { host_cpu: 'amd64',   expected_arch: 'x86_64'  },
+        { host_cpu: 'x86_64',  expected_arch: 'x86_64'  },
+        { host_cpu: 'ppc',     expected_arch: 'powerpc' },
+        { host_cpu: 'powerpc', expected_arch: 'powerpc' },
+        { host_cpu: 'unknown', expected_arch: 'unknown' },
+      ].each do |args|
+        include_context 'expected_arch_for_host_cpu', args.values
+      end
+    end
+
+    # Special cases: macosx - when host_cpu is i686, have to re-check
+    context "when os is 'macosx'" do
+      before :each do
+        allow(described_class).to receive(:os).and_return(:macosx)
+      end
+
+      context "when host_cpu is 'i686' " do
+        shared_examples 'expected_arch_on_macosx_i686' do |is_64, expected_arch|
+          context "when Ruby is #{is_64 ? 64 : 32}-bit" do
+            before :each do
+              allow(described_class).
+                to receive(:is_64_bit?).
+                and_return(is_64)
+            end
+
+            include_context 'expected_arch_for_host_cpu', 'i686', expected_arch
+          end
+        end
+
+        [
+          { is_64: true,  expected_arch: 'x86_64' },
+          { is_64: false, expected_arch: 'i386'   }
+        ].each do |args|
+          include_context 'expected_arch_on_macosx_i686', args.values
+        end
+      end
+
+      [
+        { host_cpu: 'amd64',   expected_arch: 'x86_64'  },
+        { host_cpu: 'x86_64',  expected_arch: 'x86_64'  },
+        { host_cpu: 'ppc',     expected_arch: 'powerpc' },
+        { host_cpu: 'powerpc', expected_arch: 'powerpc' },
+        { host_cpu: 'unknown', expected_arch: 'unknown' },
+      ].each do |args|
+        include_context 'expected_arch_for_host_cpu', args.values
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,261 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+unless defined?(JRUBY_VERSION)
+  require 'coveralls'
+  Coveralls.wear!
+end
+
+require 'childprocess'
+require 'rspec'
+require 'tempfile'
+require 'socket'
+require 'stringio'
+require 'ostruct'
+
+module ChildProcessSpecHelper
+  RUBY = defined?(Gem) ? Gem.ruby : 'ruby'
+
+  def ruby_process(*args)
+    @process = ChildProcess.build(RUBY , *args)
+  end
+
+  def sleeping_ruby(seconds = nil)
+    if seconds
+      ruby_process("-e", "sleep #{seconds}")
+    else
+      ruby_process("-e", "sleep")
+    end
+  end
+
+  def invalid_process
+    @process = ChildProcess.build("unlikelytoexist")
+  end
+
+  def ignored(signal)
+    code = <<-RUBY
+      trap(#{signal.inspect}, "IGNORE")
+      sleep
+    RUBY
+
+    ruby_process tmp_script(code)
+  end
+
+  def write_env(path)
+    code = <<-RUBY
+      File.open(#{path.inspect}, "w") { |f| f << ENV.inspect }
+    RUBY
+
+    ruby_process tmp_script(code)
+  end
+
+  def write_argv(path, *args)
+    code = <<-RUBY
+      File.open(#{path.inspect}, "w") { |f| f << ARGV.inspect }
+    RUBY
+
+    ruby_process(tmp_script(code), *args)
+  end
+
+  def write_pid(path)
+    code = <<-RUBY
+      File.open(#{path.inspect}, "w") { |f| f << Process.pid }
+    RUBY
+
+    ruby_process tmp_script(code)
+  end
+
+  def write_pid_in_sleepy_grand_child(path)
+    code = <<-RUBY
+      system "ruby", "-e", 'File.open(#{path.inspect}, "w") { |f| f << Process.pid; f.flush }; sleep'
+    RUBY
+
+    ruby_process tmp_script(code)
+  end
+
+  def exit_with(exit_code)
+    ruby_process(tmp_script("exit(#{exit_code})"))
+  end
+
+  def with_env(hash)
+    hash.each { |k,v| ENV[k] = v }
+    begin
+      yield
+    ensure
+      hash.each_key { |k| ENV[k] = nil }
+    end
+  end
+
+  def tmp_script(code)
+    # use an ivar to avoid GC
+    @tf = Tempfile.new("childprocess-temp")
+    @tf << code
+    @tf.close
+
+    puts code if $DEBUG
+
+    @tf.path
+  end
+
+  def cat
+    if ChildProcess.os == :windows
+      ruby(<<-CODE)
+            STDIN.sync = STDOUT.sync = true
+            IO.copy_stream(STDIN, STDOUT)
+          CODE
+    else
+      ChildProcess.build("cat")
+    end
+  end
+
+  def echo
+    if ChildProcess.os == :windows
+      ruby(<<-CODE)
+            STDIN.sync  = true
+            STDOUT.sync = true
+
+            puts "hello"
+          CODE
+    else
+      ChildProcess.build("echo", "hello")
+    end
+  end
+
+  def ruby(code)
+    ruby_process(tmp_script(code))
+  end
+
+  def with_executable_at(path, &blk)
+    if ChildProcess.os == :windows
+      path << ".cmd"
+      content = "#{RUBY} -e 'sleep 10' \n @echo foo"
+    else
+      content = "#!/bin/sh\nsleep 10\necho foo"
+    end
+
+    File.open(path, 'w', 0744) { |io| io << content }
+    proc = ChildProcess.build(path)
+
+    begin
+      yield proc
+    ensure
+      proc.stop if proc.alive?
+      File.delete path
+    end
+  end
+
+  def exit_timeout
+    10
+  end
+
+  def random_free_port
+    server = TCPServer.new('127.0.0.1', 0)
+    port   = server.addr[1]
+    server.close
+
+    port
+  end
+
+  def with_tmpdir(&blk)
+    name = "#{Time.now.strftime("%Y%m%d")}-#{$$}-#{rand(0x100000000).to_s(36)}"
+    FileUtils.mkdir_p(name)
+
+    begin
+      yield File.expand_path(name)
+    ensure
+      FileUtils.rm_rf name
+    end
+  end
+
+  def wait_until(timeout = 10, &blk)
+    end_time       = Time.now + timeout
+    last_exception = nil
+
+    until Time.now >= end_time
+      begin
+        result = yield
+        return result if result
+      rescue RSpec::Expectations::ExpectationNotMetError => ex
+        last_exception = ex
+      end
+
+      sleep 0.01
+    end
+
+    msg = "timed out after #{timeout} seconds"
+    msg << ":\n#{last_exception.message}" if last_exception
+
+    raise msg
+  end
+
+  def can_bind?(host, port)
+    TCPServer.new(host, port).close
+    true
+  rescue
+    false
+  end
+
+  def rewind_and_read(io)
+    io.rewind
+    io.read
+  end
+
+  def alive?(pid)
+    if ChildProcess.windows?
+      ChildProcess::Windows::Lib.alive?(pid)
+    else
+      begin
+        Process.getpgid pid
+        true
+      rescue Errno::ESRCH
+        false
+      end
+    end
+  end
+
+  def capture_std
+    orig_out = STDOUT.clone
+    orig_err = STDERR.clone
+
+    out = Tempfile.new 'captured-stdout'
+    err = Tempfile.new 'captured-stderr'
+    out.sync = true
+    err.sync = true
+
+    STDOUT.reopen out
+    STDERR.reopen err
+
+    yield
+
+    OpenStruct.new stdout: rewind_and_read(out), stderr: rewind_and_read(err)
+  ensure
+    STDOUT.reopen orig_out
+    STDERR.reopen orig_err
+  end
+
+  def generate_log_messages
+    ChildProcess.logger.level = Logger::DEBUG
+
+    process = exit_with(0).start
+    process.wait
+    process.poll_for_exit(0.1)
+  end
+
+end # ChildProcessSpecHelper
+
+Thread.abort_on_exception = true
+
+RSpec.configure do |c|
+  c.include(ChildProcessSpecHelper)
+  c.after(:each) {
+    defined?(@process) && @process.alive? && @process.stop
+  }
+
+  if ChildProcess.jruby? && ChildProcess.new("true").instance_of?(ChildProcess::JRuby::Process)
+    c.filter_run_excluding :process_builder => false
+  end
+
+  if ChildProcess.linux? && ChildProcess.posix_spawn?
+    c.filter_run_excluding :posix_spawn_on_linux => false
+  end
+end

data/spec/unix_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../spec_helper', __FILE__)
+require "pid_behavior"
+
+if ChildProcess.unix? && !ChildProcess.jruby? && !ChildProcess.posix_spawn?
+
+  describe ChildProcess::Unix::Process do
+    it_behaves_like "a platform that provides the child's pid"
+
+    it "handles ECHILD race condition where process dies between timeout and KILL" do
+      process = sleeping_ruby
+
+      allow(process).to receive(:fork).and_return('fakepid')
+      allow(process).to receive(:send_term)
+      allow(process).to receive(:poll_for_exit).and_raise(ChildProcess::TimeoutError)
+      allow(process).to receive(:send_kill).and_raise(Errno::ECHILD.new)
+
+      process.start
+      expect { process.stop }.not_to raise_error
+
+      allow(process).to receive(:alive?).and_return(false)
+
+      process.send(:send_signal, 'TERM')
+    end
+
+    it "handles ESRCH race condition where process dies between timeout and KILL" do
+      process = sleeping_ruby
+
+      allow(process).to receive(:fork).and_return('fakepid')
+      allow(process).to receive(:send_term)
+      allow(process).to receive(:poll_for_exit).and_raise(ChildProcess::TimeoutError)
+      allow(process).to receive(:send_kill).and_raise(Errno::ESRCH.new)
+
+      process.start
+      expect { process.stop }.not_to raise_error
+
+      allow(process).to receive(:alive?).and_return(false)
+
+      process.send(:send_signal, 'TERM')
+    end
+  end
+
+  describe ChildProcess::Unix::IO do
+    let(:io) { ChildProcess::Unix::IO.new }
+
+    it "raises an ArgumentError if given IO does not respond to :to_io" do
+      expect { io.stdout = nil }.to raise_error(ArgumentError, /to respond to :to_io/)
+    end
+
+    it "raises a TypeError if #to_io does not return an IO" do
+      fake_io = Object.new
+      def fake_io.to_io() StringIO.new end
+
+      expect { io.stdout = fake_io }.to raise_error(TypeError, /expected IO, got/)
+    end
+  end
+
+end

data/spec/windows_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../spec_helper', __FILE__)
+require "pid_behavior"
+
+if ChildProcess.windows?
+  describe ChildProcess::Windows::Process do
+    it_behaves_like "a platform that provides the child's pid"
+  end
+
+  describe ChildProcess::Windows::IO do
+    let(:io) { ChildProcess::Windows::IO.new }
+
+    it "raises an ArgumentError if given IO does not respond to :fileno" do
+      expect { io.stdout = nil }.to raise_error(ArgumentError, /must have :fileno or :to_io/)
+    end
+
+    it "raises an ArgumentError if the #to_io does not return an IO " do
+      fake_io = Object.new
+      def fake_io.to_io() StringIO.new end
+
+      expect { io.stdout = fake_io }.to raise_error(ArgumentError, /must have :fileno or :to_io/)
+    end
+  end
+end