rubysh 0.0.1

data/lib/rubysh.rb

@@ -0,0 +1,149 @@
+require 'logger'
+
+require 'rubysh/version'
+require 'rubysh/base_command'
+require 'rubysh/base_directive'
+require 'rubysh/command'
+require 'rubysh/error'
+require 'rubysh/fd'
+require 'rubysh/pipeline'
+require 'rubysh/redirect'
+require 'rubysh/runner'
+require 'rubysh/subprocess'
+require 'rubysh/triple_less_than'
+require 'rubysh/util'
+
+# Command:
+#
+# Rubysh('ls', '/tmp')
+# => Command: ls /tmp
+# Rubysh('ls', '/tmp') | Rubysh('grep', 'myfile')
+# => Command: ls /tmp | grep myfile
+# Rubysh('ls', '/tmp', Rubysh.stderr > Rubysh.stdout)
+# => Command: ls /tmp 2>&1
+# Rubysh('ls', '/tmp', Rubysh.>('/tmp/outfile.txt'))
+# => Command: ls /tmp > /tmp/outfile.txt
+#
+# TODO:
+# => Command: (ls; ls) | grep foo
+# => Command: echo <(ls /tmp)
+# => Command: echo >(cat)
+# something like the following to tee output:
+# Rubysh('cat', Rubysh.stdout >> :pipe)
+#
+# If you want to capture output:
+#
+# Rubysh('cat', Rubysh.stdout > :pipe)
+#
+# Or for interactivity:
+#
+# q = Rubysh('cat', Rubysh.stdout > :stdout, Rubysh.stderr > :stderr, Rubysh.stdin < :stdin)
+# q.write('my whole command')
+# q.communicate # closes writeable pipes and reads from all readable pipes
+# q.data_from(:stdout)
+# q.data_from(1)
+# q.status
+#
+# You can name pipes with whatever symbol name you want:
+#
+# Rubysh('cat', 2 > :stdout, 3 > :fd3)
+#
+# This API is a WIP:
+#
+# q.write('my first command') # write data (while also reading from readable pipes
+#                             # in a select() loop)
+# q.communicate(:partial => true) # read available data (don't close pipes)
+# q.data_from(:stdout)
+# q.write('my second command')
+#
+# Not sure this is needed:
+# Rubysh('ls', '/tmp', Rubysh.&)
+# => Command: ls /tmp &
+
+# Either create a new Rubysh command:
+#
+#  command = Rubysh('ls')
+#  command.run
+#
+# Or use the block syntax to create and run one:
+#
+#  Rubysh {'ls'}
+def Rubysh(*args, &blk)
+  if blk
+    raise Rubysh::Error::BaseError.new("Can't provide arguments and a block") if args.length > 0
+    command = blk.call
+    command = Rubysh::Command.new(command) unless command.kind_of?(Rubysh::Command)
+    command.run
+  else
+    Rubysh::Command.new(args)
+  end
+end
+
+module Rubysh
+  # Convenience methods
+  def self.run(command)
+    command = Rubysh::Command.new(command) unless command.kind_of?(Rubysh::Command)
+    command.run
+  end
+
+  def self.Command(*args)
+    Command.new(*args)
+  end
+
+  def self.Pipeline(*args)
+    Pipeline.new(*args)
+  end
+
+  def self.FD(*args)
+    FD.new(*args)
+  end
+
+  def self.stdin
+    FD.new(0)
+  end
+
+  def self.stdout
+    FD.new(1)
+  end
+
+  def self.stderr
+    FD.new(2)
+  end
+
+  def self.>(target)
+    Redirect.new(1, '>', target)
+  end
+
+  def self.>>(target)
+    Redirect.new(1, '>>', target)
+  end
+
+  def self.<(target)
+    Redirect.new(0, '<', target)
+  end
+
+  # Hack to implement <<<
+  def self.<<(fd=nil)
+    fd ||= FD.new(0)
+    TripleLessThan::Shell.new(fd)
+  end
+
+  # Internal utility methods
+  def self.log
+    unless @log
+      @log = Logger.new(STDERR)
+      @log.level = Logger::WARN
+    end
+
+    @log
+  end
+
+  def self.assert(fact, msg, hard=false)
+    return if fact
+
+    msg = msg ? "Assertion Failure: #{msg}" : "Assertion Failure"
+    formatted = "#{msg}\n  #{caller.join("\n  ")}"
+    log.error(formatted)
+    raise msg if hard
+  end
+end

data/rubysh.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/rubysh/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Greg Brockman"]
+  gem.email         = ["gdb@gregbrockman.com"]
+  gem.description   = "Rubysh: Ruby subprocesses made easy"
+  gem.summary       = "Rubysh makes shelling out easy with a __sh__-like syntax layer for Ruby:
+
+    irb -r rubysh
+    >> command = Rubysh('echo', 'hello-from-Rubysh') | Rubysh('grep', '--color', 'Rubysh')
+    >> command.run
+    hello-from-Rubysh
+    => Rubysh::Runner: echo hello-from-Rubysh | grep --color Rubysh (exitstatus: 0)"
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "rubysh"
+  gem.require_paths = ["lib"]
+  gem.version       = Rubysh::VERSION
+
+  gem.add_development_dependency 'minitest', '3.1.0'
+  gem.add_development_dependency 'mocha'
+end

data/test/_lib.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'mocha'
+
+$:.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
+
+require 'rubysh'
+
+module RubyshTest
+  class Test < ::MiniTest::Spec
+    def setup
+      # Put any stubs here that you want to apply globally
+    end
+
+    def stub_pipe
+      read_fd = stub(:fcntl => nil, :read => nil, :close => nil, :closed? => true)
+      write_fd = stub(:fcntl => nil, :write => nil, :close => nil, :closed? => true)
+      IO.stubs(:pipe => [read_fd, write_fd])
+      [read_fd, write_fd]
+    end
+  end
+end

data/test/functional/_lib.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../_lib', File.dirname(__FILE__))
+
+module RubyshTest::Functional
+  class FunctionalTest < RubyshTest::Test; end
+end
+
+MiniTest::Unit.runner = MiniTest::Unit.new

data/test/functional/lib/fd-lister

@@ -0,0 +1,2 @@
+#!/bin/sh
+lsof -p "$$" -F f

data/test/functional/lib/leaked_fds.rb

@@ -0,0 +1,83 @@
+require File.expand_path('../_lib', File.dirname(__FILE__))
+require 'shellwords'
+
+module RubyshTest::Functional
+  class LeakedFDsTest < FunctionalTest
+    # Try to remove inteference from other tests
+    def close_high_fds
+      begin
+        (3..20).each do |fd|
+          begin
+            io = IO.new(fd)
+          rescue Errno::EBADF
+          else
+            io.close
+          end
+        end
+      end
+    end
+
+    def parse_lsof(stdout)
+      pids = []
+      stdout.split("\n").each do |line|
+        pids << $1.to_i if line =~ /\Af(\d+)\Z/
+      end
+      pids
+    end
+
+    before do
+      close_high_fds
+    end
+
+    describe 'when spawning with no pipe' do
+      it 'has no unexpected FDs, post-exec' do
+        cmd = Rubysh(File.expand_path('fd-lister', File.dirname(__FILE__)), Rubysh.stdout > :stdout)
+        result = cmd.run
+
+        stdout = result.data(:stdout)
+        pids = parse_lsof(stdout)
+        assert_equal([0, 1, 2, 255], pids)
+      end
+    end
+
+    describe 'when spawning with a redirect' do
+      it 'has no unexpected FDs, post-exec' do
+        cmd = Rubysh(File.expand_path('fd-lister', File.dirname(__FILE__)), Rubysh.stderr > '/dev/null', Rubysh.stdout > :stdout)
+        result = cmd.run
+
+        stdout = result.data(:stdout)
+        pids = parse_lsof(stdout)
+        assert_equal([0, 1, 2, 255], pids)
+      end
+    end
+
+    describe 'when spawning with a pipe' do
+      it 'has no unexpected FDs, post-fork' do
+        cmd = Rubysh(File.expand_path('fd-lister', File.dirname(__FILE__))) | Rubysh('cat', Rubysh.stdout > :stdout)
+        result = cmd.run
+
+        stdout = result.data(:stdout)
+        pids = parse_lsof(stdout)
+        assert_equal([0, 1, 2, 255], pids)
+      end
+
+      it 'has no unexpected FDs, post-fork, when on the right side of a pipe' do
+        cmd = Rubysh('echo') | Rubysh(File.expand_path('fd-lister', File.dirname(__FILE__)), Rubysh.stdout > :stdout)
+        result = cmd.run
+
+        stdout = result.data(:stdout)
+        pids = parse_lsof(stdout)
+        assert_equal([0, 1, 2, 255], pids)
+      end
+
+      it 'has no unexpected FDs, post-fork, when in the middle of two pipes' do
+        cmd = Rubysh('echo') | Rubysh(File.expand_path('fd-lister', File.dirname(__FILE__))) | Rubysh('cat', Rubysh.stdout > :stdout)
+        result = cmd.run
+
+        stdout = result.data(:stdout)
+        pids = parse_lsof(stdout)
+        assert_equal([0, 1, 2, 255], pids)
+      end
+    end
+  end
+end

data/test/functional/lib/redirect_ordering.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../_lib', File.dirname(__FILE__))
+
+module RubyshTest::Functional
+  class RedirectOrderingTest < FunctionalTest
+    describe 'when redirecting within a pipeline' do
+      it 'the internal redirect should win' do
+        cmd = Rubysh('echo', 'whoops!', Rubysh.stdout > '/dev/null') | Rubysh('cat', Rubysh.stdout > :stdout)
+        result = cmd.run
+
+        output = result.data(:stdout)
+        assert_equal('', output)
+      end
+    end
+  end
+end

data/test/functional/lib/triple_less_than.rb

@@ -0,0 +1,16 @@
+require File.expand_path('../_lib', File.dirname(__FILE__))
+
+module RubyshTest::Functional
+  class TripleLessThanTest < FunctionalTest
+    describe 'when using <<< string' do
+      it 'the string is delivered on stdin' do
+        cmd = Rubysh('cat', Rubysh.stdout > :stdout, Rubysh.<<< 'test')
+        result = cmd.run
+
+        assert_equal(0, result.exitstatus)
+        output = result.data(:stdout)
+        assert_equal('test', output)
+      end
+    end
+  end
+end

data/test/integration/_lib.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../_lib', File.dirname(__FILE__))
+
+module RubyshTest::Integration
+  class IntegrationTest < RubyshTest::Test; end
+end
+
+MiniTest::Unit.runner = MiniTest::Unit.new

data/test/integration/lib/rubysh.rb

@@ -0,0 +1,6 @@
+require File.expand_path('../_lib', File.dirname(__FILE__))
+
+module RubyshTest::Integration
+  class RubyshTest < IntegrationTest
+  end
+end

data/test/rubysh

@@ -0,0 +1,47 @@
+# Logfile created on Fri Sep 07 20:59:21 -0500 2012 by logger.rb/1.2.6
+E, [2012-09-07T20:59:21.055389 #28117] ERROR -- : Assertion Failure: Reader should already be closed
+  /Users/gdb/projects/rubysh/lib/rubysh/subprocess/pipe_wrapper.rb:27:in `dump_yaml_and_close'
+  /Users/gdb/projects/rubysh/lib/rubysh/subprocess.rb:85:in `do_exec'
+  ./unit/lib/rubysh/subprocess.rb:10:in `send'
+  ./unit/lib/rubysh/subprocess.rb:10:in `test_0001_calls exec with the expected arguments'
+  /Library/Ruby/Gems/1.8/gems/mocha-0.12.1/lib/mocha/integration/mini_test/version_2112_to_320.rb:32:in `run_test'
+  /Library/Ruby/Gems/1.8/gems/mocha-0.12.1/lib/mocha/integration/mini_test/version_2112_to_320.rb:32:in `run'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:823:in `_run_suite'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:815:in `map'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:815:in `_run_suite'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:802:in `_run_suites'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:802:in `map'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:802:in `_run_suites'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:775:in `_run_anything'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:964:in `run_tests'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:951:in `send'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:951:in `_run'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:950:in `each'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:950:in `_run'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:939:in `run'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:697:in `autorun'
+  ./unit/lib/rubysh/subprocess.rb:5
+E, [2012-09-07T21:00:24.936576 #28135] ERROR -- : Assertion Failure: Reader should already be closed
+  /Users/gdb/projects/rubysh/lib/rubysh/subprocess/pipe_wrapper.rb:27:in `dump_yaml_and_close'
+  /Users/gdb/projects/rubysh/lib/rubysh/subprocess.rb:85:in `do_exec'
+  ./unit/lib/rubysh/subprocess.rb:11:in `send'
+  ./unit/lib/rubysh/subprocess.rb:11:in `test_0001_calls exec with the expected arguments'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:342:in `assert_raises'
+  ./unit/lib/rubysh/subprocess.rb:10:in `test_0001_calls exec with the expected arguments'
+  /Library/Ruby/Gems/1.8/gems/mocha-0.12.1/lib/mocha/integration/mini_test/version_2112_to_320.rb:32:in `run_test'
+  /Library/Ruby/Gems/1.8/gems/mocha-0.12.1/lib/mocha/integration/mini_test/version_2112_to_320.rb:32:in `run'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:823:in `_run_suite'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:815:in `map'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:815:in `_run_suite'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:802:in `_run_suites'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:802:in `map'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:802:in `_run_suites'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:775:in `_run_anything'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:964:in `run_tests'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:951:in `send'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:951:in `_run'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:950:in `each'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:950:in `_run'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:939:in `run'
+  /Library/Ruby/Gems/1.8/gems/minitest-3.1.0/lib/minitest/unit.rb:697:in `autorun'
+  ./unit/lib/rubysh/subprocess.rb:5

data/test/unit/_lib.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../_lib', File.dirname(__FILE__))
+
+module RubyshTest::Unit
+  class UnitTest < RubyshTest::Test; end
+end
+
+MiniTest::Unit.runner = MiniTest::Unit.new

data/test/unit/lib/rubysh/command.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../../_lib', File.dirname(__FILE__))
+
+module RubyshTest::Unit
+  class CommandTest < UnitTest
+    describe 'when instantiating a command' do
+      it 'parses out args and directives properly' do
+        directive = Rubysh.stderr > Rubysh.stdout
+        command = Rubysh::Command.new(['ls', '/tmp', directive, '/foo'])
+        assert_equal(['ls', '/tmp', '/foo'], command.args)
+        assert_equal([directive], command.directives)
+      end
+
+      it 'prints correctly' do
+        directive = Rubysh.stderr > Rubysh.stdout
+        command = Rubysh::Command.new(['ls', '/tmp', directive, '/foo'])
+        assert_equal('Command: ls /tmp 2>&1 /foo', command.to_s)
+      end
+    end
+  end
+end

data/test/unit/lib/rubysh/pipeline.rb

@@ -0,0 +1,108 @@
+require File.expand_path('../../_lib', File.dirname(__FILE__))
+
+module RubyshTest::Unit
+  class PipelineTest < UnitTest
+    describe 'when running a pipeline' do
+      it 'correctly sets up extra redirects for the beginning of the pipeline' do
+        subprocess = stub(:run => nil)
+        Rubysh::Subprocess.stubs(:new => subprocess)
+
+        command1 = Rubysh::Command.new(['ls', '/tmp'])
+        command2 = Rubysh::Command.new(['grep', 'foo'])
+        pipeline = Rubysh::Pipeline.new([command1, command2])
+
+        runner = Rubysh::Runner.new(pipeline)
+        runner.run_async
+
+        extra_directives1 = runner.state(command1)[:extra_directives]
+
+        assert_equal(1, extra_directives1.length)
+
+        redirect = extra_directives1[0]
+
+        assert_equal('>', redirect.direction)
+        assert_equal(Rubysh::FD.new(1), redirect.source)
+      end
+
+      it 'correctly sets up extra redirects for the end of the pipeline' do
+        subprocess = stub(:run => nil)
+        Rubysh::Subprocess.stubs(:new => subprocess)
+
+        command1 = Rubysh::Command.new(['ls', '/tmp'])
+        command2 = Rubysh::Command.new(['grep', 'foo'])
+        pipeline = Rubysh::Pipeline.new([command1, command2])
+
+        runner = Rubysh::Runner.new(pipeline)
+        runner.run_async
+
+        extra_directives2 = runner.state(command2)[:extra_directives]
+
+        assert_equal(1, extra_directives2.length)
+
+        redirect = extra_directives2[0]
+
+        assert_equal('<', redirect.direction)
+        assert_equal(Rubysh::FD.new(0), redirect.source)
+      end
+
+      it 'correctly sets up extra redirects for the middle of the pipeline' do
+        subprocess = stub(:run => nil)
+        Rubysh::Subprocess.stubs(:new => subprocess)
+
+        command1 = Rubysh::Command.new(['ls', '/tmp'])
+        command2 = Rubysh::Command.new(['grep', 'foo'])
+        command3 = Rubysh::Command.new(['cat'])
+        pipeline = Rubysh::Pipeline.new([command1, command2, command3])
+
+        runner = Rubysh::Runner.new(pipeline)
+        runner.run_async
+
+        extra_directives2 = runner.state(command2)[:extra_directives]
+
+        assert_equal(2, extra_directives2.length)
+
+        first_redirect = extra_directives2[0]
+        assert_equal('<', first_redirect.direction)
+        assert_equal(Rubysh::FD.new(0), first_redirect.source)
+
+        second_redirect = extra_directives2[1]
+        assert_equal('>', second_redirect.direction)
+        assert_equal(Rubysh::FD.new(1), second_redirect.source)
+      end
+
+      it 'instantiates the subprocess objects with expected arguments' do
+        subprocess = stub(:run => nil)
+        Rubysh::Subprocess.expects(:new).once.with do |args, directives, post_forks|
+          args == ['ls', '/tmp'] &&
+            directives.length == 1 &&
+            directives[0].direction == '>' &&
+            directives[0].source == Rubysh::FD.new(1)
+        end.returns(subprocess)
+
+        Rubysh::Subprocess.expects(:new).once.with do |args, directives, post_forks|
+          args == ['grep', 'foo'] &&
+            directives.length == 2 &&
+            directives[0].direction == '<' &&
+            directives[0].source == Rubysh::FD.new(0) &&
+            directives[1].direction == '>' &&
+            directives[1].source == Rubysh::FD.new(1)
+        end.returns(subprocess)
+
+        Rubysh::Subprocess.expects(:new).once.with do |args, directives, post_forks|
+          args = ['cat'] &&
+            directives.length == 1 &&
+            directives[0].direction == '<' &&
+            directives[0].source == Rubysh::FD.new(0)
+        end.returns(subprocess)
+
+        command1 = Rubysh::Command.new(['ls', '/tmp'])
+        command2 = Rubysh::Command.new(['grep', 'foo'])
+        command3 = Rubysh::Command.new(['cat'])
+        pipeline = Rubysh::Pipeline.new([command1, command2, command3])
+
+        runner = Rubysh::Runner.new(pipeline)
+        runner.run_async
+      end
+    end
+  end
+end

data/test/unit/lib/rubysh/redirect.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../../_lib', File.dirname(__FILE__))
+
+module RubyshTest::Unit
+  class RedirectTest < UnitTest
+    describe 'when redirecting 2>&1' do
+      it 'correctly coerces when called with IO objects' do
+        runner = mock
+        stdout = stub(:fileno => 1)
+        stderr = stub(:fileno => 2)
+
+        stdout.stubs(:kind_of?).with(Integer).returns(false)
+        stdout.stubs(:kind_of?).with(IO).returns(true)
+        stderr.stubs(:kind_of?).with(String).returns(false)
+        stderr.stubs(:kind_of?).with(IO).returns(true)
+
+        # Due to stubbing
+        IO.expects(:new).never
+
+        redirect = Rubysh::Redirect.new(stderr, '>', stdout)
+        Rubysh::Util.expects(:dup2).once.with(1, 2)
+        Rubysh::Util.expects(:set_cloexec).once.with(2, false)
+
+        redirect.apply!(runner)
+      end
+    end
+
+    describe 'when redirecting an unopened FD 3>&1' do
+      it 'applies dup2 as expected' do
+        runner = mock
+        stdout = stub(:fileno => 1)
+
+        IO.expects(:new).with(1).returns(stdout)
+
+        stdout = stub(:fileno => 1)
+
+        redirect = Rubysh::Redirect.new(3, '>', 1)
+        Rubysh::Util.expects(:dup2).once.with(1, 3)
+        Rubysh::Util.expects(:set_cloexec).once.with(3, false)
+
+        redirect.apply!(runner)
+      end
+    end
+  end
+end

data/test/unit/lib/rubysh/runner.rb

@@ -0,0 +1,16 @@
+require File.expand_path('../../_lib', File.dirname(__FILE__))
+
+module RubyshTest::Unit
+  class RunnerTest < UnitTest
+    describe 'when setting up parallel_io' do
+      it 'has the expected readers/writers' do
+        read_fd, write_fd = stub_pipe
+        command = Rubysh('ls', Rubysh.stderr > :stderr, Rubysh.stdin < :stdin)
+        runner = Rubysh::Runner.new(command)
+
+        assert_equal({read_fd => :stderr}, runner.readers)
+        assert_equal({write_fd => :stdin}, runner.writers)
+      end
+    end
+  end
+end